src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
SearchResultEntryImpl extends AbstractResponse implements SearchResultEntry { @Override public boolean equals( Object obj ) { if ( this == obj ) { return true; } if ( !super.equals( obj ) ) { return false; } if ( !( obj instanceof SearchResultEntry ) ) { return false; } SearchResultEntry resp = ( SearchResultEntry ) obj; return entry.equals( resp.getEntry() ); } SearchResultEntryImpl(); SearchResultEntryImpl( final int id ); @Override Entry getEntry(); @Override void setEntry( Entry entry ); @Override Dn getObjectName(); @Override void setObjectName( Dn objectName ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testEqualsSameObject() { SearchResultEntryImpl resp = new SearchResultEntryImpl( 5 ); assertTrue( resp.equals( resp ), "the same object should be equal" ); } |
SearchResultEntryImpl extends AbstractResponse implements SearchResultEntry { @Override public int hashCode() { int hash = 37; if ( entry != null ) { hash = hash * 17 + entry.hashCode(); } hash = hash * 17 + super.hashCode(); return hash; } SearchResultEntryImpl(); SearchResultEntryImpl( final int id ); @Override Entry getEntry(); @Override void setEntry( Entry entry ); @Override Dn getObjectName(); @Override void setObjectName( Dn objectName ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testHashCodeSameObject() { SearchResultEntryImpl resp = new SearchResultEntryImpl( 5 ); assertTrue( resp.hashCode() == resp.hashCode() ); } |
ModifyRequestImpl extends AbstractAbandonableRequest implements ModifyRequest { @Override public boolean equals( Object obj ) { if ( obj == this ) { return true; } if ( !super.equals( obj ) ) { return false; } ModifyRequest req = ( ModifyRequest ) obj; if ( name != null && req.getName() == null ) { return false; } if ( name == null && req.getName() != null ) { return false; } if ( name != null && req.getName() != null && !name.equals( req.getName() ) ) { return false; } if ( req.getModifications().size() != mods.size() ) { return false; } Iterator<Modification> list = req.getModifications().iterator(); for ( int i = 0; i < mods.size(); i++ ) { Modification item = list.next(); if ( item == null ) { if ( mods.get( i ) != null ) { return false; } } else if ( !item.equals( mods.get( i ) ) ) { return false; } } return true; } ModifyRequestImpl(); @Override Collection<Modification> getModifications(); @Override Dn getName(); @Override ModifyRequest setName( Dn name ); @Override ModifyRequest addModification( Modification mod ); @Override ModifyRequest addModification( Attribute attr, ModificationOperation modOp ); @Override ModifyRequest add( String attributeName, String... attributeValue ); ModifyRequest add( String attributeName, byte[]... attributeValue ); @Override ModifyRequest add( Attribute attr ); @Override ModifyRequest replace( String attributeName ); @Override ModifyRequest replace( String attributeName, String... attributeValue ); ModifyRequest replace( String attributeName, byte[]... attributeValue ); @Override ModifyRequest replace( Attribute attr ); @Override ModifyRequest removeModification( Modification mod ); @Override ModifyRequest remove( String attributeName, String... attributeValue ); ModifyRequest remove( String attributeName, byte[]... attributeValue ); @Override ModifyRequest remove( Attribute attr ); @Override ModifyRequest remove( String attributeName ); @Override ModifyRequest increment( String attributeName ); @Override ModifyRequest increment( String attributeName, int increment ); @Override ModifyRequest increment( Attribute attr ); @Override ModifyRequest increment( Attribute attr, int increment ); @Override ModifyRequest setMessageId( int messageId ); @Override ModifyRequest addControl( Control control ); @Override ModifyRequest addAllControls( Control[] controls ); @Override ModifyRequest removeControl( Control control ); @Override MessageTypeEnum getResponseType(); @Override ModifyResponse getResultResponse(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testEqualsSameObj() throws LdapException { ModifyRequestImpl req = getRequest(); assertTrue( req.equals( req ) ); }
@Test public void testEqualsExactCopy() throws LdapException { ModifyRequestImpl req0 = getRequest(); ModifyRequestImpl req1 = getRequest(); assertTrue( req0.equals( req1 ) ); } |
ModifyRequestImpl extends AbstractAbandonableRequest implements ModifyRequest { @Override public int hashCode() { int hash = 37; if ( name != null ) { hash = hash * 17 + name.hashCode(); } hash = hash * 17 + mods.size(); for ( int i = 0; i < mods.size(); i++ ) { hash = hash * 17 + ( ( DefaultModification ) mods.get( i ) ).hashCode(); } hash = hash * 17 + super.hashCode(); return hash; } ModifyRequestImpl(); @Override Collection<Modification> getModifications(); @Override Dn getName(); @Override ModifyRequest setName( Dn name ); @Override ModifyRequest addModification( Modification mod ); @Override ModifyRequest addModification( Attribute attr, ModificationOperation modOp ); @Override ModifyRequest add( String attributeName, String... attributeValue ); ModifyRequest add( String attributeName, byte[]... attributeValue ); @Override ModifyRequest add( Attribute attr ); @Override ModifyRequest replace( String attributeName ); @Override ModifyRequest replace( String attributeName, String... attributeValue ); ModifyRequest replace( String attributeName, byte[]... attributeValue ); @Override ModifyRequest replace( Attribute attr ); @Override ModifyRequest removeModification( Modification mod ); @Override ModifyRequest remove( String attributeName, String... attributeValue ); ModifyRequest remove( String attributeName, byte[]... attributeValue ); @Override ModifyRequest remove( Attribute attr ); @Override ModifyRequest remove( String attributeName ); @Override ModifyRequest increment( String attributeName ); @Override ModifyRequest increment( String attributeName, int increment ); @Override ModifyRequest increment( Attribute attr ); @Override ModifyRequest increment( Attribute attr, int increment ); @Override ModifyRequest setMessageId( int messageId ); @Override ModifyRequest addControl( Control control ); @Override ModifyRequest addAllControls( Control[] controls ); @Override ModifyRequest removeControl( Control control ); @Override MessageTypeEnum getResponseType(); @Override ModifyResponse getResultResponse(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testHashCodeSameObj() throws LdapException { ModifyRequestImpl req = getRequest(); assertTrue( req.hashCode() == req.hashCode() ); }
@Test public void testHashCodeExactCopy() throws LdapException { ModifyRequestImpl req0 = getRequest(); ModifyRequestImpl req1 = getRequest(); assertTrue( req0.hashCode() == req1.hashCode() ); } |
OpaqueExtendedResponse extends AbstractExtendedResponse { @Override public boolean equals( Object obj ) { if ( obj == this ) { return true; } if ( !super.equals( obj ) ) { return false; } if ( !( obj instanceof OpaqueExtendedResponse ) ) { return false; } OpaqueExtendedResponse extendedRequest = ( OpaqueExtendedResponse ) obj; if ( ( ( responseName != null ) && !responseName.equals( extendedRequest.responseName ) ) || ( ( responseName == null ) && ( extendedRequest.responseName != null ) ) ) { return false; } return Arrays.equals( responseValue, extendedRequest.responseValue ); } OpaqueExtendedResponse(); OpaqueExtendedResponse( int messageId ); OpaqueExtendedResponse( String responseName ); OpaqueExtendedResponse( int messageId, String responseName ); byte[] getResponseValue(); void setResponseValue( byte[] responseValue ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testEqualsSameObj() { ExtendedResponse resp = createStub(); assertTrue( resp.equals( resp ) ); }
@Test public void testEqualsExactCopy() { ExtendedResponse resp0 = createStub(); ExtendedResponse resp1 = createStub(); assertTrue( resp0.equals( resp1 ) ); assertTrue( resp1.equals( resp0 ) ); }
@Test public void testEqualsDiffImpl() throws LdapInvalidDnException { ExtendedResponse resp0 = createStub(); ExtendedResponse resp1 = new OpaqueExtendedResponse( 45, "1.1.1.1" ); resp1.getLdapResult().setMatchedDn( new Dn( "dc=example,dc=com" ) ); resp1.getLdapResult().setResultCode( ResultCodeEnum.SUCCESS ); ReferralImpl refs = new ReferralImpl(); refs.addLdapUrl( "ldap: refs.addLdapUrl( "ldap: refs.addLdapUrl( "ldap: resp1.getLdapResult().setReferral( refs ); assertTrue( resp0.equals( resp1 ) ); assertTrue( resp1.equals( resp0 ) ); }
@Test public void testNotEqualsDiffIds() { ExtendedResponse resp0 = new OpaqueExtendedResponse( 3 ); ExtendedResponse resp1 = new OpaqueExtendedResponse( 4 ); assertFalse( resp0.equals( resp1 ) ); assertFalse( resp1.equals( resp0 ) ); }
@Test public void testNotEqualsDiffNames() { ExtendedResponse resp0 = createStub(); resp0.setResponseName( "1.2.3.4" ); ExtendedResponse resp1 = createStub(); resp1.setResponseName( "1.2.3.4.5" ); assertFalse( resp0.equals( resp1 ) ); assertFalse( resp1.equals( resp0 ) ); } |
OpaqueExtendedResponse extends AbstractExtendedResponse { @Override public int hashCode() { int hash = 37; hash = hash * 17 + super.hashCode(); if ( responseName != null ) { hash = hash * 17 + responseName.hashCode(); } if ( responseValue != null ) { for ( byte b : responseValue ) { hash = hash * 17 + b; } } return hash; } OpaqueExtendedResponse(); OpaqueExtendedResponse( int messageId ); OpaqueExtendedResponse( String responseName ); OpaqueExtendedResponse( int messageId, String responseName ); byte[] getResponseValue(); void setResponseValue( byte[] responseValue ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testHashCodeSameObj() { ExtendedResponse resp = createStub(); assertTrue( resp.hashCode() == resp.hashCode() ); }
@Test public void testHashCodeExactCopy() { ExtendedResponse resp0 = createStub(); ExtendedResponse resp1 = createStub(); assertTrue( resp0.hashCode() == resp1.hashCode() ); } |
ReferralImpl implements Referral { @Override public boolean equals( Object obj ) { if ( obj == this ) { return true; } if ( obj instanceof Referral ) { Collection<String> refs = ( ( Referral ) obj ).getLdapUrls(); if ( refs.size() != urls.size() ) { return false; } Iterator<String> list = urls.iterator(); while ( list.hasNext() ) { if ( !refs.contains( list.next() ) ) { return false; } } return true; } return false; } @Override int getReferralLength(); @Override void setReferralLength( int referralLength ); @Override Collection<String> getLdapUrls(); @Override Collection<byte[]> getLdapUrlsBytes(); @Override void addLdapUrl( String url ); @Override void addLdapUrlBytes( byte[] urlBytes ); @Override void removeLdapUrl( String url ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testEqualsSameObject() { ReferralImpl refs = new ReferralImpl(); assertTrue( refs.equals( refs ), "equals method should work for the same object" ); }
@Test public void testEqualsDifferentImpls() { Referral refs0 = new Referral() { public Collection<String> getLdapUrls() { return Collections.emptyList(); } public void addLdapUrl( String url ) { } public void removeLdapUrl( String url ) { } public void addLdapUrlBytes( byte[] urlBytes ) { } public Collection<byte[]> getLdapUrlsBytes() { return null; } public int getReferralLength() { return 0; } public void setReferralLength( int referralLength ) { } }; ReferralImpl refs1 = new ReferralImpl(); assertFalse( refs0.equals( refs1 ), "Object.equals() in effect because we did not redefine equals for the new impl above" ); assertTrue( refs1.equals( refs0 ), "Empty Referrals should be equal even if they are different implementation classes" ); } |
ReferralImpl implements Referral { @Override public int hashCode() { int hash = 37; hash = hash * 17 + urls.size(); for ( String url : urls ) { hash = hash + url.hashCode(); } return hash; } @Override int getReferralLength(); @Override void setReferralLength( int referralLength ); @Override Collection<String> getLdapUrls(); @Override Collection<byte[]> getLdapUrlsBytes(); @Override void addLdapUrl( String url ); @Override void addLdapUrlBytes( byte[] urlBytes ); @Override void removeLdapUrl( String url ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testHashCodeSameObject() { ReferralImpl refs = new ReferralImpl(); assertTrue( refs.hashCode() == refs.hashCode() ); } |
BindResponseImpl extends AbstractResultResponse implements BindResponse { @Override public boolean equals( Object obj ) { if ( obj == this ) { return true; } if ( !( obj instanceof BindResponse ) ) { return false; } if ( !super.equals( obj ) ) { return false; } BindResponse response = ( BindResponse ) obj; byte[] creds = response.getServerSaslCreds(); if ( serverSaslCreds == null ) { if ( creds != null ) { return false; } } else if ( creds == null ) { return false; } return Arrays.equals( serverSaslCreds, creds ); } BindResponseImpl(); BindResponseImpl( final int id ); @Override byte[] getServerSaslCreds(); @Override void setServerSaslCreds( byte[] serverSaslCreds ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testEqualsSameObj() { BindResponseImpl resp = new BindResponseImpl( 1 ); assertTrue( resp.equals( resp ), "same object should be equal" ); }
@Test public void testEqualsNewWithSameId() { BindResponseImpl resp0 = new BindResponseImpl( 1 ); BindResponseImpl resp1 = new BindResponseImpl( 1 ); assertTrue( resp0.equals( resp1 ), "default copy with same id should be equal" ); assertTrue( resp1.equals( resp0 ), "default copy with same id should be equal" ); }
@Test public void testNotEqualsNewWithDiffId() { BindResponseImpl resp0 = new BindResponseImpl( 1 ); BindResponseImpl resp1 = new BindResponseImpl( 2 ); assertFalse( resp0.equals( resp1 ), "different id objects should not be equal" ); assertFalse( resp1.equals( resp0 ), "different id objects should not be equal" ); } |
BindResponseImpl extends AbstractResultResponse implements BindResponse { @Override public int hashCode() { int hash = 37; hash = hash * 17 + Arrays.hashCode( serverSaslCreds ); hash = hash * 17 + super.hashCode(); return hash; } BindResponseImpl(); BindResponseImpl( final int id ); @Override byte[] getServerSaslCreds(); @Override void setServerSaslCreds( byte[] serverSaslCreds ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testHashCodeSameObj() { BindResponseImpl resp = new BindResponseImpl( 1 ); assertTrue( resp.hashCode() == resp.hashCode() ); }
@Test public void testHashCodeNewWithSameId() { BindResponseImpl resp0 = new BindResponseImpl( 1 ); BindResponseImpl resp1 = new BindResponseImpl( 1 ); assertTrue( resp1.hashCode() == resp0.hashCode() ); } |
AbstractResultResponse extends AbstractResponse implements ResultResponse { @Override public boolean equals( Object obj ) { if ( obj == this ) { return true; } if ( !super.equals( obj ) ) { return false; } if ( !( obj instanceof ResultResponse ) ) { return false; } ResultResponse resp = ( ResultResponse ) obj; return ( ( ldapResult != null ) && ldapResult.equals( resp.getLdapResult() ) ) || ( resp.getLdapResult() == null ); } protected AbstractResultResponse( final int id, final MessageTypeEnum type ); @Override LdapResult getLdapResult(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testEqualsSameObj() { AbstractResultResponse msg; msg = new AbstractResultResponse( 5, MessageTypeEnum.BIND_REQUEST ) { }; assertTrue( msg.equals( msg ) ); }
@Test public void testNotEqualsDiffId() { AbstractResultResponse msg0; AbstractResultResponse msg1; msg0 = new AbstractResultResponse( 5, MessageTypeEnum.BIND_REQUEST ) { }; msg1 = new AbstractResultResponse( 6, MessageTypeEnum.BIND_REQUEST ) { }; assertFalse( msg0.equals( msg1 ) ); assertFalse( msg1.equals( msg0 ) ); }
@Test public void testNotEqualsDiffType() { AbstractResultResponse msg0; AbstractResultResponse msg1; msg0 = new AbstractResultResponse( 5, MessageTypeEnum.BIND_REQUEST ) { }; msg1 = new AbstractResultResponse( 5, MessageTypeEnum.UNBIND_REQUEST ) { }; assertFalse( msg0.equals( msg1 ) ); assertFalse( msg1.equals( msg0 ) ); }
@Test public void testNotEqualsDiffControls() { AbstractResultResponse msg0; AbstractResultResponse msg1; msg0 = new AbstractResultResponse( 5, MessageTypeEnum.BIND_REQUEST ) { }; msg0.addControl( new Control() { public boolean isCritical() { return false; } public void setCritical( boolean isCritical ) { } public String getOid() { return "0.0"; } } ); msg1 = new AbstractResultResponse( 5, MessageTypeEnum.BIND_REQUEST ) { }; assertFalse( msg0.equals( msg1 ) ); assertFalse( msg1.equals( msg0 ) ); } |
AbstractMessage implements Message { @Override public boolean equals( Object obj ) { if ( obj == this ) { return true; } if ( !( obj instanceof Message ) ) { return false; } Message msg = ( Message ) obj; if ( msg.getMessageId() != id ) { return false; } if ( msg.getType() != type ) { return false; } Map<String, Control> controlMap = msg.getControls(); if ( controlMap.size() != controls.size() ) { return false; } for ( String key : controls.keySet() ) { if ( !controlMap.containsKey( key ) ) { return false; } } return true; } protected AbstractMessage( final int id, final MessageTypeEnum type ); @Override int getMessageId(); @Override Message setMessageId( int id ); @Override Map<String, Control> getControls(); @Override Control getControl( String oid ); @Override boolean hasControl( String oid ); @Override Message addControl( Control control ); @Override Message removeControl( Control control ); @Override MessageTypeEnum getType(); @Override Object get( Object key ); @Override Object put( Object key, Object value ); @Override boolean equals( Object obj ); @Override int hashCode(); @Override Message addAllControls( Control[] controls ); String toString( String message ); } | @Test public void testEqualsSameObj() { AbstractMessage msg; msg = new AbstractMessage( 5, MessageTypeEnum.BIND_REQUEST ) { }; assertTrue( msg.equals( msg ) ); }
@Test public void testEqualsExactCopy() { AbstractMessage msg0; AbstractMessage msg1; msg0 = new AbstractMessage( 5, MessageTypeEnum.BIND_REQUEST ) { }; msg1 = new AbstractMessage( 5, MessageTypeEnum.BIND_REQUEST ) { }; assertTrue( msg0.equals( msg1 ) ); assertTrue( msg1.equals( msg0 ) ); }
@Test public void testNotEqualsDiffId() { AbstractMessage msg0; AbstractMessage msg1; msg0 = new AbstractMessage( 5, MessageTypeEnum.BIND_REQUEST ) { }; msg1 = new AbstractMessage( 6, MessageTypeEnum.BIND_REQUEST ) { }; assertFalse( msg0.equals( msg1 ) ); assertFalse( msg1.equals( msg0 ) ); }
@Test public void testNotEqualsDiffType() { AbstractMessage msg0; AbstractMessage msg1; msg0 = new AbstractMessage( 5, MessageTypeEnum.BIND_REQUEST ) { }; msg1 = new AbstractMessage( 5, MessageTypeEnum.UNBIND_REQUEST ) { }; assertFalse( msg0.equals( msg1 ) ); assertFalse( msg1.equals( msg0 ) ); } |
LdapResultImpl implements LdapResult { @Override public boolean equals( Object obj ) { if ( obj == this ) { return true; } if ( !( obj instanceof LdapResult ) ) { return false; } LdapResult result = ( LdapResult ) obj; if ( referral == null && result.getReferral() != null ) { return false; } if ( result.getReferral() == null && referral != null ) { return false; } if ( referral != null && result.getReferral() != null && !referral.equals( result.getReferral() ) ) { return false; } if ( !resultCode.equals( result.getResultCode() ) ) { return false; } String errMsg0 = diagnosticMessage; String errMsg1 = result.getDiagnosticMessage(); if ( errMsg0 == null ) { errMsg0 = ""; } if ( errMsg1 == null ) { errMsg1 = ""; } if ( !errMsg0.equals( errMsg1 ) ) { return false; } if ( matchedDn != null ) { if ( !matchedDn.equals( result.getMatchedDn() ) ) { return false; } } else if ( result.getMatchedDn() != null ) { return false; } return true; } @Override String getDiagnosticMessage(); @Override void setDiagnosticMessage( String diagnosticMessage ); @Override Dn getMatchedDn(); @Override void setMatchedDn( Dn matchedDn ); @Override ResultCodeEnum getResultCode(); @Override void setResultCode( ResultCodeEnum resultCode ); @Override Referral getReferral(); @Override boolean isReferral(); @Override void setReferral( Referral referral ); @Override boolean isDefaultSuccess(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testEqualsSameObj() { LdapResultImpl r0 = new LdapResultImpl(); assertTrue( r0.equals( r0 ), "same object should be equal" ); }
@Test public void testEqualsDefaultCopy() { LdapResultImpl r0 = new LdapResultImpl(); LdapResultImpl r1 = new LdapResultImpl(); assertTrue( r0.equals( r1 ), "default copy should be equal" ); assertTrue( r1.equals( r0 ), "default copy should be equal" ); }
@Test public void testEqualsDiffLockableParent() { LdapResultImpl r0 = new LdapResultImpl(); LdapResultImpl r1 = new LdapResultImpl(); assertTrue( r0.equals( r1 ), "default copy with different lockable parents should be equal" ); assertTrue( r1.equals( r0 ), "default copy with different lockable parents should be equal" ); }
@Test public void testEqualsDiffImpl() { LdapResultImpl r0 = new LdapResultImpl(); LdapResult r1 = new LdapResult() { public ResultCodeEnum getResultCode() { return ResultCodeEnum.SUCCESS; } public void setResultCode( ResultCodeEnum a_resultCode ) { } public Dn getMatchedDn() { return null; } public void setMatchedDn( Dn dn ) { } public String getDiagnosticMessage() { return null; } public void setDiagnosticMessage( String diagnosticMessage ) { } public boolean isReferral() { return false; } public Referral getReferral() { return null; } public void setReferral( Referral referral ) { } public boolean isDefaultSuccess() { return false; } }; assertTrue( r0.equals( r1 ), "r0 equals should see other impl r1 as equal" ); assertFalse( r1.equals( r0 ), "r1 impl uses Object.equals() so it should not see r0 as the same object" ); } |
LdapResultImpl implements LdapResult { @Override public int hashCode() { int hash = 37; if ( referral != null ) { hash = hash * 17 + referral.hashCode(); } hash = hash * 17 + resultCode.hashCode(); if ( diagnosticMessage != null ) { hash = hash * 17 + diagnosticMessage.hashCode(); } if ( matchedDn != null ) { hash = hash * 17 + matchedDn.hashCode(); } return hash; } @Override String getDiagnosticMessage(); @Override void setDiagnosticMessage( String diagnosticMessage ); @Override Dn getMatchedDn(); @Override void setMatchedDn( Dn matchedDn ); @Override ResultCodeEnum getResultCode(); @Override void setResultCode( ResultCodeEnum resultCode ); @Override Referral getReferral(); @Override boolean isReferral(); @Override void setReferral( Referral referral ); @Override boolean isDefaultSuccess(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testHashCodeSameObj() { LdapResultImpl r0 = new LdapResultImpl(); assertTrue( r0.hashCode() == r0.hashCode() ); }
@Test public void testHashCodeDefaultCopy() { LdapResultImpl r0 = new LdapResultImpl(); LdapResultImpl r1 = new LdapResultImpl(); assertTrue( r0.hashCode() == r1.hashCode() ); }
@Test public void testHashCodeDiffLockableParent() { LdapResultImpl r0 = new LdapResultImpl(); LdapResultImpl r1 = new LdapResultImpl(); assertTrue( r0.hashCode() == r1.hashCode() ); } |
ModifyDnRequestImpl extends AbstractAbandonableRequest implements ModifyDnRequest { @Override public boolean equals( Object obj ) { if ( obj == this ) { return true; } if ( !super.equals( obj ) ) { return false; } ModifyDnRequest req = ( ModifyDnRequest ) obj; if ( name != null && req.getName() == null ) { return false; } if ( name == null && req.getName() != null ) { return false; } if ( name != null && req.getName() != null && !name.equals( req.getName() ) ) { return false; } if ( deleteOldRdn != req.getDeleteOldRdn() ) { return false; } if ( newRdn != null && req.getNewRdn() == null ) { return false; } if ( newRdn == null && req.getNewRdn() != null ) { return false; } if ( newRdn != null && req.getNewRdn() != null && !newRdn.equals( req.getNewRdn() ) ) { return false; } if ( newSuperior != null && req.getNewSuperior() == null ) { return false; } if ( newSuperior == null && req.getNewSuperior() != null ) { return false; } return ( newSuperior == null ) || ( req.getNewSuperior() == null ) || newSuperior.equals( req .getNewSuperior() ); } ModifyDnRequestImpl(); @Override boolean getDeleteOldRdn(); @Override ModifyDnRequest setDeleteOldRdn( boolean deleteOldRdn ); @Override boolean isMove(); @Override Dn getName(); @Override ModifyDnRequest setName( Dn name ); @Override Rdn getNewRdn(); @Override ModifyDnRequest setNewRdn( Rdn newRdn ); @Override Dn getNewSuperior(); @Override ModifyDnRequest setNewSuperior( Dn newSuperior ); @Override ModifyDnRequest setMessageId( int messageId ); @Override ModifyDnRequest addControl( Control control ); @Override ModifyDnRequest addAllControls( Control[] controls ); @Override ModifyDnRequest removeControl( Control control ); @Override MessageTypeEnum getResponseType(); @Override ModifyDnResponse getResultResponse(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testEqualsExactCopy0() { ModifyDnRequestImpl req0 = getRequest(); ModifyDnRequestImpl req1 = getRequest(); assertTrue( req0.equals( req1 ) ); }
@Test public void testEqualsDiffImpl() { ModifyDnRequest req0 = new ModifyDnRequest() { public Dn getName() { try { return new Dn( "dc=admins,dc=apache,dc=org" ); } catch ( LdapException ine ) { return null; } } public ModifyDnRequest setName( Dn name ) { return this; } public Rdn getNewRdn() { try { return new Rdn( "dc=administrators" ); } catch ( LdapException ine ) { return null; } } public ModifyDnRequest setNewRdn( Rdn newRdn ) { return this; } public boolean getDeleteOldRdn() { return true; } public ModifyDnRequest setDeleteOldRdn( boolean deleteOldRdn ) { return this; } public Dn getNewSuperior() { try { return new Dn( "dc=groups,dc=apache,dc=org" ); } catch ( LdapException ine ) { return null; } } public ModifyDnRequest setNewSuperior( Dn newSuperior ) { return this; } public boolean isMove() { return false; } public MessageTypeEnum getResponseType() { return MessageTypeEnum.MODIFYDN_RESPONSE; } public boolean hasResponse() { return true; } public MessageTypeEnum getType() { return MessageTypeEnum.MODIFYDN_REQUEST; } public Map<String, Control> getControls() { return EMPTY_CONTROL_MAP; } public ModifyDnRequest addControl( Control a_control ) { return this; } public ModifyDnRequest removeControl( Control a_control ) { return this; } public int getMessageId() { return 45; } public Object get( Object a_key ) { return null; } public Object put( Object a_key, Object a_value ) { return null; } public void abandon() { } public boolean isAbandoned() { return false; } public ModifyDnRequest addAbandonListener( AbandonListener listener ) { return this; } public ModifyDnResponse getResultResponse() { return null; } public ModifyDnRequest addAllControls( Control[] controls ) { return this; } public boolean hasControl( String oid ) { return false; } public Control getControl( String oid ) { return null; } public ModifyDnRequest setMessageId( int messageId ) { return this; } }; ModifyDnRequestImpl req1 = getRequest(); assertTrue( req1.equals( req0 ) ); } |
ModifyDnRequestImpl extends AbstractAbandonableRequest implements ModifyDnRequest { @Override public int hashCode() { int hash = 37; if ( name != null ) { hash = hash * 17 + name.hashCode(); } hash = hash * 17 + ( deleteOldRdn ? 0 : 1 ); if ( newRdn != null ) { hash = hash * 17 + newRdn.hashCode(); } if ( newSuperior != null ) { hash = hash * 17 + newSuperior.hashCode(); } hash = hash * 17 + super.hashCode(); return hash; } ModifyDnRequestImpl(); @Override boolean getDeleteOldRdn(); @Override ModifyDnRequest setDeleteOldRdn( boolean deleteOldRdn ); @Override boolean isMove(); @Override Dn getName(); @Override ModifyDnRequest setName( Dn name ); @Override Rdn getNewRdn(); @Override ModifyDnRequest setNewRdn( Rdn newRdn ); @Override Dn getNewSuperior(); @Override ModifyDnRequest setNewSuperior( Dn newSuperior ); @Override ModifyDnRequest setMessageId( int messageId ); @Override ModifyDnRequest addControl( Control control ); @Override ModifyDnRequest addAllControls( Control[] controls ); @Override ModifyDnRequest removeControl( Control control ); @Override MessageTypeEnum getResponseType(); @Override ModifyDnResponse getResultResponse(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); } | @Test public void testHashCodeExactCopy0() { ModifyDnRequestImpl req0 = getRequest(); ModifyDnRequestImpl req1 = getRequest(); assertTrue( req0.hashCode() == req1.hashCode() ); } |
UndefinedNode extends AbstractExprNode { @Override public boolean isLeaf() { return false; } private UndefinedNode(); @Override boolean isLeaf(); @Override Object accept( FilterVisitor visitor ); @Override boolean isSchemaAware(); @Override String toString(); static final UndefinedNode UNDEFINED_NODE; } | @Test public void testIsLeaf() throws Exception { assertFalse( undefinedNode.isLeaf() ); } |
UndefinedNode extends AbstractExprNode { @Override public boolean isSchemaAware() { return false; } private UndefinedNode(); @Override boolean isLeaf(); @Override Object accept( FilterVisitor visitor ); @Override boolean isSchemaAware(); @Override String toString(); static final UndefinedNode UNDEFINED_NODE; } | @Test public void testIsSchemaAware() throws Exception { assertFalse( undefinedNode.isSchemaAware() ); } |
UndefinedNode extends AbstractExprNode { @Override public Object accept( FilterVisitor visitor ) { return null; } private UndefinedNode(); @Override boolean isLeaf(); @Override Object accept( FilterVisitor visitor ); @Override boolean isSchemaAware(); @Override String toString(); static final UndefinedNode UNDEFINED_NODE; } | @Test public void testAccept() throws Exception { assertNull( undefinedNode.accept( new FilterVisitor() { public Object visit( ExprNode node ) { return null; } public boolean isPrefix() { return false; } public List<ExprNode> getOrder( BranchNode node, List<ExprNode> children ) { return null; } public boolean canVisit( ExprNode node ) { return false; } } ) ); } |
BranchNormalizedVisitor implements FilterVisitor { @Override public Object visit( ExprNode node ) { if ( !( node instanceof BranchNode ) ) { return null; } BranchNode branch = ( BranchNode ) node; Comparator<ExprNode> nodeComparator = new NodeComparator(); Set<ExprNode> set = new TreeSet<>( nodeComparator ); List<ExprNode> children = branch.getChildren(); for ( ExprNode child : branch.getChildren() ) { if ( !child.isLeaf() ) { ExprNode newChild = ( ExprNode ) visit( child ); if ( newChild != null ) { set.add( newChild ); } } else { set.add( child ); } } children.clear(); children.addAll( set ); return branch; } @Override Object visit( ExprNode node ); @Override boolean canVisit( ExprNode node ); @Override boolean isPrefix(); @Override List<ExprNode> getOrder( BranchNode node, List<ExprNode> children ); static String getNormalizedFilter( SchemaManager schemaManager, String filter ); static String getNormalizedFilter( ExprNode filter ); } | @Test public void testBranchNormalizedVisitor0() throws Exception { String filter = "(ou=Human Resources)"; ExprNode ori = FilterParser.parse( filter ); ExprNode altered = FilterParser.parse( filter ); BranchNormalizedVisitor visitor = new BranchNormalizedVisitor(); visitor.visit( altered ); assertEquals( ori.toString(), altered.toString() ); }
@Test public void testBranchNormalizedVisitor1() throws Exception { String filter = "(&(ou=Human Resources)(uid=akarasulu))"; ExprNode ori = FilterParser.parse( filter ); ExprNode altered = FilterParser.parse( filter ); BranchNormalizedVisitor visitor = new BranchNormalizedVisitor(); visitor.visit( altered ); assertEquals( ori.toString(), altered.toString() ); }
@Test public void testBranchNormalizedVisitor2() throws Exception { String filter = "(&(uid=akarasulu)(ou=Human Resources)"; filter += "(|(uid=akarasulu)(ou=Human Resources))) "; ExprNode ori = FilterParser.parse( filter ); ExprNode altered = FilterParser.parse( filter ); BranchNormalizedVisitor visitor = new BranchNormalizedVisitor(); visitor.visit( altered ); assertFalse( ori.toString().equals( altered.toString() ) ); }
@Test public void testBranchNormalizedVisitor3() throws Exception { String filter = "(&(ou=Human Resources)(uid=akarasulu)"; filter += "(|(ou=Human Resources)(uid=akarasulu)))"; ExprNode ori = FilterParser.parse( filter ); ExprNode altered = FilterParser.parse( filter ); BranchNormalizedVisitor visitor = new BranchNormalizedVisitor(); visitor.visit( altered ); assertTrue( ori.toString().equals( altered.toString() ) ); } |
BranchNormalizedVisitor implements FilterVisitor { public static String getNormalizedFilter( SchemaManager schemaManager, String filter ) throws ParseException { ExprNode originalNode = FilterParser.parse( schemaManager, filter ); return getNormalizedFilter( originalNode ); } @Override Object visit( ExprNode node ); @Override boolean canVisit( ExprNode node ); @Override boolean isPrefix(); @Override List<ExprNode> getOrder( BranchNode node, List<ExprNode> children ); static String getNormalizedFilter( SchemaManager schemaManager, String filter ); static String getNormalizedFilter( ExprNode filter ); } | @Test public void testBranchNormalizedComplex() throws Exception { String filter1 = "(&(a=A)(|(b=B)(c=C)))"; String filter2 = "(&(a=A)(|(c=C)(b=B)))"; String normalizedFilter1 = BranchNormalizedVisitor.getNormalizedFilter( null, filter1 ); String normalizedFilter2 = BranchNormalizedVisitor.getNormalizedFilter( null, filter2 ); assertEquals( normalizedFilter1, normalizedFilter2 ); } |
FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); static ExprNode parse( String filter ); static ExprNode parse( String filter, boolean relaxed ); static ExprNode parse( SchemaManager schemaManager, String filter ); static ExprNode parse( SchemaManager schemaManager, String filter, boolean relaxed ); } | @Test public void testItemFilter() throws ParseException { String str = "(ou~=people)"; SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertEquals( "people", node.getValue().getString() ); assertTrue( node instanceof ApproximateNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testAndFilter() throws ParseException { String str = "(&(ou~=people)(age>=30))"; BranchNode node = ( BranchNode ) FilterParser.parse( str ); assertEquals( 2, node.getChildren().size() ); assertTrue( node instanceof AndNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testAndFilterOneChildOnly() throws ParseException { String str = "(&(ou~=people))"; BranchNode node = ( BranchNode ) FilterParser.parse( str ); assertEquals( 1, node.getChildren().size() ); assertTrue( node instanceof AndNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testOrFilter() throws ParseException { String str = "(|(ou~=people)(age>=30))"; BranchNode node = ( BranchNode ) FilterParser.parse( str ); assertEquals( 2, node.getChildren().size() ); assertTrue( node instanceof OrNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testOrFilterOneChildOnly() throws ParseException { String str = "(|(age>=30))"; BranchNode node = ( BranchNode ) FilterParser.parse( str ); assertEquals( 1, node.getChildren().size() ); assertTrue( node instanceof OrNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testNotFilter() throws ParseException { String str = "(!(&(ou~= people)(age>=30)))"; BranchNode node = ( BranchNode ) FilterParser.parse( str ); assertEquals( 1, node.getChildren().size() ); assertTrue( node instanceof NotNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testOptionAndEscapesFilter() throws ParseException { String str = "(ou;lang-de>=\\23\\42asdl fkajsd)"; SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "ou;lang-de", node.getAttribute() ); assertEquals( "#Basdl fkajsd", node.getValue().getString() ); String str2 = node.toString(); assertEquals( "(ou;lang-de>=#Basdl fkajsd)", str2 ); }
@Test public void testOptionsAndEscapesFilter() throws ParseException { String str = "(ou;lang-de;version-124>=\\23\\42asdl fkajsd)"; SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "ou;lang-de;version-124", node.getAttribute() ); assertEquals( "#Basdl fkajsd", node.getValue().getString() ); String str2 = node.toString(); assertEquals( "(ou;lang-de;version-124>=#Basdl fkajsd)", str2 ); }
@Test public void testNumericoidOptionsAndEscapesFilter() throws ParseException { String str = "(1.3.4.2;lang-de;version-124>=\\23\\42afdl fkajsd)"; SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "1.3.4.2;lang-de;version-124", node.getAttribute() ); assertEquals( "#Bafdl fkajsd", node.getValue().getString() ); String str2 = node.toString(); assertEquals( "(1.3.4.2;lang-de;version-124>=#Bafdl fkajsd)", str2 ); }
@Test public void testPresentFilter() throws ParseException { String str = "(ou=*)"; PresenceNode node = ( PresenceNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof PresenceNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testNumericoidPresentFilter() throws ParseException { String str = "(1.2.3.4=*)"; PresenceNode node = ( PresenceNode ) FilterParser.parse( str ); assertEquals( "1.2.3.4", node.getAttribute() ); assertTrue( node instanceof PresenceNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testEqualsFilter() throws ParseException { String str = "(ou=people)"; SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertEquals( "people", node.getEscapedValue() ); assertTrue( node instanceof EqualityNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testBadEqualsFilter() { try { FilterParser.parse( "ou=people" ); fail( "should fail with bad filter" ); } catch ( ParseException pe ) { assertTrue( true ); } }
@Test public void testEqualsWithForwardSlashFilter() throws ParseException { String str = "(ou=people/in/my/company)"; SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertEquals( "people/in/my/company", node.getValue().getString() ); assertTrue( node instanceof EqualityNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testExtensibleFilterForm1() throws ParseException { String str = "(ou:dn:stupidMatch:=dummyAssertion\\23\\c4\\8d)"; ExtensibleNode node = ( ExtensibleNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertEquals( "dummyAssertion#\u010D", node.getValue().getString() ); assertEquals( "stupidMatch", node.getMatchingRuleId() ); assertTrue( node.hasDnAttributes() ); assertTrue( node instanceof ExtensibleNode ); }
@Test public void testExtensibleFilterForm1WithNumericOid() throws ParseException { String str = "(1.2.3.4:dn:1.3434.23.2:=dummyAssertion\\23\\c4\\8d)"; ExtensibleNode node = ( ExtensibleNode ) FilterParser.parse( str ); assertEquals( "1.2.3.4", node.getAttribute() ); assertEquals( "dummyAssertion#\u010D", node.getValue().getString() ); assertEquals( "1.3434.23.2", node.getMatchingRuleId() ); assertTrue( node.hasDnAttributes() ); assertTrue( node instanceof ExtensibleNode ); }
@Test public void testExtensibleFilterForm1NoDnAttr() throws ParseException { String str = "(ou:stupidMatch:=dummyAssertion\\23\\c4\\8d)"; ExtensibleNode node = ( ExtensibleNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertEquals( "dummyAssertion#\u010D", node.getValue().getString() ); assertEquals( "stupidMatch", node.getMatchingRuleId() ); assertFalse( node.hasDnAttributes() ); assertTrue( node instanceof ExtensibleNode ); }
@Test public void testExtensibleFilterForm1OptionOnRule() { try { FilterParser.parse( "(ou:stupidMatch;lang-de:=dummyAssertion\\23\\c4\\8d)" ); fail( "we should never get here" ); } catch ( ParseException e ) { assertTrue( true ); } }
@Test public void testExtensibleFilterForm1NoAttrNoMatchingRule() throws ParseException { String str = "(ou:=dummyAssertion\\23\\c4\\8d)"; ExtensibleNode node = ( ExtensibleNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertEquals( "dummyAssertion#\u010D", node.getValue().getString() ); assertEquals( null, node.getMatchingRuleId() ); assertFalse( node.hasDnAttributes() ); assertTrue( node instanceof ExtensibleNode ); }
@Test public void testExtensibleFilterForm2() throws ParseException { String str = "(:dn:stupidMatch:=dummyAssertion\\23\\c4\\8d)"; ExtensibleNode node = ( ExtensibleNode ) FilterParser.parse( str ); assertEquals( null, node.getAttribute() ); assertEquals( "dummyAssertion#\u010D", node.getValue().getString() ); assertEquals( "stupidMatch", node.getMatchingRuleId() ); assertTrue( node.hasDnAttributes() ); assertTrue( node instanceof ExtensibleNode ); }
@Test public void testExtensibleFilterForm2OptionOnRule() { try { FilterParser.parse( "(:dn:stupidMatch;lang-en:=dummyAssertion\\23\\c4\\8d)" ); fail( "we should never get here" ); } catch ( ParseException e ) { assertTrue( true ); } }
@Test public void testExtensibleFilterForm2WithNumericOid() throws ParseException { String str = "(:dn:1.3434.23.2:=dummyAssertion\\23\\c4\\8d)"; ExtensibleNode node = ( ExtensibleNode ) FilterParser.parse( str ); assertEquals( null, node.getAttribute() ); assertEquals( "dummyAssertion#\u010D", node.getValue().getString() ); assertEquals( "1.3434.23.2", node.getMatchingRuleId() ); assertTrue( node.hasDnAttributes() ); assertTrue( node instanceof ExtensibleNode ); }
@Test public void testExtensibleFilterForm2NoDnAttr() throws ParseException { String str = "(:stupidMatch:=dummyAssertion\\23\\c4\\8d)"; ExtensibleNode node = ( ExtensibleNode ) FilterParser.parse( str ); assertEquals( null, node.getAttribute() ); assertEquals( "dummyAssertion#\u010D", node.getValue().getString() ); assertEquals( "stupidMatch", node.getMatchingRuleId() ); assertFalse( node.hasDnAttributes() ); assertTrue( node instanceof ExtensibleNode ); }
@Test public void testExtensibleFilterForm2NoDnAttrWithNumericOidNoAttr() throws ParseException { String str = "(:1.3434.23.2:=dummyAssertion\\23\\c4\\8d)"; ExtensibleNode node = ( ExtensibleNode ) FilterParser.parse( str ); assertEquals( null, node.getAttribute() ); assertEquals( "dummyAssertion#\u010D", node.getValue().getString() ); assertEquals( "1.3434.23.2", node.getMatchingRuleId() ); assertFalse( node.hasDnAttributes() ); assertTrue( node instanceof ExtensibleNode ); }
@Test public void testExtensibleFilterForm3() throws ParseException { try { FilterParser.parse( "(:=dummyAssertion)" ); fail( "Should never reach this point" ); } catch ( ParseException pe ) { assertTrue( true ); } }
@Test public void testReuseParser() throws ParseException { FilterParser.parse( "(ou~=people)" ); FilterParser.parse( "(&(ou~=people)(age>=30)) " ); FilterParser.parse( "(|(ou~=people)(age>=30)) " ); FilterParser.parse( "(!(&(ou~=people)(age>=30)))" ); FilterParser.parse( "(ou;lang-de>=\\23\\42asdl fkajsd)" ); FilterParser.parse( "(ou;lang-de;version-124>=\\23\\42asdl fkajsd)" ); FilterParser.parse( "(1.3.4.2;lang-de;version-124>=\\23\\42asdl fkajsd)" ); FilterParser.parse( "(ou=*)" ); FilterParser.parse( "(1.2.3.4=*)" ); FilterParser.parse( "(ou=people)" ); FilterParser.parse( "(ou=people/in/my/company)" ); FilterParser.parse( "(ou:dn:stupidMatch:=dummyAssertion\\23\\c4\\8d)" ); FilterParser.parse( "(1.2.3.4:dn:1.3434.23.2:=dummyAssertion\\23\\c4\\8d)" ); FilterParser.parse( "(ou:stupidMatch:=dummyAssertion\\23\\c4\\8d)" ); FilterParser.parse( "(ou:=dummyAssertion\\23\\c4\\8d)" ); FilterParser.parse( "(1.2.3.4:1.3434.23.2:=dummyAssertion\\23\\c4\\8d)" ); FilterParser.parse( "(:dn:stupidMatch:=dummyAssertion\\23\\c4\\8d)" ); FilterParser.parse( "(:dn:1.3434.23.2:=dummyAssertion\\23\\c4\\8d)" ); FilterParser.parse( "(:stupidMatch:=dummyAssertion\\23\\c4\\8d)" ); FilterParser.parse( "(:1.3434.23.2:=dummyAssertion\\23\\c4\\8d)" ); }
@Test public void testReuseParserAfterFailures() throws ParseException { FilterParser.parse( "(ou~=people)" ); FilterParser.parse( "(&(ou~=people)(age>=30)) " ); FilterParser.parse( "(|(ou~=people)(age>=30)) " ); FilterParser.parse( "(!(&(ou~=people)(age>=30)))" ); FilterParser.parse( "(ou;lang-de>=\\23\\42asdl fkajsd)" ); FilterParser.parse( "(ou;lang-de;version-124>=\\23\\42asdl fkajsd)" ); FilterParser.parse( "(1.3.4.2;lang-de;version-124>=\\23\\42asdl fkajsd)" ); try { FilterParser.parse( "(ou:stupidMatch;lang-de:=dummyAssertion\\23\\ac)" ); fail( "we should never get here" ); } catch ( ParseException e ) { assertTrue( true ); } FilterParser.parse( "(ou=*)" ); FilterParser.parse( "(1.2.3.4=*)" ); FilterParser.parse( "(ou=people)" ); FilterParser.parse( "(ou=people/in/my/company)" ); FilterParser.parse( "(ou:dn:stupidMatch:=dummyAssertion\\23\\ac)" ); FilterParser.parse( "(1.2.3.4:dn:1.3434.23.2:=dummyAssertion\\23\\ac)" ); FilterParser.parse( "(ou:stupidMatch:=dummyAssertion\\23\\ac)" ); try { FilterParser.parse( "(:dn:stupidMatch;lang-en:=dummyAssertion\\23\\ac)" ); fail( "we should never get here" ); } catch ( ParseException e ) { assertTrue( true ); } FilterParser.parse( "(ou:=dummyAssertion\\23\\ac)" ); FilterParser.parse( "(1.2.3.4:1.3434.23.2:=dummyAssertion\\23\\ac)" ); FilterParser.parse( "(:dn:stupidMatch:=dummyAssertion\\23\\ac)" ); FilterParser.parse( "(:dn:1.3434.23.2:=dummyAssertion\\23\\ac)" ); FilterParser.parse( "(:stupidMatch:=dummyAssertion\\23\\ac)" ); FilterParser.parse( "(:1.3434.23.2:=dummyAssertion\\23\\ac)" ); }
@Test public void testNullOrEmptyString() throws ParseException { try { FilterParser.parse( (String)null ); fail( "Should not reach this point " ); } catch ( ParseException pe ) { assertTrue( true ); } try { FilterParser.parse( "" ); fail( "Should not reach this point " ); } catch ( ParseException pe ) { assertTrue( true ); } }
@Test public void testSubstringNoAnyNoFinal() throws ParseException { String str = "(ou=foo*)"; SubstringNode node = ( SubstringNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof SubstringNode ); assertEquals( 0, node.getAny().size() ); assertFalse( node.getAny().contains( "" ) ); assertEquals( "foo", node.getInitial() ); assertEquals( null, node.getFinal() ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testSubstringNoAny() throws ParseException { String str = "(ou=foo*bar)"; SubstringNode node = ( SubstringNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof SubstringNode ); assertEquals( 0, node.getAny().size() ); assertFalse( node.getAny().contains( "" ) ); assertEquals( "foo", node.getInitial() ); assertEquals( "bar", node.getFinal() ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testSubstringNoAnyNoIni() throws ParseException { String str = "(ou=*bar)"; SubstringNode node = ( SubstringNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof SubstringNode ); assertEquals( 0, node.getAny().size() ); assertFalse( node.getAny().contains( "" ) ); assertEquals( null, node.getInitial() ); assertEquals( "bar", node.getFinal() ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testSubstringOneAny() throws ParseException { String str = "(ou=foo*guy*bar)"; SubstringNode node = ( SubstringNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof SubstringNode ); assertEquals( 1, node.getAny().size() ); assertFalse( node.getAny().contains( "" ) ); assertTrue( node.getAny().contains( "guy" ) ); assertEquals( "foo", node.getInitial() ); assertEquals( "bar", node.getFinal() ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testSubstringManyAny() throws ParseException { String str = "(ou=a*b*c*d*e*f)"; SubstringNode node = ( SubstringNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof SubstringNode ); assertEquals( 4, node.getAny().size() ); assertFalse( node.getAny().contains( "" ) ); assertTrue( node.getAny().contains( "b" ) ); assertTrue( node.getAny().contains( "c" ) ); assertTrue( node.getAny().contains( "d" ) ); assertTrue( node.getAny().contains( "e" ) ); assertEquals( "a", node.getInitial() ); assertEquals( "f", node.getFinal() ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testSubstringNoIniManyAny() throws ParseException { String str = "(ou=*b*c*d*e*f)"; SubstringNode node = ( SubstringNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof SubstringNode ); assertEquals( 4, node.getAny().size() ); assertFalse( node.getAny().contains( new Value( "" ).getString() ) ); assertTrue( node.getAny().contains( "e" ) ); assertTrue( node.getAny().contains( "b" ) ); assertTrue( node.getAny().contains( "c" ) ); assertTrue( node.getAny().contains( "d" ) ); assertEquals( null, node.getInitial() ); assertEquals( "f", node.getFinal() ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testSubstringManyAnyNoFinal() throws ParseException { String str = "(ou=a*b*c*d*e*)"; SubstringNode node = ( SubstringNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof SubstringNode ); assertEquals( 4, node.getAny().size() ); assertFalse( node.getAny().contains( "" ) ); assertTrue( node.getAny().contains( "e" ) ); assertTrue( node.getAny().contains( "b" ) ); assertTrue( node.getAny().contains( "c" ) ); assertTrue( node.getAny().contains( "d" ) ); assertEquals( "a", node.getInitial() ); assertEquals( null, node.getFinal() ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testSubstringNoIniManyAnyNoFinal() throws ParseException { String str = "(ou=*b*c*d*e*)"; SubstringNode node = ( SubstringNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof SubstringNode ); assertEquals( 4, node.getAny().size() ); assertFalse( node.getAny().contains( new Value( "" ).getString() ) ); assertTrue( node.getAny().contains( "e" ) ); assertTrue( node.getAny().contains( "b" ) ); assertTrue( node.getAny().contains( "c" ) ); assertTrue( node.getAny().contains( "d" ) ); assertEquals( null, node.getInitial() ); assertEquals( null, node.getFinal() ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testSubstringNoAnyDoubleSpaceStar() throws ParseException { String str = "(ou=foo* *bar)"; SubstringNode node = ( SubstringNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof SubstringNode ); assertEquals( 1, node.getAny().size() ); assertFalse( node.getAny().contains( "" ) ); assertTrue( node.getAny().contains( " " ) ); assertEquals( "foo", node.getInitial() ); assertEquals( "bar", node.getFinal() ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testSubstringAnyDoubleSpaceStar() throws ParseException { String str = "(ou=foo* a *bar)"; SubstringNode node = ( SubstringNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof SubstringNode ); assertEquals( 1, node.getAny().size() ); assertFalse( node.getAny().contains( "" ) ); assertTrue( node.getAny().contains( " a " ) ); assertEquals( "foo", node.getInitial() ); assertEquals( "bar", node.getFinal() ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testSubstringStarAnyStar() throws ParseException { String str = "(ou=*foo*)"; SubstringNode node = ( SubstringNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof SubstringNode ); assertEquals( 1, node.getAny().size() ); assertTrue( node.getAny().contains( "foo" ) ); assertNull( node.getInitial() ); assertNull( node.getFinal() ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testTwoByteUTF8Raw() throws ParseException { byte[] bytes = { ( byte ) 0xC2, ( byte ) 0xA2 }; new String( bytes, StandardCharsets.UTF_8 ); String str = "(cn=\\C2\\A2)"; SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "cn", node.getAttribute() ); String val = node.getValue().getString(); assertEquals( "a2", Integer.toHexString( val.charAt( 0 ) ) ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testTwoByteUTF8Escaped() throws ParseException { byte[] bytes = { ( byte ) 0xC2, ( byte ) 0xA2 }; String str = "(cn=\\C2\\A2)"; new String( bytes, StandardCharsets.UTF_8 ); SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "cn", node.getAttribute() ); String val = node.getValue().getString(); assertEquals( "a2", Integer.toHexString( val.charAt( 0 ) ) ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testThreeByteUTF8Raw() throws ParseException { byte[] bytes = { ( byte ) 0xE2, ( byte ) 0x89, ( byte ) 0xA0 }; new String( bytes, StandardCharsets.UTF_8 ); String str = "(cn=\\E2\\89\\A0)"; SimpleNode<?> node = (SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "cn", node.getAttribute() ); String val = node.getValue().getString(); assertEquals( "2260", Integer.toHexString( val.charAt( 0 ) ) ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testThreeByteUTF8Escaped() throws ParseException { byte[] bytes = { ( byte ) 0xE2, ( byte ) 0x89, ( byte ) 0xA0 }; String str = "(cn=\\E2\\89\\A0aa)"; String strEscaped = "(cn=\\E2\\89\\A0\\61\\61)"; new String( bytes, StandardCharsets.UTF_8 ); SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "cn", node.getAttribute() ); String val = node.getValue().getString(); assertEquals( "2260", Integer.toHexString( val.charAt( 0 ) ) ); String str2 = node.toString(); assertEquals( strEscaped, str2 ); }
@Test public void testThreeByteJapaneseUTF8Raw() throws ParseException { byte[] bytes = { ( byte ) 0xE3, ( byte ) 0x81, ( byte ) 0x99 }; new String( bytes, StandardCharsets.UTF_8 ); String str = "(cn=\\E3\\81\\99)"; SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "cn", node.getAttribute() ); String val = node.getValue().getString(); assertEquals( "3059", Integer.toHexString( val.charAt( 0 ) ) ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testThreeByteJapaneseUTF8Escaped() throws ParseException { byte[] bytes = { ( byte ) 0xE3, ( byte ) 0x81, ( byte ) 0x99 }; String str = "(cn=\\E3\\81\\99)"; new String( bytes, StandardCharsets.UTF_8 ); SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "cn", node.getAttribute() ); String val = node.getValue().getString(); assertEquals( "3059", Integer.toHexString( val.charAt( 0 ) ) ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testEqualsFilterWithPoundInValue() throws ParseException { String str = "(uid=#f1)"; SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str ); assertEquals( "uid", node.getAttribute() ); assertEquals( "#f1", node.getValue().getString() ); assertTrue( node instanceof EqualityNode ); assertEquals( str, node.toString() ); }
@Test public void testSpecialCharsInMemberOf() { try { FilterParser .parse( "(memberOf=1.2.840.113556.1.4.1301=$#@&*()==,2.5.4.11=local,2.5.4.11=users,2.5.4.11=readimanager)" ); fail(); } catch ( ParseException pe ) { assertTrue( true ); } }
@Test public void testAndEqOr_EqEq() { try { BranchNode node = ( BranchNode ) FilterParser .parse( "(&(objectClass=nisNetgroup)(|(nisNetGroupTriple=a*a)(nisNetGroupTriple=\\28*,acc1,*\\29)))" ); assertEquals( 2, node.getChildren().size() ); assertTrue( node instanceof AndNode ); ExprNode aEqb = node.getFirstChild(); assertTrue( aEqb instanceof EqualityNode ); assertEquals( "objectClass", ( ( EqualityNode<?> ) aEqb ).getAttribute() ); assertEquals( "nisNetgroup", ( ( EqualityNode<?> ) aEqb ).getValue().getString() ); ExprNode orNode = node.getChildren().get( 1 ); assertTrue( orNode instanceof OrNode ); assertEquals( 2, ( ( OrNode ) orNode ).getChildren().size() ); ExprNode leftNode = ( ( OrNode ) orNode ).getChildren().get( 0 ); assertTrue( leftNode instanceof SubstringNode ); assertEquals( "nisNetGroupTriple", ( ( SubstringNode ) leftNode ).getAttribute() ); assertEquals( "a", ( ( SubstringNode ) leftNode ).getInitial() ); assertEquals( 0, ( ( SubstringNode ) leftNode ).getAny().size() ); assertEquals( "a", ( ( SubstringNode ) leftNode ).getFinal() ); ExprNode rightNode = ( ( OrNode ) orNode ).getChildren().get( 1 ); assertTrue( rightNode instanceof SubstringNode ); assertEquals( "nisNetGroupTriple", ( ( SubstringNode ) rightNode ).getAttribute() ); assertEquals( "(", ( ( SubstringNode ) rightNode ).getInitial() ); assertEquals( 1, ( ( SubstringNode ) rightNode ).getAny().size() ); assertEquals( ",acc1,", ( ( SubstringNode ) rightNode ).getAny().get( 0 ) ); assertEquals( ")", ( ( SubstringNode ) rightNode ).getFinal() ); } catch ( ParseException pe ) { assertTrue( true ); } }
@Test public void testObjectClassAndFilterWithSpaces() throws ParseException { String str = "(&(objectClass=person)(objectClass=organizationalUnit))"; BranchNode node = ( BranchNode ) FilterParser.parse( str ); assertEquals( 2, node.getChildren().size() ); assertTrue( node instanceof AndNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testQuotedChars() throws ParseException { String str = "(cn='~%\\28'$'\\5C)"; ExprNode node = FilterParser.parse( str ); assertTrue( node instanceof EqualityNode ); assertEquals( "'~%('$'\\", ( ( EqualityNode<?> ) node ).getValue().getString() ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testQuotedCharsCase() throws ParseException { String str = "(cn='~%\\28'$'\\5Cac)"; ExprNode node = FilterParser.parse( str ); assertTrue( node instanceof EqualityNode ); assertEquals( "'~%('$'\\ac", ( ( EqualityNode<?> ) node ).getValue().getString() ); String str2 = node.toString(); assertEquals( Strings.upperCase( str ), Strings.upperCase( str2 ) ); }
@Test public void testQuotedSubstringManyAny() throws ParseException { String str = "(ou=\\5C*\\00*\\3D*\\2Abb)"; SubstringNode node = ( SubstringNode ) FilterParser.parse( str ); assertEquals( "ou", node.getAttribute() ); assertTrue( node instanceof SubstringNode ); assertEquals( 2, node.getAny().size() ); assertFalse( node.getAny().contains( "" ) ); assertEquals( "\\", node.getInitial() ); assertTrue( node.getAny().contains( "\0" ) ); assertTrue( node.getAny().contains( "=" ) ); assertEquals( "*bb", node.getFinal() ); String str2 = node.toString(); assertEquals( "(ou=\\5C*\\00*=*\\2Abb)", str2 ); }
@Test public void testBinaryValueEscaped() throws ParseException { String str = "(objectguid=\\29\\4C\\04\\B5\\D4\\ED\\38\\46\\87\\EE\\77\\58\\5C\\32\\AD\\91)"; FilterParser.parse( str ); }
@Test public void testAndFilterFollowed() throws ParseException { String str = "(&(ou~=people)(age>=30))} some more text"; BranchNode node = ( BranchNode ) FilterParser.parse( str ); assertEquals( 2, node.getChildren().size() ); assertTrue( node instanceof AndNode ); String str2 = node.toString(); assertTrue( str.startsWith( str2 ) ); assertEquals( "(&(ou~=people)(age>=30))", str2 ); }
@Test public void testFilterOrder() throws ParseException { String filterStr1 = "(&(&(jagplayUserGroup=Active)(!(jagplayUserGroup=Banned))(jagplayUserNickname=admin)))"; String filterStr2 = "(&(jagplayUserNickname=admin)(&(jagplayUserGroup=Active)(!(jagplayUserGroup=Banned)))) "; BranchNode node1 = ( BranchNode ) FilterParser.parse( filterStr1 ); BranchNode node2 = ( BranchNode ) FilterParser.parse( filterStr2 ); assertEquals( 1, node1.getChildren().size() ); assertTrue( node1 instanceof AndNode ); ExprNode andNode1 = node1.getChildren().get( 0 ); assertTrue( andNode1 instanceof AndNode ); List<ExprNode> children1 = ( ( AndNode ) andNode1 ).getChildren(); assertEquals( 3, children1.size() ); ExprNode child1 = children1.get( 0 ); assertTrue( child1 instanceof EqualityNode ); assertEquals( "jagplayUserGroup", ( ( EqualityNode<?> ) child1 ).getAttribute() ); assertEquals( "Active", ( ( EqualityNode<?> ) child1 ).getValue().getString() ); ExprNode child2 = children1.get( 1 ); assertTrue( child2 instanceof NotNode ); NotNode notNode1 = ( NotNode ) child2; ExprNode notNodeChild1 = notNode1.getFirstChild(); assertTrue( notNodeChild1 instanceof EqualityNode ); assertEquals( "jagplayUserGroup", ( ( EqualityNode<?> ) notNodeChild1 ).getAttribute() ); assertEquals( "Banned", ( ( EqualityNode<?> ) notNodeChild1 ).getValue().getString() ); ExprNode child3 = children1.get( 2 ); assertTrue( child3 instanceof EqualityNode ); assertEquals( "jagplayUserNickname", ( ( EqualityNode<?> ) child3 ).getAttribute() ); assertEquals( "admin", ( ( EqualityNode<?> ) child3 ).getValue().getString() ); assertEquals( 2, node2.getChildren().size() ); assertTrue( node2 instanceof AndNode ); child1 = node2.getChildren().get( 0 ); assertTrue( child1 instanceof EqualityNode ); assertEquals( "jagplayUserNickname", ( ( EqualityNode<?> ) child1 ).getAttribute() ); assertEquals( "admin", ( ( EqualityNode<?> ) child1 ).getValue().getString() ); child2 = node2.getChildren().get( 1 ); assertTrue( child2 instanceof AndNode ); AndNode andNode2 = ( ( AndNode ) child2 ); assertEquals( 2, andNode2.getChildren().size() ); child1 = andNode2.getChildren().get( 0 ); assertTrue( child1 instanceof EqualityNode ); assertEquals( "jagplayUserGroup", ( ( EqualityNode<?> ) child1 ).getAttribute() ); assertEquals( "Active", ( ( EqualityNode<?> ) child1 ).getValue().getString() ); child2 = andNode2.getChildren().get( 1 ); assertTrue( child2 instanceof NotNode ); notNode1 = ( NotNode ) child2; notNodeChild1 = notNode1.getFirstChild(); assertTrue( notNodeChild1 instanceof EqualityNode ); assertEquals( "jagplayUserGroup", ( ( EqualityNode<?> ) notNodeChild1 ).getAttribute() ); assertEquals( "Banned", ( ( EqualityNode<?> ) notNodeChild1 ).getValue().getString() ); }
@Test public void testEqualsFilterWithUnderscoreRelaxed() throws ParseException { String str = "(a_b_=people)"; SimpleNode<?> node = ( SimpleNode<?> ) FilterParser.parse( str, true ); assertEquals( "a_b_", node.getAttribute() ); assertEquals( "people", node.getValue().getString() ); assertTrue( node instanceof EqualityNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testEqualsFilterWithUnderscoreNotRelaxed() throws ParseException { String str = "(a_b_=people)"; assertThrows( ParseException.class, () -> { FilterParser.parse( str, false ); } ); }
@Test public void testAndFilterWithUnderscoreRelaxed() throws ParseException { String str = "(&(o_u~=people)(a_g_e>=30))"; BranchNode node = ( BranchNode ) FilterParser.parse( str, true ); assertEquals( 2, node.getChildren().size() ); assertTrue( node instanceof AndNode ); String str2 = node.toString(); assertEquals( str, str2 ); }
@Test public void testAndFilterWithUnderscoreNotRelaxed() throws ParseException { String str = "(&(o_u~=people)(a_g_e>=30))"; assertThrows( ParseException.class, () -> { FilterParser.parse( str, false ); } ); }
@Test public void testRelaxedFilterParse() throws ParseException { String str = " ( cn =*) "; ExprNode node = FilterParser.parse( str, false ); assertTrue( node instanceof PresenceNode ); assertEquals( "cn", ((PresenceNode)node).attribute ); str = " ( & ( cn =*) ) "; node = FilterParser.parse( str, false ); assertTrue( node instanceof AndNode ); assertEquals( 1, ((AndNode)node).children.size() ); ExprNode child = ((AndNode)node).children.get( 0 ); assertTrue( child instanceof PresenceNode ); assertEquals( "cn", ((PresenceNode)child).attribute ); } |
Oid { public static Oid fromString( String oidString ) throws DecoderException { if ( ( oidString == null ) || oidString.isEmpty() ) { throw new DecoderException( I18n.err( I18n.ERR_00003_INVALID_OID, "empty" ) ); } byte[] buffer = new byte[oidString.length()]; OidFSAState state = OidFSAState.START; int arcNbChars = 0; int bufPos = 0; int startArc = 0; int nbBytes; for ( int i = 0; i < oidString.length(); i++ ) { switch ( state ) { case START : state = processStateStart( oidString, buffer, i ); break; case STATE_A : state = processStateA( oidString, i ); break; case STATE_B : state = processStateB( oidString, buffer, i ); break; case STATE_C : state = processStateC( oidString, buffer, i ); bufPos = 1; break; case STATE_D : case STATE_E : state = processStateDE( oidString, buffer, i ); bufPos = 1; break; case STATE_F : state = processStateF( oidString, i ); break; case STATE_G : state = processStateG( oidString, buffer, i ); arcNbChars = 1; startArc = i; break; case STATE_H : state = processStateH( oidString, buffer, i ); if ( state == OidFSAState.STATE_J ) { arcNbChars = 2; bufPos = 0; } break; case STATE_I : state = processStateI( oidString, buffer, i ); bufPos = 1; break; case STATE_J : state = processStateJ( oidString, buffer, arcNbChars + bufPos, i ); if ( state == OidFSAState.STATE_J ) { arcNbChars++; } else { bufPos += convert( oidString, buffer, bufPos, arcNbChars, 0, true ); } break; case STATE_K : startArc = i; state = processStateK( oidString, buffer, bufPos, i ); if ( state == OidFSAState.STATE_M ) { bufPos++; } else { arcNbChars = 1; } break; case STATE_L : state = processStateL( oidString, buffer, arcNbChars + bufPos, i ); if ( state == OidFSAState.STATE_L ) { arcNbChars++; break; } else { bufPos += convert( oidString, buffer, startArc, arcNbChars, bufPos, false ); } break; case STATE_M : state = processStateM( oidString, i ); break; default : break; } } switch ( state ) { case STATE_C : case STATE_D : case STATE_E : case STATE_H : case STATE_I : byte[] bytes = new byte[1]; bytes[0] = ( byte ) ( buffer[0] | buffer[1] ); return new Oid( oidString, bytes ); case STATE_J : nbBytes = convert( oidString, buffer, 2, arcNbChars, 0, true ); bytes = new byte[nbBytes]; System.arraycopy( buffer, 0, bytes, 0, nbBytes ); return new Oid( oidString, bytes ); case STATE_L : bufPos += convert( oidString, buffer, startArc, arcNbChars, bufPos, false ); bytes = new byte[bufPos]; System.arraycopy( buffer, 0, bytes, 0, bufPos ); return new Oid( oidString, bytes ); case STATE_M : bytes = new byte[bufPos]; System.arraycopy( buffer, 0, bytes, 0, bufPos ); return new Oid( oidString, bytes ); default : throw new DecoderException( I18n.err( I18n.ERR_00003_INVALID_OID, "Wrong OID" ) ); } } private Oid( String oidString, byte[] oidBytes ); @Override boolean equals( Object other ); static Oid fromBytes( byte[] oidBytes ); static Oid fromString( String oidString ); int getEncodedLength(); @Override int hashCode(); static boolean isOid( String oidString ); byte[] toBytes(); @Override String toString(); void writeBytesTo( ByteBuffer buffer ); void writeBytesTo( OutputStream outputStream ); } | @Test public void fromString() throws DecoderException { for ( int i = 0; i < 2; i++ ) { for ( int j = 0; j < 40; j++ ) { String oidStr = i + "." + j; byte[] expected = new byte[]{ ( byte ) ( i * 40 + j ) }; byte[] oidBytes = Oid.fromString( oidStr ).toBytes(); assertTrue( Arrays.equals( expected, oidBytes ) ); } } assertTrue( Arrays.equals( new byte[] { 0x2A, ( byte ) 0x86, 0x48, ( byte ) 0x86, ( byte ) 0xF7, 0x12, 0x01, 0x02, 0x02 }, Oid.fromString( "1.2.840.113554.1.2.2" ).toBytes() ) ); } |
SubstringNode extends LeafNode { public static Pattern getRegex( String initialPattern, String[] anyPattern, String finalPattern ) { StringBuilder buf = new StringBuilder(); if ( initialPattern != null ) { buf.append( '^' ).append( Pattern.quote( initialPattern ) ); } if ( anyPattern != null ) { for ( int i = 0; i < anyPattern.length; i++ ) { buf.append( ".*" ).append( Pattern.quote( anyPattern[i] ) ); } } if ( finalPattern != null ) { buf.append( ".*" ).append( Pattern.quote( finalPattern ) ); } else { buf.append( ".*" ); } return Pattern.compile( buf.toString() ); } SubstringNode( AttributeType attributeType, String initialPattern, String finalPattern ); SubstringNode( String attribute, String initialPattern, String finalPattern ); SubstringNode( AttributeType attribute ); SubstringNode( String attributeType ); SubstringNode( List<String> anyPattern, AttributeType attributeType, String initialPattern,
String finalPattern ); SubstringNode( List<String> anyPattern, String attribute, String initialPattern, String finalPattern ); static Pattern getRegex( String initialPattern, String[] anyPattern, String finalPattern ); @Override ExprNode clone(); final String getInitial(); void setInitial( String initialPattern ); final String getFinal(); void setFinal( String finalPattern ); final List<String> getAny(); void setAny( List<String> anyPattern ); void addAny( String anyPattern ); final Pattern getRegex( Normalizer normalizer ); @Override boolean equals( Object obj ); @Override int hashCode(); @Override String toString(); } | @Test public void testGetRegexpEmpty() throws Exception { Pattern pattern = SubstringNode.getRegex( "", new String[] { "" }, "" ); boolean b1 = pattern.matcher( "" ).matches(); assertTrue( b1 ); }
@Test public void testGetRegexpInitial() throws Exception { Pattern pattern = SubstringNode.getRegex( "Test", new String[] { "" }, "" ); boolean b1 = pattern.matcher( "Test just a test" ).matches(); assertTrue( b1 ); boolean b3 = pattern.matcher( "test just a test" ).matches(); assertFalse( b3 ); }
@Test public void testGetRegexpFinal() throws Exception { Pattern pattern = SubstringNode.getRegex( "", new String[] { "" }, "Test" ); boolean b1 = pattern.matcher( "test just a Test" ).matches(); assertTrue( b1 ); boolean b3 = pattern.matcher( "test just a test" ).matches(); assertFalse( b3 ); }
@Test public void testGetRegexpAny() throws Exception { Pattern pattern = SubstringNode.getRegex( "", new String[] { "just", "a" }, "" ); boolean b1 = pattern.matcher( "test just a Test" ).matches(); assertTrue( b1 ); boolean b3 = pattern.matcher( "test just A test" ).matches(); assertFalse( b3 ); }
@Test public void testGetRegexpFull() throws Exception { Pattern pattern = SubstringNode.getRegex( "Test", new String[] { "just", "a" }, "test" ); boolean b1 = pattern.matcher( "Test (this is) just (truly !) a (little) test" ).matches(); assertTrue( b1 ); boolean b3 = pattern.matcher( "Test (this is) just (truly !) A (little) test" ).matches(); assertFalse( b3 ); }
@Test public void testGetRegexpWithLdapFilterSpecialChars() throws Exception { Pattern[] patterns = new Pattern[] { SubstringNode.getRegex( null, new String[] { "(" }, null ), SubstringNode.getRegex( null, new String[] { ")" }, null ), SubstringNode.getRegex( null, new String[] { "*" }, null ), SubstringNode.getRegex( null, new String[] { "\\" }, null ), }; for ( Pattern pattern : patterns ) { boolean b1 = pattern.matcher( "a(b*c\\d)e" ).matches(); assertTrue( b1 ); boolean b3 = pattern.matcher( "Test test" ).matches(); assertFalse( b3 ); } } |
FilterEncoder { public static String format( String filterTemplate, String... values ) { if ( values == null ) { values = Strings.EMPTY_STRING_ARRAY; } MessageFormat mf = new MessageFormat( filterTemplate, Locale.ROOT ); Format[] formats = mf.getFormatsByArgumentIndex(); if ( formats.length != values.length ) { throw new IllegalArgumentException( I18n.err( I18n.ERR_13300_BAD_PLACE_HOLDERS_NUMBER, filterTemplate, formats.length, values.length ) ); } for ( int i = 0; i < values.length; i++ ) { values[i] = encodeFilterValue( values[i] ); } return mf.format( values ); } private FilterEncoder(); static String format( String filterTemplate, String... values ); static String encodeFilterValue( String value ); } | @Test public void testFormatWithNoPlaceholdersAndCorrectArgumentCount() { assertEquals( "(cn=foo)", FilterEncoder.format( "(cn=foo)", (String[])null ) ); assertEquals( "(cn=foo)", FilterEncoder.format( "(cn=foo)", ZERO ) ); }
@Test public void testFormatWithNoPlaceholdersAndTooManyArguments() { assertThrows( IllegalArgumentException.class, () -> { FilterEncoder.format( "(cn=foo)", ONE ); } ); }
@Test public void testFormatWithPlaceholdersAndTooFewArguments() { assertThrows( IllegalArgumentException.class, () -> { FilterEncoder.format( "(cn={0})", ZERO ); } ); }
@Test public void testFormatWithPlaceholdersAndCorrectArgumentCount() { assertEquals( "(cn=foo)", FilterEncoder.format( "(cn={0})", ONE ) ); assertEquals( "(&(cn=foo)(uid=bar))", FilterEncoder.format( "(&(cn={0})(uid={1}))", TWO ) ); }
@Test public void testFormatWithPlaceholdersAndTooManyArguments() { assertThrows( IllegalArgumentException.class, () -> { FilterEncoder.format( "(cn={0})", TWO ); } ); }
@Test public void testFormatWithPlaceholdersAndSpecialChars() { assertEquals( "(cn=\\28\\5C\\2A\\00\\29)", FilterEncoder.format( "(cn={0})", SPECIAL_CHARS ) ); }
@Test public void testExceptionMessage() { try { FilterEncoder.format( "(&(cn={0})(uid={1}))", ONE ); fail( "IllegalArgumentException expected" ); } catch ( IllegalArgumentException e ) { String message = e.getMessage(); assertTrue( message.contains( " (&(cn={0})(uid={1})) " ) ); assertTrue( message.contains( " 2 " ) ); assertTrue( message.contains( " 1 " ) ); } } |
FilterEncoder { public static String encodeFilterValue( String value ) { StringBuilder sb = new StringBuilder( value.length() ); boolean escaped = false; boolean hexPair = false; char hex = '\0'; for ( int i = 0; i < value.length(); i++ ) { char ch = value.charAt( i ); switch ( ch ) { case '*': if ( escaped ) { sb.append( "\\5C" ); if ( hexPair ) { sb.append( hex ); hexPair = false; } escaped = false; } sb.append( "\\2A" ); break; case '(': if ( escaped ) { sb.append( "\\5C" ); if ( hexPair ) { sb.append( hex ); hexPair = false; } escaped = false; } sb.append( "\\28" ); break; case ')': if ( escaped ) { sb.append( "\\5C" ); if ( hexPair ) { sb.append( hex ); hexPair = false; } escaped = false; } sb.append( "\\29" ); break; case '\0': if ( escaped ) { sb.append( "\\5C" ); if ( hexPair ) { sb.append( hex ); hexPair = false; } escaped = false; } sb.append( "\\00" ); break; case '\\': if ( escaped ) { sb.append( "\\5C" ); escaped = false; } else { escaped = true; hexPair = false; } break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': if ( escaped ) { if ( hexPair ) { sb.append( '\\' ).append( hex ).append( ch ); escaped = false; hexPair = false; } else { hexPair = true; hex = ch; } } else { sb.append( ch ); } break; default: if ( escaped ) { sb.append( "\\5C" ); if ( hexPair ) { sb.append( hex ); hexPair = false; } escaped = false; } sb.append( ch ); } } if ( escaped ) { sb.append( "\\5C" ); } return sb.toString(); } private FilterEncoder(); static String format( String filterTemplate, String... values ); static String encodeFilterValue( String value ); } | @Test public void testEncodeFilterValue() { assertEquals( "1234567890", FilterEncoder.encodeFilterValue( "1234567890" ) ); assertEquals( "\\28", FilterEncoder.encodeFilterValue( "(" ) ); assertEquals( "\\29", FilterEncoder.encodeFilterValue( ")" ) ); assertEquals( "\\2A", FilterEncoder.encodeFilterValue( "*" ) ); assertEquals( "\\5C", FilterEncoder.encodeFilterValue( "\\" ) ); assertEquals( "\\00", FilterEncoder.encodeFilterValue( "\0" ) ); assertEquals( "\\28\\2A\\29", FilterEncoder.encodeFilterValue( "(*)" ) ); assertEquals( "a test \\2A \\5Cend", FilterEncoder.encodeFilterValue( "a test \\2A \\end" ) ); } |
PasswordUtil { public static boolean compareCredentials( byte[] receivedCredentials, byte[] storedCredentials ) { LdapSecurityConstants algorithm = findAlgorithm( storedCredentials ); if ( algorithm != null ) { PasswordDetails passwordDetails = PasswordUtil.splitCredentials( storedCredentials ); byte[] userPassword = PasswordUtil.encryptPassword( receivedCredentials, passwordDetails.getAlgorithm(), passwordDetails.getSalt() ); return compareBytes( userPassword, passwordDetails.getPassword() ); } else { return compareBytes( receivedCredentials, storedCredentials ); } } private PasswordUtil(); static LdapSecurityConstants findAlgorithm( byte[] credentials ); static byte[] createStoragePassword( String credentials, LdapSecurityConstants algorithm ); static byte[] createStoragePassword( byte[] credentials, LdapSecurityConstants algorithm ); static boolean compareCredentials( byte[] receivedCredentials, byte[] storedCredentials ); static PasswordDetails splitCredentials( byte[] credentials ); static boolean isPwdExpired( String pwdChangedZtime, int pwdMaxAgeSec, TimeProvider timeProvider ); static final int SHA1_LENGTH; static final int SHA256_LENGTH; static final int SHA384_LENGTH; static final int SHA512_LENGTH; static final int MD5_LENGTH; static final int PKCS5S2_LENGTH; static final int CRYPT_LENGTH; static final int CRYPT_MD5_LENGTH; static final int CRYPT_SHA256_LENGTH; static final int CRYPT_SHA512_LENGTH; static final int CRYPT_BCRYPT_LENGTH; } | @Test public void compareCredentialTest() { assertTrue( PasswordUtil.compareCredentials( null, null ) ); assertTrue( PasswordUtil.compareCredentials( new byte[] {}, new byte[] {} ) ); assertTrue( PasswordUtil.compareCredentials( new byte[] { 0x01 }, new byte[] { 0x01 } ) ); assertFalse( PasswordUtil.compareCredentials( null, new byte[] { 0x01 } ) ); assertFalse( PasswordUtil.compareCredentials( new byte[] { 0x01 }, null ) ); assertFalse( PasswordUtil.compareCredentials( new byte[] { 0x01 }, new byte[] { 0x02 } ) ); assertFalse( PasswordUtil.compareCredentials( Strings.getBytesUtf8( "Password1" ), Strings.getBytesUtf8( "Password1 " ) ) ); assertFalse( PasswordUtil.compareCredentials( Strings.getBytesUtf8( "Password1" ), Strings.getBytesUtf8( "password1" ) ) ); assertTrue( PasswordUtil.compareCredentials( Strings.getBytesUtf8( "Password1" ), Strings.getBytesUtf8( "Password1" ) ) ); } |
AttributeUtils { public static void applyModification( Entry entry, Modification modification ) throws LdapException { Attribute modAttr = modification.getAttribute(); String modificationId = modAttr.getUpId(); switch ( modification.getOperation() ) { case ADD_ATTRIBUTE: Attribute modifiedAttr = entry.get( modificationId ); if ( modifiedAttr == null ) { entry.put( modAttr ); } else { for ( Value value : modAttr ) { modifiedAttr.add( value ); } } break; case REMOVE_ATTRIBUTE: if ( modAttr.get() == null ) { entry.removeAttributes( modificationId ); } else { modifiedAttr = entry.get( modificationId ); if ( modifiedAttr == null ) { break; } for ( Value value : modAttr ) { modifiedAttr.remove( value ); } if ( modifiedAttr.size() == 0 ) { entry.removeAttributes( modifiedAttr.getUpId() ); } } break; case REPLACE_ATTRIBUTE: if ( modAttr.get() == null ) { entry.removeAttributes( modificationId ); } else { entry.put( modAttr ); } break; default: break; } } private AttributeUtils(); static boolean containsValueCaseIgnore( javax.naming.directory.Attribute attr, Object value ); static Attributes toCaseInsensitive( Attributes attributes ); static String parseAttribute( char[] str, Position pos, boolean withOption, boolean relaxed ); static String parseAttribute( byte[] bytes, Position pos, boolean withOption, boolean relaxed ); static void applyModification( Entry entry, Modification modification ); static Entry toEntry( Attributes attributes, Dn dn ); static Attributes toAttributes( Entry entry ); static javax.naming.directory.Attribute toJndiAttribute( Attribute attribute ); static Attribute toApiAttribute( javax.naming.directory.Attribute jndiAttribute ); } | @Test public void testApplyAddModificationToEmptyEntry() throws LdapException { Entry entry = new DefaultEntry(); Attribute attr = new DefaultAttribute( "cn", "test" ); Modification modification = new DefaultModification( ModificationOperation.ADD_ATTRIBUTE, attr ); AttributeUtils.applyModification( entry, modification ); assertNotNull( entry.get( "cn" ) ); assertEquals( 1, entry.size() ); assertEquals( attr, entry.get( "cn" ) ); }
@Test public void testApplyAddModificationToEntry() throws LdapException { Entry entry = new DefaultEntry(); entry.add( "dc", "apache" ); assertEquals( 1, entry.size() ); Attribute attr = new DefaultAttribute( "cn", "test" ); Modification modification = new DefaultModification( ModificationOperation.ADD_ATTRIBUTE, attr ); AttributeUtils.applyModification( entry, modification ); assertNotNull( entry.get( "cn" ) ); assertEquals( 2, entry.size() ); assertEquals( attr, entry.get( "cn" ) ); }
@Test public void testApplyAddModificationToEntryWithValues() throws LdapException { Entry entry = new DefaultEntry(); entry.put( "cn", "apache" ); assertEquals( 1, entry.size() ); Attribute attr = new DefaultAttribute( "cn", "test" ); Modification modification = new DefaultModification( ModificationOperation.ADD_ATTRIBUTE, attr ); AttributeUtils.applyModification( entry, modification ); assertNotNull( entry.get( "cn" ) ); assertEquals( 1, entry.size() ); Attribute attribute = entry.get( "cn" ); assertTrue( attribute.size() != 0 ); Set<String> expectedValues = new HashSet<String>(); expectedValues.add( "apache" ); expectedValues.add( "test" ); for ( Value value : attribute ) { String valueStr = value.getString(); assertTrue( expectedValues.contains( valueStr ) ); expectedValues.remove( valueStr ); } assertEquals( 0, expectedValues.size() ); }
@Test public void testApplyAddModificationToEntryWithSameValue() throws LdapException { Entry entry = new DefaultEntry(); entry.put( "cn", "test", "apache" ); assertEquals( 1, entry.size() ); Attribute attr = new DefaultAttribute( "cn", "test" ); Modification modification = new DefaultModification( ModificationOperation.ADD_ATTRIBUTE, attr ); AttributeUtils.applyModification( entry, modification ); assertNotNull( entry.get( "cn" ) ); assertEquals( 1, entry.size() ); Attribute cnAttr = entry.get( "cn" ); assertTrue( cnAttr.size() != 0 ); Set<String> expectedValues = new HashSet<String>(); expectedValues.add( "apache" ); expectedValues.add( "test" ); for ( Value value : cnAttr ) { String valueStr = value.getString(); assertTrue( expectedValues.contains( valueStr ) ); expectedValues.remove( valueStr ); } assertEquals( 0, expectedValues.size() ); }
@Test public void testApplyRemoveModificationFromEmptyEntry() throws LdapException { Entry entry = new DefaultEntry(); Attribute attr = new DefaultAttribute( "cn", "test" ); Modification modification = new DefaultModification( ModificationOperation.REMOVE_ATTRIBUTE, attr ); AttributeUtils.applyModification( entry, modification ); assertNull( entry.get( "cn" ) ); assertEquals( 0, entry.size() ); }
@Test public void testApplyRemoveModificationFromEntryAttributeNotPresent() throws LdapException { Entry entry = new DefaultEntry(); Attribute dc = new DefaultAttribute( "dc", "apache" ); entry.put( dc ); Attribute cn = new DefaultAttribute( "cn", "test" ); Modification modification = new DefaultModification( ModificationOperation.REMOVE_ATTRIBUTE, cn ); AttributeUtils.applyModification( entry, modification ); assertNull( entry.get( "cn" ) ); assertNotNull( entry.get( "dc" ) ); assertEquals( 1, entry.size() ); assertEquals( dc, entry.get( "dc" ) ); }
@Test public void testApplyRemoveModificationFromEntryAttributeNotSameValue() throws LdapException { Entry entry = new DefaultEntry(); Attribute cn = new DefaultAttribute( "cn", "apache" ); entry.put( cn ); Attribute attr = new DefaultAttribute( "cn", "test" ); Modification modification = new DefaultModification( ModificationOperation.REMOVE_ATTRIBUTE, attr ); AttributeUtils.applyModification( entry, modification ); assertNotNull( entry.get( "cn" ) ); assertEquals( 1, entry.size() ); assertEquals( cn, entry.get( "cn" ) ); }
@Test public void testApplyRemoveModificationFromEntrySameAttributeSameValue() throws LdapException { Entry entry = new DefaultEntry(); entry.put( "cn", "test" ); Attribute attr = new DefaultAttribute( "cn", "test" ); Modification modification = new DefaultModification( ModificationOperation.REMOVE_ATTRIBUTE, attr ); AttributeUtils.applyModification( entry, modification ); assertNull( entry.get( "cn" ) ); assertEquals( 0, entry.size() ); }
@Test public void testApplyRemoveModificationFromEntrySameAttributeValues() throws LdapException { Entry entry = new DefaultEntry(); entry.put( "cn", "test", "apache" ); Attribute attr = new DefaultAttribute( "cn", "test" ); Modification modification = new DefaultModification( ModificationOperation.REMOVE_ATTRIBUTE, attr ); AttributeUtils.applyModification( entry, modification ); assertNotNull( entry.get( "cn" ) ); assertEquals( 1, entry.size() ); Attribute modifiedAttr = entry.get( "cn" ); assertTrue( modifiedAttr.size() != 0 ); boolean isFirst = true; for ( Value value : modifiedAttr ) { assertTrue( isFirst ); isFirst = false; assertEquals( "apache", value.getString() ); } }
@Test public void testApplyModifyModificationFromEmptyEntry() throws LdapException { Entry entry = new DefaultEntry(); Attribute attr = new DefaultAttribute( "cn", "test" ); Modification modification = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, attr ); AttributeUtils.applyModification( entry, modification ); assertNotNull( entry.get( "cn" ) ); assertEquals( 1, entry.size() ); }
@Test public void testApplyModifyEmptyModificationFromEmptyEntry() throws LdapException { Entry entry = new DefaultEntry(); Attribute attr = new DefaultAttribute( "cn" ); Modification modification = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, attr ); AttributeUtils.applyModification( entry, modification ); assertNull( entry.get( "cn" ) ); assertEquals( 0, entry.size() ); }
@Test public void testApplyModifyAttributeModification() throws LdapException { Entry entry = new DefaultEntry(); entry.put( "cn", "test" ); entry.put( "ou", "apache", "acme corp" ); Attribute newOu = new DefaultAttribute( "ou", "Big Company", "directory" ); Modification modification = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, newOu ); AttributeUtils.applyModification( entry, modification ); assertEquals( 2, entry.size() ); assertNotNull( entry.get( "cn" ) ); assertNotNull( entry.get( "ou" ) ); Attribute modifiedAttr = entry.get( "ou" ); assertTrue( modifiedAttr.size() != 0 ); Set<String> expectedValues = new HashSet<String>(); expectedValues.add( "Big Company" ); expectedValues.add( "directory" ); for ( Value value : modifiedAttr ) { String valueStr = value.getString(); assertTrue( expectedValues.contains( valueStr ) ); expectedValues.remove( valueStr ); } assertEquals( 0, expectedValues.size() ); }
@Test public void testApplyModifyModificationRemoveAttribute() throws LdapException { Entry entry = new DefaultEntry(); entry.put( "cn", "test" ); entry.put( "ou", "apache", "acme corp" ); Attribute newOu = new DefaultAttribute( "ou" ); Modification modification = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, newOu ); AttributeUtils.applyModification( entry, modification ); assertEquals( 1, entry.size() ); assertNotNull( entry.get( "cn" ) ); assertNull( entry.get( "ou" ) ); } |
CsnFactory { public Csn newInstance() { int tmpChangeCount; synchronized ( lock ) { long newTimestamp = System.currentTimeMillis(); if ( lastTimestamp == newTimestamp ) { changeCount++; } else { lastTimestamp = newTimestamp; changeCount = 0; } tmpChangeCount = changeCount; } return new Csn( lastTimestamp, tmpChangeCount, replicaId, 0 ); } CsnFactory( int replicaId ); Csn newInstance(); Csn newInstance( long timestamp, int changeCount ); Csn newPurgeCsn( long expirationDate ); void setReplicaId( int replicaId ); } | @Test public void testUnique() { int replicaId = 001; CsnFactory defaultCSNFactory = new CsnFactory( replicaId ); Csn[] csns = new Csn[NUM_GENERATES]; for ( int i = 0; i < NUM_GENERATES; i++ ) { csns[i] = defaultCSNFactory.newInstance(); } for ( int i = 0; i < NUM_GENERATES; i++ ) { for ( int j = i + 1; j < NUM_GENERATES; j++ ) { assertFalse( csns[i].equals( csns[j] ) ); } } } |
Csn implements Comparable<Csn> { public Csn( long timestamp, int changeCount, int replicaId, int operationNumber ) { this.timestamp = timestamp; this.replicaId = replicaId; this.operationNumber = operationNumber; this.changeCount = changeCount; sdf.setTimeZone( UTC_TIME_ZONE ); } Csn( long timestamp, int changeCount, int replicaId, int operationNumber ); Csn( String value ); Csn( byte[] value ); static boolean isValid( String value ); byte[] getBytes(); long getTimestamp(); int getChangeCount(); int getReplicaId(); int getOperationNumber(); @Override String toString(); @Override int hashCode(); @Override boolean equals( Object o ); @Override int compareTo( Csn csn ); } | @Test public void testCSN() { synchronized ( SDF ) { long ts = System.currentTimeMillis(); Csn csn = new Csn( SDF.format( new Date( ts ) ) + "#123456#abc#654321" ); assertEquals( ts / 1000, csn.getTimestamp() / 1000 ); assertEquals( 1193046, csn.getChangeCount() ); assertEquals( 6636321, csn.getOperationNumber() ); assertEquals( 2748, csn.getReplicaId() ); } } |
Csn implements Comparable<Csn> { public static boolean isValid( String value ) { if ( Strings.isEmpty( value ) ) { return false; } char[] chars = value.toCharArray(); if ( chars.length != 40 ) { return false; } for ( int pos = 0; pos < 4; pos++ ) { if ( !Chars.isDigit( chars[pos] ) ) { return false; } } switch ( chars[4] ) { case '0' : if ( !Chars.isDigit( chars[5] ) ) { return false; } if ( chars[5] == '0' ) { return false; } break; case '1' : if ( ( chars[5] != '0' ) && ( chars[5] != '1' ) && ( chars[5] != '2' ) ) { return false; } break; default : return false; } switch ( chars[6] ) { case '0' : if ( !Chars.isDigit( chars[7] ) ) { return false; } if ( chars[7] == '0' ) { return false; } break; case '1' : case '2' : if ( !Chars.isDigit( chars[7] ) ) { return false; } break; case '3' : if ( ( chars[7] != '0' ) && ( chars[7] != '1' ) ) { return false; } break; default : return false; } switch ( chars[8] ) { case '0' : case '1' : if ( !Chars.isDigit( chars[9] ) ) { return false; } break; case '2' : if ( ( chars[9] != '0' ) && ( chars[9] != '1' ) && ( chars[9] != '2' ) && ( chars[9] != '3' ) ) { return false; } break; default : return false; } switch ( chars[10] ) { case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : break; default : return false; } if ( !Chars.isDigit( chars[11] ) ) { return false; } switch ( chars[12] ) { case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : break; default : return false; } if ( !Chars.isDigit( chars[13] ) ) { return false; } if ( chars[14] != '.' ) { return false; } for ( int i = 0; i < 6; i++ ) { if ( !Chars.isDigit( chars[15 + i] ) ) { return false; } } if ( chars[21] != 'Z' ) { return false; } if ( chars[22] != '#' ) { return false; } if ( !Chars.isHex( ( byte ) chars[23] ) || !Chars.isHex( ( byte ) chars[24] ) || !Chars.isHex( ( byte ) chars[25] ) || !Chars.isHex( ( byte ) chars[26] ) || !Chars.isHex( ( byte ) chars[27] ) || !Chars.isHex( ( byte ) chars[28] ) ) { return false; } if ( chars[29] != '#' ) { return false; } if ( !Chars.isHex( ( byte ) chars[30] ) || !Chars.isHex( ( byte ) chars[31] ) || !Chars.isHex( ( byte ) chars[32] ) ) { return false; } if ( chars[33] != '#' ) { return false; } if ( !Chars.isHex( ( byte ) chars[34] ) || !Chars.isHex( ( byte ) chars[35] ) || !Chars.isHex( ( byte ) chars[36] ) || !Chars.isHex( ( byte ) chars[37] ) || !Chars.isHex( ( byte ) chars[38] ) || !Chars.isHex( ( byte ) chars[39] ) ) { return false; } return true; } Csn( long timestamp, int changeCount, int replicaId, int operationNumber ); Csn( String value ); Csn( byte[] value ); static boolean isValid( String value ); byte[] getBytes(); long getTimestamp(); int getChangeCount(); int getReplicaId(); int getOperationNumber(); @Override String toString(); @Override int hashCode(); @Override boolean equals( Object o ); @Override int compareTo( Csn csn ); } | @Test public void testIsValidCsn() { assertTrue( Csn.isValid( "20100111202217.914000Z#000000#000#000000" ) ); } |
ListCursor extends AbstractCursor<E> { @Override public void close() throws IOException { if ( LOG_CURSOR.isDebugEnabled() ) { LOG_CURSOR.debug( I18n.msg( I18n.MSG_13101_CLOSING_LIST_CURSOR, this ) ); } super.close(); } ListCursor( Comparator<E> comparator, int start, List<E> list, int end ); ListCursor( int start, List<E> list, int end ); ListCursor( List<E> list, int end ); ListCursor( Comparator<E> comparator, List<E> list, int end ); ListCursor( int start, List<E> list ); ListCursor( Comparator<E> comparator, int start, List<E> list ); ListCursor( List<E> list ); ListCursor( Comparator<E> comparator, List<E> list ); @SuppressWarnings("unchecked") ListCursor(); @SuppressWarnings("unchecked") ListCursor( Comparator<E> comparator ); @Override boolean available(); @Override void before( E element ); @Override void after( E element ); @Override void beforeFirst(); @Override void afterLast(); @Override boolean first(); @Override boolean last(); @Override boolean isFirst(); @Override boolean isLast(); @Override boolean isAfterLast(); @Override boolean isBeforeFirst(); @Override boolean previous(); @Override boolean next(); @Override E get(); @Override void close(); @Override void close( Exception cause ); } | @Test public void testEmptyList() throws Exception { ListCursor<String> cursor = new ListCursor<String>(); cursor.close(); assertClosed( cursor, "cursor.isClosed() should return true after closing the cursor", true ); }
@Test public void testSingleElementList() throws Exception { ListCursor<String> cursor = new ListCursor<String>( Collections.singletonList( "singleton" ) ); cursor.close(); assertClosed( cursor, "cursor.isClosed() should return true after closing the cursor", true ); try { cursor = new ListCursor<String>( Collections.singletonList( "singleton" ), 0 ); cursor.close(); fail( "when the start = end bounds this is senseless and should complain" ); } catch ( IllegalArgumentException e ) { assertNotNull( e ); } try { cursor = new ListCursor<String>( 1, Collections.singletonList( "singleton" ) ); cursor.close(); fail( "when the start = end bounds this is senseless and should complain" ); } catch ( IllegalArgumentException e ) { assertNotNull( e ); } try { cursor = new ListCursor<String>( 5, Collections.singletonList( "singleton" ) ); cursor.close(); fail( "when the start = end bounds this is senseless and should complain" ); } catch ( IllegalArgumentException e ) { assertNotNull( e ); } try { cursor = new ListCursor<String>( Collections.singletonList( "singleton" ), -5 ); cursor.close(); fail( "when the start = end bounds this is senseless and should complain" ); } catch ( IllegalArgumentException e ) { assertNotNull( e ); } try { cursor = new ListCursor<String>( -5, Collections.singletonList( "singleton" ) ); cursor.close(); fail( "when the start = end bounds this is senseless and should complain" ); } catch ( IllegalArgumentException e ) { assertNotNull( e ); } try { cursor = new ListCursor<String>( Collections.singletonList( "singleton" ), 5 ); cursor.close(); fail( "when the start = end bounds this is senseless and should complain" ); } catch ( IllegalArgumentException e ) { assertNotNull( e ); } }
@Test public void testManyElementList() throws Exception { List<String> list = new ArrayList<String>(); list.add( "item 1" ); list.add( "item 2" ); list.add( "item 3" ); list.add( "item 4" ); list.add( "item 5" ); ListCursor<String> cursor = new ListCursor<String>( list ); cursor.close(); cursor = new ListCursor<String>( 1, list ); cursor.close(); cursor = new ListCursor<String>( 1, list, 4 ); cursor.close(); assertClosed( cursor, "cursor.isClosed() should return true after closing the cursor", true ); try { cursor = new ListCursor<String>( list, 0 ); cursor.close(); fail( "when the start = end bounds this is senseless and should complain" ); } catch ( IllegalArgumentException e ) { assertNotNull( e ); } try { cursor = new ListCursor<String>( 5, list ); cursor.close(); fail( "when the start = end bounds this is senseless and should complain" ); } catch ( IllegalArgumentException e ) { assertNotNull( e ); } try { cursor = new ListCursor<String>( 10, list ); cursor.close(); fail( "when the start = end bounds this is senseless and should complain" ); } catch ( IllegalArgumentException e ) { assertNotNull( e ); } try { cursor = new ListCursor<String>( list, -5 ); cursor.close(); fail( "when the start = end bounds this is senseless and should complain" ); } catch ( IllegalArgumentException e ) { assertNotNull( e ); } try { cursor = new ListCursor<String>( -5, list ); cursor.close(); fail( "when the start = end bounds this is senseless and should complain" ); } catch ( IllegalArgumentException e ) { assertNotNull( e ); } try { cursor = new ListCursor<String>( list, 10 ); cursor.close(); fail( "when the start = end bounds this is senseless and should complain" ); } catch ( IllegalArgumentException e ) { assertNotNull( e ); } } |
CsnComparator extends LdapComparator<Object> { @Override public int compare( Object csnObj1, Object csnObj2 ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13745_COMPARING_CSN, csnObj1, csnObj2 ) ); } if ( csnObj1 == csnObj2 ) { return 0; } if ( csnObj1 == null ) { return -1; } if ( csnObj2 == null ) { return 1; } String csnStr1; String csnStr2; if ( csnObj1 instanceof Value ) { csnStr1 = ( ( Value ) csnObj1 ).getString(); } else { csnStr1 = csnObj1.toString(); } if ( csnObj2 instanceof Value ) { csnStr2 = ( ( Value ) csnObj2 ).getString(); } else { csnStr2 = csnObj2.toString(); } return csnStr1.compareTo( csnStr2 ); } CsnComparator( String oid ); @Override int compare( Object csnObj1, Object csnObj2 ); } | @Test public void testNullCSNs() { assertEquals( 0, comparator.compare( null, null ) ); Csn csn2 = new Csn( System.currentTimeMillis(), 1, 1, 1 ); assertEquals( -1, comparator.compare( null, csn2.toString() ) ); assertEquals( 1, comparator.compare( csn2.toString(), null ) ); }
@Test public void testEqualsCSNs() { long t0 = System.currentTimeMillis(); Csn csn1 = new Csn( t0, 0, 0, 0 ); Csn csn2 = new Csn( t0, 0, 0, 0 ); assertEquals( 0, comparator.compare( csn1.toString(), csn2.toString() ) ); }
@Test public void testDifferentTimeStampCSNs() { long t0 = System.currentTimeMillis(); long t1 = System.currentTimeMillis() + 1000; Csn csn1 = new Csn( t0, 0, 0, 0 ); Csn csn2 = new Csn( t1, 0, 0, 0 ); assertEquals( -1, comparator.compare( csn1.toString(), csn2.toString() ) ); assertEquals( 1, comparator.compare( csn2.toString(), csn1.toString() ) ); }
@Test public void testDifferentChangeCountCSNs() { long t0 = System.currentTimeMillis(); Csn csn1 = new Csn( t0, 0, 0, 0 ); Csn csn2 = new Csn( t0, 1, 0, 0 ); assertEquals( -1, comparator.compare( csn1.toString(), csn2.toString() ) ); assertEquals( 1, comparator.compare( csn2.toString(), csn1.toString() ) ); }
@Test public void testDifferentReplicaIdCSNs() { long t0 = System.currentTimeMillis(); Csn csn1 = new Csn( t0, 0, 0, 0 ); Csn csn2 = new Csn( t0, 0, 1, 0 ); assertEquals( -1, comparator.compare( csn1.toString(), csn2.toString() ) ); assertEquals( 1, comparator.compare( csn2.toString(), csn1.toString() ) ); }
@Test public void testDifferentOperationNumberCSNs() { long t0 = System.currentTimeMillis(); Csn csn1 = new Csn( t0, 0, 0, 0 ); Csn csn2 = new Csn( t0, 0, 0, 1 ); assertEquals( -1, comparator.compare( csn1.toString(), csn2.toString() ) ); assertEquals( 1, comparator.compare( csn2.toString(), csn1.toString() ) ); } |
IntegerComparator extends LdapComparator<Object> implements Serializable { @Override public int compare( Object v1, Object v2 ) { if ( v1 == null ) { if ( v2 == null ) { return 0; } else { return -1; } } else if ( v2 == null ) { return 1; } if ( v1 instanceof String ) { return compare( ( String ) v1, ( String ) v2 ); } else if ( v1 instanceof Value ) { return compare( ( ( Value ) v1 ).getString(), ( ( Value ) v2 ).getString() ); } else { return Long.compare( ( Long ) v1, ( Long ) v2 ); } } IntegerComparator( String oid ); @Override int compare( Object v1, Object v2 ); } | @Test public void testNullIntegers() { assertEquals( 0, comparator.compare( null, null ) ); String int1 = "1"; assertEquals( -1, comparator.compare( ( String ) null, int1 ) ); assertEquals( 1, comparator.compare( int1, ( String ) null ) ); }
@Test public void testBigIntegerValues() { assertEquals( -1, comparator.compare( null, "1000000000000000000000000" ) ); assertEquals( 1, comparator.compare( "1000000000000000000000000", null ) ); assertEquals( 0, comparator.compare( "1000000000000000000000000", "1000000000000000000000000" ) ); long t0 = System.currentTimeMillis(); for ( int i = 0; i < 10000000; i++ ) { assertEquals( -1, comparator.compare( "9223372036854775805", "9223372036854775806" ) ); } long t1 = System.currentTimeMillis(); System.out.println( "Delta = " + ( t1 - t0 ) ); assertEquals( 1, comparator.compare( "1000000000000000000000001", "1000000000000000000000000" ) ); } |
CsnSidComparator extends LdapComparator<String> { public int compare( String sidStr1, String sidStr2 ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13744_COMPARING_CSN_SID, sidStr1, sidStr2 ) ); } if ( sidStr1 == null ) { return ( sidStr2 == null ) ? 0 : -1; } if ( sidStr2 == null ) { return 1; } int sid1 = 0; int sid2; try { sid1 = Integer.parseInt( sidStr1, 16 ); } catch ( NumberFormatException nfe ) { return -1; } try { sid2 = Integer.parseInt( sidStr2, 16 ); } catch ( NumberFormatException nfe ) { return 1; } if ( sid1 > sid2 ) { return 1; } else if ( sid2 > sid1 ) { return -1; } return 0; } CsnSidComparator( String oid ); int compare( String sidStr1, String sidStr2 ); } | @Test public void testNullSids() { assertEquals( 0, comparator.compare( null, null ) ); assertEquals( -1, comparator.compare( null, "000" ) ); assertEquals( 1, comparator.compare( "000", null ) ); }
@Test public void testEqualsSids() { assertEquals( 0, comparator.compare( "000", "000" ) ); assertEquals( 0, comparator.compare( "000", "0" ) ); assertEquals( 0, comparator.compare( "fff", "fff" ) ); }
@Test public void testDifferentSids() { assertEquals( -1, comparator.compare( "123", "456" ) ); assertEquals( 1, comparator.compare( "FFF", "000" ) ); assertEquals( 1, comparator.compare( "FFF", "GGG" ) ); } |
BitStringComparator extends LdapComparator<String> { public int compare( String bs1, String bs2 ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13743_COMPARING_BITSTRING, bs1, bs2 ) ); } if ( bs1 == bs2 ) { return 0; } if ( ( bs1 == null ) || ( bs2 == null ) ) { return bs1 == null ? -1 : 1; } char[] array1 = bs1.toCharArray(); char[] array2 = bs2.toCharArray(); int pos1 = bs1.indexOf( '1' ); int pos2 = bs2.indexOf( '1' ); if ( pos1 == -1 ) { if ( pos2 == -1 ) { return 0; } else { return -1; } } else if ( pos2 == -1 ) { return 1; } int length1 = array1.length - pos1; int length2 = array2.length - pos2; if ( length1 == length2 ) { for ( int i = 0; i < length1; i++ ) { int i1 = i + pos1; int i2 = i + pos2; if ( array1[i1] < array2[i2] ) { return -1; } else if ( array1[i1] > array2[i2] ) { return 1; } } return 0; } if ( length1 < length2 ) { return -1; } else { return 1; } } BitStringComparator( String oid ); int compare( String bs1, String bs2 ); } | @Test public void testNullBitString() { assertEquals( 0, comparator.compare( null, null ) ); assertEquals( -1, comparator.compare( null, "0101B" ) ); assertEquals( -1, comparator.compare( null, "000B" ) ); assertEquals( 1, comparator.compare( "0101B", null ) ); assertEquals( 1, comparator.compare( "111B", null ) ); }
@Test public void testBitStringsEquals() { assertEquals( 0, comparator.compare( "0B", "0B" ) ); assertEquals( 0, comparator.compare( "1B", "1B" ) ); assertEquals( 0, comparator.compare( "101010B", "101010B" ) ); assertEquals( 0, comparator.compare( "00000101010B", "00101010B" ) ); }
@Test public void testBitStringsNotEquals() { assertEquals( -1, comparator.compare( "0B", "1B" ) ); assertEquals( 1, comparator.compare( "1B", "0B" ) ); assertEquals( 1, comparator.compare( "101110B", "101010B" ) ); assertEquals( -1, comparator.compare( "00000101010B", "00111010B" ) ); } |
ByteArrayComparator extends LdapComparator<byte[]> { public int compare( byte[] b1, byte[] b2 ) { return Strings.compare( b1, b2 ); } ByteArrayComparator( String oid ); int compare( byte[] b1, byte[] b2 ); } | @Test public void testBothNull() { assertEquals( 0, new ByteArrayComparator( null ).compare( null, null ) ); }
@Test public void testB2Null() { assertEquals( 1, new ByteArrayComparator( null ).compare( new byte[0], null ) ); }
@Test public void testB1Null() { assertEquals( -1, new ByteArrayComparator( null ).compare( null, new byte[0] ) ); }
@Test public void testBothEmpty() { assertEquals( 0, new ByteArrayComparator( null ).compare( new byte[0], new byte[0] ) ); }
@Test public void testBothEqualLengthOne() { assertEquals( 0, new ByteArrayComparator( null ).compare( new byte[1], new byte[1] ) ); }
@Test public void testBothEqualLengthTen() { assertEquals( 0, new ByteArrayComparator( null ).compare( new byte[10], new byte[10] ) ); }
@Test public void testB1PrefixOfB2() { byte[] b1 = new byte[] { 0, 1, 2 }; byte[] b2 = new byte[] { 0, 1, 2, 3 }; assertEquals( -1, new ByteArrayComparator( null ).compare( b1, b2 ) ); }
@Test public void testB2PrefixOfB1() { byte[] b1 = new byte[] { 0, 1, 2, 3 }; byte[] b2 = new byte[] { 0, 1, 2 }; assertEquals( 1, new ByteArrayComparator( null ).compare( b1, b2 ) ); }
@Test public void testB1GreaterThanB2() { byte[] b1 = new byte[] { 0, 5 }; byte[] b2 = new byte[] { 0, 1, 2 }; assertEquals( 1, new ByteArrayComparator( null ).compare( b1, b2 ) ); }
@Test public void testB1GreaterThanB2SameLength() { byte[] b1 = new byte[] { 0, 5 }; byte[] b2 = new byte[] { 0, 1 }; assertEquals( 1, new ByteArrayComparator( null ).compare( b1, b2 ) ); }
@Test public void testB2GreaterThanB1() { byte[] b1 = new byte[] { 0, 1, 2 }; byte[] b2 = new byte[] { 0, 5 }; assertEquals( -1, new ByteArrayComparator( null ).compare( b1, b2 ) ); }
@Test public void testB2GreaterThanB1SameLength() { byte[] b1 = new byte[] { 0, 1 }; byte[] b2 = new byte[] { 0, 5 }; assertEquals( -1, new ByteArrayComparator( null ).compare( b1, b2 ) ); } |
ObjectIdentifierFirstComponentComparator extends LdapComparator<String> { public int compare( String s1, String s2 ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13748_COMPARING_OBJECT_IDENTIFIER_FIRST_COMPONENT, s1, s2 ) ); } if ( s1 == null ) { return ( s2 == null ) ? 0 : -1; } if ( s2 == null ) { return -1; } if ( s1.equals( s2 ) ) { return 0; } String oid1 = getNumericOid( s1 ); if ( oid1 == null ) { return -1; } String oid2 = getNumericOid( s2 ); if ( oid2 == null ) { return -1; } if ( oid1.equals( oid2 ) ) { return 0; } else { return -1; } } ObjectIdentifierFirstComponentComparator( String oid ); int compare( String s1, String s2 ); } | @Test public void testNullObjectIdentifiers() { assertEquals( 0, comparator.compare( null, null ) ); String c2 = "( 1.1 FQCN org.apache.directory.SimpleComparator BYTECODE ABCDEFGHIJKLMNOPQRSTUVWXYZ+/abcdefghijklmnopqrstuvwxyz0123456789==== )"; assertEquals( -1, comparator.compare( null, c2 ) ); assertEquals( -1, comparator.compare( c2, null ) ); }
@Test public void testEqualsObjectIdentifiers() { String c1 = "( 1.1 FQCN org.apache.directory.SimpleComparator BYTECODE ABCDEFGHIJKLMNOPQRSTUVWXYZ+/abcdefghijklmnopqrstuvwxyz0123456789==== )"; String c2 = "( 1.1 fqcn org.apache.directory.SimpleComparator bytecode ABCDEFGHIJKLMNOPQRSTUVWXYZ+/abcdefghijklmnopqrstuvwxyz0123456789==== )"; assertEquals( 0, comparator.compare( c1, c2 ) ); String c3 = "( 1.1 FQCN org.apache.directory.SimpleComparator BYTECODE ABCDEFGHIJKLMNOPQRSTUVWXYZ+/abcdefghijklmnopqrstuvwxyz0123456789==== X-SCHEMA 'system' )"; String c4 = "( 1.1 fqcn org.apache.directory.SimpleComparator bytecode ABCDEFGHIJKLMNOPQRSTUVWXYZ+/abcdefghijklmnopqrstuvwxyz0123456789==== )"; assertEquals( 0, comparator.compare( c3, c4 ) ); }
@Test public void testDifferentObjectIdentifiers() { String c1 = "( 1.1 FQCN org.apache.directory.SimpleComparator BYTECODE ABCDEFGHIJKLMNOPQRSTUVWXYZ+/abcdefghijklmnopqrstuvwxyz0123456789==== )"; String c2 = "( 1.2 fqcn org.apache.directory.SimpleComparator bytecode ABCDEFGHIJKLMNOPQRSTUVWXYZ+/abcdefghijklmnopqrstuvwxyz0123456789==== )"; assertEquals( -1, comparator.compare( c1, c2 ) ); String c3 = "( 1.1 FQCN org.apache.directory.SimpleComparator BYTECODE ABCDEFGHIJKLMNOPQRSTUVWXYZ+/abcdefghijklmnopqrstuvwxyz0123456789==== X-SCHEMA 'system' )"; String c4 = "( 1.1.1 fqcn org.apache.directory.SimpleComparator bytecode ABCDEFGHIJKLMNOPQRSTUVWXYZ+/abcdefghijklmnopqrstuvwxyz0123456789==== )"; assertNotSame( 0, comparator.compare( c3, c4 ) ); } |
GeneralizedTime implements Comparable<GeneralizedTime> { @Override public int compareTo( GeneralizedTime other ) { return calendar.compareTo( other.calendar ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( String generalizedTime ); String toGeneralizedTime(); String toGeneralizedTimeWithoutFraction(); String toGeneralizedTime( Format format, FractionDelimiter fractionDelimiter, int fractionLength,
TimeZoneFormat timeZoneFormat ); Calendar getCalendar(); @Override String toString(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override int compareTo( GeneralizedTime other ); long getTime(); Date getDate(); int getYear(); int getMonth(); int getDay(); int getHour(); int getMinutes(); int getSeconds(); int getFraction(); static Date getDate( String zuluTime ); } | @Test public void testCompareTo() throws ParseException { String gt1 = "20080102121313,999Z"; GeneralizedTime generalizedTime1 = new GeneralizedTime( gt1 ); String gt2 = "20080102121314Z"; GeneralizedTime generalizedTime2 = new GeneralizedTime( gt2 ); String gt3 = "20080102121314,001Z"; GeneralizedTime generalizedTime3 = new GeneralizedTime( gt3 ); assertTrue( generalizedTime1.compareTo( generalizedTime2 ) < 0 ); assertTrue( generalizedTime1.compareTo( generalizedTime3 ) < 0 ); assertTrue( generalizedTime2.compareTo( generalizedTime3 ) < 0 ); assertTrue( generalizedTime2.compareTo( generalizedTime1 ) > 0 ); assertTrue( generalizedTime3.compareTo( generalizedTime1 ) > 0 ); assertTrue( generalizedTime3.compareTo( generalizedTime2 ) > 0 ); assertTrue( generalizedTime1.compareTo( generalizedTime1 ) == 0 ); assertTrue( generalizedTime2.compareTo( generalizedTime2 ) == 0 ); assertTrue( generalizedTime3.compareTo( generalizedTime3 ) == 0 ); } |
WordComparator extends LdapComparator<String> { public int compare( String value, String assertion ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13749_COMPARING_STRING, value, assertion ) ); } if ( value == assertion ) { return 0; } if ( ( value == null ) || ( assertion == null ) ) { return ( assertion == null ) ? 1 : -1; } String trimmedAssertion = Strings.trim( assertion ); int pos = value.indexOf( trimmedAssertion ); if ( pos != -1 ) { int assertionLength = trimmedAssertion.length(); if ( assertionLength == value.length() ) { return 0; } if ( pos == 0 ) { char after = value.charAt( assertionLength ); if ( !Character.isLetterOrDigit( after ) ) { return 0; } else { return -1; } } if ( pos + assertionLength == value.length() ) { char before = value.charAt( value.length() - assertionLength - 1 ); if ( !Character.isLetterOrDigit( before ) ) { return 0; } else { return -1; } } char before = value.charAt( value.length() - assertionLength ); char after = value.charAt( assertionLength ); if ( Character.isLetterOrDigit( after ) ) { return -1; } if ( !Character.isLetterOrDigit( before ) ) { return -1; } return 0; } return -1; } WordComparator( String oid ); int compare( String value, String assertion ); } | @Test public void testNullWordss() { assertEquals( 0, comparator.compare( null, null ) ); assertEquals( -1, comparator.compare( null, " abc " ) ); assertEquals( 1, comparator.compare( " abc def ghi ", null ) ); }
@Test public void testEqualsWords() { assertEquals( 0, comparator.compare( "abc", "abc" ) ); assertEquals( 0, comparator.compare( "abc", " abc " ) ); assertEquals( 0, comparator.compare( "abc def ghi", "def" ) ); assertEquals( 0, comparator.compare( "abc def ghi", " def " ) ); assertEquals( 0, comparator.compare( "abc def ghi", "abc" ) ); assertEquals( 0, comparator.compare( "abc def ghi", "ghi" ) ); }
@Test public void testNotEqualsWords() { assertEquals( -1, comparator.compare( "abc", "" ) ); assertEquals( -1, comparator.compare( "abc", "ab" ) ); assertEquals( -1, comparator.compare( "abc", " ab " ) ); assertEquals( -1, comparator.compare( "abc def ghi", "dkf" ) ); assertEquals( -1, comparator.compare( "abc def ghi", " dkf " ) ); assertEquals( -1, comparator.compare( "abc def ghi", "hi" ) ); assertEquals( -1, comparator.compare( "abc def ghi", "e" ) ); } |
BooleanComparator extends LdapComparator<String> { public int compare( String b1, String b2 ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13752_COMPARING_BOOLEAN, b1, b2 ) ); } if ( b1 == b2 ) { return 0; } if ( ( b1 == null ) || ( b2 == null ) ) { return b1 == null ? -1 : 1; } boolean boolean1 = Boolean.parseBoolean( b1 ); boolean boolean2 = Boolean.parseBoolean( b2 ); if ( boolean1 == boolean2 ) { return 0; } return boolean1 ? 1 : -1; } BooleanComparator( String oid ); int compare( String b1, String b2 ); } | @Test public void testNullBooleans() { assertEquals( 0, comparator.compare( null, null ) ); assertEquals( -1, comparator.compare( null, "TRUE" ) ); assertEquals( -1, comparator.compare( null, "FALSE" ) ); assertEquals( 1, comparator.compare( "TRUE", null ) ); assertEquals( 1, comparator.compare( "FALSE", null ) ); }
@Test public void testBooleans() { assertEquals( 0, comparator.compare( "TRUE", "TRUE" ) ); assertEquals( 0, comparator.compare( "FALSE", "FALSE" ) ); assertEquals( -1, comparator.compare( "FALSE", "TRUE" ) ); assertEquals( 1, comparator.compare( "TRUE", "FALSE" ) ); String b1 = "TRUE"; String b2 = "true"; assertEquals( 0, comparator.compare( b1, Strings.upperCase( b2 ) ) ); } |
TelephoneNumberComparator extends LdapComparator<String> { public int compare( String telephoneNumber1, String telephoneNumber2 ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13750_COMPARING_TELEPHONE_NUMBER, telephoneNumber1, telephoneNumber2 ) ); } if ( telephoneNumber1 == null ) { return ( telephoneNumber2 == null ) ? 0 : -1; } if ( telephoneNumber2 == null ) { return 1; } String strippedTelephoneNumber1 = strip( telephoneNumber1 ); String strippedTelephoneNumber2 = strip( telephoneNumber2 ); return strippedTelephoneNumber1.compareToIgnoreCase( strippedTelephoneNumber2 ); } TelephoneNumberComparator( String oid ); int compare( String telephoneNumber1, String telephoneNumber2 ); } | @Test public void testNullTelephoneNumbers() { String tel1 = null; String tel2 = null; assertEquals( 0, comparator.compare( tel1, tel2 ) ); tel2 = "abc"; assertEquals( -1, comparator.compare( tel1, tel2 ) ); String tel3 = null; assertEquals( 1, comparator.compare( tel2, tel3 ) ); }
@Test public void testEmptyTelephoneNumbers() { String tel1 = ""; String tel2 = ""; assertEquals( 0, comparator.compare( tel1, tel2 ) ); tel2 = "abc"; assertTrue( comparator.compare( tel1, tel2 ) < 0 ); String tel3 = ""; assertTrue( comparator.compare( tel2, tel3 ) > 0 ); }
@Test public void testSimpleTelephoneNumbers() { String tel1 = "01 02 03 04 05"; String tel2 = "01 02 03 04 05"; assertEquals( 0, comparator.compare( tel1, tel2 ) ); tel2 = "0102030405"; assertEquals( 0, comparator.compare( tel1, tel2 ) ); }
@Test public void testComplexTelephoneNumbers() { String tel1 = " + 33 1 01-02-03-04-05 "; String tel2 = "+3310102030405"; assertEquals( 0, comparator.compare( tel1, tel2 ) ); tel1 = "1-801-555-1212"; tel2 = "18015551212"; assertEquals( 0, comparator.compare( tel1, tel2 ) ); assertEquals( 0, comparator.compare( "1 801 555 1212", tel1 ) ); assertEquals( 0, comparator.compare( "1 801 555 1212", tel2 ) ); } |
GeneralizedTime implements Comparable<GeneralizedTime> { @Override public boolean equals( Object obj ) { if ( obj instanceof GeneralizedTime ) { GeneralizedTime other = ( GeneralizedTime ) obj; return calendar.equals( other.calendar ); } else { return false; } } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( String generalizedTime ); String toGeneralizedTime(); String toGeneralizedTimeWithoutFraction(); String toGeneralizedTime( Format format, FractionDelimiter fractionDelimiter, int fractionLength,
TimeZoneFormat timeZoneFormat ); Calendar getCalendar(); @Override String toString(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override int compareTo( GeneralizedTime other ); long getTime(); Date getDate(); int getYear(); int getMonth(); int getDay(); int getHour(); int getMinutes(); int getSeconds(); int getFraction(); static Date getDate( String zuluTime ); } | @Test public void testEquals() throws ParseException { String gt1 = "20080102121314Z"; GeneralizedTime generalizedTime1 = new GeneralizedTime( gt1 ); String gt2 = "20080102121314Z"; GeneralizedTime generalizedTime2 = new GeneralizedTime( gt2 ); String gt3 = "20080102121314,001Z"; GeneralizedTime generalizedTime3 = new GeneralizedTime( gt3 ); assertTrue( generalizedTime1.equals( generalizedTime2 ) ); assertFalse( generalizedTime1.equals( generalizedTime3 ) ); assertFalse( generalizedTime1.equals( null ) ); } |
NameForm extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } NameForm( String oid ); String getStructuralObjectClassOid(); ObjectClass getStructuralObjectClass(); void setStructuralObjectClassOid( String structuralObjectClassOid ); void setStructuralObjectClass( ObjectClass structuralObjectClass ); List<String> getMustAttributeTypeOids(); List<AttributeType> getMustAttributeTypes(); void setMustAttributeTypeOids( List<String> mustAttributeTypeOids ); void setMustAttributeTypes( List<AttributeType> mustAttributeTypes ); void addMustAttributeTypeOids( String oid ); void addMustAttributeTypes( AttributeType attributeType ); List<String> getMayAttributeTypeOids(); List<AttributeType> getMayAttributeTypes(); void setMayAttributeTypeOids( List<String> mayAttributeTypeOids ); void setMayAttributeTypes( List<AttributeType> mayAttributeTypes ); void addMayAttributeTypeOids( String oid ); void addMayAttributeTypes( AttributeType attributeType ); @Override String toString(); @Override NameForm copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; } | @Test public void testToString() throws Exception { String string = nameForm.toString(); assertNotNull( string ); assertTrue( string.startsWith( "nameform (" ) ); assertTrue( string.contains( " NAME " ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tOC" ) ); assertTrue( string.contains( "\n\tMUST" ) ); assertTrue( string.contains( "\n\tMAY" ) ); } |
MatchingRule extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } MatchingRule( String oid ); LdapSyntax getSyntax(); void setSyntax( LdapSyntax ldapSyntax ); String getSyntaxOid(); void setSyntaxOid( String oid ); LdapComparator<? super Object> getLdapComparator(); @SuppressWarnings("unchecked") void setLdapComparator( LdapComparator<?> ldapComparator ); Normalizer getNormalizer(); void setNormalizer( Normalizer normalizer ); @Override String toString(); @Override MatchingRule copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; } | @Test public void testToString() throws Exception { String string = matchingRule.toString(); assertNotNull( string ); assertTrue( string.startsWith( "matchingrule (" ) ); assertTrue( string.contains( " NAME " ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tSYNTAX " ) ); } |
LdapSyntax extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } LdapSyntax( String oid ); LdapSyntax( String oid, String description ); LdapSyntax( String oid, String description, boolean isHumanReadable ); boolean isHumanReadable(); void setHumanReadable( boolean humanReadable ); SyntaxChecker getSyntaxChecker(); void setSyntaxChecker( SyntaxChecker syntaxChecker ); void updateSyntaxChecker( SyntaxChecker newSyntaxChecker ); @Override String toString(); @Override LdapSyntax copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; } | @Test public void testToString() throws Exception { String string = ldapSyntax.toString(); assertNotNull( string ); assertTrue( string.startsWith( "ldapsyntax (" ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tX-NOT-HUMAN-READABLE " ) ); } |
SchemaObjectRenderer { public String render( ObjectClass oc ) { StringBuilder buf = renderStartOidNamesDescObsolete( oc, "objectclass" ); renderOids( buf, "SUP", oc.getSuperiorOids() ); if ( oc.getType() != null ) { prettyPrintIndent( buf ); buf.append( oc.getType() ); prettyPrintNewLine( buf ); } renderOids( buf, "MUST", oc.getMustAttributeTypeOids() ); renderOids( buf, "MAY", oc.getMayAttributeTypeOids() ); renderXSchemaName( oc, buf ); renderClose( buf ); return buf.toString(); } private SchemaObjectRenderer( Style style ); String render( ObjectClass oc ); String render( AttributeType at ); String render( MatchingRule mr ); String render( LdapSyntax syntax ); String render( MatchingRuleUse mru ); String render( DitContentRule dcr ); String render( DitStructureRule dsr ); String render( NameForm nf ); static final SchemaObjectRenderer SUBSCHEMA_SUBENTRY_RENDERER; static final SchemaObjectRenderer OPEN_LDAP_SCHEMA_RENDERER; } | @Test public void testOpenLdapSchemaRendererObjectClassMinimal() { String actual = SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( new ObjectClass( "1.2.3" ) ); String expected = "objectclass ( 1.2.3\n\tSTRUCTURAL )"; assertEquals( expected, actual ); }
@Test public void testOpenLdapSchemaRendererObjectClassSimple() { String actual = SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( objectClassSimple ); String expected = "objectclass ( 1.2.3.4 NAME 'name0'\n\tSTRUCTURAL\n\tMUST att0 )"; assertEquals( expected, actual ); }
@Test public void testOpenLdapSchemaRendererObjectClassComplex() { String actual = SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( objectClassComplex ); String expected = "objectclass ( 1.2.3.4 NAME ( 'name1' 'name2' )\n\tDESC 'description with \\27quotes\\27'\n\tOBSOLETE\n\tSUP 1.3.5.7\n\tAUXILIARY\n\tMUST ( att1 $ att2 )\n\tMAY ( att3 $ att4 ) )"; assertEquals( expected, actual ); }
@Test public void testSubschemSubentryRendererObjectClassMinimal() { String actual = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( new ObjectClass( "1.2.3" ) ); String expected = "( 1.2.3 STRUCTURAL X-SCHEMA 'null' )"; assertEquals( expected, actual ); }
@Test public void testSubschemSubentryRendererObjectClassSimple() { String actual = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( objectClassSimple ); String expected = "( 1.2.3.4 NAME 'name0' STRUCTURAL MUST att0 X-SCHEMA 'dummy' )"; assertEquals( expected, actual ); }
@Test public void testSubschemSubentryRendererObjectClassComplex() { String actual = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( objectClassComplex ); String expected = "( 1.2.3.4 NAME ( 'name1' 'name2' ) DESC 'description with \\27quotes\\27' OBSOLETE SUP 1.3.5.7 AUXILIARY MUST ( att1 $ att2 ) MAY ( att3 $ att4 ) X-SCHEMA 'dummy' )"; assertEquals( expected, actual ); }
@Test public void testOpenLdapSchemaRendererAttributeTypeSimple() { String actual = SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( attributeTypeSimple ); String expected = "attributetype ( 1.2.3.4 NAME 'name0'\n\tEQUALITY matchingRule0\n\tSYNTAX 2.3.4.5{512}\n\tCOLLECTIVE\n\tUSAGE userApplications )"; assertEquals( expected, actual ); }
@Test public void testOpenLdapSchemaRendererAttributeTypeComplex() { String actual = SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( attributeTypeComplex ); String expected = "attributetype ( 1.2.3.4 NAME ( 'name1' 'name2' )\n\tDESC 'description with \\27quotes\\27'\n\tOBSOLETE\n\tSUP superAttr\n\tEQUALITY matchingRule1\n\tORDERING matchingRule2\n\tSUBSTR matchingRule3\n\tSINGLE-VALUE\n\tNO-USER-MODIFICATION\n\tUSAGE directoryOperation )"; assertEquals( expected, actual ); }
@Test public void testSubschemSubentryRendererAttributeTypeSimple() { String actual = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( attributeTypeSimple ); String expected = "( 1.2.3.4 NAME 'name0' EQUALITY matchingRule0 SYNTAX 2.3.4.5{512} COLLECTIVE USAGE userApplications X-SCHEMA 'dummy' )"; assertEquals( expected, actual ); }
@Test public void testSubschemSubentryRendererAttributeTypeComplex() { String actual = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( attributeTypeComplex ); String expected = "( 1.2.3.4 NAME ( 'name1' 'name2' ) DESC 'description with \\27quotes\\27' OBSOLETE SUP superAttr EQUALITY matchingRule1 ORDERING matchingRule2 SUBSTR matchingRule3 SINGLE-VALUE NO-USER-MODIFICATION USAGE directoryOperation X-SCHEMA 'dummy' )"; assertEquals( expected, actual ); }
@Test public void testOpenLdapSchemaRendererMatchingRule() { String actual = SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( matchingRule ); String expected = "matchingrule ( 1.2.3.4 NAME 'name0'\n\tDESC 'description with \\27quotes\\27'\n\tOBSOLETE\n\tSYNTAX 2.3.4.5 )"; assertEquals( expected, actual ); }
@Test public void testSubschemSubentryRendererMatchingRule() { String actual = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( matchingRule ); String expected = "( 1.2.3.4 NAME 'name0' DESC 'description with \\27quotes\\27' OBSOLETE SYNTAX 2.3.4.5 X-SCHEMA 'dummy' )"; assertEquals( expected, actual ); }
@Test public void testOpenLdapSchemaRendererLdapSyntax() { String actual = SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( ldapSyntax ); String expected = "ldapsyntax ( 1.2.3.4\n\tDESC 'description with \\27quotes\\27'\n\tX-NOT-HUMAN-READABLE 'true' )"; assertEquals( expected, actual ); }
@Test public void testSubschemSubentryRendererLdapSyntax() { String actual = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( ldapSyntax ); String expected = "( 1.2.3.4 DESC 'description with \\27quotes\\27' X-SCHEMA 'dummy' X-NOT-HUMAN-READABLE 'true' )"; assertEquals( expected, actual ); }
@Test public void testOpenLdapSchemaRendererMatchingRuleUse() { String actual = SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( matchingRuleUse ); String expected = "matchingruleuse ( 1.2.3.4 NAME 'name0'\n\tDESC 'description with \\27quotes\\27'\n\tOBSOLETE\n\tAPPLIES ( 2.3.4.5 $ 1.3.4.5.6 ) )"; assertEquals( expected, actual ); }
@Test public void testSubschemSubentryRendererMatchingRuleUse() { String actual = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( matchingRuleUse ); String expected = "( 1.2.3.4 NAME 'name0' DESC 'description with \\27quotes\\27' OBSOLETE APPLIES ( 2.3.4.5 $ 1.3.4.5.6 ) X-SCHEMA 'dummy' )"; assertEquals( expected, actual ); }
@Test public void testOpenLdapSchemaRendererDitContentRule() { String actual = SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( ditContentRule ); String expected = "ditcontentrule ( 1.2.3.4 NAME ( 'name1' 'name2' )\n\tDESC 'description with \\27quotes\\27'\n\tOBSOLETE\n\tAUX ( oc1 $ oc2 )\n\tMUST ( must1 $ must2 )\n\tMAY ( may1 $ may2 )\n\tNOT ( not1 $ not2 ) )"; assertEquals( expected, actual ); }
@Test public void testSubschemSubentryRendererDitContentRule() { String actual = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( ditContentRule ); String expected = "( 1.2.3.4 NAME ( 'name1' 'name2' ) DESC 'description with \\27quotes\\27' OBSOLETE AUX ( oc1 $ oc2 ) MUST ( must1 $ must2 ) MAY ( may1 $ may2 ) NOT ( not1 $ not2 ) X-SCHEMA 'dummy' )"; assertEquals( expected, actual ); }
@Test public void testOpenLdapSchemaRendererDitStructureRule() { String actual = SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( ditStructureRule ); String expected = "ditstructurerule ( 1234 NAME ( 'name1' 'name2' )\n\tDESC 'description with \\27quotes\\27'\n\tOBSOLETE\n\tFORM form1\n\tSUP ( 111 222 333 ) )"; assertEquals( expected, actual ); }
@Test public void testSubschemSubentryRendererDitStructureRule() { String actual = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( ditStructureRule ); String expected = "( 1234 NAME ( 'name1' 'name2' ) DESC 'description with \\27quotes\\27' OBSOLETE FORM form1 SUP ( 111 222 333 ) X-SCHEMA 'dummy' )"; assertEquals( expected, actual ); ditStructureRule.setSuperRules( null ); String actual2 = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( ditStructureRule ); String expected2 = "( 1234 NAME ( 'name1' 'name2' ) DESC 'description with \\27quotes\\27' OBSOLETE FORM form1 X-SCHEMA 'dummy' )"; assertEquals( expected2, actual2 ); }
@Test public void testOpenLdapSchemaRendererNameForm() { String actual = SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( nameForm ); String expected = "nameform ( 1.2.3.4 NAME ( 'name1' 'name2' )\n\tDESC 'description with \\27quotes\\27'\n\tOBSOLETE\n\tOC oc1\n\tMUST ( must1 $ must2 )\n\tMAY may0 )"; assertEquals( expected, actual ); }
@Test public void testSubschemSubentryRendererNameForm() { String actual = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( nameForm ); String expected = "( 1.2.3.4 NAME ( 'name1' 'name2' ) DESC 'description with \\27quotes\\27' OBSOLETE OC oc1 MUST ( must1 $ must2 ) MAY may0 X-SCHEMA 'dummy' )"; assertEquals( expected, actual ); nameForm.setMayAttributeTypeOids( new ArrayList<String>() ); String actual2 = SchemaObjectRenderer.SUBSCHEMA_SUBENTRY_RENDERER.render( nameForm ); String expected2 = "( 1.2.3.4 NAME ( 'name1' 'name2' ) DESC 'description with \\27quotes\\27' OBSOLETE OC oc1 MUST ( must1 $ must2 ) X-SCHEMA 'dummy' )"; assertEquals( expected2, actual2 ); } |
GeneralizedTime implements Comparable<GeneralizedTime> { public Date getDate() { return calendar.getTime(); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( String generalizedTime ); String toGeneralizedTime(); String toGeneralizedTimeWithoutFraction(); String toGeneralizedTime( Format format, FractionDelimiter fractionDelimiter, int fractionLength,
TimeZoneFormat timeZoneFormat ); Calendar getCalendar(); @Override String toString(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override int compareTo( GeneralizedTime other ); long getTime(); Date getDate(); int getYear(); int getMonth(); int getDay(); int getHour(); int getMinutes(); int getSeconds(); int getFraction(); static Date getDate( String zuluTime ); } | @Test public void fractionCloseToOne() throws ParseException { GeneralizedTime close = new GeneralizedTime( "20000101000000.9994Z" ); assertThat( close.getDate(), is( equalTo( format.parse( "01/01/2000 00:00:00.999 GMT" ) ) ) ); GeneralizedTime closer = new GeneralizedTime( "20000101000000.9995Z" ); assertThat( closer.getDate(), is( equalTo( format.parse( "01/01/2000 00:00:00.999 GMT" ) ) ) ); GeneralizedTime larger = new GeneralizedTime( "20000101000000.9Z" ); assertThat( larger.getDate(), is( equalTo( format.parse( "01/01/2000 00:00:00.900 GMT" ) ) ) ); } |
MethodUtils { public static Method getAssignmentCompatibleMethod( Class<?> clazz, String candidateMethodName, Class<?>[] candidateParameterTypes ) throws NoSuchMethodException { if ( LOG.isDebugEnabled() ) { StringBuilder buf = new StringBuilder(); buf.append( "call to getAssignmentCompatibleMethod(): \n\tclazz = " ); buf.append( clazz.getName() ); buf.append( "\n\tcandidateMethodName = " ); buf.append( candidateMethodName ); buf.append( "\n\tcandidateParameterTypes = " ); for ( Class<?> argClass : candidateParameterTypes ) { buf.append( "\n\t\t" ); buf.append( argClass.getName() ); } if ( LOG.isDebugEnabled() ) { LOG.debug( buf.toString() ); } } try { Method exactMethod = clazz.getMethod( candidateMethodName, candidateParameterTypes ); if ( exactMethod != null ) { return exactMethod; } } catch ( Exception e ) { if ( LOG.isInfoEnabled() ) { LOG.info( I18n.msg( I18n.MSG_17009_NO_EXACT_MATCH, candidateMethodName, e ) ); } } Method[] methods = clazz.getMethods(); for ( int mx = 0; mx < methods.length; mx++ ) { if ( !candidateMethodName.equals( methods[mx].getName() ) ) { continue; } Class<?>[] parameterTypes = methods[mx].getParameterTypes(); if ( parameterTypes.length != candidateParameterTypes.length ) { continue; } for ( int px = 0; px < parameterTypes.length; px++ ) { if ( !parameterTypes[px].isAssignableFrom( candidateParameterTypes[px] ) ) { break; } } return methods[mx]; } throw new NoSuchMethodException( clazz.getName() + "." + candidateMethodName + "(" + Arrays.toString( candidateParameterTypes ) + ")" ); } private MethodUtils(); static Method getAssignmentCompatibleMethod( Class<?> clazz,
String candidateMethodName,
Class<?>[] candidateParameterTypes
); } | @Test public void testSameBehaviourOfStandardGetMethod() { Method m1 = null; Method m2 = null; try { m1 = TestClass.class.getMethod( "methodA", new Class[] { String.class } ); } catch ( SecurityException e ) { e.printStackTrace(); } catch ( NoSuchMethodException e ) { e.printStackTrace(); } try { m2 = MethodUtils.getAssignmentCompatibleMethod( TestClass.class, "methodA", new Class[] { String.class } ); } catch ( NoSuchMethodException e ) { e.printStackTrace(); } assertEquals( m1, m2 ); }
@Test public void testNewBehaviourOfAssignmentCompatibleGetMethod() { Method m2 = null; try { TestClass.class.getMethod( "methodB", new Class[] { ArrayList.class } ); fail( "We should not have come here." ); } catch ( SecurityException e ) { e.printStackTrace(); } catch ( NoSuchMethodException e ) { assertNotNull( e ); } try { m2 = MethodUtils.getAssignmentCompatibleMethod( TestClass.class, "methodB", new Class[] { ArrayList.class } ); } catch ( NoSuchMethodException e ) { e.printStackTrace(); } assertNotNull( m2 ); } |
SchemaUtils { static StringBuilder renderQDescrs( StringBuilder buf, List<String> qdescrs ) { if ( ( qdescrs == null ) || qdescrs.isEmpty() ) { return buf; } if ( qdescrs.size() == 1 ) { buf.append( '\'' ).append( qdescrs.get( 0 ) ).append( '\'' ); } else { buf.append( "( " ); for ( String qdescr : qdescrs ) { buf.append( '\'' ).append( qdescr ).append( "' " ); } buf.append( ")" ); } return buf; } private SchemaUtils(); static Entry getTargetEntry( List<? extends Modification> mods, Entry entry ); static StringBuilder render( StringBuilder buf, List<String> qdescrs ); static StringBuilder render( ObjectClass[] ocs ); static StringBuilder render( StringBuilder buf, ObjectClass[] ocs ); static StringBuilder render( AttributeType[] ats ); static StringBuilder render( StringBuilder buf, AttributeType[] ats ); static StringBuilder render( Map<String, List<String>> extensions ); static String render( LoadableSchemaObject description ); static String stripOptions( String attributeId ); static Set<String> getOptions( String attributeId ); static byte[] uuidToBytes( UUID uuid ); static boolean isAttributeNameValid( String attributeName ); } | @Test public void testRenderQdescrs() { assertEquals( "", SchemaUtils.renderQDescrs( new StringBuilder(), ( List<String> ) null ).toString() ); assertEquals( "", SchemaUtils.renderQDescrs( new StringBuilder(), Arrays.asList( new String[] {} ) ).toString() ); assertEquals( "'name1'", SchemaUtils.renderQDescrs( new StringBuilder(), Arrays.asList( new String[] { "name1" } ) ).toString() ); assertEquals( "( 'name1' 'name2' )", SchemaUtils.renderQDescrs( new StringBuilder(), Arrays.asList( new String[] { "name1", "name2" } ) ).toString() ); assertEquals( "( 'name1' 'name2' 'name3' )", SchemaUtils.renderQDescrs( new StringBuilder(), Arrays.asList( new String[] { "name1", "name2", "name3" } ) ).toString() ); assertEquals( "", SchemaUtils.renderQDescrs( new StringBuilder(), ( List<String> ) null ).toString() ); assertEquals( "", SchemaUtils.renderQDescrs( new StringBuilder(), Arrays.asList( new String[] {} ) ).toString() ); assertEquals( "'name1'", SchemaUtils.renderQDescrs( new StringBuilder(), Arrays.asList( new String[] { "name1" } ) ).toString() ); assertEquals( "( 'name1' 'name2' )", SchemaUtils.renderQDescrs( new StringBuilder(), Arrays.asList( new String[] { "name1", "name2" } ) ).toString() ); assertEquals( "( 'name1' 'name2' 'name3' )", SchemaUtils.renderQDescrs( new StringBuilder(), Arrays.asList( new String[] { "name1", "name2", "name3" } ) ).toString() ); } |
SchemaUtils { public static boolean isAttributeNameValid( String attributeName ) { if ( Strings.isEmpty( attributeName ) ) { return false; } boolean descr; boolean zero = false; boolean dot = false; char c = attributeName.charAt( 0 ); if ( ( ( c >= 'a' ) && ( c <= 'z' ) ) || ( ( c >= 'A' ) && ( c <= 'Z' ) ) ) { descr = true; } else if ( ( c >= '0' ) && ( c <= '9' ) ) { descr = false; zero = c == '0'; } else { return false; } for ( int i = 1; i < attributeName.length(); i++ ) { c = attributeName.charAt( i ); if ( descr ) { if ( ( ( c < 'a' ) || ( c > 'z' ) ) && ( ( c < 'A' ) || ( c > 'Z' ) ) && ( ( c < '0' ) || ( c > '9' ) ) && ( c != '-' ) && ( c != '_' ) ) { return false; } } else { if ( c == '.' ) { if ( dot ) { return false; } dot = true; zero = false; } else if ( ( c >= '0' ) && ( c <= '9' ) ) { dot = false; if ( zero ) { return false; } else if ( c == '0' ) { zero = true; } } else { return false; } } } return true; } private SchemaUtils(); static Entry getTargetEntry( List<? extends Modification> mods, Entry entry ); static StringBuilder render( StringBuilder buf, List<String> qdescrs ); static StringBuilder render( ObjectClass[] ocs ); static StringBuilder render( StringBuilder buf, ObjectClass[] ocs ); static StringBuilder render( AttributeType[] ats ); static StringBuilder render( StringBuilder buf, AttributeType[] ats ); static StringBuilder render( Map<String, List<String>> extensions ); static String render( LoadableSchemaObject description ); static String stripOptions( String attributeId ); static Set<String> getOptions( String attributeId ); static byte[] uuidToBytes( UUID uuid ); static boolean isAttributeNameValid( String attributeName ); } | @Test public void testIsAttributeNameValid() { assertFalse( SchemaUtils.isAttributeNameValid( null ) ); assertFalse( SchemaUtils.isAttributeNameValid( "" ) ); assertFalse( SchemaUtils.isAttributeNameValid( " " ) ); assertTrue( SchemaUtils.isAttributeNameValid( "a" ) ); assertTrue( SchemaUtils.isAttributeNameValid( "ObjectClass-text_test123" ) ); assertFalse( SchemaUtils.isAttributeNameValid( "-text_test123" ) ); assertFalse( SchemaUtils.isAttributeNameValid( "text_te&st123" ) ); assertFalse( SchemaUtils.isAttributeNameValid( "text_te st123" ) ); assertTrue( SchemaUtils.isAttributeNameValid( "0" ) ); assertTrue( SchemaUtils.isAttributeNameValid( "0" ) ); assertFalse( SchemaUtils.isAttributeNameValid( "00.1.2.3" ) ); assertFalse( SchemaUtils.isAttributeNameValid( "0.1.2..3" ) ); assertFalse( SchemaUtils.isAttributeNameValid( "0.01.2.3" ) ); } |
SchemaObjectSorter { public static Iterable<AttributeType> hierarchicalOrdered( List<AttributeType> attributeTypes ) { return new SchemaObjectIterable<>( attributeTypes, new ReferenceCallback<AttributeType>() { @Override public Collection<String> getSuperiorOids( AttributeType at ) { return Collections.singleton( at.getSuperiorOid() ); } } ); } private SchemaObjectSorter(); static Iterable<AttributeType> hierarchicalOrdered( List<AttributeType> attributeTypes ); static Iterable<ObjectClass> sortObjectClasses( List<ObjectClass> objectClasses ); } | @Test public void testSortAttributeTypesAlreadySorted() { List<AttributeType> attributeTypes = new ArrayList<AttributeType>(); addAttributeType( attributeTypes, "1.1.1", "att1", null ); addAttributeType( attributeTypes, "1.1.2", "att2", "att1" ); addAttributeType( attributeTypes, "1.1.3", "att3", "att2" ); addAttributeType( attributeTypes, "1.1.4", "att4", "att3" ); addAttributeType( attributeTypes, "1.1.5", "att5", "att1" ); addAttributeType( attributeTypes, "1.1.6", "att6", null ); addAttributeType( attributeTypes, "1.1.7", "att7", "other" ); Iterable<AttributeType> sorted = SchemaObjectSorter.hierarchicalOrdered( attributeTypes ); assertHierarchicalOrderAT( sorted ); }
@Test public void testSortAttributeTypesShuffled() { List<String> oids = Arrays.asList( "1.1.1", "1.1.2", "1.1.3", "1.1.4", "1.1.5", "1.1.6", "1.1.7" ); for ( int i = 0; i < 1000; i++ ) { Collections.shuffle( oids ); Iterator<String> oidIterator = oids.iterator(); List<AttributeType> attributeTypes = new ArrayList<AttributeType>(); addAttributeType( attributeTypes, oidIterator.next(), "att1", null ); addAttributeType( attributeTypes, oidIterator.next(), "aTT2", "att1" ); addAttributeType( attributeTypes, oidIterator.next(), "att3", "att2" ); addAttributeType( attributeTypes, oidIterator.next(), "att4", "atT3" ); addAttributeType( attributeTypes, oidIterator.next(), "att5", "aTt1" ); addAttributeType( attributeTypes, oidIterator.next(), "att6", null ); addAttributeType( attributeTypes, oidIterator.next(), "att7", "other" ); Iterable<AttributeType> sorted = SchemaObjectSorter.hierarchicalOrdered( attributeTypes ); assertHierarchicalOrderAT( sorted ); } }
@Test public void testSortAttributeTypesLoop() { List<AttributeType> attributeTypes = new ArrayList<AttributeType>(); addAttributeType( attributeTypes, "1.1.1", "att1", "att4" ); addAttributeType( attributeTypes, "1.1.2", "att2", "att1" ); addAttributeType( attributeTypes, "1.1.3", "att3", "att2" ); addAttributeType( attributeTypes, "1.1.4", "att4", "att3" ); Iterable<AttributeType> sorted = SchemaObjectSorter.hierarchicalOrdered( attributeTypes ); assertThrows( IllegalStateException.class, () -> { sorted.iterator().next(); } ); } |
SchemaObjectSorter { public static Iterable<ObjectClass> sortObjectClasses( List<ObjectClass> objectClasses ) { return new SchemaObjectIterable<>( objectClasses, new ReferenceCallback<ObjectClass>() { @Override public Collection<String> getSuperiorOids( ObjectClass oc ) { return oc.getSuperiorOids(); } } ); } private SchemaObjectSorter(); static Iterable<AttributeType> hierarchicalOrdered( List<AttributeType> attributeTypes ); static Iterable<ObjectClass> sortObjectClasses( List<ObjectClass> objectClasses ); } | @Test public void testSortObjectClassesAlreadySorted() { List<ObjectClass> objectClasses = new ArrayList<ObjectClass>(); addObjectClass( objectClasses, "1.2.1", "oc1" ); addObjectClass( objectClasses, "1.2.2", "OC2", "oc1" ); addObjectClass( objectClasses, "1.2.3", "oc3", "oC2" ); addObjectClass( objectClasses, "1.2.4", "oc4" ); addObjectClass( objectClasses, "1.2.5", "oc5", "Oc2", "oC4" ); addObjectClass( objectClasses, "1.2.6", "oc6", "other" ); Iterable<ObjectClass> sorted = SchemaObjectSorter.sortObjectClasses( objectClasses ); assertHierarchicalOrderOC( sorted ); }
@Test public void testSortObjectClassesShuffled() { List<String> oids = Arrays.asList( "1.1.1", "1.1.2", "1.1.3", "1.1.4", "1.1.5", "1.1.6" ); for ( int i = 0; i < 1000; i++ ) { Collections.shuffle( oids ); Iterator<String> oidIterator = oids.iterator(); List<ObjectClass> objectClasses = new ArrayList<ObjectClass>(); addObjectClass( objectClasses, oidIterator.next(), "oc1" ); addObjectClass( objectClasses, oidIterator.next(), "OC2", "oc1" ); addObjectClass( objectClasses, oidIterator.next(), "oc3", "Oc2" ); addObjectClass( objectClasses, oidIterator.next(), "oc4" ); addObjectClass( objectClasses, oidIterator.next(), "oc5", "oC2", "OC4" ); addObjectClass( objectClasses, oidIterator.next(), "oc6", "other" ); Iterable<ObjectClass> sorted = SchemaObjectSorter.sortObjectClasses( objectClasses ); assertHierarchicalOrderOC( sorted ); } }
@Test public void testSortObjectClassesLoop() { List<ObjectClass> objectClasses = new ArrayList<ObjectClass>(); addObjectClass( objectClasses, "1.2.1", "oc1", "oc3" ); addObjectClass( objectClasses, "1.2.2", "oc2", "oc1" ); addObjectClass( objectClasses, "1.2.3", "oc3", "oc2" ); Iterable<ObjectClass> sorted = SchemaObjectSorter.sortObjectClasses( objectClasses ); assertThrows( IllegalStateException.class, () -> { sorted.iterator().next(); } ); } |
ObjectClass extends AbstractSchemaObject { @Override public boolean equals( Object o ) { if ( !super.equals( o ) ) { return false; } if ( !( o instanceof ObjectClass ) ) { return false; } ObjectClass that = ( ObjectClass ) o; if ( objectClassType != that.objectClassType ) { return false; } if ( superiorOids.size() != that.superiorOids.size() ) { return false; } for ( String oid : superiorOids ) { if ( !that.superiorOids.contains( oid ) ) { return false; } } for ( String oid : that.superiorOids ) { if ( !superiorOids.contains( oid ) ) { return false; } } if ( superiors.size() != that.superiors.size() ) { return false; } for ( ObjectClass superior : superiors ) { if ( !that.superiors.contains( superior ) ) { return false; } } for ( ObjectClass superior : that.superiors ) { if ( !superiors.contains( superior ) ) { return false; } } if ( mayAttributeTypeOids.size() != that.mayAttributeTypeOids.size() ) { return false; } for ( String oid : mayAttributeTypeOids ) { if ( !that.mayAttributeTypeOids.contains( oid ) ) { return false; } } for ( String oid : that.mayAttributeTypeOids ) { if ( !mayAttributeTypeOids.contains( oid ) ) { return false; } } if ( mayAttributeTypes.size() != that.mayAttributeTypes.size() ) { return false; } for ( AttributeType oid : mayAttributeTypes ) { if ( !that.mayAttributeTypes.contains( oid ) ) { return false; } } for ( AttributeType oid : that.mayAttributeTypes ) { if ( !mayAttributeTypes.contains( oid ) ) { return false; } } if ( mustAttributeTypeOids.size() != that.mustAttributeTypeOids.size() ) { return false; } for ( String oid : mustAttributeTypeOids ) { if ( !that.mustAttributeTypeOids.contains( oid ) ) { return false; } } for ( String oid : that.mustAttributeTypeOids ) { if ( !mustAttributeTypeOids.contains( oid ) ) { return false; } } if ( mustAttributeTypes.size() != that.mustAttributeTypes.size() ) { return false; } for ( AttributeType oid : mustAttributeTypes ) { if ( !that.mustAttributeTypes.contains( oid ) ) { return false; } } for ( AttributeType oid : that.mustAttributeTypes ) { if ( !mustAttributeTypes.contains( oid ) ) { return false; } } return true; } ObjectClass( String oid ); List<String> getMayAttributeTypeOids(); List<AttributeType> getMayAttributeTypes(); void addMayAttributeTypeOids( String... oids ); void addMayAttributeTypes( AttributeType... attributeTypes ); void setMayAttributeTypeOids( List<String> mayAttributeTypeOids ); void setMayAttributeTypes( List<AttributeType> mayAttributeTypes ); List<String> getMustAttributeTypeOids(); List<AttributeType> getMustAttributeTypes(); void addMustAttributeTypeOids( String... oids ); void addMustAttributeTypes( AttributeType... attributeTypes ); void setMustAttributeTypeOids( List<String> mustAttributeTypeOids ); void setMustAttributeTypes( List<AttributeType> mustAttributeTypes ); List<ObjectClass> getSuperiors(); List<String> getSuperiorOids(); void addSuperiorOids( String... oids ); void addSuperior( ObjectClass... objectClasses ); void setSuperiors( List<ObjectClass> superiors ); void setSuperiorOids( List<String> superiorOids ); ObjectClassTypeEnum getType(); void setType( ObjectClassTypeEnum objectClassType ); boolean isStructural(); boolean isAbstract(); boolean isAuxiliary(); @Override String toString(); @Override ObjectClass copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; } | @Test public void testEqualsNull() throws Exception { assertFalse( objectClassA.equals( null ) ); }
@Test public void testNotEqualDiffValue() throws Exception { assertFalse( objectClassA.equals( objectClassC ) ); assertFalse( objectClassC.equals( objectClassA ) ); } |
ObjectClass extends AbstractSchemaObject { @Override public int hashCode() { int hash = h; hash = hash * 17 + objectClassType.getValue(); int tempHash = 0; for ( String oid : superiorOids ) { tempHash += oid.hashCode(); } hash = hash * 17 + tempHash; tempHash = 0; for ( String may : mayAttributeTypeOids ) { tempHash += may.hashCode(); } hash = hash * 17 + tempHash; tempHash = 0; for ( String must : mustAttributeTypeOids ) { tempHash += must.hashCode(); } hash = hash * 17 + tempHash; return hash; } ObjectClass( String oid ); List<String> getMayAttributeTypeOids(); List<AttributeType> getMayAttributeTypes(); void addMayAttributeTypeOids( String... oids ); void addMayAttributeTypes( AttributeType... attributeTypes ); void setMayAttributeTypeOids( List<String> mayAttributeTypeOids ); void setMayAttributeTypes( List<AttributeType> mayAttributeTypes ); List<String> getMustAttributeTypeOids(); List<AttributeType> getMustAttributeTypes(); void addMustAttributeTypeOids( String... oids ); void addMustAttributeTypes( AttributeType... attributeTypes ); void setMustAttributeTypeOids( List<String> mustAttributeTypeOids ); void setMustAttributeTypes( List<AttributeType> mustAttributeTypes ); List<ObjectClass> getSuperiors(); List<String> getSuperiorOids(); void addSuperiorOids( String... oids ); void addSuperior( ObjectClass... objectClasses ); void setSuperiors( List<ObjectClass> superiors ); void setSuperiorOids( List<String> superiorOids ); ObjectClassTypeEnum getType(); void setType( ObjectClassTypeEnum objectClassType ); boolean isStructural(); boolean isAbstract(); boolean isAuxiliary(); @Override String toString(); @Override ObjectClass copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; } | @Test public void testHashCodeReflexive() throws Exception { assertEquals( objectClassA.hashCode(), objectClassA.hashCode() ); }
@Test public void testHashCodeSymmetric() throws Exception { assertEquals( objectClassA.hashCode(), objectClassACopy.hashCode() ); assertEquals( objectClassACopy.hashCode(), objectClassA.hashCode() ); }
@Test public void testHashCodeTransitive() throws Exception { assertEquals( objectClassA.hashCode(), objectClassACopy.hashCode() ); assertEquals( objectClassACopy.hashCode(), objectClassB.hashCode() ); assertEquals( objectClassA.hashCode(), objectClassB.hashCode() ); } |
ObjectClass extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } ObjectClass( String oid ); List<String> getMayAttributeTypeOids(); List<AttributeType> getMayAttributeTypes(); void addMayAttributeTypeOids( String... oids ); void addMayAttributeTypes( AttributeType... attributeTypes ); void setMayAttributeTypeOids( List<String> mayAttributeTypeOids ); void setMayAttributeTypes( List<AttributeType> mayAttributeTypes ); List<String> getMustAttributeTypeOids(); List<AttributeType> getMustAttributeTypes(); void addMustAttributeTypeOids( String... oids ); void addMustAttributeTypes( AttributeType... attributeTypes ); void setMustAttributeTypeOids( List<String> mustAttributeTypeOids ); void setMustAttributeTypes( List<AttributeType> mustAttributeTypes ); List<ObjectClass> getSuperiors(); List<String> getSuperiorOids(); void addSuperiorOids( String... oids ); void addSuperior( ObjectClass... objectClasses ); void setSuperiors( List<ObjectClass> superiors ); void setSuperiorOids( List<String> superiorOids ); ObjectClassTypeEnum getType(); void setType( ObjectClassTypeEnum objectClassType ); boolean isStructural(); boolean isAbstract(); boolean isAuxiliary(); @Override String toString(); @Override ObjectClass copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; } | @Test public void testToString() throws Exception { String string = objectClass.toString(); assertNotNull( string ); assertTrue( string.startsWith( "objectclass (" ) ); assertTrue( string.contains( " NAME " ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tSUP " ) ); assertTrue( string.contains( "\n\tSTRUCTURAL" ) ); assertTrue( string.contains( "\n\tMUST" ) ); assertTrue( string.contains( "\n\tMAY" ) ); assertTrue( string.endsWith( " )" ) ); } |
Strings { public static String trimConsecutiveToOne( String str, char ch ) { if ( ( null == str ) || ( str.length() == 0 ) ) { return ""; } char[] buffer = str.toCharArray(); char[] newbuf = new char[buffer.length]; int pos = 0; boolean same = false; for ( int i = 0; i < buffer.length; i++ ) { char car = buffer[i]; if ( car == ch ) { if ( !same ) { same = true; newbuf[pos++] = car; } } else { same = false; newbuf[pos++] = car; } } return new String( newbuf, 0, pos ); } private Strings(); static String dumpBytes( byte[] buffer ); static String byteToString( byte b ); static String dumpByte( byte octet ); static char dumpHex( byte hex ); static String dumpHexPairs( byte[] buffer ); static String deepTrim( String str, boolean toLowerCase ); static String deepTrimToLower( String string ); static String deepTrim( String string ); static String trimConsecutiveToOne( String str, char ch ); static String centerTrunc( String str, int head, int tail ); static String toHexString( byte[] res ); static byte[] toByteArray( String hexString ); static String formatHtml( String source, boolean replaceNl, boolean replaceTag,
boolean replaceQuote ); static boolean areEquals( String string, int index, String text ); static boolean isCharASCII( byte[] byteArray, int index, char car ); static boolean isCharASCII( char[] charArray, int index, char car ); static boolean isCharASCII( String string, int index, char car ); static String utf8ToString( byte[] bytes ); static String utf8ToString( byte[] bytes, int length ); static String utf8ToString( byte[] bytes, int start, int length ); static int areEquals( byte[] bytes, int index, String text ); static int areEquals( char[] chars, int index, String text ); static int areEquals( char[] chars, int index, String text, boolean caseSensitive ); static int areEquals( char[] chars, int index, char[] chars2 ); static int areEquals( char[] chars, int index, char[] chars2, boolean caseSensitive ); static int areEquals( byte[] bytes, int index, byte[] bytes2 ); static boolean isEmpty( String str ); static boolean isEmpty( byte[] bytes ); static String trim( String str ); static byte[] trim( byte[] bytes ); static String trimLeft( String str ); static int trimLeft( char[] chars, int pos ); static void trimLeft( String string, Position pos ); static void trimLeft( byte[] bytes, Position pos ); static int trimLeft( byte[] bytes, int pos ); static String trimRight( String str ); static String trimRight( String str, int escapedSpace ); static int trimRight( char[] chars, int pos ); static String trimRight( String string, Position pos ); static String trimRight( byte[] bytes, Position pos ); static int trimRight( byte[] bytes, int pos ); static char charAt( String string, int index ); static byte byteAt( byte[] bytes, int index ); static char charAt( char[] chars, int index ); static String asciiBytesToString( byte[] bytes ); static byte[] getBytesUtf8( String string ); static byte[] getBytesUtf8Ascii( String string ); static String getDefaultCharsetName(); static boolean equals( String str1, String str2 ); static String listToString( List<?> list ); static String setToString( Set<?> set ); static String listToString( List<?> list, String tabs ); static String mapToString( Map<?, ?> map ); static String mapToString( Map<?, ?> map, String tabs ); @Deprecated static String toLowerCase( String value ); static String toLowerCaseAscii( String value ); static String toLowerCase( byte[] value ); @Deprecated static String toUpperCase( String value ); static String toUpperCaseAscii( String value ); static String upperCase( String str ); static String lowerCase( String str ); static String lowerCaseAscii( String str ); static boolean isPrintableString( String str ); static boolean isNotEmpty( String str ); static boolean isIA5String( String str ); static boolean isValidUuid( String uuid ); static String uuidToString( byte[] bytes ); static byte[] uuidToBytes( String string ); static byte[] copy( byte[] value ); static String getString( final byte[] data, int offset, int length, String charset ); static String getString( final byte[] data, int offset, int length, Charset charset ); static String getString( final byte[] data, String charset ); static String getString( final byte[] data, Charset charset ); static String getUUID( long value ); static int parseInt( String value ); static int compare( byte[] b1, byte[] b2 ); static final byte[] HEX_CHAR; static final byte[] EMPTY_BYTES; static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; } | @Test public void testTrimConsecutiveToOne() { String input = null; String result = null; input = "akarasulu**"; result = Strings.trimConsecutiveToOne( input, '*' ); assertEquals( "akarasulu*", result ); input = "*****akarasulu**"; result = Strings.trimConsecutiveToOne( input, '*' ); assertEquals( "*akarasulu*", result ); input = "**akarasulu"; result = Strings.trimConsecutiveToOne( input, '*' ); assertEquals( "*akarasulu", result ); input = "**akar****asulu**"; result = Strings.trimConsecutiveToOne( input, '*' ); assertEquals( "*akar*asulu*", result ); input = "akarasulu"; result = Strings.trimConsecutiveToOne( input, '*' ); assertEquals( "akarasulu", result ); input = "*a*k*a*r*a*s*u*l*u*"; result = Strings.trimConsecutiveToOne( input, '*' ); assertEquals( "*a*k*a*r*a*s*u*l*u*", result ); } |
OidRegistry implements Iterable<T> { public OidRegistry<T> copy() { OidRegistry<T> copy = new OidRegistry<>(); copy.byOid = new HashMap<>(); return copy; } boolean contains( String oid ); String getPrimaryName( String oid ); T getSchemaObject( String oid ); List<String> getNameSet( String oid ); Iterator<String> iteratorOids(); @Override Iterator<T> iterator(); boolean isRelaxed(); boolean isStrict(); void setRelaxed(); void setStrict(); SchemaErrorHandler getErrorHandler(); void setErrorHandler( SchemaErrorHandler errorHandler ); void register( T schemaObject ); void unregister( String oid ); OidRegistry<T> copy(); int size(); void clear(); @Override String toString(); } | @Test public void testCopy() throws Exception { } |
Registries implements SchemaLoaderListener, Cloneable { @Override public Registries clone() throws CloneNotSupportedException { Registries clone = ( Registries ) super.clone(); clone.globalOidRegistry = globalOidRegistry.copy(); clone.attributeTypeRegistry = attributeTypeRegistry.copy(); clone.comparatorRegistry = comparatorRegistry.copy(); clone.ditContentRuleRegistry = ditContentRuleRegistry.copy(); clone.ditStructureRuleRegistry = ditStructureRuleRegistry.copy(); clone.ldapSyntaxRegistry = ldapSyntaxRegistry.copy(); clone.matchingRuleRegistry = matchingRuleRegistry.copy(); clone.matchingRuleUseRegistry = matchingRuleUseRegistry.copy(); clone.nameFormRegistry = nameFormRegistry.copy(); clone.normalizerRegistry = normalizerRegistry.copy(); clone.objectClassRegistry = objectClassRegistry.copy(); clone.syntaxCheckerRegistry = syntaxCheckerRegistry.copy(); clone.errorHandler = errorHandler; for ( AttributeType attributeType : clone.attributeTypeRegistry ) { clone.globalOidRegistry.put( attributeType ); } for ( DitContentRule ditContentRule : clone.ditContentRuleRegistry ) { clone.globalOidRegistry.put( ditContentRule ); } for ( DitStructureRule ditStructureRule : clone.ditStructureRuleRegistry ) { clone.globalOidRegistry.put( ditStructureRule ); } for ( MatchingRule matchingRule : clone.matchingRuleRegistry ) { clone.globalOidRegistry.put( matchingRule ); } for ( MatchingRuleUse matchingRuleUse : clone.matchingRuleUseRegistry ) { clone.globalOidRegistry.put( matchingRuleUse ); } for ( NameForm nameForm : clone.nameFormRegistry ) { clone.globalOidRegistry.put( nameForm ); } for ( ObjectClass objectClass : clone.objectClassRegistry ) { clone.globalOidRegistry.put( objectClass ); } for ( LdapSyntax syntax : clone.ldapSyntaxRegistry ) { clone.globalOidRegistry.put( syntax ); } clone.loadedSchemas = new HashMap<>(); for ( Map.Entry<String, Set<SchemaObjectWrapper>> entry : schemaObjects.entrySet() ) { clone.loadedSchemas.put( entry.getKey(), loadedSchemas.get( entry.getKey() ) ); } clone.using = new HashMap<>(); clone.usedBy = new HashMap<>(); clone.buildReferences(); clone.checkRefInteg(); clone.schemaObjects = new HashMap<>(); for ( Map.Entry<String, Set<SchemaObjectWrapper>> entry : schemaObjects.entrySet() ) { Set<SchemaObjectWrapper> objects = new HashSet<>(); for ( SchemaObjectWrapper schemaObjectWrapper : entry.getValue() ) { SchemaObject original = schemaObjectWrapper.get(); try { if ( !( original instanceof LoadableSchemaObject ) ) { SchemaObject copy = clone.globalOidRegistry.getSchemaObject( original.getOid() ); SchemaObjectWrapper newWrapper = new SchemaObjectWrapper( copy ); objects.add( newWrapper ); } else { SchemaObjectWrapper newWrapper = new SchemaObjectWrapper( original ); objects.add( newWrapper ); } } catch ( LdapException ne ) { } } clone.schemaObjects.put( entry.getKey(), objects ); } return clone; } Registries(); AttributeTypeRegistry getAttributeTypeRegistry(); ComparatorRegistry getComparatorRegistry(); DitContentRuleRegistry getDitContentRuleRegistry(); DitStructureRuleRegistry getDitStructureRuleRegistry(); MatchingRuleRegistry getMatchingRuleRegistry(); MatchingRuleUseRegistry getMatchingRuleUseRegistry(); NameFormRegistry getNameFormRegistry(); NormalizerRegistry getNormalizerRegistry(); ObjectClassRegistry getObjectClassRegistry(); OidRegistry<SchemaObject> getGlobalOidRegistry(); SyntaxCheckerRegistry getSyntaxCheckerRegistry(); LdapSyntaxRegistry getLdapSyntaxRegistry(); String getOid( String name ); Schema getLoadedSchema( String schemaName ); boolean isSchemaLoaded( String schemaName ); void checkRefInteg(); void delCrossReferences( AttributeType attributeType ); void delCrossReferences( MatchingRule matchingRule ); void buildReference( SchemaObject schemaObject ); void removeReference( SchemaObject schemaObject ); void buildReferences(); void add( SchemaObject schemaObject, boolean check ); void delete( SchemaObject schemaObject ); @Override void schemaLoaded( Schema schema ); @Override void schemaUnloaded( Schema schema ); Map<String, Schema> getLoadedSchemas(); Map<String, Set<SchemaObjectWrapper>> getObjectBySchemaName(); boolean contains( SchemaObject schemaObject ); Set<SchemaObjectWrapper> addSchema( String schemaName ); void associateWithSchema( SchemaObject schemaObject ); void dissociateFromSchema( SchemaObject schemaObject ); boolean isReferenced( SchemaObject schemaObject ); Set<SchemaObjectWrapper> getUsedBy( SchemaObject schemaObject ); String dumpUsedBy(); String dumpUsing(); Set<SchemaObjectWrapper> getUsing( SchemaObject schemaObject ); void addReference( SchemaObject base, SchemaObject referenced ); void delReference( SchemaObject base, SchemaObject referenced ); boolean check(); @Override Registries clone(); boolean isRelaxed(); boolean isStrict(); void setRelaxed(); void setStrict(); SchemaErrorHandler getErrorHandler(); void setErrorHandler( SchemaErrorHandler errorHandler ); boolean isDisabledAccepted(); Set<SchemaObjectWrapper> getReferencing( SchemaObject schemaObject ); void setDisabledAccepted( boolean disabledAccepted ); void clear(); @Override String toString(); static final boolean STRICT; static final boolean RELAXED; } | @Test public void testClone() { } |
AttributeType extends AbstractSchemaObject implements Cloneable { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } AttributeType( String oid ); boolean isSingleValued(); void setSingleValued( boolean singleValued ); boolean isUserModifiable(); void setUserModifiable( boolean userModifiable ); boolean isCollective(); void setCollective( boolean collective ); boolean isRelaxed(); void setRelaxed( boolean isRelaxed ); UsageEnum getUsage(); void setUsage( UsageEnum usage ); long getSyntaxLength(); void setSyntaxLength( long length ); AttributeType getSuperior(); String getSuperiorOid(); void setSuperior( AttributeType superior ); void setSuperior( String newSuperiorOid ); void setSuperiorOid( String superiorOid ); String getSuperiorName(); LdapSyntax getSyntax(); void setSyntax( LdapSyntax syntax ); String getSyntaxName(); String getSyntaxOid(); void setSyntaxOid( String syntaxOid ); MatchingRule getEquality(); void setEquality( MatchingRule equality ); String getEqualityOid(); void setEqualityOid( String equalityOid ); String getEqualityName(); MatchingRule getOrdering(); void setOrdering( MatchingRule ordering ); String getOrderingName(); String getOrderingOid(); void setOrderingOid( String orderingOid ); MatchingRule getSubstring(); void setSubstring( MatchingRule substring ); String getSubstringName(); String getSubstringOid(); void setSubstringOid( String substrOid ); boolean isUser(); boolean isOperational(); boolean isAncestorOf( AttributeType descendant ); boolean isHR(); boolean isDescendantOf( AttributeType ancestor ); @Override String toString(); @Override AttributeType copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; } | @Test public void testToString() throws Exception { String string = attributeType.toString(); assertNotNull( string ); assertTrue( string.startsWith( "attributetype (" ) ); assertTrue( string.contains( " NAME " ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tSUP " ) ); assertTrue( string.contains( "\n\tUSAGE" ) ); } |
DitStructureRule extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } DitStructureRule( int ruleId ); String getForm(); void setForm( String form ); int getRuleId(); void setRuleId( int ruleId ); List<Integer> getSuperRules(); void setSuperRules( List<Integer> superRules ); void addSuperRule( Integer superRule ); @Override String getOid(); @Override String toString(); @Override DitStructureRule copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; } | @Test public void testToString() throws Exception { String string = ditStructureRule.toString(); assertNotNull( string ); assertTrue( string.startsWith( "ditstructurerule (" ) ); assertTrue( string.contains( " NAME " ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tFORM " ) ); assertTrue( string.contains( "\n\tSUP" ) ); } |
NumericNormalizer extends Normalizer implements PreparedNormalizer { public Value normalize( Value value ) throws LdapException { String normalized = normalize( value.getString() ); return new Value( normalized ); } NumericNormalizer(); Value normalize( Value value ); @Override String normalize( String value ); @Override String normalize( String value, PrepareString.AssertionType assertionType ); } | @Test public void testNumericNormalizerNull() throws LdapException { Normalizer normalizer = new NumericNormalizer(); assertEquals( null, normalizer.normalize( ( String ) null ) ); }
@Test public void testNumericNormalizerEmpty() throws LdapException { Normalizer normalizer = new NumericNormalizer(); assertEquals( "", normalizer.normalize( "" ) ); }
@Test public void testNumericNormalizerOneSpace() throws LdapException { Normalizer normalizer = new NumericNormalizer(); assertEquals( "", normalizer.normalize( " " ) ); }
@Test public void testNumericNormalizerTwoSpaces() throws LdapException { Normalizer normalizer = new NumericNormalizer(); assertEquals( "", normalizer.normalize( " " ) ); }
@Test public void testNumericNormalizerNSpaces() throws LdapException { Normalizer normalizer = new NumericNormalizer(); assertEquals( "", normalizer.normalize( " " ) ); }
@Test public void testInsignifiantSpacesStringOneChar() throws LdapException { Normalizer normalizer = new NumericNormalizer(); assertEquals( "1", normalizer.normalize( "1" ) ); }
@Test public void testInsignifiantSpacesStringTwoChars() throws LdapException { Normalizer normalizer = new NumericNormalizer(); assertEquals( "11", normalizer.normalize( "11" ) ); }
@Test public void testInsignifiantSpacesStringNChars() throws LdapException { Normalizer normalizer = new NumericNormalizer(); assertEquals( "123456", normalizer.normalize( "123456" ) ); }
@Test public void testInsignifiantNumericCharsSpaces() throws LdapException { Normalizer normalizer = new NumericNormalizer(); assertEquals( "1", normalizer.normalize( " 1" ) ); assertEquals( "1", normalizer.normalize( "1 " ) ); assertEquals( "1", normalizer.normalize( " 1 " ) ); assertEquals( "11", normalizer.normalize( "1 1" ) ); assertEquals( "11", normalizer.normalize( " 1 1" ) ); assertEquals( "11", normalizer.normalize( "1 1 " ) ); assertEquals( "11", normalizer.normalize( "1 1" ) ); assertEquals( "11", normalizer.normalize( " 1 1 " ) ); assertEquals( "123456789", normalizer.normalize( " 123 456 789 " ) ); } |
Strings { public static String listToString( List<?> list ) { if ( ( list == null ) || list.isEmpty() ) { return ""; } StringBuilder sb = new StringBuilder(); boolean isFirst = true; for ( Object elem : list ) { if ( isFirst ) { isFirst = false; } else { sb.append( ", " ); } sb.append( elem ); } return sb.toString(); } private Strings(); static String dumpBytes( byte[] buffer ); static String byteToString( byte b ); static String dumpByte( byte octet ); static char dumpHex( byte hex ); static String dumpHexPairs( byte[] buffer ); static String deepTrim( String str, boolean toLowerCase ); static String deepTrimToLower( String string ); static String deepTrim( String string ); static String trimConsecutiveToOne( String str, char ch ); static String centerTrunc( String str, int head, int tail ); static String toHexString( byte[] res ); static byte[] toByteArray( String hexString ); static String formatHtml( String source, boolean replaceNl, boolean replaceTag,
boolean replaceQuote ); static boolean areEquals( String string, int index, String text ); static boolean isCharASCII( byte[] byteArray, int index, char car ); static boolean isCharASCII( char[] charArray, int index, char car ); static boolean isCharASCII( String string, int index, char car ); static String utf8ToString( byte[] bytes ); static String utf8ToString( byte[] bytes, int length ); static String utf8ToString( byte[] bytes, int start, int length ); static int areEquals( byte[] bytes, int index, String text ); static int areEquals( char[] chars, int index, String text ); static int areEquals( char[] chars, int index, String text, boolean caseSensitive ); static int areEquals( char[] chars, int index, char[] chars2 ); static int areEquals( char[] chars, int index, char[] chars2, boolean caseSensitive ); static int areEquals( byte[] bytes, int index, byte[] bytes2 ); static boolean isEmpty( String str ); static boolean isEmpty( byte[] bytes ); static String trim( String str ); static byte[] trim( byte[] bytes ); static String trimLeft( String str ); static int trimLeft( char[] chars, int pos ); static void trimLeft( String string, Position pos ); static void trimLeft( byte[] bytes, Position pos ); static int trimLeft( byte[] bytes, int pos ); static String trimRight( String str ); static String trimRight( String str, int escapedSpace ); static int trimRight( char[] chars, int pos ); static String trimRight( String string, Position pos ); static String trimRight( byte[] bytes, Position pos ); static int trimRight( byte[] bytes, int pos ); static char charAt( String string, int index ); static byte byteAt( byte[] bytes, int index ); static char charAt( char[] chars, int index ); static String asciiBytesToString( byte[] bytes ); static byte[] getBytesUtf8( String string ); static byte[] getBytesUtf8Ascii( String string ); static String getDefaultCharsetName(); static boolean equals( String str1, String str2 ); static String listToString( List<?> list ); static String setToString( Set<?> set ); static String listToString( List<?> list, String tabs ); static String mapToString( Map<?, ?> map ); static String mapToString( Map<?, ?> map, String tabs ); @Deprecated static String toLowerCase( String value ); static String toLowerCaseAscii( String value ); static String toLowerCase( byte[] value ); @Deprecated static String toUpperCase( String value ); static String toUpperCaseAscii( String value ); static String upperCase( String str ); static String lowerCase( String str ); static String lowerCaseAscii( String str ); static boolean isPrintableString( String str ); static boolean isNotEmpty( String str ); static boolean isIA5String( String str ); static boolean isValidUuid( String uuid ); static String uuidToString( byte[] bytes ); static byte[] uuidToBytes( String string ); static byte[] copy( byte[] value ); static String getString( final byte[] data, int offset, int length, String charset ); static String getString( final byte[] data, int offset, int length, Charset charset ); static String getString( final byte[] data, String charset ); static String getString( final byte[] data, Charset charset ); static String getUUID( long value ); static int parseInt( String value ); static int compare( byte[] b1, byte[] b2 ); static final byte[] HEX_CHAR; static final byte[] EMPTY_BYTES; static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; } | @Test public void testListToString() { List<String> list = new ArrayList<String>(); list.add( "elem1" ); list.add( "elem2" ); list.add( "elem3" ); assertEquals( "elem1, elem2, elem3", Strings.listToString( list ) ); } |
DeepTrimNormalizer extends Normalizer implements PreparedNormalizer { @Override public String normalize( String value ) throws LdapException { return normalize( value, PrepareString.AssertionType.ATTRIBUTE_VALUE ); } DeepTrimNormalizer( String oid ); DeepTrimNormalizer(); @Override String normalize( String value ); @Override String normalize( String value, PrepareString.AssertionType assertionType ); } | @Test public void testDeepTrimNormalizerNull() throws LdapException { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); assertEquals( null, normalizer.normalize( ( String ) null ) ); }
@Test public void testDeepTrimNormalizerEmpty() throws LdapException { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); assertEquals( " ", normalizer.normalize( "" ) ); }
@Test public void testDeepTrimNormalizerOneSpace() throws LdapException { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); assertEquals( " ", normalizer.normalize( " " ) ); }
@Test public void testDeepTrimNormalizerTwoSpaces() throws LdapException { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); assertEquals( " ", normalizer.normalize( " " ) ); }
@Test public void testDeepTrimNormalizerNSpaces() throws LdapException { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); assertEquals( " ", normalizer.normalize( " " ) ); }
@Test public void testInsignifiantSpacesStringOneChar() throws LdapException { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); assertEquals( " a ", normalizer.normalize( "a" ) ); }
@Test public void testInsignifiantSpacesStringTwoChars() throws LdapException { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); assertEquals( " aa ", normalizer.normalize( "aa" ) ); }
@Test public void testInsignifiantSpacesStringNChars() throws LdapException { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); assertEquals( " aaaaa ", normalizer.normalize( "aaaaa" ) ); }
@Test public void testInsignifiantSpacesStringOneCombining() throws LdapException { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); char[] chars = new char[] { ' ', 0x0310 }; char[] expected = new char[] { ' ', 0x0310, ' ' }; String expectedStr = new String( expected ); String charsStr = new String( chars ); assertEquals( expectedStr, normalizer.normalize( charsStr ) ); }
@Test public void testInsignifiantSpacesStringNCombining() throws LdapException { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); char[] chars = new char[] { ' ', 0x0310, ' ', 0x0311, ' ', 0x0312 }; char[] expected = new char[] { ' ', 0x0310, ' ', ' ', 0x0311, ' ', ' ', 0x0312, ' ' }; assertEquals( new String( expected ), normalizer.normalize( new String( chars ) ) ); }
@Test public void testInsignifiantSpacesStringCharsSpaces() throws LdapException { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); assertEquals( " a ", normalizer.normalize( " a" ) ); assertEquals( " a ", normalizer.normalize( "a " ) ); assertEquals( " a ", normalizer.normalize( " a " ) ); assertEquals( " a a ", normalizer.normalize( "a a" ) ); assertEquals( " a a ", normalizer.normalize( " a a" ) ); assertEquals( " a a ", normalizer.normalize( "a a " ) ); assertEquals( " a a ", normalizer.normalize( "a a" ) ); assertEquals( " a a ", normalizer.normalize( " a a " ) ); assertEquals( " aaa aaa aaa ", normalizer.normalize( " aaa aaa aaa " ) ); }
@Test public void testNormalizeCharsCombiningSpaces() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); char[] chars = new char[] { 'a', 'm', ' ', 'e', 0x0301, 'l', 'i', 'e' }; char[] expected = new char[] { ' ', 'a', 'm', ' ', ' ', '\u00e9', 'l', 'i' , 'e', ' ' }; String expectedStr = new String( expected ); String charsStr = new String( chars ); assertEquals( expectedStr, normalizer.normalize( charsStr ) ); }
@Test public void testNormalizeString() throws Exception { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); assertEquals( " abcd ", normalizer.normalize( "abcd" ) ); }
@Test public void testMapToSpace() throws Exception { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); char[] chars = new char[] { 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0085, 0x00A0, 0x1680, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x2028, 0x2029, 0x202F, 0x205F }; assertEquals( " ", normalizer.normalize( new String( chars ) ) ); }
@Test public void testNormalizeIgnore() throws Exception { Normalizer normalizer = new DeepTrimNormalizer( "1.1.1" ); char[] chars = new char[58]; int pos = 0; for ( char c = 0x0000; c < 0x0008; c++ ) { chars[pos++] = c; } for ( char c = 0x000E; c < 0x001F; c++ ) { chars[pos++] = c; } for ( char c = 0x007F; c < 0x0084; c++ ) { chars[pos++] = c; } for ( char c = 0x0086; c < 0x009F; c++ ) { chars[pos++] = c; } chars[pos++] = 0x00AD; assertEquals( " ", normalizer.normalize( new String( chars ) ) ); } |
Strings { public static String mapToString( Map<?, ?> map ) { if ( ( map == null ) || ( map.size() == 0 ) ) { return ""; } StringBuilder sb = new StringBuilder(); boolean isFirst = true; for ( Map.Entry<?, ?> entry : map.entrySet() ) { if ( isFirst ) { isFirst = false; } else { sb.append( ", " ); } sb.append( entry.getKey() ); sb.append( " = '" ).append( entry.getValue() ).append( "'" ); } return sb.toString(); } private Strings(); static String dumpBytes( byte[] buffer ); static String byteToString( byte b ); static String dumpByte( byte octet ); static char dumpHex( byte hex ); static String dumpHexPairs( byte[] buffer ); static String deepTrim( String str, boolean toLowerCase ); static String deepTrimToLower( String string ); static String deepTrim( String string ); static String trimConsecutiveToOne( String str, char ch ); static String centerTrunc( String str, int head, int tail ); static String toHexString( byte[] res ); static byte[] toByteArray( String hexString ); static String formatHtml( String source, boolean replaceNl, boolean replaceTag,
boolean replaceQuote ); static boolean areEquals( String string, int index, String text ); static boolean isCharASCII( byte[] byteArray, int index, char car ); static boolean isCharASCII( char[] charArray, int index, char car ); static boolean isCharASCII( String string, int index, char car ); static String utf8ToString( byte[] bytes ); static String utf8ToString( byte[] bytes, int length ); static String utf8ToString( byte[] bytes, int start, int length ); static int areEquals( byte[] bytes, int index, String text ); static int areEquals( char[] chars, int index, String text ); static int areEquals( char[] chars, int index, String text, boolean caseSensitive ); static int areEquals( char[] chars, int index, char[] chars2 ); static int areEquals( char[] chars, int index, char[] chars2, boolean caseSensitive ); static int areEquals( byte[] bytes, int index, byte[] bytes2 ); static boolean isEmpty( String str ); static boolean isEmpty( byte[] bytes ); static String trim( String str ); static byte[] trim( byte[] bytes ); static String trimLeft( String str ); static int trimLeft( char[] chars, int pos ); static void trimLeft( String string, Position pos ); static void trimLeft( byte[] bytes, Position pos ); static int trimLeft( byte[] bytes, int pos ); static String trimRight( String str ); static String trimRight( String str, int escapedSpace ); static int trimRight( char[] chars, int pos ); static String trimRight( String string, Position pos ); static String trimRight( byte[] bytes, Position pos ); static int trimRight( byte[] bytes, int pos ); static char charAt( String string, int index ); static byte byteAt( byte[] bytes, int index ); static char charAt( char[] chars, int index ); static String asciiBytesToString( byte[] bytes ); static byte[] getBytesUtf8( String string ); static byte[] getBytesUtf8Ascii( String string ); static String getDefaultCharsetName(); static boolean equals( String str1, String str2 ); static String listToString( List<?> list ); static String setToString( Set<?> set ); static String listToString( List<?> list, String tabs ); static String mapToString( Map<?, ?> map ); static String mapToString( Map<?, ?> map, String tabs ); @Deprecated static String toLowerCase( String value ); static String toLowerCaseAscii( String value ); static String toLowerCase( byte[] value ); @Deprecated static String toUpperCase( String value ); static String toUpperCaseAscii( String value ); static String upperCase( String str ); static String lowerCase( String str ); static String lowerCaseAscii( String str ); static boolean isPrintableString( String str ); static boolean isNotEmpty( String str ); static boolean isIA5String( String str ); static boolean isValidUuid( String uuid ); static String uuidToString( byte[] bytes ); static byte[] uuidToBytes( String string ); static byte[] copy( byte[] value ); static String getString( final byte[] data, int offset, int length, String charset ); static String getString( final byte[] data, int offset, int length, Charset charset ); static String getString( final byte[] data, String charset ); static String getString( final byte[] data, Charset charset ); static String getUUID( long value ); static int parseInt( String value ); static int compare( byte[] b1, byte[] b2 ); static final byte[] HEX_CHAR; static final byte[] EMPTY_BYTES; static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; } | @Test public void testMapToString() { class Value { String name; int val; public Value( String name, int val ) { this.name = name; this.val = val; } public String toString() { return "[" + name + ", " + val + "]"; } } Map<String, Value> map = new HashMap<String, Value>(); map.put( "elem1", new Value( "name1", 1 ) ); map.put( "elem2", new Value( "name2", 2 ) ); map.put( "elem3", new Value( "name3", 3 ) ); String result = Strings.mapToString( map ); boolean res = "elem1 = '[name1, 1]', elem2 = '[name2, 2]', elem3 = '[name3, 3]'".equals( result ) || "elem1 = '[name1, 1]', elem3 = '[name3, 3]', elem2 = '[name2, 2]'".equals( result ) || "elem2 = '[name2, 2]', elem1 = '[name1, 1]', elem3 = '[name3, 3]'".equals( result ) || "elem2 = '[name2, 2]', elem3 = '[name3, 3]', elem1 = '[name1, 1]'".equals( result ) || "elem3 = '[name3, 3]', elem1 = '[name1, 1]', elem2 = '[name2, 2]'".equals( result ) || "elem3 = '[name3, 3]', elem2 = '[name2, 2]', elem1 = '[name1, 1]'".equals( result ); assertTrue( res ); } |
DeepTrimToLowerNormalizer extends Normalizer implements PreparedNormalizer { @Override public String normalize( String value ) throws LdapException { return normalize( value, PrepareString.AssertionType.ATTRIBUTE_VALUE ); } DeepTrimToLowerNormalizer( String oid ); DeepTrimToLowerNormalizer(); @Override String normalize( String value ); @Override String normalize( String value, PrepareString.AssertionType assertionType ); } | @Test public void testDeepTrimToLowerNormalizerNull() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); assertNull( normalizer.normalize( ( String ) null ) ); }
@Test public void testDeepTrimToLowerNormalizerEmpty() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); assertEquals( " ", normalizer.normalize( "" ) ); }
@Test public void testDeepTrimToLowerNormalizerOneSpace() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); assertEquals( " ", normalizer.normalize( " " ) ); }
@Test public void testDeepTrimToLowerNormalizerTwoSpaces() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); assertEquals( " ", normalizer.normalize( " " ) ); }
@Test public void testDeepTrimToLowerNormalizerNSpaces() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); assertEquals( " ", normalizer.normalize( " " ) ); }
@Test public void testInsignifiantSpacesStringOneChar() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); assertEquals( " a ", normalizer.normalize( "a" ) ); }
@Test public void testInsignifiantSpacesStringTwoChars() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); assertEquals( " aa ", normalizer.normalize( "aa" ) ); }
@Test public void testInsignifiantSpacesStringNChars() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); assertEquals( " aaaaa ", normalizer.normalize( "aaaaa" ) ); }
@Test public void testInsignifiantSpacesStringOneCombining() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); char[] chars = new char[] { 'e', 0x0301 }; char[] expected = new char[] { ' ', '\u00E9', ' ' }; String expectedStr = new String( expected ); String charsStr = new String( chars ); assertEquals( expectedStr, normalizer.normalize( charsStr ) ); }
@Test public void testInsignifiantSpacesStringNCombining() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); char[] chars = new char[] { 'e', 0x0301, ' ', 'a', 0x0300, 'i', 0x0302 }; char[] expected = new char[] { ' ', '\u00E9', ' ', ' ', '\u00E0', '\u00EE', ' ' }; assertEquals( new String( expected ), normalizer.normalize( new String( chars ) ) ); }
@Test public void testInsignifiantSpacesStringCharsSpaces() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); assertEquals( " a ", normalizer.normalize( " a" ) ); assertEquals( " a ", normalizer.normalize( "a " ) ); assertEquals( " a ", normalizer.normalize( " a " ) ); assertEquals( " a a ", normalizer.normalize( "a a" ) ); assertEquals( " a a ", normalizer.normalize( " a a" ) ); assertEquals( " a a ", normalizer.normalize( "a a " ) ); assertEquals( " a a ", normalizer.normalize( "a a" ) ); assertEquals( " a a ", normalizer.normalize( " a a " ) ); assertEquals( " aaa aaa aaa ", normalizer.normalize( " aaa aaa aaa " ) ); }
@Test public void testNormalizeCharsCombiningSpaces() throws LdapException { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); char[] chars = new char[] { 'a', 'm', ' ', 'e', 0x0301, 'l', 'i', 'e' }; char[] expected = new char[] { ' ', 'a', 'm', ' ', ' ', '\u00e9', 'l', 'i' , 'e', ' ' }; String expectedStr = new String( expected ); String charsStr = new String( chars ); assertEquals( expectedStr, normalizer.normalize( charsStr ) ); }
@Test public void testNormalizeString() throws Exception { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); assertEquals( " abcd ", normalizer.normalize( "abcd" ) ); }
@Test public void testMapToSpace() throws Exception { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); char[] chars = new char[] { 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0085, 0x00A0, 0x1680, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x2028, 0x2029, 0x202F, 0x205F }; assertEquals( " ", normalizer.normalize( new String( chars ) ) ); }
@Test public void testNormalizeIgnore() throws Exception { Normalizer normalizer = new DeepTrimToLowerNormalizer( "1.1.1" ); char[] chars = new char[58]; int pos = 0; for ( char c = 0x0000; c < 0x0008; c++ ) { chars[pos++] = c; } for ( char c = 0x000E; c < 0x001F; c++ ) { chars[pos++] = c; } for ( char c = 0x007F; c < 0x0084; c++ ) { chars[pos++] = c; } for ( char c = 0x0086; c < 0x009F; c++ ) { chars[pos++] = c; } chars[pos++] = 0x00AD; assertEquals( " ", normalizer.normalize( new String( chars ) ) ); }
@Test @Disabled public void testSpeed() throws Exception { Normalizer normalizer = new DeepTrimToLowerNormalizer(); String t = "xs crvtbynU Jikl7897A90"; normalizer.normalize( t ); long t0 = System.currentTimeMillis(); for ( int i = 0; i < 100000000; i++ ) { normalizer.normalize( t ); } long t1 = System.currentTimeMillis(); System.out.println( t1 - t0 ); Strings.deepTrimToLower( t ); t0 = System.currentTimeMillis(); for ( int i = 0; i < 100000000; i++ ) { Strings.deepTrimToLower( t ); } t1 = System.currentTimeMillis(); System.out.println( t1 - t0 ); } |
Strings { public static String deepTrim( String str, boolean toLowerCase ) { if ( ( null == str ) || ( str.length() == 0 ) ) { return ""; } char ch; int length = str.length(); char[] newbuf = new char[length]; boolean wsSeen = false; boolean isStart = true; int pos = 0; for ( int i = 0; i < length; i++ ) { ch = str.charAt( i ); if ( toLowerCase && Character.isUpperCase( ch ) ) { ch = Character.toLowerCase( ch ); } if ( Character.isWhitespace( ch ) ) { if ( !wsSeen ) { wsSeen = true; if ( isStart ) { isStart = false; } else { newbuf[pos++] = ch; } } } else { wsSeen = false; isStart = false; newbuf[pos++] = ch; } } return pos == 0 ? "" : new String( newbuf, 0, wsSeen ? pos - 1 : pos ); } private Strings(); static String dumpBytes( byte[] buffer ); static String byteToString( byte b ); static String dumpByte( byte octet ); static char dumpHex( byte hex ); static String dumpHexPairs( byte[] buffer ); static String deepTrim( String str, boolean toLowerCase ); static String deepTrimToLower( String string ); static String deepTrim( String string ); static String trimConsecutiveToOne( String str, char ch ); static String centerTrunc( String str, int head, int tail ); static String toHexString( byte[] res ); static byte[] toByteArray( String hexString ); static String formatHtml( String source, boolean replaceNl, boolean replaceTag,
boolean replaceQuote ); static boolean areEquals( String string, int index, String text ); static boolean isCharASCII( byte[] byteArray, int index, char car ); static boolean isCharASCII( char[] charArray, int index, char car ); static boolean isCharASCII( String string, int index, char car ); static String utf8ToString( byte[] bytes ); static String utf8ToString( byte[] bytes, int length ); static String utf8ToString( byte[] bytes, int start, int length ); static int areEquals( byte[] bytes, int index, String text ); static int areEquals( char[] chars, int index, String text ); static int areEquals( char[] chars, int index, String text, boolean caseSensitive ); static int areEquals( char[] chars, int index, char[] chars2 ); static int areEquals( char[] chars, int index, char[] chars2, boolean caseSensitive ); static int areEquals( byte[] bytes, int index, byte[] bytes2 ); static boolean isEmpty( String str ); static boolean isEmpty( byte[] bytes ); static String trim( String str ); static byte[] trim( byte[] bytes ); static String trimLeft( String str ); static int trimLeft( char[] chars, int pos ); static void trimLeft( String string, Position pos ); static void trimLeft( byte[] bytes, Position pos ); static int trimLeft( byte[] bytes, int pos ); static String trimRight( String str ); static String trimRight( String str, int escapedSpace ); static int trimRight( char[] chars, int pos ); static String trimRight( String string, Position pos ); static String trimRight( byte[] bytes, Position pos ); static int trimRight( byte[] bytes, int pos ); static char charAt( String string, int index ); static byte byteAt( byte[] bytes, int index ); static char charAt( char[] chars, int index ); static String asciiBytesToString( byte[] bytes ); static byte[] getBytesUtf8( String string ); static byte[] getBytesUtf8Ascii( String string ); static String getDefaultCharsetName(); static boolean equals( String str1, String str2 ); static String listToString( List<?> list ); static String setToString( Set<?> set ); static String listToString( List<?> list, String tabs ); static String mapToString( Map<?, ?> map ); static String mapToString( Map<?, ?> map, String tabs ); @Deprecated static String toLowerCase( String value ); static String toLowerCaseAscii( String value ); static String toLowerCase( byte[] value ); @Deprecated static String toUpperCase( String value ); static String toUpperCaseAscii( String value ); static String upperCase( String str ); static String lowerCase( String str ); static String lowerCaseAscii( String str ); static boolean isPrintableString( String str ); static boolean isNotEmpty( String str ); static boolean isIA5String( String str ); static boolean isValidUuid( String uuid ); static String uuidToString( byte[] bytes ); static byte[] uuidToBytes( String string ); static byte[] copy( byte[] value ); static String getString( final byte[] data, int offset, int length, String charset ); static String getString( final byte[] data, int offset, int length, Charset charset ); static String getString( final byte[] data, String charset ); static String getString( final byte[] data, Charset charset ); static String getUUID( long value ); static int parseInt( String value ); static int compare( byte[] b1, byte[] b2 ); static final byte[] HEX_CHAR; static final byte[] EMPTY_BYTES; static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; } | @Test public void testDeepTrim() { assertEquals( "", Strings.deepTrim( " ", false ) ); assertEquals( "ab", Strings.deepTrim( " ab ", false ) ); assertEquals( "a b", Strings.deepTrim( " a b ", false ) ); assertEquals( "a b", Strings.deepTrim( " a b ", false ) ); assertEquals( "a b", Strings.deepTrim( " a b ", false ) ); assertEquals( "ab", Strings.deepTrim( "ab ", false ) ); assertEquals( "ab", Strings.deepTrim( " ab", false ) ); assertEquals( "ab", Strings.deepTrim( "ab ", false ) ); assertEquals( "ab", Strings.deepTrim( " ab", false ) ); assertEquals( "a b", Strings.deepTrim( "a b", false ) ); assertEquals( "a b", Strings.deepTrim( "a b", false ) ); assertEquals( "a b", Strings.deepTrim( " a b", false ) ); assertEquals( "a b", Strings.deepTrim( "a b ", false ) ); } |
Strings { public static String trim( String str ) { return isEmpty( str ) ? "" : str.trim(); } private Strings(); static String dumpBytes( byte[] buffer ); static String byteToString( byte b ); static String dumpByte( byte octet ); static char dumpHex( byte hex ); static String dumpHexPairs( byte[] buffer ); static String deepTrim( String str, boolean toLowerCase ); static String deepTrimToLower( String string ); static String deepTrim( String string ); static String trimConsecutiveToOne( String str, char ch ); static String centerTrunc( String str, int head, int tail ); static String toHexString( byte[] res ); static byte[] toByteArray( String hexString ); static String formatHtml( String source, boolean replaceNl, boolean replaceTag,
boolean replaceQuote ); static boolean areEquals( String string, int index, String text ); static boolean isCharASCII( byte[] byteArray, int index, char car ); static boolean isCharASCII( char[] charArray, int index, char car ); static boolean isCharASCII( String string, int index, char car ); static String utf8ToString( byte[] bytes ); static String utf8ToString( byte[] bytes, int length ); static String utf8ToString( byte[] bytes, int start, int length ); static int areEquals( byte[] bytes, int index, String text ); static int areEquals( char[] chars, int index, String text ); static int areEquals( char[] chars, int index, String text, boolean caseSensitive ); static int areEquals( char[] chars, int index, char[] chars2 ); static int areEquals( char[] chars, int index, char[] chars2, boolean caseSensitive ); static int areEquals( byte[] bytes, int index, byte[] bytes2 ); static boolean isEmpty( String str ); static boolean isEmpty( byte[] bytes ); static String trim( String str ); static byte[] trim( byte[] bytes ); static String trimLeft( String str ); static int trimLeft( char[] chars, int pos ); static void trimLeft( String string, Position pos ); static void trimLeft( byte[] bytes, Position pos ); static int trimLeft( byte[] bytes, int pos ); static String trimRight( String str ); static String trimRight( String str, int escapedSpace ); static int trimRight( char[] chars, int pos ); static String trimRight( String string, Position pos ); static String trimRight( byte[] bytes, Position pos ); static int trimRight( byte[] bytes, int pos ); static char charAt( String string, int index ); static byte byteAt( byte[] bytes, int index ); static char charAt( char[] chars, int index ); static String asciiBytesToString( byte[] bytes ); static byte[] getBytesUtf8( String string ); static byte[] getBytesUtf8Ascii( String string ); static String getDefaultCharsetName(); static boolean equals( String str1, String str2 ); static String listToString( List<?> list ); static String setToString( Set<?> set ); static String listToString( List<?> list, String tabs ); static String mapToString( Map<?, ?> map ); static String mapToString( Map<?, ?> map, String tabs ); @Deprecated static String toLowerCase( String value ); static String toLowerCaseAscii( String value ); static String toLowerCase( byte[] value ); @Deprecated static String toUpperCase( String value ); static String toUpperCaseAscii( String value ); static String upperCase( String str ); static String lowerCase( String str ); static String lowerCaseAscii( String str ); static boolean isPrintableString( String str ); static boolean isNotEmpty( String str ); static boolean isIA5String( String str ); static boolean isValidUuid( String uuid ); static String uuidToString( byte[] bytes ); static byte[] uuidToBytes( String string ); static byte[] copy( byte[] value ); static String getString( final byte[] data, int offset, int length, String charset ); static String getString( final byte[] data, int offset, int length, Charset charset ); static String getString( final byte[] data, String charset ); static String getString( final byte[] data, Charset charset ); static String getUUID( long value ); static int parseInt( String value ); static int compare( byte[] b1, byte[] b2 ); static final byte[] HEX_CHAR; static final byte[] EMPTY_BYTES; static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; } | @Test public void testTrim() { assertEquals( "", Strings.trim( ( String ) null ) ); assertEquals( "", Strings.trim( "" ) ); assertEquals( "", Strings.trim( " " ) ); assertEquals( "", Strings.trim( " " ) ); assertEquals( "a", Strings.trim( "a " ) ); assertEquals( "a", Strings.trim( " a" ) ); assertEquals( "a", Strings.trim( " a " ) ); } |
BooleanNormalizer extends Normalizer { @Override public String normalize( String value ) throws LdapInvalidDnException { if ( value == null ) { return null; } return Strings.upperCase( value.trim() ); } BooleanNormalizer(); @Override String normalize( String value ); @Override String normalize( String value, PrepareString.AssertionType assertionType ); } | @Test public void testNormalizeNullValue() throws Exception { assertNull( normalizer.normalize( null ) ); }
@Test public void testNormalizeNonNullValue() throws Exception { assertEquals( "TRUE", normalizer.normalize( "true" ) ); assertEquals( "ABC", normalizer.normalize( "aBc" ) ); assertEquals( "FALSE", normalizer.normalize( "falsE" ) ); }
@Test public void testNormalizeValueWithSpaces() throws Exception { assertEquals( "TRUE", normalizer.normalize( " tRuE " ) ); } |
TelephoneNumberNormalizer extends Normalizer { @Override public String normalize( String value ) throws LdapException { return normalize( value, PrepareString.AssertionType.ATTRIBUTE_VALUE ); } TelephoneNumberNormalizer(); @Override String normalize( String value ); @Override String normalize( String value, PrepareString.AssertionType assertiontype ); } | @Test public void testTelephoneNumberNormalizerNull() throws LdapException { Normalizer normalizer = new TelephoneNumberNormalizer(); assertEquals( null, normalizer.normalize( ( String ) null ) ); }
@Test public void testTelephoneNumberNormalizerEmpty() throws LdapException { Normalizer normalizer = new TelephoneNumberNormalizer(); assertEquals( "", normalizer.normalize( "" ) ); }
@Test public void testTelephoneNumberNormalizerOneSpace() throws LdapException { Normalizer normalizer = new TelephoneNumberNormalizer(); assertEquals( "", normalizer.normalize( " " ) ); }
@Test public void testTelephoneNumberNormalizerTwoSpaces() throws LdapException { Normalizer normalizer = new TelephoneNumberNormalizer(); assertEquals( "", normalizer.normalize( " " ) ); }
@Test public void testTelephoneNumberNormalizerNSpaces() throws LdapException { Normalizer normalizer = new TelephoneNumberNormalizer(); assertEquals( "", normalizer.normalize( " " ) ); }
@Test public void testTelephoneNumberNormalizerOneHyphen() throws LdapException { Normalizer normalizer = new TelephoneNumberNormalizer(); assertEquals( "", normalizer.normalize( "-" ) ); }
@Test public void testTelephoneNumberNormalizerTwoHyphen() throws LdapException { Normalizer normalizer = new TelephoneNumberNormalizer(); assertEquals( "", normalizer.normalize( "--" ) ); }
@Test public void testTelephoneNumberNormalizerHyphensSpaces() throws LdapException { Normalizer normalizer = new TelephoneNumberNormalizer(); assertEquals( "", normalizer.normalize( " -- - -- " ) ); }
@Test public void testInsignifiantSpacesStringOneChar() throws LdapException { Normalizer normalizer = new TelephoneNumberNormalizer(); assertEquals( "1", normalizer.normalize( "1" ) ); }
@Test public void testInsignifiantSpacesStringTwoChars() throws LdapException { Normalizer normalizer = new TelephoneNumberNormalizer(); assertEquals( "11", normalizer.normalize( "11" ) ); }
@Test public void testInsignifiantSpacesStringNChars() throws LdapException { Normalizer normalizer = new TelephoneNumberNormalizer(); assertEquals( "123456", normalizer.normalize( "123456" ) ); }
@Test public void testInsignifiantTelephoneNumberCharsSpaces() throws LdapException { Normalizer normalizer = new TelephoneNumberNormalizer(); assertEquals( "1", normalizer.normalize( " 1" ) ); assertEquals( "1", normalizer.normalize( "1 " ) ); assertEquals( "1", normalizer.normalize( " 1 " ) ); assertEquals( "11", normalizer.normalize( "1 1" ) ); assertEquals( "11", normalizer.normalize( " 1 1" ) ); assertEquals( "11", normalizer.normalize( "1 1 " ) ); assertEquals( "11", normalizer.normalize( "1 1" ) ); assertEquals( "11", normalizer.normalize( " 1 1 " ) ); assertEquals( "123456789", normalizer.normalize( " 123 456 789 " ) ); assertEquals( "1", normalizer.normalize( "-1" ) ); assertEquals( "1", normalizer.normalize( "1-" ) ); assertEquals( "1", normalizer.normalize( "-1-" ) ); assertEquals( "11", normalizer.normalize( "1-1" ) ); assertEquals( "11", normalizer.normalize( "-1-1" ) ); assertEquals( "11", normalizer.normalize( "1-1-" ) ); assertEquals( "11", normalizer.normalize( "1--1" ) ); assertEquals( "11", normalizer.normalize( "-1---1-" ) ); assertEquals( "1(2)+3456789", normalizer.normalize( "---1(2)+3 456- 789 --" ) ); } |
Strings { public static String trimLeft( String str ) { if ( isEmpty( str ) ) { return ""; } int start = 0; int end = str.length(); while ( ( start < end ) && ( str.charAt( start ) == ' ' ) ) { start++; } return start == 0 ? str : str.substring( start ); } private Strings(); static String dumpBytes( byte[] buffer ); static String byteToString( byte b ); static String dumpByte( byte octet ); static char dumpHex( byte hex ); static String dumpHexPairs( byte[] buffer ); static String deepTrim( String str, boolean toLowerCase ); static String deepTrimToLower( String string ); static String deepTrim( String string ); static String trimConsecutiveToOne( String str, char ch ); static String centerTrunc( String str, int head, int tail ); static String toHexString( byte[] res ); static byte[] toByteArray( String hexString ); static String formatHtml( String source, boolean replaceNl, boolean replaceTag,
boolean replaceQuote ); static boolean areEquals( String string, int index, String text ); static boolean isCharASCII( byte[] byteArray, int index, char car ); static boolean isCharASCII( char[] charArray, int index, char car ); static boolean isCharASCII( String string, int index, char car ); static String utf8ToString( byte[] bytes ); static String utf8ToString( byte[] bytes, int length ); static String utf8ToString( byte[] bytes, int start, int length ); static int areEquals( byte[] bytes, int index, String text ); static int areEquals( char[] chars, int index, String text ); static int areEquals( char[] chars, int index, String text, boolean caseSensitive ); static int areEquals( char[] chars, int index, char[] chars2 ); static int areEquals( char[] chars, int index, char[] chars2, boolean caseSensitive ); static int areEquals( byte[] bytes, int index, byte[] bytes2 ); static boolean isEmpty( String str ); static boolean isEmpty( byte[] bytes ); static String trim( String str ); static byte[] trim( byte[] bytes ); static String trimLeft( String str ); static int trimLeft( char[] chars, int pos ); static void trimLeft( String string, Position pos ); static void trimLeft( byte[] bytes, Position pos ); static int trimLeft( byte[] bytes, int pos ); static String trimRight( String str ); static String trimRight( String str, int escapedSpace ); static int trimRight( char[] chars, int pos ); static String trimRight( String string, Position pos ); static String trimRight( byte[] bytes, Position pos ); static int trimRight( byte[] bytes, int pos ); static char charAt( String string, int index ); static byte byteAt( byte[] bytes, int index ); static char charAt( char[] chars, int index ); static String asciiBytesToString( byte[] bytes ); static byte[] getBytesUtf8( String string ); static byte[] getBytesUtf8Ascii( String string ); static String getDefaultCharsetName(); static boolean equals( String str1, String str2 ); static String listToString( List<?> list ); static String setToString( Set<?> set ); static String listToString( List<?> list, String tabs ); static String mapToString( Map<?, ?> map ); static String mapToString( Map<?, ?> map, String tabs ); @Deprecated static String toLowerCase( String value ); static String toLowerCaseAscii( String value ); static String toLowerCase( byte[] value ); @Deprecated static String toUpperCase( String value ); static String toUpperCaseAscii( String value ); static String upperCase( String str ); static String lowerCase( String str ); static String lowerCaseAscii( String str ); static boolean isPrintableString( String str ); static boolean isNotEmpty( String str ); static boolean isIA5String( String str ); static boolean isValidUuid( String uuid ); static String uuidToString( byte[] bytes ); static byte[] uuidToBytes( String string ); static byte[] copy( byte[] value ); static String getString( final byte[] data, int offset, int length, String charset ); static String getString( final byte[] data, int offset, int length, Charset charset ); static String getString( final byte[] data, String charset ); static String getString( final byte[] data, Charset charset ); static String getUUID( long value ); static int parseInt( String value ); static int compare( byte[] b1, byte[] b2 ); static final byte[] HEX_CHAR; static final byte[] EMPTY_BYTES; static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; } | @Test public void testTrimLeft() { assertEquals( "", Strings.trimLeft( ( String ) null ) ); assertEquals( "", Strings.trimLeft( "" ) ); assertEquals( "", Strings.trimLeft( " " ) ); assertEquals( "", Strings.trimLeft( " " ) ); assertEquals( "a ", Strings.trimLeft( "a " ) ); assertEquals( "a", Strings.trimLeft( " a" ) ); assertEquals( "a ", Strings.trimLeft( " a " ) ); } |
SyntaxChecker extends LoadableSchemaObject { @Override public boolean equals( Object o ) { if ( !super.equals( o ) ) { return false; } return o instanceof SyntaxChecker; } protected SyntaxChecker( String oid ); protected SyntaxChecker(); boolean isValidSyntax( Object value ); void setSchemaManager( SchemaManager schemaManager ); @Override boolean equals( Object o ); @Override String toString(); static final long serialVersionUID; } | @Test public void testEqualsNull() throws Exception { assertFalse( objectClassA.equals( null ) ); }
@Test public void testNotEqualDiffValue() throws Exception { assertFalse( objectClassA.equals( objectClassC ) ); assertFalse( objectClassC.equals( objectClassA ) ); } |
Strings { public static String trimRight( String str ) { if ( isEmpty( str ) ) { return ""; } int length = str.length(); int end = length; while ( ( end > 0 ) && ( str.charAt( end - 1 ) == ' ' ) ) { if ( ( end > 1 ) && ( str.charAt( end - 2 ) == '\\' ) ) { break; } end--; } return end == length ? str : str.substring( 0, end ); } private Strings(); static String dumpBytes( byte[] buffer ); static String byteToString( byte b ); static String dumpByte( byte octet ); static char dumpHex( byte hex ); static String dumpHexPairs( byte[] buffer ); static String deepTrim( String str, boolean toLowerCase ); static String deepTrimToLower( String string ); static String deepTrim( String string ); static String trimConsecutiveToOne( String str, char ch ); static String centerTrunc( String str, int head, int tail ); static String toHexString( byte[] res ); static byte[] toByteArray( String hexString ); static String formatHtml( String source, boolean replaceNl, boolean replaceTag,
boolean replaceQuote ); static boolean areEquals( String string, int index, String text ); static boolean isCharASCII( byte[] byteArray, int index, char car ); static boolean isCharASCII( char[] charArray, int index, char car ); static boolean isCharASCII( String string, int index, char car ); static String utf8ToString( byte[] bytes ); static String utf8ToString( byte[] bytes, int length ); static String utf8ToString( byte[] bytes, int start, int length ); static int areEquals( byte[] bytes, int index, String text ); static int areEquals( char[] chars, int index, String text ); static int areEquals( char[] chars, int index, String text, boolean caseSensitive ); static int areEquals( char[] chars, int index, char[] chars2 ); static int areEquals( char[] chars, int index, char[] chars2, boolean caseSensitive ); static int areEquals( byte[] bytes, int index, byte[] bytes2 ); static boolean isEmpty( String str ); static boolean isEmpty( byte[] bytes ); static String trim( String str ); static byte[] trim( byte[] bytes ); static String trimLeft( String str ); static int trimLeft( char[] chars, int pos ); static void trimLeft( String string, Position pos ); static void trimLeft( byte[] bytes, Position pos ); static int trimLeft( byte[] bytes, int pos ); static String trimRight( String str ); static String trimRight( String str, int escapedSpace ); static int trimRight( char[] chars, int pos ); static String trimRight( String string, Position pos ); static String trimRight( byte[] bytes, Position pos ); static int trimRight( byte[] bytes, int pos ); static char charAt( String string, int index ); static byte byteAt( byte[] bytes, int index ); static char charAt( char[] chars, int index ); static String asciiBytesToString( byte[] bytes ); static byte[] getBytesUtf8( String string ); static byte[] getBytesUtf8Ascii( String string ); static String getDefaultCharsetName(); static boolean equals( String str1, String str2 ); static String listToString( List<?> list ); static String setToString( Set<?> set ); static String listToString( List<?> list, String tabs ); static String mapToString( Map<?, ?> map ); static String mapToString( Map<?, ?> map, String tabs ); @Deprecated static String toLowerCase( String value ); static String toLowerCaseAscii( String value ); static String toLowerCase( byte[] value ); @Deprecated static String toUpperCase( String value ); static String toUpperCaseAscii( String value ); static String upperCase( String str ); static String lowerCase( String str ); static String lowerCaseAscii( String str ); static boolean isPrintableString( String str ); static boolean isNotEmpty( String str ); static boolean isIA5String( String str ); static boolean isValidUuid( String uuid ); static String uuidToString( byte[] bytes ); static byte[] uuidToBytes( String string ); static byte[] copy( byte[] value ); static String getString( final byte[] data, int offset, int length, String charset ); static String getString( final byte[] data, int offset, int length, Charset charset ); static String getString( final byte[] data, String charset ); static String getString( final byte[] data, Charset charset ); static String getUUID( long value ); static int parseInt( String value ); static int compare( byte[] b1, byte[] b2 ); static final byte[] HEX_CHAR; static final byte[] EMPTY_BYTES; static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; } | @Test public void testTrimRight() { assertEquals( "", Strings.trimRight( ( String ) null ) ); assertEquals( "", Strings.trimRight( "" ) ); assertEquals( "", Strings.trimRight( " " ) ); assertEquals( "", Strings.trimRight( " " ) ); assertEquals( "a", Strings.trimRight( "a " ) ); assertEquals( " a", Strings.trimRight( " a" ) ); assertEquals( " a", Strings.trimRight( " a " ) ); } |
PrepareString { public static String normalize( String value ) { if ( !Normalizer.isNormalized( value, Normalizer.Form.NFKC ) ) { return Normalizer.normalize( value, Normalizer.Form.NFKC ); } else { return value; } } private PrepareString(); static String transcode( byte[] bytes ); static String normalize( String value ); static String mapCaseSensitive( String unicode ); static void checkProhibited( char[] value ); static String insignificantNumericStringHandling( char[] source ); static String insignificantTelephoneNumberStringHandling( char[] source ); static String insignificantSpacesStringValue( char[] origin ); static String insignificantSpacesStringInitial( char[] origin ); static String insignificantSpacesStringAny( char[] origin ); static String insignificantSpacesStringFinal( char[] origin ); static String mapIgnoreCase( String unicode ); static final boolean CASE_SENSITIVE; static final boolean IGNORE_CASE; } | @Test public void testEscapeBackSlash() throws IOException { String result = PrepareString.normalize( "C:\\a\\b\\c" ); System.out.println( result ); } |
PrepareString { public static String insignificantSpacesStringInitial( char[] origin ) { if ( origin == null ) { return " "; } int pos = 0; char[] target = new char[origin.length * 2]; int newPos = 0; NormStateEnum normState = NormStateEnum.START; while ( normState != NormStateEnum.END ) { switch ( normState ) { case START : if ( pos == origin.length ) { return " "; } char c = origin[pos]; if ( c == ' ' ) { pos++; normState = NormStateEnum.INITIAL_SPACES; } else { target[newPos++] = ' '; target[newPos++] = c; pos++; normState = NormStateEnum.INITIAL_CHAR; } break; case INITIAL_CHAR : if ( pos == origin.length ) { normState = NormStateEnum.END; break; } c = origin[pos]; if ( c == ' ' ) { pos++; normState = NormStateEnum.SPACES; } else { target[newPos++] = c; pos++; normState = NormStateEnum.CHARS; } break; case INITIAL_SPACES : if ( pos == origin.length ) { return " "; } c = origin[pos]; if ( c == ' ' ) { pos++; } else { target[newPos++] = ' '; target[newPos++] = c; pos++; normState = NormStateEnum.INITIAL_CHAR; } break; case CHARS : if ( pos == origin.length ) { normState = NormStateEnum.END; break; } c = origin[pos]; if ( c == ' ' ) { pos++; normState = NormStateEnum.SPACES; } else { target[newPos++] = c; pos++; } break; case SPACES : if ( pos == origin.length ) { target[newPos++] = ' '; normState = NormStateEnum.END; break; } c = origin[pos]; if ( c == ' ' ) { pos++; } else { target[newPos++] = ' '; target[newPos++] = ' '; target[newPos++] = c; pos++; normState = NormStateEnum.SPACE_CHAR; } break; case SPACE_CHAR : if ( pos == origin.length ) { normState = NormStateEnum.END; break; } c = origin[pos]; if ( c == ' ' ) { pos++; normState = NormStateEnum.SPACES; } else { target[newPos++] = c; pos++; normState = NormStateEnum.CHARS; } break; default : break; } } return new String( target, 0, newPos ); } private PrepareString(); static String transcode( byte[] bytes ); static String normalize( String value ); static String mapCaseSensitive( String unicode ); static void checkProhibited( char[] value ); static String insignificantNumericStringHandling( char[] source ); static String insignificantTelephoneNumberStringHandling( char[] source ); static String insignificantSpacesStringValue( char[] origin ); static String insignificantSpacesStringInitial( char[] origin ); static String insignificantSpacesStringAny( char[] origin ); static String insignificantSpacesStringFinal( char[] origin ); static String mapIgnoreCase( String unicode ); static final boolean CASE_SENSITIVE; static final boolean IGNORE_CASE; } | @Test public void insignificantSpacesStringInitialNull() throws InvalidCharacterException { char[] empty = null; assertEquals( " ", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialEmpty() throws InvalidCharacterException { char[] empty = new char[]{}; assertEquals( " ", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ ' ' }; assertEquals( " ", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ ' ', ' ', ' ', ' '}; assertEquals( " ", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialA() throws InvalidCharacterException { char[] empty = new char[]{ 'a' }; assertEquals( " a", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialABC() throws InvalidCharacterException { char[] empty = new char[]{ 'a', 'b', 'c' }; assertEquals( " abc", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialOneSpaceA() throws InvalidCharacterException { char[] empty = new char[]{ ' ', 'a' }; assertEquals( " a", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialNSpacesA() throws InvalidCharacterException { char[] empty = new char[]{ ' ', ' ', ' ', 'a' }; assertEquals( " a", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialOneSpaceABC() throws InvalidCharacterException { char[] empty = new char[]{ ' ', 'a', 'b', 'c' }; assertEquals( " abc", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialNSpacesABC() throws InvalidCharacterException { char[] empty = new char[]{ ' ', ' ', ' ', 'a', 'b', 'c' }; assertEquals( " abc", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialInnerOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ', 'b', ' ', 'c' }; assertEquals( " a b c", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialInnerNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ', ' ', 'b', ' ', ' ', ' ', ' ', 'c' }; assertEquals( " a b c", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialEndingOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ' }; assertEquals( " a ", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialEndingNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ', ' ', ' ' }; assertEquals( " a ", PrepareString.insignificantSpacesStringInitial( empty ) ); }
@Test public void insignificantSpacesStringInitialAll() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ', ' ', 'b', ' ', ' ', ' ', ' ', 'c', ' ', ' ', ' ' }; assertEquals( " a b c ", PrepareString.insignificantSpacesStringInitial( empty ) ); } |
Strings { public static boolean areEquals( String string, int index, String text ) { if ( ( string == null ) || ( text == null ) ) { return false; } int length1 = string.length(); int length2 = text.length(); if ( ( length1 == 0 ) || ( length1 <= index ) || ( index < 0 ) || ( length2 == 0 ) || ( length2 > ( length1 + index ) ) ) { return false; } else { return string.substring( index ).startsWith( text ); } } private Strings(); static String dumpBytes( byte[] buffer ); static String byteToString( byte b ); static String dumpByte( byte octet ); static char dumpHex( byte hex ); static String dumpHexPairs( byte[] buffer ); static String deepTrim( String str, boolean toLowerCase ); static String deepTrimToLower( String string ); static String deepTrim( String string ); static String trimConsecutiveToOne( String str, char ch ); static String centerTrunc( String str, int head, int tail ); static String toHexString( byte[] res ); static byte[] toByteArray( String hexString ); static String formatHtml( String source, boolean replaceNl, boolean replaceTag,
boolean replaceQuote ); static boolean areEquals( String string, int index, String text ); static boolean isCharASCII( byte[] byteArray, int index, char car ); static boolean isCharASCII( char[] charArray, int index, char car ); static boolean isCharASCII( String string, int index, char car ); static String utf8ToString( byte[] bytes ); static String utf8ToString( byte[] bytes, int length ); static String utf8ToString( byte[] bytes, int start, int length ); static int areEquals( byte[] bytes, int index, String text ); static int areEquals( char[] chars, int index, String text ); static int areEquals( char[] chars, int index, String text, boolean caseSensitive ); static int areEquals( char[] chars, int index, char[] chars2 ); static int areEquals( char[] chars, int index, char[] chars2, boolean caseSensitive ); static int areEquals( byte[] bytes, int index, byte[] bytes2 ); static boolean isEmpty( String str ); static boolean isEmpty( byte[] bytes ); static String trim( String str ); static byte[] trim( byte[] bytes ); static String trimLeft( String str ); static int trimLeft( char[] chars, int pos ); static void trimLeft( String string, Position pos ); static void trimLeft( byte[] bytes, Position pos ); static int trimLeft( byte[] bytes, int pos ); static String trimRight( String str ); static String trimRight( String str, int escapedSpace ); static int trimRight( char[] chars, int pos ); static String trimRight( String string, Position pos ); static String trimRight( byte[] bytes, Position pos ); static int trimRight( byte[] bytes, int pos ); static char charAt( String string, int index ); static byte byteAt( byte[] bytes, int index ); static char charAt( char[] chars, int index ); static String asciiBytesToString( byte[] bytes ); static byte[] getBytesUtf8( String string ); static byte[] getBytesUtf8Ascii( String string ); static String getDefaultCharsetName(); static boolean equals( String str1, String str2 ); static String listToString( List<?> list ); static String setToString( Set<?> set ); static String listToString( List<?> list, String tabs ); static String mapToString( Map<?, ?> map ); static String mapToString( Map<?, ?> map, String tabs ); @Deprecated static String toLowerCase( String value ); static String toLowerCaseAscii( String value ); static String toLowerCase( byte[] value ); @Deprecated static String toUpperCase( String value ); static String toUpperCaseAscii( String value ); static String upperCase( String str ); static String lowerCase( String str ); static String lowerCaseAscii( String str ); static boolean isPrintableString( String str ); static boolean isNotEmpty( String str ); static boolean isIA5String( String str ); static boolean isValidUuid( String uuid ); static String uuidToString( byte[] bytes ); static byte[] uuidToBytes( String string ); static byte[] copy( byte[] value ); static String getString( final byte[] data, int offset, int length, String charset ); static String getString( final byte[] data, int offset, int length, Charset charset ); static String getString( final byte[] data, String charset ); static String getString( final byte[] data, Charset charset ); static String getUUID( long value ); static int parseInt( String value ); static int compare( byte[] b1, byte[] b2 ); static final byte[] HEX_CHAR; static final byte[] EMPTY_BYTES; static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; } | @Test public void testAreEqualsFull() { assertEquals( 6, Strings.areEquals( AZERTY, 0, "azerty" ) ); }
@Test public void testAreEqualsDiff() { assertEquals( -1, Strings.areEquals( AZERTY, 0, "Azerty" ) ); }
@Test public void testAreEqualsEmpty() { assertEquals( -1, Strings.areEquals( AZERTY, 0, "" ) ); }
@Test public void testAreEqualsFirstCharDiff() { assertEquals( -1, Strings.areEquals( AZERTY, 0, "Azerty" ) ); }
@Test public void testAreEqualsMiddleCharDiff() { assertEquals( -1, Strings.areEquals( AZERTY, 0, "azeRty" ) ); }
@Test public void testAreEqualsLastCharDiff() { assertEquals( -1, Strings.areEquals( AZERTY, 0, "azertY" ) ); }
@Test public void testAreEqualsCharByChar() { assertEquals( 1, Strings.areEquals( AZERTY, 0, "a" ) ); assertEquals( 2, Strings.areEquals( AZERTY, 1, "z" ) ); assertEquals( 3, Strings.areEquals( AZERTY, 2, "e" ) ); assertEquals( 4, Strings.areEquals( AZERTY, 3, "r" ) ); assertEquals( 5, Strings.areEquals( AZERTY, 4, "t" ) ); assertEquals( 6, Strings.areEquals( AZERTY, 5, "y" ) ); }
@Test public void testAreEqualsTooShort() { assertEquals( -1, Strings.areEquals( AZERTY, 0, "azertyiop" ) ); }
@Test public void testAreEqualsTooShortMiddle() { assertEquals( -1, Strings.areEquals( AZERTY, 0, "ertyiop" ) ); }
@Test public void testAreEqualsLastChar() { assertEquals( 6, Strings.areEquals( AZERTY, 5, "y" ) ); }
@Test public void testAreEqualsMiddle() { assertEquals( 4, Strings.areEquals( AZERTY, 2, "er" ) ); } |
PrepareString { public static String insignificantSpacesStringFinal( char[] origin ) { if ( origin == null ) { return " "; } int pos = 0; char[] target = new char[origin.length * 2 + 1]; int newPos = 0; NormStateEnum normState = NormStateEnum.START; while ( normState != NormStateEnum.END ) { switch ( normState ) { case START : if ( pos == origin.length ) { return " "; } char c = origin[pos]; if ( c == ' ' ) { pos++; normState = NormStateEnum.INITIAL_SPACES; } else { target[newPos++] = c; pos++; normState = NormStateEnum.INITIAL_CHAR; } break; case INITIAL_CHAR : if ( pos == origin.length ) { target[newPos++] = ' '; normState = NormStateEnum.END; break; } c = origin[pos]; if ( c == ' ' ) { pos++; normState = NormStateEnum.SPACES; } else { target[newPos++] = c; pos++; normState = NormStateEnum.CHARS; } break; case INITIAL_SPACES : if ( pos == origin.length ) { return " "; } c = origin[pos]; if ( c == ' ' ) { pos++; } else { target[newPos++] = ' '; target[newPos++] = c; pos++; normState = NormStateEnum.INITIAL_CHAR; } break; case CHARS : if ( pos == origin.length ) { target[newPos++] = ' '; normState = NormStateEnum.END; break; } c = origin[pos]; if ( c == ' ' ) { pos++; normState = NormStateEnum.SPACES; } else { target[newPos++] = c; pos++; } break; case SPACES : if ( pos == origin.length ) { target[newPos++] = ' '; normState = NormStateEnum.END; break; } c = origin[pos]; if ( c == ' ' ) { pos++; } else { target[newPos++] = ' '; target[newPos++] = ' '; target[newPos++] = c; pos++; normState = NormStateEnum.SPACE_CHAR; } break; case SPACE_CHAR : if ( pos == origin.length ) { target[newPos++] = ' '; normState = NormStateEnum.END; break; } c = origin[pos]; if ( c == ' ' ) { pos++; normState = NormStateEnum.SPACES; } else { target[newPos++] = c; pos++; normState = NormStateEnum.CHARS; } break; default : break; } } return new String( target, 0, newPos ); } private PrepareString(); static String transcode( byte[] bytes ); static String normalize( String value ); static String mapCaseSensitive( String unicode ); static void checkProhibited( char[] value ); static String insignificantNumericStringHandling( char[] source ); static String insignificantTelephoneNumberStringHandling( char[] source ); static String insignificantSpacesStringValue( char[] origin ); static String insignificantSpacesStringInitial( char[] origin ); static String insignificantSpacesStringAny( char[] origin ); static String insignificantSpacesStringFinal( char[] origin ); static String mapIgnoreCase( String unicode ); static final boolean CASE_SENSITIVE; static final boolean IGNORE_CASE; } | @Test public void insignificantSpacesStringFinalNull() throws InvalidCharacterException { char[] empty = null; assertEquals( " ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalEmpty() throws InvalidCharacterException { char[] empty = new char[]{}; assertEquals( " ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ ' ' }; assertEquals( " ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ ' ', ' ', ' ', ' '}; assertEquals( " ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalA() throws InvalidCharacterException { char[] empty = new char[]{ 'a' }; assertEquals( "a ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalABC() throws InvalidCharacterException { char[] empty = new char[]{ 'a', 'b', 'c' }; assertEquals( "abc ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalAOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ' }; assertEquals( "a ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalANSpaces() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ', ' ', ' ' }; assertEquals( "a ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalABCOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ 'a', 'b', 'c', ' ' }; assertEquals( "abc ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalABCNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ 'a', 'b', 'c', ' ', ' ', ' ' }; assertEquals( "abc ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalInnerOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ', 'b', ' ', 'c' }; assertEquals( "a b c ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalInnerNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ', ' ', 'b', ' ', ' ', ' ', ' ', 'c' }; assertEquals( "a b c ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalStartingOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ ' ', 'a' }; assertEquals( " a ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalStartingNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ ' ', ' ', ' ', 'a'}; assertEquals( " a ", PrepareString.insignificantSpacesStringFinal( empty ) ); }
@Test public void insignificantSpacesStringFinalAll() throws InvalidCharacterException { char[] empty = new char[]{ ' ', ' ', ' ', 'a', ' ', ' ', 'b', ' ', ' ', ' ', ' ', 'c', ' ', 'd' }; assertEquals( " a b c d ", PrepareString.insignificantSpacesStringFinal( empty ) ); } |
PrepareString { public static String insignificantSpacesStringAny( char[] origin ) { if ( origin == null ) { return " "; } int pos = 0; char[] target = new char[origin.length * 2 + 1]; int newPos = 0; NormStateEnum normState = NormStateEnum.START; while ( normState != NormStateEnum.END ) { switch ( normState ) { case START : if ( pos == origin.length ) { return " "; } char c = origin[pos]; if ( c == ' ' ) { pos++; normState = NormStateEnum.INITIAL_SPACES; } else { target[newPos++] = c; pos++; normState = NormStateEnum.INITIAL_CHAR; } break; case INITIAL_CHAR : if ( pos == origin.length ) { normState = NormStateEnum.END; break; } c = origin[pos]; if ( c == ' ' ) { target[newPos++] = ' '; pos++; normState = NormStateEnum.SPACES; } else { target[newPos++] = c; pos++; normState = NormStateEnum.CHARS; } break; case INITIAL_SPACES : if ( pos == origin.length ) { return " "; } c = origin[pos]; if ( c == ' ' ) { pos++; } else { target[newPos++] = ' '; target[newPos++] = c; pos++; normState = NormStateEnum.INITIAL_CHAR; } break; case CHARS : if ( pos == origin.length ) { normState = NormStateEnum.END; break; } c = origin[pos]; if ( c == ' ' ) { target[newPos++] = ' '; pos++; normState = NormStateEnum.SPACES; } else { target[newPos++] = c; pos++; } break; case SPACES : if ( pos == origin.length ) { normState = NormStateEnum.END; break; } c = origin[pos]; if ( c == ' ' ) { pos++; } else { target[newPos++] = ' '; target[newPos++] = c; pos++; normState = NormStateEnum.SPACE_CHAR; } break; case SPACE_CHAR : if ( pos == origin.length ) { normState = NormStateEnum.END; break; } c = origin[pos]; if ( c == ' ' ) { pos++; target[newPos++] = ' '; normState = NormStateEnum.SPACES; } else { target[newPos++] = c; pos++; normState = NormStateEnum.CHARS; } break; default : break; } } return new String( target, 0, newPos ); } private PrepareString(); static String transcode( byte[] bytes ); static String normalize( String value ); static String mapCaseSensitive( String unicode ); static void checkProhibited( char[] value ); static String insignificantNumericStringHandling( char[] source ); static String insignificantTelephoneNumberStringHandling( char[] source ); static String insignificantSpacesStringValue( char[] origin ); static String insignificantSpacesStringInitial( char[] origin ); static String insignificantSpacesStringAny( char[] origin ); static String insignificantSpacesStringFinal( char[] origin ); static String mapIgnoreCase( String unicode ); static final boolean CASE_SENSITIVE; static final boolean IGNORE_CASE; } | @Test public void insignificantSpacesStringAnyNull() throws InvalidCharacterException { char[] empty = null; assertEquals( " ", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyEmpty() throws InvalidCharacterException { char[] empty = new char[]{}; assertEquals( " ", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ ' ' }; assertEquals( " ", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ ' ', ' ', ' ', ' '}; assertEquals( " ", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyA() throws InvalidCharacterException { char[] empty = new char[]{ 'a' }; assertEquals( "a", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyABC() throws InvalidCharacterException { char[] empty = new char[]{ 'a', 'b', 'c' }; assertEquals( "abc", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyAOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ' }; assertEquals( "a ", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyANSpaces() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ', ' ', ' ' }; assertEquals( "a ", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyOneSpaceA() throws InvalidCharacterException { char[] empty = new char[]{ ' ', 'a' }; assertEquals( " a", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyNSpacesA() throws InvalidCharacterException { char[] empty = new char[]{ ' ', ' ', ' ', 'a' }; assertEquals( " a", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyABCOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ 'a', 'b', 'c', ' ' }; assertEquals( "abc ", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyABCNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ 'a', 'b', 'c', ' ', ' ', ' ' }; assertEquals( "abc ", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyOneSpaceABC() throws InvalidCharacterException { char[] empty = new char[]{ ' ', 'a', 'b', 'c' }; assertEquals( " abc", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyNSpacesABC() throws InvalidCharacterException { char[] empty = new char[]{ ' ', ' ', ' ', 'a', 'b', 'c' }; assertEquals( " abc", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyInnerOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ', 'b', ' ', 'c' }; assertEquals( "a b c", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyInnerNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ', ' ', 'b', ' ', ' ', ' ', ' ', 'c' }; assertEquals( "a b c", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyStartingOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ ' ', 'a' }; assertEquals( " a", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyStartingNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ ' ', ' ', ' ', 'a'}; assertEquals( " a", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyEndingOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ' }; assertEquals( "a ", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyEndingNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ 'a', ' ', ' ', ' ' }; assertEquals( "a ", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyStartingEndingOneSpace() throws InvalidCharacterException { char[] empty = new char[]{ ' ', 'a', ' ' }; assertEquals( " a ", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyStartingEndingNSpaces() throws InvalidCharacterException { char[] empty = new char[]{ ' ', ' ', ' ', 'a', ' ', ' ', ' ' }; assertEquals( " a ", PrepareString.insignificantSpacesStringAny( empty ) ); }
@Test public void insignificantSpacesStringAnyAll() throws InvalidCharacterException { char[] empty = new char[]{ ' ', ' ', ' ', 'a', ' ', ' ', 'b', ' ', ' ', ' ', ' ', 'c', ' ', 'd', ' ', ' ', ' ' }; assertEquals( " a b c d ", PrepareString.insignificantSpacesStringAny( empty ) ); } |
DitContentRule extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } DitContentRule( String oid ); List<String> getAuxObjectClassOids(); void addAuxObjectClassOidOids( String oid ); void addAuxObjectClasses( ObjectClass objectClass ); void setAuxObjectClassOids( List<String> auxObjectClassOids ); void setAuxObjectClasses( List<ObjectClass> auxObjectClasses ); List<ObjectClass> getAuxObjectClasses(); List<String> getMayAttributeTypeOids(); void addMayAttributeTypeOids( String oid ); void addMayAttributeTypes( AttributeType attributeType ); void setMayAttributeTypeOids( List<String> mayAttributeTypeOids ); void setMayAttributeTypes( List<AttributeType> mayAttributeTypes ); List<AttributeType> getMayAttributeTypes(); List<String> getMustAttributeTypeOids(); void addMustAttributeTypeOids( String oid ); void addMustAttributeTypes( AttributeType attributeType ); void setMustAttributeTypeOids( List<String> mustAttributeTypeOids ); void setMustAttributeTypes( List<AttributeType> mustAttributeTypes ); List<AttributeType> getMustAttributeTypes(); List<String> getNotAttributeTypeOids(); void addNotAttributeTypeOids( String oid ); void addNotAttributeTypes( AttributeType attributeType ); void setNotAttributeTypeOids( List<String> notAttributeTypeOids ); void setNotAttributeTypes( List<AttributeType> notAttributeTypes ); List<AttributeType> getNotAttributeTypes(); @Override String toString(); @Override DitContentRule copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; } | @Test public void testToString() throws Exception { String string = ditContentRule.toString(); assertNotNull( string ); assertTrue( string.startsWith( "ditcontentrule (" ) ); assertTrue( string.contains( " NAME " ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tAUX " ) ); assertTrue( string.contains( "\n\tMUST" ) ); assertTrue( string.contains( "\n\tMAY" ) ); assertTrue( string.contains( "\n\tNOT" ) ); } |
MatchingRuleUse extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } MatchingRuleUse( String oid ); List<String> getApplicableAttributeOids(); List<AttributeType> getApplicableAttributes(); void setApplicableAttributeOids( List<String> applicableAttributeOids ); void setApplicableAttributes( List<AttributeType> applicableAttributes ); void addApplicableAttributeOids( String oid ); void addApplicableAttribute( AttributeType attributeType ); @Override String toString(); @Override MatchingRuleUse copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; } | @Test public void testToString() throws Exception { String string = matchingRuleUse.toString(); assertNotNull( string ); assertTrue( string.startsWith( "matchingruleuse (" ) ); assertTrue( string.contains( " NAME " ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tAPPLIES " ) ); } |
Ava implements Externalizable, Cloneable, Comparable<Ava> { @Override public boolean equals( Object obj ) { if ( this == obj ) { return true; } if ( !( obj instanceof Ava ) ) { return false; } Ava instance = ( Ava ) obj; if ( attributeType == null ) { if ( normType == null ) { if ( instance.normType != null ) { return false; } } else { if ( !normType.equals( instance.normType ) ) { return false; } } } else { if ( instance.getAttributeType() == null ) { if ( ( schemaManager != null ) && !attributeType.equals( schemaManager.getAttributeType( instance.getType() ) ) ) { return false; } } else if ( !attributeType.equals( instance.getAttributeType() ) ) { return false; } } if ( ( value == null ) || value.isNull() ) { return ( instance.value == null ) || instance.value.isNull(); } else { if ( schemaManager != null ) { if ( ( value.getString() != null ) && value.getString().equals( instance.value.getString() ) ) { return true; } if ( attributeType == null ) { attributeType = schemaManager.getAttributeType( normType ); } MatchingRule equalityMatchingRule = attributeType.getEquality(); if ( equalityMatchingRule != null ) { Normalizer normalizer = equalityMatchingRule.getNormalizer(); try { return equalityMatchingRule.getLdapComparator().compare( normalizer.normalize( value.getString() ), instance.value.getString() ) == 0; } catch ( LdapException le ) { LOG.error( I18n.err( I18n.ERR_13620_CANNOT_NORMALIZE_VALUE ), le.getMessage() ); return false; } } else { if ( !value.isHumanReadable() ) { return Arrays.equals( value.getBytes(), instance.value.getBytes() ); } else { return value.getString().equals( instance.value.getString() ); } } } else { return value.equals( instance.value ); } } } Ava(); Ava( SchemaManager schemaManager ); Ava( SchemaManager schemaManager, Ava ava ); Ava( String upType, byte[] upValue ); Ava( SchemaManager schemaManager, String upType, byte[] upValue ); Ava( SchemaManager schemaManager, String upType, String upName, byte[] upValue ); Ava( String upType, String upValue ); Ava( SchemaManager schemaManager, String upType, String upValue ); Ava( SchemaManager schemaManager, String upType, String upName, String upValue ); Ava( String upType, String normType, Value value, String upName ); Ava( AttributeType attributeType, String upType, String normType, Value value, String upName ); Ava( SchemaManager schemaManager, String upType, String normType, Value value ); String getNormType(); String getType(); Value getValue(); String getName(); String getEscaped(); @Override Ava clone(); @Override int hashCode(); @Override boolean equals( Object obj ); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); boolean isSchemaAware(); AttributeType getAttributeType(); @Override int compareTo( Ava that ); @Override String toString(); } | @Test public void testEqualsAttributeEquals() throws LdapException { Ava atav1 = new Ava( schemaManager, "a", "b" ); Ava atav2 = new Ava( schemaManager, "a", "b" ); assertTrue( atav1.equals( atav2 ) ); }
@Test public void testEqualsAttributeIdSameCase() throws LdapException { Ava atav1 = new Ava( schemaManager, "a", "b" ); Ava atav2 = new Ava( schemaManager, "A", "b" ); assertTrue( atav1.equals( atav2 ) ); }
@Test public void testEqualsAtav1TypeSuperior() throws LdapException { Ava atav1 = new Ava( schemaManager, "b", "b" ); Ava atav2 = new Ava( schemaManager, "a", "b" ); assertFalse( atav1.equals( atav2 ) ); }
@Test public void testEqualsAtav2TypeSuperior() throws LdapException { Ava atav1 = new Ava( schemaManager, "a", "b" ); Ava atav2 = new Ava( schemaManager, "b", "b" ); assertFalse( atav1.equals( atav2 ) ); }
@Test public void testEqualsAtav1ValueSuperior() throws LdapException { Ava atav1 = new Ava( schemaManager, "a", "b" ); Ava atav2 = new Ava( schemaManager, "a", "a" ); assertFalse( atav1.equals( atav2 ) ); }
@Test public void testEqualsAtav2ValueSuperior() throws LdapException { Ava atav1 = new Ava( schemaManager, "a", "a" ); Ava atav2 = new Ava( schemaManager, "a", "b" ); assertFalse( atav1.equals( atav2 ) ); } |
Ava implements Externalizable, Cloneable, Comparable<Ava> { public String getName() { return upName; } Ava(); Ava( SchemaManager schemaManager ); Ava( SchemaManager schemaManager, Ava ava ); Ava( String upType, byte[] upValue ); Ava( SchemaManager schemaManager, String upType, byte[] upValue ); Ava( SchemaManager schemaManager, String upType, String upName, byte[] upValue ); Ava( String upType, String upValue ); Ava( SchemaManager schemaManager, String upType, String upValue ); Ava( SchemaManager schemaManager, String upType, String upName, String upValue ); Ava( String upType, String normType, Value value, String upName ); Ava( AttributeType attributeType, String upType, String normType, Value value, String upName ); Ava( SchemaManager schemaManager, String upType, String normType, Value value ); String getNormType(); String getType(); Value getValue(); String getName(); String getEscaped(); @Override Ava clone(); @Override int hashCode(); @Override boolean equals( Object obj ); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); boolean isSchemaAware(); AttributeType getAttributeType(); @Override int compareTo( Ava that ); @Override String toString(); } | @Test public void testNormalize() throws LdapException { Ava atav = new Ava( schemaManager, " A ", "a" ); assertEquals( " A =a", atav.getName() ); } |
Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable<Rdn> { @Override public String toString() { return upName == null ? "" : upName; } Rdn(); Rdn( SchemaManager schemaManager ); Rdn( SchemaManager schemaManager, String rdn ); Rdn( String rdn ); Rdn( SchemaManager schemaManager, String upType, String upValue ); Rdn( String upType, String upValue ); Rdn( SchemaManager schemaManager, Ava... avas ); Rdn( Ava... avas ); Rdn( Rdn rdn ); Rdn( SchemaManager schemaManager, Rdn rdn ); Object getValue( String type ); Ava getAva( String type ); @Override Iterator<Ava> iterator(); @Override Rdn clone(); String getName(); String getNormName(); Ava getAva(); Ava getAva( int pos ); String getType(); String getNormType(); String getValue(); @Override boolean equals( Object that ); int size(); static Object unescapeValue( String value ); static String escapeValue( String value ); String getEscaped(); static String escapeValue( byte[] attrValue ); boolean isSchemaAware(); static boolean isValid( String dn ); static boolean isValid( SchemaManager schemaManager, String dn ); @Override int hashCode(); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); @Override int compareTo( Rdn otherRdn ); @Override String toString(); static final Rdn EMPTY_RDN; static final int UNDEFINED; static final int SUPERIOR; static final int INFERIOR; static final int EQUAL; } | @Test public void testRdnNull() { assertEquals( "", new Rdn().toString() ); }
@Test public void testRdnEmpty() throws LdapException { assertEquals( "", new Rdn( "" ).toString() ); } |
Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable<Rdn> { public String getName() { return upName; } Rdn(); Rdn( SchemaManager schemaManager ); Rdn( SchemaManager schemaManager, String rdn ); Rdn( String rdn ); Rdn( SchemaManager schemaManager, String upType, String upValue ); Rdn( String upType, String upValue ); Rdn( SchemaManager schemaManager, Ava... avas ); Rdn( Ava... avas ); Rdn( Rdn rdn ); Rdn( SchemaManager schemaManager, Rdn rdn ); Object getValue( String type ); Ava getAva( String type ); @Override Iterator<Ava> iterator(); @Override Rdn clone(); String getName(); String getNormName(); Ava getAva(); Ava getAva( int pos ); String getType(); String getNormType(); String getValue(); @Override boolean equals( Object that ); int size(); static Object unescapeValue( String value ); static String escapeValue( String value ); String getEscaped(); static String escapeValue( byte[] attrValue ); boolean isSchemaAware(); static boolean isValid( String dn ); static boolean isValid( SchemaManager schemaManager, String dn ); @Override int hashCode(); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); @Override int compareTo( Rdn otherRdn ); @Override String toString(); static final Rdn EMPTY_RDN; static final int UNDEFINED; static final int SUPERIOR; static final int INFERIOR; static final int EQUAL; } | @Test public void testRdnSimple() throws LdapException { assertEquals( "a = b", new Rdn( "a = b" ).getName() ); }
@Test public void testRdnComposite() throws LdapException { assertEquals( "a = b + c = d", new Rdn( "a = b + c = d" ).getName() ); }
@Test public void testRdnCompositeWithSpace() throws LdapException { assertEquals( "a=b", new Rdn( "a", "b" ).getName() ); assertEquals( " a=b", new Rdn( " a", "b" ).getName() ); assertEquals( "a =b", new Rdn( "a ", "b" ).getName() ); assertEquals( "a= b", new Rdn( "a", " b" ).getName() ); assertEquals( "a=b ", new Rdn( "a", "b " ).getName() ); assertEquals( " a =b", new Rdn( " a ", "b" ).getName() ); assertEquals( " a= b", new Rdn( " a", " b" ).getName() ); assertEquals( " a=b ", new Rdn( " a", "b " ).getName() ); assertEquals( "a = b", new Rdn( "a ", " b" ).getName() ); assertEquals( "a =b ", new Rdn( "a ", "b " ).getName() ); assertEquals( "a= b ", new Rdn( "a", " b " ).getName() ); assertEquals( " a = b", new Rdn( " a ", " b" ).getName() ); assertEquals( " a =b ", new Rdn( " a ", "b " ).getName() ); assertEquals( " a= b ", new Rdn( " a", " b " ).getName() ); assertEquals( "a = b ", new Rdn( "a ", " b " ).getName() ); assertEquals( " a = b ", new Rdn( " a ", " b " ).getName() ); }
@Test public void testRdnSimpleMultivaluedAttribute() throws LdapException { String result = new Rdn( "a = b + c = d" ).getName(); assertEquals( "a = b + c = d", result ); }
@Test public void testRdnOidUpper() throws LdapException { assertEquals( "OID.12.34.56 = azerty", new Rdn( "OID.12.34.56 = azerty" ).getName() ); }
@Test public void testRdnOidLower() throws LdapException { assertEquals( "oid.12.34.56 = azerty", new Rdn( "oid.12.34.56 = azerty" ).getName() ); }
@Test public void testRdnOidWithoutPrefix() throws LdapException { assertEquals( "12.34.56 = azerty", new Rdn( "12.34.56 = azerty" ).getName() ); }
@Test public void testRdnCompositeOidWithoutPrefix() throws LdapException { String result = new Rdn( "12.34.56 = azerty + 7.8 = test" ).getName(); assertEquals( "12.34.56 = azerty + 7.8 = test", result ); }
@Test public void testRdnHexStringAttributeValue() throws LdapException { assertEquals( "a = #0010A0AAFF", new Rdn( "a = #0010A0AAFF" ).getName() ); }
@Test public void testDIRSERVER_703() throws LdapException { Rdn rdn = new Rdn( "cn=Kate Bush+sn=Bush" ); assertEquals( "cn=Kate Bush+sn=Bush", rdn.getName() ); }
@Test public void testRdnWithSpaces() throws LdapException { Rdn rdn = new Rdn( "cn=a\\ b\\ c" ); assertEquals( "cn=a\\ b\\ c", rdn.getName() ); }
@Test public void testGetUpNameMultipleAtav() throws LdapException { Rdn rdn = new Rdn( " A = b + C = d " ); assertEquals( " A = b + C = d ", rdn.getName() ); }
@Test public void testRdnAtUsedTwice() throws LdapException { Rdn rdn = new Rdn( " A = b + A = d " ); assertEquals( " A = b + A = d ", rdn.getName() ); }
@Test public void testAvaConstructorRdnAtUsedTwice() throws LdapException { Rdn rdn = new Rdn( new Ava( "A", "b" ), new Ava( "A", "d" ) ); assertEquals( "A=b+A=d", rdn.getName() ); } |
Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable<Rdn> { public Object getValue( String type ) throws LdapInvalidDnException { String normalizedType = Strings.lowerCaseAscii( Strings.trim( type ) ); if ( schemaManager != null ) { AttributeType attributeType = schemaManager.getAttributeType( normalizedType ); if ( attributeType != null ) { normalizedType = attributeType.getOid(); } } switch ( nbAvas ) { case 0: return ""; case 1: if ( ava.getNormType().equals( normalizedType ) ) { if ( ava.getValue() != null ) { return ava.getValue().getString(); } else { return null; } } return ""; default: List<Ava> avaList = avaTypes.get( normalizedType ); if ( avaList != null ) { for ( Ava elem : avaList ) { if ( elem.getNormType().equals( normalizedType ) ) { if ( elem.getValue() != null ) { return elem.getValue().getString(); } else { return null; } } } return null; } return null; } } Rdn(); Rdn( SchemaManager schemaManager ); Rdn( SchemaManager schemaManager, String rdn ); Rdn( String rdn ); Rdn( SchemaManager schemaManager, String upType, String upValue ); Rdn( String upType, String upValue ); Rdn( SchemaManager schemaManager, Ava... avas ); Rdn( Ava... avas ); Rdn( Rdn rdn ); Rdn( SchemaManager schemaManager, Rdn rdn ); Object getValue( String type ); Ava getAva( String type ); @Override Iterator<Ava> iterator(); @Override Rdn clone(); String getName(); String getNormName(); Ava getAva(); Ava getAva( int pos ); String getType(); String getNormType(); String getValue(); @Override boolean equals( Object that ); int size(); static Object unescapeValue( String value ); static String escapeValue( String value ); String getEscaped(); static String escapeValue( byte[] attrValue ); boolean isSchemaAware(); static boolean isValid( String dn ); static boolean isValid( SchemaManager schemaManager, String dn ); @Override int hashCode(); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); @Override int compareTo( Rdn otherRdn ); @Override String toString(); static final Rdn EMPTY_RDN; static final int UNDEFINED; static final int SUPERIOR; static final int INFERIOR; static final int EQUAL; } | @Test public void testRdnCompositeMultivaluedAttribute() throws LdapException { Rdn rdn = new Rdn( "a =b+c=d + e=f + g =h + i =j " ); assertEquals( "b", rdn.getValue( "a" ) ); assertEquals( "d", rdn.getValue( "c" ) ); assertEquals( "f", rdn.getValue( " E " ) ); assertEquals( "h", rdn.getValue( "g" ) ); assertEquals( "j", rdn.getValue( "i" ) ); }
@Test public void testGetValue() throws LdapException { Rdn rdn = new Rdn( " a = b + b = f + g = h + c = d " ); assertEquals( "b", rdn.getValue() ); } |
Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable<Rdn> { @Override public boolean equals( Object that ) { if ( this == that ) { return true; } Rdn rdn; if ( that instanceof String ) { try { rdn = new Rdn( schemaManager, ( String ) that ); } catch ( LdapInvalidDnException e ) { return false; } } else if ( !( that instanceof Rdn ) ) { return false; } else { rdn = ( Rdn ) that; } if ( rdn.nbAvas != nbAvas ) { return false; } switch ( nbAvas ) { case 0: return true; case 1: return ava.equals( rdn.ava ); default: for ( Ava paramAva : rdn.avas ) { List<Ava> avaList = avaTypes.get( paramAva.getNormType() ); if ( ( avaList == null ) || !avaList.contains( paramAva ) ) { return false; } } return true; } } Rdn(); Rdn( SchemaManager schemaManager ); Rdn( SchemaManager schemaManager, String rdn ); Rdn( String rdn ); Rdn( SchemaManager schemaManager, String upType, String upValue ); Rdn( String upType, String upValue ); Rdn( SchemaManager schemaManager, Ava... avas ); Rdn( Ava... avas ); Rdn( Rdn rdn ); Rdn( SchemaManager schemaManager, Rdn rdn ); Object getValue( String type ); Ava getAva( String type ); @Override Iterator<Ava> iterator(); @Override Rdn clone(); String getName(); String getNormName(); Ava getAva(); Ava getAva( int pos ); String getType(); String getNormType(); String getValue(); @Override boolean equals( Object that ); int size(); static Object unescapeValue( String value ); static String escapeValue( String value ); String getEscaped(); static String escapeValue( byte[] attrValue ); boolean isSchemaAware(); static boolean isValid( String dn ); static boolean isValid( SchemaManager schemaManager, String dn ); @Override int hashCode(); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); @Override int compareTo( Rdn otherRdn ); @Override String toString(); static final Rdn EMPTY_RDN; static final int UNDEFINED; static final int SUPERIOR; static final int INFERIOR; static final int EQUAL; } | @Test public void testRDNCompareToNull() throws LdapException { Rdn rdn1 = new Rdn( " a = b + c = d + e = f + g = h " ); Rdn rdn2 = null; assertFalse( rdn1.equals( rdn2 ) ); }
@Test public void testRDNCompareToNCS2NC() throws LdapException { Rdn rdn1 = new Rdn( " a = b + c = d + e = f + g = h " ); Rdn rdn2 = new Rdn( " a = b " ); assertFalse( rdn1.equals( rdn2 ) ); }
@Test public void testRDNCompareToNC2NCS() throws LdapException { Rdn rdn1 = new Rdn( " a = b " ); Rdn rdn2 = new Rdn( " a = b + c = d + e = f + g = h " ); assertFalse( rdn1.equals( rdn2 ) ); }
@Test public void testRDNCompareToNCS2NCSOrdered() throws LdapException { Rdn rdn1 = new Rdn( " a = b + c = d + e = f + g = h " ); Rdn rdn2 = new Rdn( " a = b + c = d + e = f + g = h " ); assertTrue( rdn1.equals( rdn2 ) ); }
@Test public void testRDNCompareToNCS2NCSUnordered() throws LdapException { Rdn rdn1 = new Rdn( " a = b + b = f + g = h + c = d " ); Rdn rdn2 = new Rdn( " a = b + c = d + b = f + g = h " ); assertTrue( rdn1.equals( rdn2 ) ); }
@Test public void testRDNCompareToNCS2NCSNotEquals() throws LdapException { Rdn rdn1 = new Rdn( " a = f + g = h + c = d " ); Rdn rdn2 = new Rdn( " c = d + a = h + g = h " ); assertFalse( rdn1.equals( rdn2 ) ); assertFalse( rdn2.equals( rdn1 ) ); }
@Test public void testCompareSecondAtav() throws LdapException { Rdn rdn1 = new Rdn( " a = b + c = d " ); Rdn rdn2 = new Rdn( " a = b + c = y " ); assertFalse( rdn1.equals( rdn2 ) ); assertFalse( rdn2.equals( rdn1 ) ); Rdn rdn3 = new Rdn( " a = b + c = d + e = f " ); Rdn rdn4 = new Rdn( " a = b + c = d + e = y " ); assertFalse( rdn3.equals( rdn4 ) ); assertFalse( rdn4.equals( rdn3 ) ); Rdn rdn5 = new Rdn( " a = b + b = c " ); Rdn rdn6 = new Rdn( " a = b + b = y " ); assertFalse( rdn5.equals( rdn6 ) ); assertFalse( rdn6.equals( rdn5 ) ); }
@Test public void testCompareIndependentFromOrder() throws LdapException { Rdn rdn1 = new Rdn( " a = b + c = d " ); Rdn rdn2 = new Rdn( " c = d + a = b " ); assertTrue( rdn1.equals( rdn2 ) ); rdn1 = new Rdn( " a = b + c = e " ); rdn2 = new Rdn( " c = d + a = b " ); assertFalse( rdn1.equals( rdn2 ) ); assertFalse( rdn2.equals( rdn1 ) ); rdn1 = new Rdn( " a = b + c = d " ); rdn2 = new Rdn( " e = f + g = h " ); assertFalse( rdn1.equals( rdn2 ) ); assertFalse( rdn2.equals( rdn1 ) ); }
@Test public void testCompareInvertableNC2NC() throws LdapException { Rdn rdn1 = new Rdn( " a = b " ); Rdn rdn2 = new Rdn( " a = c " ); assertFalse( rdn1.equals( rdn2 ) ); assertFalse( rdn2.equals( rdn1 ) ); }
@Test public void testCompareInvertableNCS2NCSDifferentValues() throws LdapException { Rdn rdn1 = new Rdn( " a = b + b = c " ); Rdn rdn2 = new Rdn( " a = b + b = y " ); assertFalse( rdn1.equals( rdn2 ) ); assertFalse( rdn2.equals( rdn1 ) ); }
@Test public void testCompareInvertableNCS2NCSDifferentTypes() throws LdapException { Rdn rdn1 = new Rdn( " a = b + c = d " ); Rdn rdn2 = new Rdn( " e = f + g = h " ); assertFalse( rdn1.equals( rdn2 ) ); assertFalse( rdn2.equals( rdn1 ) ); }
@Test public void testCompareInvertableNCS2NCSUnordered() throws LdapException { Rdn rdn1 = new Rdn( " c = d + a = b " ); Rdn rdn2 = new Rdn( " a = b + e = f " ); assertFalse( rdn1.equals( rdn2 ) ); assertFalse( rdn2.equals( rdn1 ) ); }
@Test public void testRDNCompareToNullRdn() throws LdapException { Rdn rdn1 = new Rdn( " a = b " ); assertFalse( rdn1.equals( null ) ); }
@Test public void testRDNCompareToNC2NC() throws LdapException { Rdn rdn1 = new Rdn( " a = b " ); Rdn rdn2 = new Rdn( " a = b " ); assertTrue( rdn1.equals( rdn2 ) ); }
@Test public void testRDNCompareToNC2NCUperCase() throws LdapException { Rdn rdn1 = new Rdn( " a = b " ); Rdn rdn2 = new Rdn( " A = b " ); assertTrue( rdn1.equals( rdn2 ) ); }
@Test public void testRDNCompareToNC2NCNotEquals() throws LdapException { Rdn rdn1 = new Rdn( " a = b " ); Rdn rdn2 = new Rdn( " A = d " ); assertFalse( rdn1.equals( rdn2 ) ); }
@Test public void testEquals() throws LdapException { Rdn rdn = new Rdn( "a=b + c=d + e=f" ); assertFalse( rdn.equals( null ) ); assertFalse( rdn.equals( "test" ) ); assertFalse( rdn.equals( new Rdn( "a=c + c=d + e=f" ) ) ); assertFalse( rdn.equals( new Rdn( "a=b" ) ) ); assertTrue( rdn.equals( new Rdn( "a=b + c=d + e=f" ) ) ); assertTrue( rdn.equals( new Rdn( "a=b + C=d + E=f" ) ) ); assertTrue( rdn.equals( new Rdn( "c=d + e=f + a=b" ) ) ); }
@Test public void testComparingOfCopyConstructedMultiValuedRDNs() throws LdapException { Rdn rdn = new Rdn( " A = b + C = d" ); Rdn copiedRdn = new Rdn( rdn ); assertTrue( rdn.equals( copiedRdn ) ); } |
Oid { public static boolean isOid( String oidString ) { try { Oid.fromString( oidString ); return true; } catch ( DecoderException e ) { return false; } } private Oid( String oidString, byte[] oidBytes ); @Override boolean equals( Object other ); static Oid fromBytes( byte[] oidBytes ); static Oid fromString( String oidString ); int getEncodedLength(); @Override int hashCode(); static boolean isOid( String oidString ); byte[] toBytes(); @Override String toString(); void writeBytesTo( ByteBuffer buffer ); void writeBytesTo( OutputStream outputStream ); } | @Test public void testNewOidStringBad() { assertFalse( Oid.isOid( "0" ) ); assertFalse( Oid.isOid( "1" ) ); assertFalse( Oid.isOid( "0." ) ); assertFalse( Oid.isOid( "1." ) ); assertFalse( Oid.isOid( "2." ) ); assertFalse( Oid.isOid( "2." ) ); assertFalse( Oid.isOid( "." ) ); assertFalse( Oid.isOid( "0.1.2." ) ); assertFalse( Oid.isOid( "3.1" ) ); assertFalse( Oid.isOid( "0..1" ) ); assertFalse( Oid.isOid( "0..12" ) ); assertFalse( Oid.isOid( "0.a.2" ) ); assertFalse( Oid.isOid( "0.40" ) ); assertFalse( Oid.isOid( "0.51" ) ); assertFalse( Oid.isOid( "0.01" ) ); assertFalse( Oid.isOid( "0.123456" ) ); assertFalse( Oid.isOid( "1.123456" ) ); } |
Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable<Rdn> { public String getType() { switch ( nbAvas ) { case 0: return null; case 1: return ava.getType(); default: return avas.get( 0 ).getType(); } } Rdn(); Rdn( SchemaManager schemaManager ); Rdn( SchemaManager schemaManager, String rdn ); Rdn( String rdn ); Rdn( SchemaManager schemaManager, String upType, String upValue ); Rdn( String upType, String upValue ); Rdn( SchemaManager schemaManager, Ava... avas ); Rdn( Ava... avas ); Rdn( Rdn rdn ); Rdn( SchemaManager schemaManager, Rdn rdn ); Object getValue( String type ); Ava getAva( String type ); @Override Iterator<Ava> iterator(); @Override Rdn clone(); String getName(); String getNormName(); Ava getAva(); Ava getAva( int pos ); String getType(); String getNormType(); String getValue(); @Override boolean equals( Object that ); int size(); static Object unescapeValue( String value ); static String escapeValue( String value ); String getEscaped(); static String escapeValue( byte[] attrValue ); boolean isSchemaAware(); static boolean isValid( String dn ); static boolean isValid( SchemaManager schemaManager, String dn ); @Override int hashCode(); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); @Override int compareTo( Rdn otherRdn ); @Override String toString(); static final Rdn EMPTY_RDN; static final int UNDEFINED; static final int SUPERIOR; static final int INFERIOR; static final int EQUAL; } | @Test public void testGetType() throws LdapException { Rdn rdn = new Rdn( " a = b + b = f + g = h + c = d " ); assertEquals( "a", rdn.getNormType() ); } |
Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable<Rdn> { public int size() { return nbAvas; } Rdn(); Rdn( SchemaManager schemaManager ); Rdn( SchemaManager schemaManager, String rdn ); Rdn( String rdn ); Rdn( SchemaManager schemaManager, String upType, String upValue ); Rdn( String upType, String upValue ); Rdn( SchemaManager schemaManager, Ava... avas ); Rdn( Ava... avas ); Rdn( Rdn rdn ); Rdn( SchemaManager schemaManager, Rdn rdn ); Object getValue( String type ); Ava getAva( String type ); @Override Iterator<Ava> iterator(); @Override Rdn clone(); String getName(); String getNormName(); Ava getAva(); Ava getAva( int pos ); String getType(); String getNormType(); String getValue(); @Override boolean equals( Object that ); int size(); static Object unescapeValue( String value ); static String escapeValue( String value ); String getEscaped(); static String escapeValue( byte[] attrValue ); boolean isSchemaAware(); static boolean isValid( String dn ); static boolean isValid( SchemaManager schemaManager, String dn ); @Override int hashCode(); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); @Override int compareTo( Rdn otherRdn ); @Override String toString(); static final Rdn EMPTY_RDN; static final int UNDEFINED; static final int SUPERIOR; static final int INFERIOR; static final int EQUAL; } | @Test public void testGetSize() throws LdapException { Rdn rdn = new Rdn( " a = b + b = f + g = h + c = d " ); assertEquals( 4, rdn.size() ); }
@Test public void testGetSize0() { Rdn rdn = new Rdn(); assertEquals( 0, rdn.size() ); } |
Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable<Rdn> { public static Object unescapeValue( String value ) { if ( Strings.isEmpty( value ) ) { return ""; } char[] chars = value.toCharArray(); if ( ( chars[0] == '\"' ) && ( chars[chars.length - 1] == '\"' ) ) { return new String( chars, 1, chars.length - 2 ); } if ( chars[0] == '#' ) { if ( chars.length == 1 ) { return Strings.EMPTY_BYTES; } if ( ( chars.length % 2 ) != 1 ) { throw new IllegalArgumentException( I18n.err( I18n.ERR_13613_VALUE_NOT_IN_HEX_FORM_ODD_NUMBER ) ); } byte[] hexValue = new byte[( chars.length - 1 ) / 2]; int pos = 0; for ( int i = 1; i < chars.length; i += 2 ) { if ( Chars.isHex( chars, i ) && Chars.isHex( chars, i + 1 ) ) { hexValue[pos++] = Hex.getHexValue( chars[i], chars[i + 1] ); } else { throw new IllegalArgumentException( I18n.err( I18n.ERR_13614_VALUE_NOT_IN_HEX_FORM ) ); } } return hexValue; } else { boolean escaped = false; boolean isHex = false; byte pair = -1; int pos = 0; byte[] bytes = new byte[chars.length * 6]; for ( int i = 0; i < chars.length; i++ ) { if ( escaped ) { escaped = false; switch ( chars[i] ) { case '\\': case '"': case '+': case ',': case ';': case '<': case '>': case '#': case '=': case ' ': bytes[pos++] = ( byte ) chars[i]; break; default: if ( Chars.isHex( chars, i ) ) { isHex = true; pair = ( byte ) ( Hex.getHexValue( chars[i] ) << 4 ); } break; } } else { if ( isHex ) { if ( Chars.isHex( chars, i ) ) { pair += Hex.getHexValue( chars[i] ); bytes[pos++] = pair; isHex = false; pair = 0; } } else { switch ( chars[i] ) { case '\\': escaped = true; break; case '"': case '+': case ',': case ';': case '<': case '>': case '#': if ( i != 0 ) { bytes[pos++] = '#'; } break; case ' ': if ( ( i == 0 ) || ( i == chars.length - 1 ) ) { throw new IllegalArgumentException( I18n.err( I18n.ERR_13615_UNESCAPED_CHARS_NOT_ALLOWED ) ); } else { bytes[pos++] = ' '; break; } default: if ( chars[i] < 128 ) { bytes[pos++] = ( byte ) chars[i]; } else { byte[] result = Unicode.charToBytes( chars[i] ); System.arraycopy( result, 0, bytes, pos, result.length ); pos += result.length; } break; } } } } return Strings.utf8ToString( bytes, pos ); } } Rdn(); Rdn( SchemaManager schemaManager ); Rdn( SchemaManager schemaManager, String rdn ); Rdn( String rdn ); Rdn( SchemaManager schemaManager, String upType, String upValue ); Rdn( String upType, String upValue ); Rdn( SchemaManager schemaManager, Ava... avas ); Rdn( Ava... avas ); Rdn( Rdn rdn ); Rdn( SchemaManager schemaManager, Rdn rdn ); Object getValue( String type ); Ava getAva( String type ); @Override Iterator<Ava> iterator(); @Override Rdn clone(); String getName(); String getNormName(); Ava getAva(); Ava getAva( int pos ); String getType(); String getNormType(); String getValue(); @Override boolean equals( Object that ); int size(); static Object unescapeValue( String value ); static String escapeValue( String value ); String getEscaped(); static String escapeValue( byte[] attrValue ); boolean isSchemaAware(); static boolean isValid( String dn ); static boolean isValid( SchemaManager schemaManager, String dn ); @Override int hashCode(); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); @Override int compareTo( Rdn otherRdn ); @Override String toString(); static final Rdn EMPTY_RDN; static final int UNDEFINED; static final int SUPERIOR; static final int INFERIOR; static final int EQUAL; } | @Test public void testUnescapeValueHexa() { byte[] res = ( byte[] ) Rdn.unescapeValue( "#fF" ); assertEquals( "0xFF ", Strings.dumpBytes( res ) ); res = ( byte[] ) Rdn.unescapeValue( "#0123456789aBCDEF" ); assertEquals( "0x01 0x23 0x45 0x67 0x89 0xAB 0xCD 0xEF ", Strings.dumpBytes( res ) ); }
@Test public void testUnescapeValueHexaWrong() { try { Rdn.unescapeValue( "#fF1" ); fail(); } catch ( IllegalArgumentException iae ) { assertTrue( true ); } }
@Test public void testUnescapeValueString() { String res = ( String ) Rdn.unescapeValue( "azerty" ); assertEquals( "azerty", res ); }
@Test public void testUnescapeValueStringSpecial() { String res = ( String ) Rdn.unescapeValue( "\\\\\\#\\,\\+\\;\\<\\>\\=\\\"\\ " ); assertEquals( "\\#,+;<>=\" ", res ); }
@Test public void testUnescapeValueStringWithSpaceInTheMiddle() { String res = ( String ) Rdn.unescapeValue( "a b" ); assertEquals( "a b", res ); }
@Test public void testUnescapeValueStringWithSpaceInAtTheBeginning() { String res = ( String ) Rdn.unescapeValue( "\\ a b" ); assertEquals( " a b", res ); }
@Test public void testUnescapeValueStringWithSpaceInAtTheEnd() { String res = ( String ) Rdn.unescapeValue( "a b\\ " ); assertEquals( "a b ", res ); }
@Test public void testUnescapeValueStringWithPoundInTheMiddle() { String res = ( String ) Rdn.unescapeValue( "a#b" ); assertEquals( "a#b", res ); }
@Test public void testUnescapeValueStringWithPoundAtTheEnd() { String res = ( String ) Rdn.unescapeValue( "ab#" ); assertEquals( "ab#", res ); }
@Test public void testUnescapeValueStringWithEqualInTheMiddle() { String res = ( String ) Rdn.unescapeValue( "a=b" ); assertEquals( "a=b", res ); } |
Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable<Rdn> { public static String escapeValue( String value ) { if ( Strings.isEmpty( value ) ) { return ""; } char[] chars = value.toCharArray(); char[] newChars = new char[chars.length * 3]; int pos = 0; for ( int i = 0; i < chars.length; i++ ) { switch ( chars[i] ) { case ' ': if ( ( i > 0 ) && ( i < chars.length - 1 ) ) { newChars[pos++] = chars[i]; } else { newChars[pos++] = '\\'; newChars[pos++] = chars[i]; } break; case '#': if ( i != 0 ) { newChars[pos++] = chars[i]; } else { newChars[pos++] = '\\'; newChars[pos++] = chars[i]; } break; case '"': case '+': case ',': case ';': case '=': case '<': case '>': case '\\': newChars[pos++] = '\\'; newChars[pos++] = chars[i]; break; case 0x7F: newChars[pos++] = '\\'; newChars[pos++] = '7'; newChars[pos++] = 'F'; break; case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: case 0x08: case 0x09: case 0x0A: case 0x0B: case 0x0C: case 0x0D: case 0x0E: case 0x0F: newChars[pos++] = '\\'; newChars[pos++] = '0'; newChars[pos++] = Strings.dumpHex( ( byte ) ( chars[i] & 0x0F ) ); break; case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: case 0x18: case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1E: case 0x1F: newChars[pos++] = '\\'; newChars[pos++] = '1'; newChars[pos++] = Strings.dumpHex( ( byte ) ( chars[i] & 0x0F ) ); break; default: newChars[pos++] = chars[i]; break; } } return new String( newChars, 0, pos ); } Rdn(); Rdn( SchemaManager schemaManager ); Rdn( SchemaManager schemaManager, String rdn ); Rdn( String rdn ); Rdn( SchemaManager schemaManager, String upType, String upValue ); Rdn( String upType, String upValue ); Rdn( SchemaManager schemaManager, Ava... avas ); Rdn( Ava... avas ); Rdn( Rdn rdn ); Rdn( SchemaManager schemaManager, Rdn rdn ); Object getValue( String type ); Ava getAva( String type ); @Override Iterator<Ava> iterator(); @Override Rdn clone(); String getName(); String getNormName(); Ava getAva(); Ava getAva( int pos ); String getType(); String getNormType(); String getValue(); @Override boolean equals( Object that ); int size(); static Object unescapeValue( String value ); static String escapeValue( String value ); String getEscaped(); static String escapeValue( byte[] attrValue ); boolean isSchemaAware(); static boolean isValid( String dn ); static boolean isValid( SchemaManager schemaManager, String dn ); @Override int hashCode(); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); @Override int compareTo( Rdn otherRdn ); @Override String toString(); static final Rdn EMPTY_RDN; static final int UNDEFINED; static final int SUPERIOR; static final int INFERIOR; static final int EQUAL; } | @Test public void testEscapeValueString() { String res = Rdn.escapeValue( Strings.getBytesUtf8( "azerty" ) ); assertEquals( "azerty", res ); }
@Test public void testEscapeValueStringSpecial() { String res = Rdn.escapeValue( Strings.getBytesUtf8( "\\#,+;<>=\" " ) ); assertEquals( "\\\\#\\,\\+\\;\\<\\>\\=\\\"\\ ", res ); }
@Test public void testEscapeValueNumeric() { String res = Rdn.escapeValue( new byte[] { '-', 0x00, '-', 0x1F, '-', 0x7F, '-' } ); assertEquals( "-\\00-\\1F-\\7F-", res ); }
@Test public void testEscapeValueMix() { String res = Rdn.escapeValue( new byte[] { '\\', 0x00, '-', '+', '#', 0x7F, '-' } ); assertEquals( "\\\\\\00-\\+#\\7F-", res ); }
@Test public void testEscapedAttributeValue() { assertEquals( "a b", Rdn.escapeValue( "a b" ) ); assertEquals( "a b c", Rdn.escapeValue( "a b c" ) ); assertEquals( "a b c d", Rdn.escapeValue( "a b c d" ) ); assertEquals( "\\ a b", Rdn.escapeValue( " a b" ) ); assertEquals( "a b\\ ", Rdn.escapeValue( "a b " ) ); assertEquals( "\\ a b\\ ", Rdn.escapeValue( " a b " ) ); assertEquals( "\\ a b \\ ", Rdn.escapeValue( " a b " ) ); assertEquals( "a#b", Rdn.escapeValue( "a#b" ) ); assertEquals( "a#b#", Rdn.escapeValue( "a#b#" ) ); assertEquals( "a#b#c", Rdn.escapeValue( "a#b#c" ) ); assertEquals( "a#b#c#", Rdn.escapeValue( "a#b#c#" ) ); assertEquals( "a#b#c#d", Rdn.escapeValue( "a#b#c#d" ) ); assertEquals( "a#b#c#d#", Rdn.escapeValue( "a#b#c#d#" ) ); assertEquals( "\\#a#b", Rdn.escapeValue( "#a#b" ) ); assertEquals( "\\##a#b", Rdn.escapeValue( "##a#b" ) ); assertEquals( "\\\"\\+\\,\\;\\<\\>\\\\\\00", Rdn.escapeValue( "\"+,;<>\\\u0000" ) ); assertEquals( "\u00e9\u20AC\uD83D\uDE08", Rdn.escapeValue( "\u00e9\u20AC\uD83D\uDE08" ) ); } |
Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable<Rdn> { @Override public Iterator<Ava> iterator() { if ( nbAvas < 2 ) { return new Iterator<Ava>() { private boolean hasMoreElement = nbAvas == 1; @Override public boolean hasNext() { return hasMoreElement; } @Override public Ava next() { Ava obj = ava; hasMoreElement = false; return obj; } @Override public void remove() { } }; } else { return avas.iterator(); } } Rdn(); Rdn( SchemaManager schemaManager ); Rdn( SchemaManager schemaManager, String rdn ); Rdn( String rdn ); Rdn( SchemaManager schemaManager, String upType, String upValue ); Rdn( String upType, String upValue ); Rdn( SchemaManager schemaManager, Ava... avas ); Rdn( Ava... avas ); Rdn( Rdn rdn ); Rdn( SchemaManager schemaManager, Rdn rdn ); Object getValue( String type ); Ava getAva( String type ); @Override Iterator<Ava> iterator(); @Override Rdn clone(); String getName(); String getNormName(); Ava getAva(); Ava getAva( int pos ); String getType(); String getNormType(); String getValue(); @Override boolean equals( Object that ); int size(); static Object unescapeValue( String value ); static String escapeValue( String value ); String getEscaped(); static String escapeValue( byte[] attrValue ); boolean isSchemaAware(); static boolean isValid( String dn ); static boolean isValid( SchemaManager schemaManager, String dn ); @Override int hashCode(); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); @Override int compareTo( Rdn otherRdn ); @Override String toString(); static final Rdn EMPTY_RDN; static final int UNDEFINED; static final int SUPERIOR; static final int INFERIOR; static final int EQUAL; } | @Test public void testMultiValuedIterator() throws LdapException { Rdn rdn = new Rdn( "cn=Kate Bush+sn=Bush" ); Iterator<Ava> iterator = rdn.iterator(); assertNotNull( iterator ); assertTrue( iterator.hasNext() ); assertNotNull( iterator.next() ); assertTrue( iterator.hasNext() ); assertNotNull( iterator.next() ); assertFalse( iterator.hasNext() ); }
@Test public void testSingleValuedIterator() throws LdapException { Rdn rdn = new Rdn( "cn=Kate Bush" ); Iterator<Ava> iterator = rdn.iterator(); assertNotNull( iterator ); assertTrue( iterator.hasNext() ); assertNotNull( iterator.next() ); assertFalse( iterator.hasNext() ); }
@Test public void testEmptyIterator() { Rdn rdn = new Rdn(); Iterator<Ava> iterator = rdn.iterator(); assertNotNull( iterator ); assertFalse( iterator.hasNext() ); }
@Test public void testIterator() throws LdapException { Rdn rdn = new Rdn( "cn=John + sn=Doe" ); String[] expected = new String[] { "cn=John ", " sn=Doe" }; int i = 0; for ( Ava ava : rdn ) { assertEquals( expected[i], ava.getName() ); i++; } } |
OsgiUtils { public static Set<String> splitIntoPackages( String exports, Set<String> pkgs ) { if ( pkgs == null ) { pkgs = new HashSet<>(); } int index = 0; boolean inPkg = true; boolean inProps = false; StringBuilder pkg = new StringBuilder(); while ( index < exports.length() ) { if ( inPkg && exports.charAt( index ) != ';' ) { pkg.append( exports.charAt( index ) ); index++; } else if ( inPkg && exports.charAt( index ) == ';' ) { inPkg = false; inProps = true; pkgs.add( pkg.toString() ); if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_17002_ADDED_PACKAGE, pkg.toString() ) ); } pkg.setLength( 0 ); index += 8; } else if ( inProps && exports.charAt( index ) == '"' && index + 1 < exports.length() && exports.charAt( index + 1 ) == ',' ) { inPkg = true; inProps = false; index += 2; } else if ( inProps ) { index++; } else { LOG.error( I18n.err( I18n.ERR_17000_UNEXPECTED_PARSER_CONDITION ) ); throw new IllegalStateException( I18n.err( I18n.ERR_17068_SHOULD_NOT_GET_HERE ) ); } } return pkgs; } private OsgiUtils(); static Set<String> getAllBundleExports( FileFilter filter, Set<String> pkgs ); static Set<String> splitIntoPackages( String exports, Set<String> pkgs ); static Set<File> getClasspathCandidates( FileFilter filter ); static String getBundleExports( File bundle ); } | @Test public void testSplitIntoPackageVersions() { Set<String> pkgs = OsgiUtils.splitIntoPackages( "org.ops4j.store.intern;uses:=\"org.ops4j.store,org.ops4j.io,org.apache.commons.logging\";" + "version=\"1.2.2\",org.ops4j.store;uses:=\"org.ops4j.store.intern\";version=\"1.2.2", null ); assertTrue( pkgs.contains( "org.ops4j.store.intern" ), "org.ops4j.store.intern" ); assertTrue( pkgs.contains( "org.ops4j.store" ), "org.ops4j.store" ); assertEquals( 2, pkgs.size(), "Expecting 2 packages" ); }
@Test public void testSplitIntoPackages() { Set<String> pkgs = OsgiUtils.splitIntoPackages( "org.apache.log4j.net;uses:=\"org.apache.log4j,org.apache.log4j.spi," + "javax.naming,org.apache.log4j.helpers,javax.jms,org.apache.log4j.xml," + "javax.mail,javax.mail.internet,org.w3c.dom,javax.jmdns\"," + "org.apache.log4j.jmx;uses:=\"org.apache.log4j,javax.management," + "com.sun.jdmk.comm,org.apache.log4j.helpers,org.apache.log4j.spi\"," + "org.apache.log4j.jdbc;uses:=\"org.apache.log4j,org.apache.log4j.spi\"," + "org.apache.log4j.config;uses:=\"org.apache.log4j.helpers,org.apache.log4j," + "org.apache.log4j.spi\",org.apache.log4j.helpers;uses:=\"org.apache.log4j," + "org.apache.log4j.spi,org.apache.log4j.pattern\",org.apache.log4j;uses:=\"" + "org.apache.log4j.spi,org.apache.log4j.helpers,org.apache.log4j.pattern," + "org.apache.log4j.or,org.apache.log4j.config\",org.apache.log4j.or.jms;" + "uses:=\"org.apache.log4j.helpers,javax.jms,org.apache.log4j.or\"," + "org.apache.log4j.nt;uses:=\"org.apache.log4j.helpers,org.apache.log4j," + "org.apache.log4j.spi\",org.apache.log4j.or.sax;uses:=\"org.apache.log4j.or," + "org.xml.sax\",org.apache.log4j.pattern;uses:=\"org.apache.log4j.helpers," + "org.apache.log4j.spi,org.apache.log4j,org.apache.log4j.or\"," + "org.apache.log4j.spi;uses:=\"org.apache.log4j,org.apache.log4j.helpers," + "com.ibm.uvm.tools,org.apache.log4j.or\",org.apache.log4j.or;uses:=\"" + "org.apache.log4j.helpers,org.apache.log4j.spi,org.apache.log4j\"," + "org.apache.log4j.xml;uses:=\"javax.xml.parsers,org.w3c.dom,org.xml.sax," + "org.apache.log4j.config,org.apache.log4j.helpers,org.apache.log4j," + "org.apache.log4j.spi,org.apache.log4j.or\",org.apache.log4j.varia;uses:=\"" + "org.apache.log4j.spi,org.apache.log4j,org.apache.log4j.helpers\"", null ); assertTrue( pkgs.contains( "org.apache.log4j.net" ), "org.apache.log4j.net" ); assertTrue( pkgs.contains( "org.apache.log4j.jmx" ), "org.apache.log4j.jmx" ); assertTrue( pkgs.contains( "org.apache.log4j.jdbc" ), "org.apache.log4j.jdbc" ); assertTrue( pkgs.contains( "org.apache.log4j.config" ), "org.apache.log4j.config" ); assertTrue( pkgs.contains( "org.apache.log4j.helpers" ), "org.apache.log4j.helpers" ); assertTrue( pkgs.contains( "org.apache.log4j" ), "org.apache.log4j" ); assertTrue( pkgs.contains( "org.apache.log4j.or" ), "org.apache.log4j.or" ); assertTrue( pkgs.contains( "org.apache.log4j.or.jms" ), "org.apache.log4j.or.jms" ); assertTrue( pkgs.contains( "org.apache.log4j.or.sax" ), "org.apache.log4j.or.sax" ); assertTrue( pkgs.contains( "org.apache.log4j.nt" ), "org.apache.log4j.nt" ); assertTrue( pkgs.contains( "org.apache.log4j.spi" ), "org.apache.log4j.spi" ); assertTrue( pkgs.contains( "org.apache.log4j.pattern" ), "org.apache.log4j.pattern" ); assertTrue( pkgs.contains( "org.apache.log4j.xml" ), "org.apache.log4j.xml" ); assertTrue( pkgs.contains( "org.apache.log4j.varia" ), "org.apache.log4j.varia" ); assertEquals( 14, pkgs.size(), "Expecting 14 packages" ); } |
LdifAttributesReader extends LdifReader { private Entry parseEntry( SchemaManager schemaManager ) throws LdapLdifException { if ( ( lines == null ) || lines.isEmpty() ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13408_END_OF_LDIF ) ); } return null; } Entry entry = new DefaultEntry( schemaManager ); for ( String line : lines ) { String lowerLine = Strings.toLowerCaseAscii( line ); if ( lowerLine.startsWith( "control:" ) ) { LOG.error( I18n.err( I18n.ERR_13401_CHANGE_NOT_ALLOWED ) ); throw new LdapLdifException( I18n.err( I18n.ERR_13440_NO_CHANGE ) ); } else if ( lowerLine.startsWith( "changetype:" ) ) { LOG.error( I18n.err( I18n.ERR_13401_CHANGE_NOT_ALLOWED ) ); throw new LdapLdifException( I18n.err( I18n.ERR_13440_NO_CHANGE ) ); } else if ( line.indexOf( ':' ) > 0 ) { parseEntryAttribute( schemaManager, entry, line, lowerLine ); } else { LOG.error( I18n.err( I18n.ERR_13402_EXPECTING_ATTRIBUTE_TYPE ) ); throw new LdapLdifException( I18n.err( I18n.ERR_13441_BAD_ATTRIBUTE ) ); } } if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13405_READ_ATTR, entry ) ); } return entry; } LdifAttributesReader(); Attributes parseAttributes( String ldif ); Entry parseEntry( String ldif ); Entry parseEntry( SchemaManager schemaManager, String ldif ); } | @Test public void testLdifNull() throws LdapLdifException, IOException { String ldif = null; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); assertEquals( 0, entry.size() ); reader.close(); }
@Test public void testLdifEmpty() throws LdapLdifException, IOException { String ldif = ""; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); assertEquals( 0, entry.size() ); reader.close(); }
@Test public void testLdifEmptyLines() throws LdapLdifException, IOException { String ldif = "\n\n\r\r\n"; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); assertNull( entry ); reader.close(); }
@Test public void testLdifComments() throws LdapLdifException, IOException { String ldif = "#Comment 1\r" + "#\r" + " th\n" + " is is still a comment\n" + "\n"; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); assertNull( entry ); reader.close(); }
@Test public void testLdifVersionStart() throws LdapLdifException, IOException { String ldif = "cn: app1\n" + "objectClass: top\n" + "objectClass: apApplication\n" + "displayName: app1 \n" + "dependencies:\n" + "envVars:"; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); assertEquals( 1, reader.getVersion() ); assertNotNull( entry ); Attribute attr = entry.get( "displayname" ); assertTrue( attr.contains( "app1" ) ); reader.close(); }
@Test public void testLdifParserEndSpaces() throws LdapLdifException, IOException { String ldif = "cn: app1\n" + "objectClass: top\n" + "objectClass: apApplication\n" + "displayName: app1 \n" + "dependencies:\n" + "envVars:"; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); assertNotNull( entry ); Attribute attr = entry.get( "displayname" ); assertTrue( attr.contains( "app1" ) ); reader.close(); }
@Test public void testLdifParser() throws LdapLdifException, LdapInvalidAttributeValueException, IOException { String ldif = "cn: app1\n" + "objectClass: top\n" + "objectClass: apApplication\n" + "displayName: app1 \n" + "dependencies:\n" + "envVars:"; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); assertNotNull( entry ); Attribute attr = entry.get( "cn" ); assertTrue( attr.contains( "app1" ) ); attr = entry.get( "objectclass" ); assertTrue( attr.contains( "top" ) ); assertTrue( attr.contains( "apApplication" ) ); attr = entry.get( "displayname" ); assertTrue( attr.contains( "app1" ) ); attr = entry.get( "dependencies" ); assertEquals( "", attr.get().getString() ); attr = entry.get( "envvars" ); assertEquals( "", attr.get().getString() ); reader.close(); }
@Test public void testLdifParserMuiltiLineComments() throws LdapLdifException, IOException { String ldif = "#comment\n" + " still a comment\n" + "cn: app1#another comment\n" + "objectClass: top\n" + "objectClass: apApplication\n" + "displayName: app1\n" + "serviceType: http\n" + "dependencies:\n" + "httpHeaders:\n" + "startupOptions:\n" + "envVars:"; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); assertNotNull( entry ); Attribute attr = entry.get( "cn" ); assertTrue( attr.contains( "app1#another comment" ) ); attr = entry.get( "objectclass" ); assertTrue( attr.contains( "top" ) ); assertTrue( attr.contains( "apApplication" ) ); attr = entry.get( "displayname" ); assertTrue( attr.contains( "app1" ) ); attr = entry.get( "dependencies" ); assertEquals( "", attr.get().getString() ); attr = entry.get( "envvars" ); assertEquals( "", attr.get().getString() ); reader.close(); }
@Test public void testLdifParserMultiLineEntries() throws LdapLdifException, IOException { String ldif = "#comment\n" + "cn: app1#another comment\n" + "objectClass: top\n" + "objectClass: apAppli\n" + " cation\n" + "displayName: app1\n" + "serviceType: http\n" + "dependencies:\n" + "httpHeaders:\n" + "startupOptions:\n" + "envVars:"; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); assertNotNull( entry ); Attribute attr = entry.get( "cn" ); assertTrue( attr.contains( "app1#another comment" ) ); attr = entry.get( "objectclass" ); assertTrue( attr.contains( "top" ) ); assertTrue( attr.contains( "apApplication" ) ); attr = entry.get( "displayname" ); assertTrue( attr.contains( "app1" ) ); attr = entry.get( "dependencies" ); assertEquals( "", attr.get().getString() ); attr = entry.get( "envvars" ); assertEquals( "", attr.get().getString() ); reader.close(); }
@Test public void testLdifParserBase64() throws LdapLdifException, IOException { String ldif = "#comment\n" + "cn:: RW1tYW51ZWwgTMOpY2hhcm55\n" + "objectClass: top\n" + "objectClass: apApplication\n" + "displayName: app1\n" + "serviceType: http\n" + "dependencies:\n" + "httpHeaders:\n" + "startupOptions:\n" + "envVars:"; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); assertNotNull( entry ); Attribute attr = entry.get( "cn" ); assertTrue( attr.contains( "Emmanuel L\u00e9charny".getBytes( StandardCharsets.UTF_8 ) ) ); attr = entry.get( "objectclass" ); assertTrue( attr.contains( "top" ) ); assertTrue( attr.contains( "apApplication" ) ); attr = entry.get( "displayname" ); assertTrue( attr.contains( "app1" ) ); attr = entry.get( "dependencies" ); assertEquals( "", attr.get().getString() ); attr = entry.get( "envvars" ); assertEquals( "", attr.get().getString() ); reader.close(); }
@Test public void testLdifParserBase64MultiLine() throws LdapLdifException, IOException { String ldif = "#comment\n" + "cn:: RW1tYW51ZWwg\n" + " TMOpY2hhcm55ICA=\n" + "objectClass: top\n" + "objectClass: apApplication\n" + "displayName: app1\n" + "serviceType: http\n" + "dependencies:\n" + "httpHeaders:\n" + "startupOptions:\n" + "envVars:"; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); assertNotNull( entry ); Attribute attr = entry.get( "cn" ); assertTrue( attr.contains( "Emmanuel L\u00e9charny ".getBytes( StandardCharsets.UTF_8 ) ) ); attr = entry.get( "objectclass" ); assertTrue( attr.contains( "top" ) ); assertTrue( attr.contains( "apApplication" ) ); attr = entry.get( "displayname" ); assertTrue( attr.contains( "app1" ) ); attr = entry.get( "dependencies" ); assertEquals( "", attr.get().getString() ); attr = entry.get( "envvars" ); assertEquals( "", attr.get().getString() ); reader.close(); }
@Test public void testLdifParserRFC2849Sample1() throws LdapLdifException, IOException { String ldif = "objectclass: top\n" + "objectclass: person\n" + "objectclass: organizationalPerson\n" + "cn: Barbara Jensen\n" + "cn: Barbara J Jensen\n" + "cn: Babs Jensen\n" + "sn: Jensen\n" + "uid: bjensen\n" + "telephonenumber: +1 408 555 1212\n" + "description: A big sailing fan.\n"; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); Attribute attr = entry.get( "objectclass" ); assertTrue( attr.contains( "top" ) ); assertTrue( attr.contains( "person" ) ); assertTrue( attr.contains( "organizationalPerson" ) ); attr = entry.get( "cn" ); assertTrue( attr.contains( "Barbara Jensen" ) ); assertTrue( attr.contains( "Barbara J Jensen" ) ); assertTrue( attr.contains( "Babs Jensen" ) ); attr = entry.get( "sn" ); assertTrue( attr.contains( "Jensen" ) ); attr = entry.get( "uid" ); assertTrue( attr.contains( "bjensen" ) ); attr = entry.get( "telephonenumber" ); assertTrue( attr.contains( "+1 408 555 1212" ) ); attr = entry.get( "description" ); assertTrue( attr.contains( "A big sailing fan." ) ); reader.close(); }
@Test public void testLdifParserRFC2849Sample2() throws LdapLdifException, IOException { String ldif = "objectclass: top\n" + "objectclass: person\n" + "objectclass: organizationalPerson\n" + "cn: Barbara Jensen\n" + "cn: Barbara J Jensen\n" + "cn: Babs Jensen\n" + "sn: Jensen\n" + "uid: bjensen\n" + "telephonenumber: +1 408 555 1212\n" + "description:Babs is a big sailing fan, and travels extensively in sea\n" + " rch of perfect sailing conditions.\n" + "title:Product Manager, Rod and Reel Division"; LdifAttributesReader reader = new LdifAttributesReader(); Entry entry = reader.parseEntry( ldif ); Attribute attr = entry.get( "objectclass" ); assertTrue( attr.contains( "top" ) ); assertTrue( attr.contains( "person" ) ); assertTrue( attr.contains( "organizationalPerson" ) ); attr = entry.get( "cn" ); assertTrue( attr.contains( "Barbara Jensen" ) ); assertTrue( attr.contains( "Barbara J Jensen" ) ); assertTrue( attr.contains( "Babs Jensen" ) ); attr = entry.get( "sn" ); assertTrue( attr.contains( "Jensen" ) ); attr = entry.get( "uid" ); assertTrue( attr.contains( "bjensen" ) ); attr = entry.get( "telephonenumber" ); assertTrue( attr.contains( "+1 408 555 1212" ) ); attr = entry.get( "description" ); assertTrue( attr .contains( "Babs is a big sailing fan, and travels extensively in search of perfect sailing conditions." ) ); attr = entry.get( "title" ); assertTrue( attr.contains( "Product Manager, Rod and Reel Division" ) ); reader.close(); }
@Test public void testLdifParserRFC2849Sample5WithSizeLimit() throws Exception { String ldif = "objectclass: top\n" + "objectclass: person\n" + "objectclass: organizationalPerson\n" + "cn: Horatio Jensen\n" + "cn: Horatio N Jensen\n" + "sn: Jensen\n" + "uid: hjensen\n" + "telephonenumber: +1 408 555 1212\n" + "jpegphoto:< file:" + HJENSEN_JPEG_FILE.getAbsolutePath() + "\n"; LdifAttributesReader reader = new LdifAttributesReader(); reader.setSizeLimit( 128 ); try { reader.parseEntry( ldif ); fail(); } catch ( LdapLdifException ne ) { assertTrue( ne.getMessage().startsWith( I18n.ERR_13442_ERROR_PARSING_LDIF_BUFFER.getErrorCode() ), I18n.err( I18n.ERR_13442_ERROR_PARSING_LDIF_BUFFER ) ); } reader.close(); } |
LdifAttributesReader extends LdifReader { private Attributes parseAttributes() throws LdapLdifException { if ( ( lines == null ) || lines.isEmpty() ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13408_END_OF_LDIF ) ); } return null; } Attributes attributes = new BasicAttributes( true ); for ( String line : lines ) { String lowerLine = Strings.toLowerCaseAscii( line ); if ( lowerLine.startsWith( "control:" ) ) { LOG.error( I18n.err( I18n.ERR_13401_CHANGE_NOT_ALLOWED ) ); throw new LdapLdifException( I18n.err( I18n.ERR_13440_NO_CHANGE ) ); } else if ( lowerLine.startsWith( "changetype:" ) ) { LOG.error( I18n.err( I18n.ERR_13401_CHANGE_NOT_ALLOWED ) ); throw new LdapLdifException( I18n.err( I18n.ERR_13440_NO_CHANGE ) ); } else if ( line.indexOf( ':' ) > 0 ) { parseAttribute( attributes, line, lowerLine ); } else { LOG.error( I18n.err( I18n.ERR_13402_EXPECTING_ATTRIBUTE_TYPE ) ); throw new LdapLdifException( I18n.err( I18n.ERR_13441_BAD_ATTRIBUTE ) ); } } if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13405_READ_ATTR, attributes ) ); } return attributes; } LdifAttributesReader(); Attributes parseAttributes( String ldif ); Entry parseEntry( String ldif ); Entry parseEntry( SchemaManager schemaManager, String ldif ); } | @Test public void testLdifParserRFC2849Sample3() throws LdapLdifException, Exception { String ldif = "objectclass: top\n" + "objectclass: person\n" + "objectclass: organizationalPerson\n" + "cn: Gern Jensen\n" + "cn: Gern O Jensen\n" + "sn: Jensen\n" + "uid: gernj\n" + "telephonenumber: +1 408 555 1212\n" + "description:: V2hhdCBhIGNhcmVmdWwgcmVhZGVyIHlvdSBhcmUhICBUaGlzIHZhbHVl\n" + " IGlzIGJhc2UtNjQtZW5jb2RlZCBiZWNhdXNlIGl0IGhhcyBhIGNvbnRyb2wgY2hhcmFjdG\n" + " VyIGluIGl0IChhIENSKS4NICBCeSB0aGUgd2F5LCB5b3Ugc2hvdWxkIHJlYWxseSBnZXQg\n" + " b3V0IG1vcmUu"; LdifAttributesReader reader = new LdifAttributesReader(); Attributes attributes = reader.parseAttributes( ldif ); javax.naming.directory.Attribute attr = attributes.get( "objectclass" ); assertTrue( attr.contains( "top" ) ); assertTrue( attr.contains( "person" ) ); assertTrue( attr.contains( "organizationalPerson" ) ); attr = attributes.get( "cn" ); assertTrue( attr.contains( "Gern Jensen" ) ); assertTrue( attr.contains( "Gern O Jensen" ) ); attr = attributes.get( "sn" ); assertTrue( attr.contains( "Jensen" ) ); attr = attributes.get( "uid" ); assertTrue( attr.contains( "gernj" ) ); attr = attributes.get( "telephonenumber" ); assertTrue( attr.contains( "+1 408 555 1212" ) ); attr = attributes.get( "description" ); assertTrue( attr .contains( "What a careful reader you are! This value is base-64-encoded because it has a control character in it (a CR).\r By the way, you should really get out more." .getBytes( StandardCharsets.UTF_8 ) ) ); reader.close(); }
@Test public void testLdifParserRFC2849Sample3VariousSpacing() throws LdapLdifException, Exception { String ldif = "objectclass:top\n" + "objectclass: person \n" + "objectclass:organizationalPerson\n" + "cn:Gern Jensen\n" + "cn:Gern O Jensen\n" + "sn:Jensen\n" + "uid:gernj\n" + "telephonenumber:+1 408 555 1212 \n" + "description:: V2hhdCBhIGNhcmVmdWwgcmVhZGVyIHlvdSBhcmUhICBUaGlzIHZhbHVl\n" + " IGlzIGJhc2UtNjQtZW5jb2RlZCBiZWNhdXNlIGl0IGhhcyBhIGNvbnRyb2wgY2hhcmFjdG\n" + " VyIGluIGl0IChhIENSKS4NICBCeSB0aGUgd2F5LCB5b3Ugc2hvdWxkIHJlYWxseSBnZXQg\n" + " b3V0IG1vcmUu "; LdifAttributesReader reader = new LdifAttributesReader(); Attributes attributes = reader.parseAttributes( ldif ); javax.naming.directory.Attribute attr = attributes.get( "objectclass" ); assertTrue( attr.contains( "top" ) ); assertTrue( attr.contains( "person" ) ); assertTrue( attr.contains( "organizationalPerson" ) ); attr = attributes.get( "cn" ); assertTrue( attr.contains( "Gern Jensen" ) ); assertTrue( attr.contains( "Gern O Jensen" ) ); attr = attributes.get( "sn" ); assertTrue( attr.contains( "Jensen" ) ); attr = attributes.get( "uid" ); assertTrue( attr.contains( "gernj" ) ); attr = attributes.get( "telephonenumber" ); assertTrue( attr.contains( "+1 408 555 1212" ) ); attr = attributes.get( "description" ); assertTrue( attr .contains( "What a careful reader you are! This value is base-64-encoded because it has a control character in it (a CR).\r By the way, you should really get out more." .getBytes( StandardCharsets.UTF_8 ) ) ); reader.close(); }
@Test public void testLdifParserRFC2849Sample4() throws NamingException, Exception { String ldif = "# dn:: ou=���������,o=Airius\n" + "objectclass: top\n" + "objectclass: organizationalUnit\n" + "ou:: 5Za25qWt6YOo\n" + "# ou:: ���������\n" + "ou;lang-ja:: 5Za25qWt6YOo\n" + "# ou;lang-ja:: ���������\n" + "ou;lang-ja;phonetic:: 44GI44GE44GO44KH44GG44G2\n" + "# ou;lang-ja:: ������������������\n" + "ou;lang-en: Sales\n" + "description: Japanese office\n"; LdifAttributesReader reader = new LdifAttributesReader(); Attributes attributes = reader.parseAttributes( ldif ); String[][] values = { { "objectclass", "top" }, { "objectclass", "organizationalUnit" }, { "ou", "\u55b6\u696d\u90e8" }, { "ou;lang-ja", "\u55b6\u696d\u90e8" }, { "ou;lang-ja;phonetic", "\u3048\u3044\u304e\u3087\u3046\u3076" }, { "ou;lang-en", "Sales" }, { "description", "Japanese office" } }; for ( int j = 0; j < values.length; j++ ) { javax.naming.directory.Attribute attr = attributes.get( values[j][0] ); if ( attr.contains( values[j][1] ) ) { assertTrue( true ); } else { assertTrue( attr.contains( values[j][1].getBytes( StandardCharsets.UTF_8 ) ) ); } } reader.close(); }
@Test public void testLdifParserRFC2849Sample5() throws NamingException, Exception { String ldif = "objectclass: top\n" + "objectclass: person\n" + "objectclass: organizationalPerson\n" + "cn: Horatio Jensen\n" + "cn: Horatio N Jensen\n" + "sn: Jensen\n" + "uid: hjensen\n" + "telephonenumber: +1 408 555 1212\n" + "jpegphoto:< file:" + HJENSEN_JPEG_FILE.getAbsolutePath() + "\n"; LdifAttributesReader reader = new LdifAttributesReader(); Attributes attributes = reader.parseAttributes( ldif ); String[][] values = { { "objectclass", "top" }, { "objectclass", "person" }, { "objectclass", "organizationalPerson" }, { "cn", "Horatio Jensen" }, { "cn", "Horatio N Jensen" }, { "sn", "Jensen" }, { "uid", "hjensen" }, { "telephonenumber", "+1 408 555 1212" }, { "jpegphoto", null } }; for ( int i = 0; i < values.length; i++ ) { if ( "jpegphoto".equalsIgnoreCase( values[i][0] ) ) { javax.naming.directory.Attribute attr = attributes.get( values[i][0] ); assertEquals( Strings.dumpBytes( data ), Strings.dumpBytes( ( byte[] ) attr.get() ) ); } else { javax.naming.directory.Attribute attr = attributes.get( values[i][0] ); if ( attr.contains( values[i][1] ) ) { assertTrue( true ); } else { assertTrue( attr.contains( values[i][1].getBytes( StandardCharsets.UTF_8 ) ) ); } } } reader.close(); }
@Test public void testLdifAttributesReaderDirServer() throws NamingException, Exception { String ldif = "# -------------------------------------------------------------------\n" + "#\n" + "# Licensed to the Apache Software Foundation (ASF) under one\n" + "# or more contributor license agreements. See the NOTICE file\n" + "# distributed with this work for additional information\n" + "# regarding copyright ownership. The ASF licenses this file\n" + "# to you under the Apache License, Version 2.0 (the\n" + "# \"License\"); you may not use this file except in compliance\n" + "# with the License. You may obtain a copy of the License at\n" + "# \n" + "# http: + "# \n" + "# Unless required by applicable law or agreed to in writing,\n" + "# software distributed under the License is distributed on an\n" + "# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n" + "# KIND, either express or implied. See the License for the\n" + "# specific language governing permissions and limitations\n" + "# under the License. \n" + "# \n" + "#\n" + "# EXAMPLE.COM is freely and reserved for testing according to this RFC:\n" + "#\n" + "# http: + "#\n" + "# -------------------------------------------------------------------\n" + "\n" + "objectclass: top\n" + "objectclass: organizationalunit\n" + "ou: Users"; LdifAttributesReader reader = new LdifAttributesReader(); Attributes attributes = reader.parseAttributes( ldif ); javax.naming.directory.Attribute attr = attributes.get( "objectclass" ); assertTrue( attr.contains( "top" ) ); assertTrue( attr.contains( "organizationalunit" ) ); attr = attributes.get( "ou" ); assertTrue( attr.contains( "Users" ) ); reader.close(); }
@Test public void testLdifParserCommentsEmptyLines() throws NamingException, Exception { String ldif = "#\n" + "# Licensed to the Apache Software Foundation (ASF) under one\n" + "# or more contributor license agreements. See the NOTICE file\n" + "# distributed with this work for additional information\n" + "# regarding copyright ownership. The ASF licenses this file\n" + "# to you under the Apache License, Version 2.0 (the\n" + "# \"License\"); you may not use this file except in compliance\n" + "# with the License. You may obtain a copy of the License at\n" + "# \n" + "# http: + "# \n" + "# Unless required by applicable law or agreed to in writing,\n" + "# software distributed under the License is distributed on an\n" + "# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n" + "# KIND, either express or implied. See the License for the\n" + "# specific language governing permissions and limitations\n" + "# under the License. \n" + "# \n" + "#\n" + "#\n" + "# EXAMPLE.COM is freely and reserved for testing according to this RFC:\n" + "#\n" + "# http: + "#\n" + "#\n" + "\n" + "#\n" + "# This ACI allows brouse access to the root suffix and one level below that to anyone.\n" + "# At this level there is nothing critical exposed. Everything that matters is one or\n" + "# more levels below this.\n" + "#\n" + "\n" + "objectClass: top\n" + "objectClass: subentry\n" + "objectClass: accessControlSubentry\n" + "subtreeSpecification: { maximum 1 }\n" + "prescriptiveACI: { identificationTag \"browseRoot\", precedence 100, authenticationLevel none, itemOrUserFirst userFirst: { userClasses { allUsers }, userPermissions { { protectedItems {entry}, grantsAndDenials { grantReturnDN, grantBrowse } } } } }\n"; LdifAttributesReader reader = new LdifAttributesReader(); Attributes attributes = reader.parseAttributes( ldif ); javax.naming.directory.Attribute attr = attributes.get( "objectClass" ); assertTrue( attr.contains( "top" ) ); assertTrue( attr.contains( SchemaConstants.SUBENTRY_OC ) ); assertTrue( attr.contains( "accessControlSubentry" ) ); attr = attributes.get( "subtreeSpecification" ); assertTrue( attr.contains( "{ maximum 1 }" ) ); attr = attributes.get( "prescriptiveACI" ); assertTrue( attr .contains( "{ identificationTag \"browseRoot\", precedence 100, authenticationLevel none, itemOrUserFirst userFirst: { userClasses { allUsers }, userPermissions { { protectedItems {entry}, grantsAndDenials { grantReturnDN, grantBrowse } } } } }" ) ); reader.close(); } |
OsgiUtils { public static Set<File> getClasspathCandidates( FileFilter filter ) { Set<File> candidates = new HashSet<>(); String separator = System.getProperty( "path.separator" ); String[] cpElements = System.getProperty( "java.class.path" ).split( separator ); for ( String element : cpElements ) { File candidate = new File( element ); if ( candidate.isFile() ) { if ( filter != null && filter.accept( candidate ) ) { candidates.add( candidate ); if ( LOG.isInfoEnabled() ) { LOG.info( I18n.msg( I18n.MSG_17003_ACCEPTED_CANDIDATE_WITH_FILTER, candidate.toString() ) ); } } else if ( filter == null && candidate.getName().endsWith( ".jar" ) ) { candidates.add( candidate ); if ( LOG.isInfoEnabled() ) { LOG.info( I18n.msg( I18n.MSG_17004_ACCEPTED_CANDIDATE_NO_FILTER, candidate.toString() ) ); } } else { if ( LOG.isInfoEnabled() ) { LOG.info( I18n.msg( I18n.MSG_17005_REJECTING_CANDIDATE, candidate.toString() ) ); } } } } return candidates; } private OsgiUtils(); static Set<String> getAllBundleExports( FileFilter filter, Set<String> pkgs ); static Set<String> splitIntoPackages( String exports, Set<String> pkgs ); static Set<File> getClasspathCandidates( FileFilter filter ); static String getBundleExports( File bundle ); } | @Test public void testGetClasspathCandidates() { Set<File> candidates = OsgiUtils.getClasspathCandidates( REJECTION_FILTER ); assertEquals( 0, candidates.size(), "Should have no results with REJECTION_FILTER" ); candidates = OsgiUtils.getClasspathCandidates( ONLY_ONE_FILTER ); assertEquals( 1, candidates.size(), "Should have one result with ONLY_ONE_FILTER" ); candidates = OsgiUtils.getClasspathCandidates( JUNIT_SLF4J_FILTER ); assertTrue( candidates.size() >= 4, "Should have at least 4 results with JUNIT_SLF4J_FILTER" ); candidates = OsgiUtils.getClasspathCandidates( null ); assertTrue( candidates.size() >= 4, "Should have at least 4 results with no filter" ); } |
LdifRevertor { public static LdifEntry reverseAdd( Dn dn ) { LdifEntry entry = new LdifEntry(); entry.setChangeType( ChangeType.Delete ); entry.setDn( dn ); return entry; } private LdifRevertor(); static LdifEntry reverseAdd( Dn dn ); static LdifEntry reverseDel( Dn dn, Entry deletedEntry ); static LdifEntry reverseModify( Dn dn, List<Modification> forwardModifications, Entry modifiedEntry ); static LdifEntry reverseMove( Dn newSuperiorDn, Dn modifiedDn ); static List<LdifEntry> reverseRename( Entry entry, Rdn newRdn, boolean deleteOldRdn ); static List<LdifEntry> reverseMoveAndRename( Entry entry, Dn newSuperior, Rdn newRdn, boolean deleteOldRdn ); static final boolean DELETE_OLD_RDN; static final boolean KEEP_OLD_RDN; } | @Test public void testReverseAdd() throws LdapInvalidDnException { Dn dn = new Dn( "dc=apache, dc=com" ); LdifEntry reversed = LdifRevertor.reverseAdd( dn ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Delete, reversed.getChangeType() ); assertNull( reversed.getEntry() ); }
@Test public void testReverseAddBase64DN() throws LdapException { Dn dn = new Dn( "dc=Emmanuel L\u00c9charny" ); LdifEntry reversed = LdifRevertor.reverseAdd( dn ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Delete, reversed.getChangeType() ); assertNull( reversed.getEntry() ); } |
LdifRevertor { public static LdifEntry reverseDel( Dn dn, Entry deletedEntry ) throws LdapException { LdifEntry entry = new LdifEntry(); entry.setDn( dn ); entry.setChangeType( ChangeType.Add ); for ( Attribute attribute : deletedEntry ) { entry.addAttribute( attribute ); } return entry; } private LdifRevertor(); static LdifEntry reverseAdd( Dn dn ); static LdifEntry reverseDel( Dn dn, Entry deletedEntry ); static LdifEntry reverseModify( Dn dn, List<Modification> forwardModifications, Entry modifiedEntry ); static LdifEntry reverseMove( Dn newSuperiorDn, Dn modifiedDn ); static List<LdifEntry> reverseRename( Entry entry, Rdn newRdn, boolean deleteOldRdn ); static List<LdifEntry> reverseMoveAndRename( Entry entry, Dn newSuperior, Rdn newRdn, boolean deleteOldRdn ); static final boolean DELETE_OLD_RDN; static final boolean KEEP_OLD_RDN; } | @Test public void testReverseDel() throws LdapException { Dn dn = new Dn( "dc=apache, dc=com" ); Entry deletedEntry = new DefaultEntry( dn , "objectClass: top", "objectClass: person", "cn: test", "sn: apache", "dc: apache" ); LdifEntry reversed = LdifRevertor.reverseDel( dn, deletedEntry ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Add, reversed.getChangeType() ); assertNotNull( reversed.getEntry() ); assertEquals( deletedEntry, reversed.getEntry() ); } |
LdifRevertor { public static LdifEntry reverseModify( Dn dn, List<Modification> forwardModifications, Entry modifiedEntry ) throws LdapException { Entry clonedEntry = modifiedEntry.clone(); LdifEntry entry = new LdifEntry(); entry.setChangeType( ChangeType.Modify ); entry.setDn( dn ); List<Modification> reverseModifications = new ArrayList<>(); for ( Modification modification : forwardModifications ) { switch ( modification.getOperation() ) { case ADD_ATTRIBUTE: Attribute mod = modification.getAttribute(); Attribute previous = clonedEntry.get( mod.getId() ); if ( mod.equals( previous ) ) { continue; } Modification reverseModification = new DefaultModification( ModificationOperation.REMOVE_ATTRIBUTE, mod ); reverseModifications.add( 0, reverseModification ); break; case REMOVE_ATTRIBUTE: mod = modification.getAttribute(); previous = clonedEntry.get( mod.getId() ); if ( previous == null ) { continue; } if ( mod.get() == null ) { reverseModification = new DefaultModification( ModificationOperation.ADD_ATTRIBUTE, previous ); reverseModifications.add( 0, reverseModification ); break; } reverseModification = new DefaultModification( ModificationOperation.ADD_ATTRIBUTE, mod ); reverseModifications.add( 0, reverseModification ); break; case REPLACE_ATTRIBUTE: mod = modification.getAttribute(); previous = clonedEntry.get( mod.getId() ); if ( ( mod.get() == null ) && ( previous == null ) ) { reverseModification = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, new DefaultAttribute( mod.getId() ) ); reverseModifications.add( 0, reverseModification ); continue; } if ( mod.get() == null ) { reverseModification = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, previous ); reverseModifications.add( 0, reverseModification ); continue; } if ( previous == null ) { Attribute emptyAttribute = new DefaultAttribute( mod.getId() ); reverseModification = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, emptyAttribute ); reverseModifications.add( 0, reverseModification ); continue; } reverseModification = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, previous ); reverseModifications.add( 0, reverseModification ); break; case INCREMENT_ATTRIBUTE: mod = modification.getAttribute(); previous = clonedEntry.get( mod.getId() ); reverseModification = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, previous ); reverseModifications.add( 0, reverseModification ); break; default: break; } AttributeUtils.applyModification( clonedEntry, modification ); } if ( reverseModifications.isEmpty() ) { throw new IllegalArgumentException( I18n.err( I18n.ERR_13465_CANT_DEDUCE_REVERSE_FOR_MOD, forwardModifications ) ); } for ( Modification modification : reverseModifications ) { entry.addModification( modification ); } return entry; } private LdifRevertor(); static LdifEntry reverseAdd( Dn dn ); static LdifEntry reverseDel( Dn dn, Entry deletedEntry ); static LdifEntry reverseModify( Dn dn, List<Modification> forwardModifications, Entry modifiedEntry ); static LdifEntry reverseMove( Dn newSuperiorDn, Dn modifiedDn ); static List<LdifEntry> reverseRename( Entry entry, Rdn newRdn, boolean deleteOldRdn ); static List<LdifEntry> reverseMoveAndRename( Entry entry, Dn newSuperior, Rdn newRdn, boolean deleteOldRdn ); static final boolean DELETE_OLD_RDN; static final boolean KEEP_OLD_RDN; } | @Test public void testReverseModifyDelExistingOuValue() throws LdapException { Entry modifiedEntry = buildEntry(); modifiedEntry.put( "ou", "apache", "acme corp" ); Dn dn = new Dn( "cn=test, ou=system" ); Modification mod = new DefaultModification( ModificationOperation.REMOVE_ATTRIBUTE, new DefaultAttribute( "ou", "acme corp" ) ); LdifEntry reversed = LdifRevertor.reverseModify( dn, Collections.<Modification> singletonList( mod ), modifiedEntry ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); assertNull( reversed.getEntry() ); List<Modification> mods = reversed.getModifications(); assertNotNull( mods ); assertEquals( 1, mods.size() ); Modification modif = mods.get( 0 ); assertEquals( ModificationOperation.ADD_ATTRIBUTE, modif.getOperation() ); Attribute attr = modif.getAttribute(); assertNotNull( attr ); assertEquals( "ou", attr.getId() ); assertEquals( "acme corp", attr.getString() ); }
@Test public void testReverseModifyDeleteOU() throws LdapException { Entry modifiedEntry = buildEntry(); modifiedEntry.put( "ou", "apache", "acme corp" ); Dn dn = new Dn( "cn=test, ou=system" ); Modification mod = new DefaultModification( ModificationOperation.REMOVE_ATTRIBUTE, new DefaultAttribute( "ou" ) ); LdifEntry reversed = LdifRevertor.reverseModify( dn, Collections.<Modification> singletonList( mod ), modifiedEntry ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); assertNull( reversed.getEntry() ); List<Modification> mods = reversed.getModifications(); assertNotNull( mods ); assertEquals( 1, mods.size() ); Modification modif = mods.get( 0 ); assertEquals( ModificationOperation.ADD_ATTRIBUTE, modif.getOperation() ); Attribute attr = modif.getAttribute(); assertNotNull( attr ); assertEquals( "ou", attr.getId() ); assertTrue( attr.contains( "apache", "acme corp" ) ); }
@Test public void testReverseModifyDelExistingOuWithAllValues() throws LdapException { Entry modifiedEntry = buildEntry(); Attribute ou = new DefaultAttribute( "ou", "apache", "acme corp" ); modifiedEntry.put( ou ); Dn dn = new Dn( "cn=test, ou=system" ); Modification mod = new DefaultModification( ModificationOperation.REMOVE_ATTRIBUTE, ou ); LdifEntry reversed = LdifRevertor.reverseModify( dn, Collections.<Modification> singletonList( mod ), modifiedEntry ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); assertNull( reversed.getEntry() ); List<Modification> mods = reversed.getModifications(); assertNotNull( mods ); assertEquals( 1, mods.size() ); Modification modif = mods.get( 0 ); assertEquals( ModificationOperation.ADD_ATTRIBUTE, modif.getOperation() ); Attribute attr = modif.getAttribute(); assertNotNull( attr ); assertEquals( "ou", attr.getId() ); assertTrue( ou.contains( "apache", "acme corp" ) ); }
@Test public void testReverseModifyReplaceExistingOuValues() throws LdapException { Entry modifiedEntry = buildEntry(); Attribute ou = new DefaultAttribute( "ou", "apache", "acme corp" ); modifiedEntry.put( ou ); Dn dn = new Dn( "cn=test, ou=system" ); Attribute ouModified = new DefaultAttribute( "ou", "directory", "BigCompany inc." ); Modification mod = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, ouModified ); LdifEntry reversed = LdifRevertor.reverseModify( dn, Collections.<Modification> singletonList( mod ), modifiedEntry ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); assertNull( reversed.getEntry() ); List<Modification> mods = reversed.getModifications(); assertNotNull( mods ); assertEquals( 1, mods.size() ); Modification modif = mods.get( 0 ); assertEquals( ModificationOperation.REPLACE_ATTRIBUTE, modif.getOperation() ); Attribute attr = modif.getAttribute(); assertNotNull( attr ); assertEquals( ou, attr ); }
@Test public void testReverseModifyReplaceNewAttribute() throws LdapException { Entry modifiedEntry = buildEntry(); Dn dn = new Dn( "cn=test, ou=system" ); Attribute newOu = new DefaultAttribute( "ou", "apache", "acme corp" ); Modification mod = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, newOu ); LdifEntry reversed = LdifRevertor.reverseModify( dn, Collections.<Modification> singletonList( mod ), modifiedEntry ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); assertNull( reversed.getEntry() ); List<Modification> mods = reversed.getModifications(); assertNotNull( mods ); assertEquals( 1, mods.size() ); Modification modif = mods.get( 0 ); assertEquals( ModificationOperation.REPLACE_ATTRIBUTE, modif.getOperation() ); Attribute attr = modif.getAttribute(); assertNotNull( attr ); assertEquals( "ou", attr.getId() ); assertNull( attr.get() ); }
@Test public void testReverseModifyReplaceExistingOuWithNothing() throws LdapException { Entry modifiedEntry = buildEntry(); modifiedEntry.put( "ou", "apache", "acme corp" ); Dn dn = new Dn( "cn=test, ou=system" ); Modification mod = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, new DefaultAttribute( "ou" ) ); LdifEntry reversed = LdifRevertor.reverseModify( dn, Collections.<Modification> singletonList( mod ), modifiedEntry ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); assertNull( reversed.getEntry() ); List<Modification> mods = reversed.getModifications(); assertNotNull( mods ); assertEquals( 1, mods.size() ); Modification modif = mods.get( 0 ); assertEquals( ModificationOperation.REPLACE_ATTRIBUTE, modif.getOperation() ); Attribute attr = modif.getAttribute(); assertNotNull( attr ); assertEquals( "ou", attr.getId() ); assertTrue( attr.contains( "apache", "acme corp" ) ); }
@Test public void testReverseMultipleModifications() throws Exception { String initialEntryLdif = "dn: cn=test, ou=system\n" + "objectclass: top\n" + "objectclass: person\n" + "cn: test\n" + "sn: joe doe\n" + "l: USA\n" + "ou: apache\n" + "ou: acme corp\n"; LdifReader reader = new LdifReader(); List<LdifEntry> entries = reader.parseLdif( initialEntryLdif ); reader.close(); LdifEntry initialEntry = entries.get( 0 ); Dn dn = new Dn( "cn=test, ou=system" ); List<Modification> modifications = new ArrayList<Modification>(); Modification mod = new DefaultModification( ModificationOperation.ADD_ATTRIBUTE, new DefaultAttribute( "ou", "BigCompany inc." ) ); modifications.add( mod ); mod = new DefaultModification( ModificationOperation.REMOVE_ATTRIBUTE, new DefaultAttribute( "l" ) ); modifications.add( mod ); mod = new DefaultModification( ModificationOperation.ADD_ATTRIBUTE, new DefaultAttribute( "l", "FR" ) ); modifications.add( mod ); mod = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, new DefaultAttribute( "l", "USA" ) ); modifications.add( mod ); mod = new DefaultModification( ModificationOperation.REPLACE_ATTRIBUTE, new DefaultAttribute( "ou", "apache" ) ); modifications.add( mod ); LdifEntry reversedEntry = LdifRevertor.reverseModify( dn, modifications, initialEntry.getEntry() ); String expectedEntryLdif = "dn: cn=test, ou=system\n" + "changetype: modify\n" + "replace: ou\n" + "ou: apache\n" + "ou: acme corp\n" + "ou: BigCompany inc.\n" + "-\n" + "replace: l\n" + "l: FR\n" + "-\n" + "delete: l\n" + "l: FR\n" + "-\n" + "add: l\n" + "l: USA\n" + "-\n" + "delete: ou\n" + "ou: BigCompany inc.\n" + "-\n\n"; reader = new LdifReader(); entries = reader.parseLdif( expectedEntryLdif ); reader.close(); LdifEntry expectedEntry = entries.get( 0 ); assertEquals( expectedEntry, reversedEntry ); }
@Test public void testReverseModifyAddNewOuValue() throws LdapException { Entry modifiedEntry = buildEntry(); modifiedEntry.put( "ou", "apache", "acme corp" ); Dn dn = new Dn( "cn=test, ou=system" ); Modification mod = new DefaultModification( ModificationOperation.ADD_ATTRIBUTE, new DefaultAttribute( "ou", "BigCompany inc." ) ); LdifEntry reversed = LdifRevertor.reverseModify( dn, Collections.<Modification> singletonList( mod ), modifiedEntry ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); assertNull( reversed.getEntry() ); List<Modification> mods = reversed.getModifications(); assertNotNull( mods ); assertEquals( 1, mods.size() ); Modification modif = mods.get( 0 ); assertEquals( ModificationOperation.REMOVE_ATTRIBUTE, modif.getOperation() ); Attribute attr = modif.getAttribute(); assertNotNull( attr ); assertEquals( "ou", attr.getId() ); assertEquals( "BigCompany inc.", attr.getString() ); }
@Test public void testReverseModifyAddNewOu() throws LdapException { Entry modifiedEntry = buildEntry(); Dn dn = new Dn( "cn=test, ou=system" ); Modification mod = new DefaultModification( ModificationOperation.ADD_ATTRIBUTE, new DefaultAttribute( "ou", "BigCompany inc." ) ); LdifEntry reversed = LdifRevertor.reverseModify( dn, Collections.<Modification> singletonList( mod ), modifiedEntry ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); assertNull( reversed.getEntry() ); List<Modification> mods = reversed.getModifications(); assertNotNull( mods ); assertEquals( 1, mods.size() ); Modification modif = mods.get( 0 ); assertEquals( ModificationOperation.REMOVE_ATTRIBUTE, modif.getOperation() ); Attribute attr = modif.getAttribute(); assertNotNull( attr ); assertEquals( "ou", attr.getId() ); assertEquals( "BigCompany inc.", attr.getString() ); } |
OsgiUtils { public static Set<String> getAllBundleExports( FileFilter filter, Set<String> pkgs ) { if ( pkgs == null ) { pkgs = new HashSet<>(); } Set<File> candidates = getClasspathCandidates( filter ); for ( File candidate : candidates ) { String exports = getBundleExports( candidate ); if ( exports == null ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_17000_NO_EXPORT_FOUND, candidate ) ); } continue; } if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_17001_PROCESSING_EXPORTS, candidate, exports ) ); } splitIntoPackages( exports, pkgs ); } return pkgs; } private OsgiUtils(); static Set<String> getAllBundleExports( FileFilter filter, Set<String> pkgs ); static Set<String> splitIntoPackages( String exports, Set<String> pkgs ); static Set<File> getClasspathCandidates( FileFilter filter ); static String getBundleExports( File bundle ); } | @Test public void testGetAllBundleExports() { OsgiUtils.getAllBundleExports( null, null ); } |
Subsets and Splits