target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@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 instan... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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() ); asser... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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.getValu... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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() ); ... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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 ); } } | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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() ); ... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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() ); assertE... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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 ); } } | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@Test public void testYearMonthDayHourDotFractionZulu() throws ParseException { String gt = "200801021213.987Z"; GeneralizedTime generalizedTime = new GeneralizedTime( gt ); String result = generalizedTime.toGeneralizedTime(); assertEquals( gt, result ); } | public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... |
@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 ) ); } } ass... | 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 b... | 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;... | 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;... | 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;... | 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;... |
@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().getStrin... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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() ); as... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@Test public void testExtensibleFilterForm3() throws ParseException { try { FilterParser.parse( "(:=dummyAssertion)" ); fail( "Should never reach this point" ); } catch ( ParseException pe ) { assertTrue( true ); } } | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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)" ); FilterPa... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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)... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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( tr... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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().co... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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().contai... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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().cont... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@Test public void testYearMonthDayHourDotFractionPlusHour() throws ParseException { String gt = "2008010212.987+0100"; GeneralizedTime generalizedTime = new GeneralizedTime( gt ); String result = generalizedTime.toGeneralizedTime(); assertEquals( gt, result ); } | public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... |
@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().c... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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().... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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.getAn... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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.get... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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( nod... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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( nod... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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().con... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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.getVal... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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.ge... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@Test public void testYearMonthDayHourDotFractionMinusHourMin() throws ParseException { String gt = "2008010212.987-1030"; GeneralizedTime generalizedTime = new GeneralizedTime( gt ); String result = generalizedTime.toGeneralizedTime(); assertEquals( gt, result ); } | public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... |
@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() ); Stri... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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(... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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.getAttrib... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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 ); assertEqual... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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 ); } } | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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(); as... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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.toStr... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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 ... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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( St... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@Test public void testYearMonthDayHourCommaFractionZulu() throws ParseException { String gt = "2008010212,987Z"; GeneralizedTime generalizedTime = new GeneralizedTime( gt ); String result = generalizedTime.toGeneralizedTime(); assertEquals( gt, result ); } | public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... |
@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... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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 ); } | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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.start... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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 ) Filte... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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 Equality... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@Test public void testEqualsFilterWithUnderscoreNotRelaxed() throws ParseException { String str = "(a_b_=people)"; assertThrows( ParseException.class, () -> { FilterParser.parse( str, false ); } ); } | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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( s... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@Test public void testAndFilterWithUnderscoreNotRelaxed() throws ParseException { String str = "(&(o_u~=people)(a_g_e>=30))"; assertThrows( ParseException.class, () -> { FilterParser.parse( str, false ); } ); } | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@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(... | public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } } | FilterParser { public static ExprNode parse( String filter ) throws ParseException { return parse( null, filter, false ); } private FilterParser(); } | 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 ); stati... | 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 ); stati... |
@Test public void testGetRegexpEmpty() throws Exception { Pattern pattern = SubstringNode.getRegex( "", new String[] { "" }, "" ); boolean b1 = pattern.matcher( "" ).matches(); assertTrue( b1 ); } | 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.appe... | 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 < an... | 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 < an... | 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 < an... | 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 < an... |
@Test public void testYearMonthDayHourCommaFractionPlusHour() throws ParseException { String gt = "2008010212,987+0100"; GeneralizedTime generalizedTime = new GeneralizedTime( gt ); String result = generalizedTime.toGeneralizedTime(); assertEquals( gt, result ); } | public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... |
@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 ); } | 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.appe... | 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 < an... | 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 < an... | 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 < an... | 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 < an... |
@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 ); } | 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.appe... | 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 < an... | 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 < an... | 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 < an... | 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 < an... |
@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 ); } | 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.appe... | 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 < an... | 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 < an... | 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 < an... | 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 < an... |
@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 (... | 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.appe... | 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 < an... | 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 < an... | 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 < an... | 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 < an... |
@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( ... | 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.appe... | 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 < an... | 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 < an... | 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 < an... | 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 < an... |
@Test public void testFormatWithNoPlaceholdersAndCorrectArgumentCount() { assertEquals( "(cn=foo)", FilterEncoder.format( "(cn=foo)", (String[])null ) ); assertEquals( "(cn=foo)", FilterEncoder.format( "(cn=foo)", ZERO ) ); } | 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 IllegalArgume... | 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 n... | 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 n... | 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 n... | 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 n... |
@Test public void testFormatWithNoPlaceholdersAndTooManyArguments() { assertThrows( IllegalArgumentException.class, () -> { FilterEncoder.format( "(cn=foo)", ONE ); } ); } | 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 IllegalArgume... | 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 n... | 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 n... | 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 n... | 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 n... |
@Test public void testFormatWithPlaceholdersAndTooFewArguments() { assertThrows( IllegalArgumentException.class, () -> { FilterEncoder.format( "(cn={0})", ZERO ); } ); } | 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 IllegalArgume... | 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 n... | 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 n... | 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 n... | 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 n... |
@Test public void testFormatWithPlaceholdersAndCorrectArgumentCount() { assertEquals( "(cn=foo)", FilterEncoder.format( "(cn={0})", ONE ) ); assertEquals( "(&(cn=foo)(uid=bar))", FilterEncoder.format( "(&(cn={0})(uid={1}))", TWO ) ); } | 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 IllegalArgume... | 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 n... | 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 n... | 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 n... | 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 n... |
@Test public void testFormatWithPlaceholdersAndTooManyArguments() { assertThrows( IllegalArgumentException.class, () -> { FilterEncoder.format( "(cn={0})", TWO ); } ); } | 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 IllegalArgume... | 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 n... | 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 n... | 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 n... | 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 n... |
@Test public void testYearMonthDayHourCommaFractionMinusHourMin() throws ParseException { String gt = "2008010212,987-1030"; GeneralizedTime generalizedTime = new GeneralizedTime( gt ); String result = generalizedTime.toGeneralizedTime(); assertEquals( gt, result ); } | public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... |
@Test public void testFormatWithPlaceholdersAndSpecialChars() { assertEquals( "(cn=\\28\\5C\\2A\\00\\29)", FilterEncoder.format( "(cn={0})", SPECIAL_CHARS ) ); } | 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 IllegalArgume... | 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 n... | 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 n... | 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 n... | 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 n... |
@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 " ) )... | 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 IllegalArgume... | 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 n... | 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 n... | 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 n... | 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 n... |
@Test public void testEncodeFilterValue() { assertEquals( "1234567890", FilterEncoder.encodeFilterValue( "1234567890" ) ); assertEquals( "\\28", FilterEncoder.encodeFilterValue( "(" ) ); assertEquals( "\\29", FilterEncoder.encodeFilterValue( ")" ) ); assertEquals( "\\2A", FilterEncoder.encodeFilterValue( "*" ) ); asser... | 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... | 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.appe... | 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.appe... | 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.appe... | 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.appe... |
@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(... | public static boolean compareCredentials( byte[] receivedCredentials, byte[] storedCredentials ) { LdapSecurityConstants algorithm = findAlgorithm( storedCredentials ); if ( algorithm != null ) { PasswordDetails passwordDetails = PasswordUtil.splitCredentials( storedCredentials ); byte[] userPassword = PasswordUtil.enc... | PasswordUtil { public static boolean compareCredentials( byte[] receivedCredentials, byte[] storedCredentials ) { LdapSecurityConstants algorithm = findAlgorithm( storedCredentials ); if ( algorithm != null ) { PasswordDetails passwordDetails = PasswordUtil.splitCredentials( storedCredentials ); byte[] userPassword = P... | PasswordUtil { public static boolean compareCredentials( byte[] receivedCredentials, byte[] storedCredentials ) { LdapSecurityConstants algorithm = findAlgorithm( storedCredentials ); if ( algorithm != null ) { PasswordDetails passwordDetails = PasswordUtil.splitCredentials( storedCredentials ); byte[] userPassword = P... | PasswordUtil { public static boolean compareCredentials( byte[] receivedCredentials, byte[] storedCredentials ) { LdapSecurityConstants algorithm = findAlgorithm( storedCredentials ); if ( algorithm != null ) { PasswordDetails passwordDetails = PasswordUtil.splitCredentials( storedCredentials ); byte[] userPassword = P... | PasswordUtil { public static boolean compareCredentials( byte[] receivedCredentials, byte[] storedCredentials ) { LdapSecurityConstants algorithm = findAlgorithm( storedCredentials ); if ( algorithm != null ) { PasswordDetails passwordDetails = PasswordUtil.splitCredentials( storedCredentials ); byte[] userPassword = P... |
@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... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@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... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@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_ATTRI... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@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( ModificationOperatio... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@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, modi... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@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( Modificat... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@Test public void testFormatting() throws ParseException { String gt = "20080102121314Z"; GeneralizedTime generalizedTime = new GeneralizedTime( gt ); String result = generalizedTime.toGeneralizedTime(); assertEquals( gt, result ); result = generalizedTime.toGeneralizedTime( Format.YEAR_MONTH_DAY_HOUR_MIN, null, 0, Tim... | public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... |
@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( Modif... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@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 ); A... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@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, at... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@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, mod... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@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, modifi... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@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( Modifica... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@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_... | 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 ( modifi... | 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( modification... | 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( modification... | 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( modification... | 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( modification... |
@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_GENERAT... | 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,... | 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, tmpChangeCoun... | 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, tmpChangeCoun... | 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, tmpChangeCoun... | 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, tmpChangeCoun... |
@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() ); ass... | 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 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 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, i... | 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, i... | 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, i... |
@Test public void testIsValidCsn() { assertTrue( Csn.isValid( "20100111202217.914000Z#000000#000#000000" ) ); } | 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.isD... | 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[... | 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[... | 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[... | 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[... |
@Test public void testAdjustWhileFormatting() throws ParseException { String gt = "20080102121314+0130"; GeneralizedTime generalizedTime = new GeneralizedTime( gt ); String result = generalizedTime.toGeneralizedTime(); assertEquals( gt, result ); result = generalizedTime.toGeneralizedTime( Format.YEAR_MONTH_DAY_HOUR_MI... | public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... |
@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 ); } | @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 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 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, Li... | 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, Li... | 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, Li... |
@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.s... | @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 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 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, Li... | 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, Li... | 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, Li... |
@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... | @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 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 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, Li... | 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, Li... | 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, Li... |
@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 ) ); } | @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 ... | 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 ) { ... | 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 ) { ... | 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 ) { ... | 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 ) { ... |
@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() ) ); } | @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 ... | 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 ) { ... | 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 ) { ... | 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 ) { ... | 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 ) { ... |
@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.... | @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 ... | 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 ) { ... | 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 ) { ... | 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 ) { ... | 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 ) { ... |
@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() ) ); } | @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 ... | 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 ) { ... | 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 ) { ... | 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 ) { ... | 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 ) { ... |
@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() ) ); } | @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 ... | 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 ) { ... | 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 ) { ... | 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 ) { ... | 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 ) { ... |
@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() ) ); } | @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 ... | 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 ) { ... | 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 ) { ... | 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 ) { ... | 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 ) { ... |
@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 ) ); } | @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 ).getStri... | 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 ); }... | 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 ); }... | 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 ); }... | 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 ); }... |
@Test public void testFebruary29inLeapYear() throws ParseException { String gt = "20080229000000Z"; GeneralizedTime generalizedTime = new GeneralizedTime( gt ); String result = generalizedTime.toGeneralizedTime(); assertEquals( gt, result ); } | public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } } | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... | GeneralizedTime implements Comparable<GeneralizedTime> { public String toGeneralizedTime() { return toGeneralizedTime( upFormat, upFractionDelimiter, upFractionLength, upTimeZoneFormat ); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( Stri... |
@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.currentT... | @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 ).getStri... | 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 ); }... | 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 ); }... | 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 ); }... | 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 ); }... |
@Test public void testNullSids() { assertEquals( 0, comparator.compare( null, null ) ); assertEquals( -1, comparator.compare( null, "000" ) ); assertEquals( 1, comparator.compare( "000", null ) ); } | 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( ... | 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 s... | 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 s... | 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 s... | 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 s... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.