src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
LdifRevertor { public static LdifEntry reverseMove( Dn newSuperiorDn, Dn modifiedDn ) throws LdapException { LdifEntry entry = new LdifEntry(); Dn currentParent; Rdn currentRdn; Dn newDn; if ( newSuperiorDn == null ) { throw new IllegalArgumentException( I18n.err( I18n.ERR_13466_NEW_SUPERIOR_DN_NULL ) ); } if ( modifiedDn == null ) { throw new IllegalArgumentException( I18n.err( I18n.ERR_13467_NULL_MODIFIED_DN ) ); } if ( modifiedDn.size() == 0 ) { throw new IllegalArgumentException( I18n.err( I18n.ERR_13468_DONT_MOVE_ROOTDSE ) ); } currentParent = modifiedDn; currentRdn = currentParent.getRdn(); currentParent = currentParent.getParent(); newDn = newSuperiorDn; newDn = newDn.add( modifiedDn.getRdn() ); entry.setChangeType( ChangeType.ModDn ); entry.setDn( newDn ); entry.setNewRdn( currentRdn.getName() ); entry.setNewSuperior( currentParent.getName() ); entry.setDeleteOldRdn( false ); return entry; } private LdifRevertor(); static LdifEntry reverseAdd( Dn dn ); static LdifEntry reverseDel( Dn dn, Entry deletedEntry ); static LdifEntry reverseModify( Dn dn, List<Modification> forwardModifications, Entry modifiedEntry ); static LdifEntry reverseMove( Dn newSuperiorDn, Dn modifiedDn ); static List<LdifEntry> reverseRename( Entry entry, Rdn newRdn, boolean deleteOldRdn ); static List<LdifEntry> reverseMoveAndRename( Entry entry, Dn newSuperior, Rdn newRdn, boolean deleteOldRdn ); static final boolean DELETE_OLD_RDN; static final boolean KEEP_OLD_RDN; } | @Test public void testReverseModifyDNMove() throws LdapException { Dn dn = new Dn( "cn=john doe, dc=example, dc=com" ); Dn newSuperior = new Dn( "ou=system" ); Rdn rdn = new Rdn( "cn=john doe" ); LdifEntry reversed = LdifRevertor.reverseMove( newSuperior, dn ); assertNotNull( reversed ); assertEquals( "cn=john doe,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModDn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( rdn.getName(), reversed.getNewRdn() ); assertEquals( "dc=example, dc=com", Strings.trim( reversed.getNewSuperior() ) ); assertNull( reversed.getEntry() ); } |
LdifRevertor { public static List<LdifEntry> reverseRename( Entry entry, Rdn newRdn, boolean deleteOldRdn ) throws LdapInvalidDnException { return reverseMoveAndRename( entry, null, newRdn, deleteOldRdn ); } private LdifRevertor(); static LdifEntry reverseAdd( Dn dn ); static LdifEntry reverseDel( Dn dn, Entry deletedEntry ); static LdifEntry reverseModify( Dn dn, List<Modification> forwardModifications, Entry modifiedEntry ); static LdifEntry reverseMove( Dn newSuperiorDn, Dn modifiedDn ); static List<LdifEntry> reverseRename( Entry entry, Rdn newRdn, boolean deleteOldRdn ); static List<LdifEntry> reverseMoveAndRename( Entry entry, Dn newSuperior, Rdn newRdn, boolean deleteOldRdn ); static final boolean DELETE_OLD_RDN; static final boolean KEEP_OLD_RDN; } | @Test public void test11ReverseRenameSimpleSimpleNotOverlappingKeepOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "cn=test,ou=system" ); Rdn oldRdn = new Rdn( "cn=test" ); Rdn newRdn = new Rdn( "cn=joe" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=joe,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertTrue( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test12ReverseRenameSimpleSimpleNotOverlappingKeepOldRdnExistInEntry() throws LdapException { Dn dn = new Dn( "cn=test,ou=system" ); Rdn oldRdn = new Rdn( "cn=test" ); Rdn newRdn = new Rdn( "cn=small" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "cn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=small,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test21ReverseRenameSimpleSimpleNotOverlappingDeleteOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "cn=test,ou=system" ); Rdn oldRdn = new Rdn( "cn=test" ); Rdn newRdn = new Rdn( "cn=joe" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=joe,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertTrue( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test22ReverseRenameSimpleSimpleNotOverlappingDeleteOldRdnExistInEntry() throws LdapException { Dn dn = new Dn( "cn=test,ou=system" ); Rdn oldRdn = new Rdn( "cn=test" ); Rdn newRdn = new Rdn( "cn=small" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "cn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=small,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test3ReverseRenameCompositeSimpleNotOverlappingKeepOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "cn=joe" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=joe,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertTrue( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test3ReverseRenameCompositeSimpleNotOverlappingKeepOldRdnExistsInEntry() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "cn=big" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "cn: big", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=big,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test4ReverseRenameCompositeSimpleNotOverlappingDeleteOldRdnDontExistsInEntry() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "cn=joe" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=joe,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertTrue( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test4ReverseRenameCompositeSimpleNotOverlappingDeleteOldRdnExistInEntry() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "cn=big" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "cn: big", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=big,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test5ReverseRenameCompositeSimpleOverlappingKeepOldRdn() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "cn=test" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test5ReverseRenameCompositeSimpleOverlappingDeleteOldRdn() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "cn=test" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test61ReverseRenameSimpleCompositeNotOverlappingKeepOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "cn=test,ou=system" ); Rdn oldRdn = new Rdn( "cn=test" ); Rdn newRdn = new Rdn( "cn=joe+sn=plumber" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "cn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=joe+sn=plumber,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertTrue( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test62ReverseRenameSimpleCompositeNotOverlappingKeepOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "cn=test,ou=system" ); Rdn oldRdn = new Rdn( "cn=test" ); Rdn newRdn = new Rdn( "cn=joe+sn=small" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 2, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=joe+sn=small,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); reversed = reverseds.get( 1 ); assertEquals( "cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); Modification[] mods = reversed.getModificationArray(); assertNotNull( mods ); assertEquals( 1, mods.length ); assertEquals( ModificationOperation.REMOVE_ATTRIBUTE, mods[0].getOperation() ); assertNotNull( mods[0].getAttribute() ); assertEquals( "cn", mods[0].getAttribute().getId() ); assertEquals( "joe", mods[0].getAttribute().getString() ); }
@Test public void test71ReverseRenameSimpleCompositeNotOverlappingDeleteOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "cn=test,ou=system" ); Rdn oldRdn = new Rdn( "cn=test" ); Rdn newRdn = new Rdn( "cn=joe+sn=plumber" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "cn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=joe+sn=plumber,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertTrue( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test72ReverseRenameSimpleCompositeNotOverlappingDeleteOldRdnExistInEntry() throws LdapException { Dn dn = new Dn( "cn=test,ou=system" ); Rdn oldRdn = new Rdn( "cn=test" ); Rdn newRdn = new Rdn( "cn=joe+sn=small" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 2, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=joe+sn=small,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); reversed = reverseds.get( 1 ); assertEquals( "cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); Modification[] mods = reversed.getModificationArray(); assertNotNull( mods ); assertEquals( 1, mods.length ); assertEquals( ModificationOperation.REMOVE_ATTRIBUTE, mods[0].getOperation() ); assertNotNull( mods[0].getAttribute() ); assertEquals( "cn", mods[0].getAttribute().getId() ); assertEquals( "joe", mods[0].getAttribute().getString() ); }
@Test public void test81ReverseRenameSimpleCompositeOverlappingKeepOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "cn=test,ou=system" ); Rdn oldRdn = new Rdn( "cn=test" ); Rdn newRdn = new Rdn( "sn=small+cn=test" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "cn: big", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "sn=small+cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertTrue( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test82ReverseRenameSimpleCompositeOverlappingKeepOldRdnExistInEntry() throws LdapException { Dn dn = new Dn( "cn=test,ou=system" ); Rdn oldRdn = new Rdn( "cn=test" ); Rdn newRdn = new Rdn( "sn=small+cn=test+seeAlso=big" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "seeAlso: big", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 2, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "sn=small+cn=test+seeAlso=big,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); reversed = reverseds.get( 1 ); assertEquals( "cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); Modification[] mods = reversed.getModificationArray(); assertNotNull( mods ); assertEquals( 1, mods.length ); assertEquals( ModificationOperation.REMOVE_ATTRIBUTE, mods[0].getOperation() ); assertNotNull( mods[0].getAttribute() ); assertEquals( "sn", mods[0].getAttribute().getId() ); assertEquals( "small", mods[0].getAttribute().getString() ); }
@Test public void test91ReverseRenameSimpleCompositeOverlappingDeleteOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "cn=test,ou=system" ); Rdn oldRdn = new Rdn( "cn=test" ); Rdn newRdn = new Rdn( "sn=small+cn=test" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "cn: big", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "sn=small+cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertTrue( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test92ReverseRenameSimpleCompositeOverlappingDeleteOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "cn=test,ou=system" ); Rdn oldRdn = new Rdn( "cn=test" ); Rdn newRdn = new Rdn( "sn=small+cn=test+seeAlso=big" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "seeAlso: big", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 2, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "sn=small+cn=test+seeAlso=big,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); reversed = reverseds.get( 1 ); assertEquals( "cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); Modification[] mods = reversed.getModificationArray(); assertNotNull( mods ); assertEquals( 1, mods.length ); assertEquals( ModificationOperation.REMOVE_ATTRIBUTE, mods[0].getOperation() ); assertNotNull( mods[0].getAttribute() ); assertEquals( "sn", mods[0].getAttribute().getId() ); assertEquals( "small", mods[0].getAttribute().getString() ); }
@Test public void test101ReverseRenameCompositeCompositeNotOverlappingKeepOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "cn=joe+sn=plumber" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "cn: big", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=joe+sn=plumber,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertTrue( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test102ReverseRenameCompositeCompositeNotOverlappingKeepOldRdnExistInEntry() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "sn=joe+cn=big" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "cn: big", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 2, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "sn=joe+cn=big,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); reversed = reverseds.get( 1 ); assertEquals( "sn=small+cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); Modification[] mods = reversed.getModificationArray(); assertNotNull( mods ); assertEquals( 1, mods.length ); assertEquals( ModificationOperation.REMOVE_ATTRIBUTE, mods[0].getOperation() ); assertNotNull( mods[0].getAttribute() ); assertEquals( "sn", mods[0].getAttribute().getId() ); assertEquals( "joe", mods[0].getAttribute().getString() ); }
@Test public void test111ReverseRenameCompositeCompositeNotOverlappingDeleteOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "cn=joe+sn=plumber" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "sn: big", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=joe+sn=plumber,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertTrue( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test112ReverseRenameCompositeCompositeNotOverlappingDeleteOldRdnExistInEntry() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "cn=joe+sn=big" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "sn: big", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 2, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "cn=joe+sn=big,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); reversed = reverseds.get( 1 ); assertEquals( "sn=small+cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.Modify, reversed.getChangeType() ); Modification[] mods = reversed.getModificationArray(); assertNotNull( mods ); assertEquals( 1, mods.length ); assertEquals( ModificationOperation.REMOVE_ATTRIBUTE, mods[0].getOperation() ); assertNotNull( mods[0].getAttribute() ); assertEquals( "cn", mods[0].getAttribute().getId() ); assertEquals( "joe", mods[0].getAttribute().getString() ); }
@Test public void test121ReverseRenameCompositeCompositeOverlappingKeepOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "sn=joe+cn=test" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "cn: big", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "sn=joe+cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertTrue( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test122ReverseRenameCompositeCompositeOverlappingKeepOldRdnExistInEntry() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "sn=big+cn=test" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "sn: big", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.KEEP_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "sn=big+cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test131ReverseRenameCompositeCompositeOverlappingDeleteOldRdnDontExistInEntry() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "sn=joe+cn=test" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "cn: big", "sn: small", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "sn=joe+cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertTrue( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); }
@Test public void test132ReverseRenameCompositeCompositeOverlappingDeleteOldRdnExistInEntry() throws LdapException { Dn dn = new Dn( "sn=small+cn=test,ou=system" ); Rdn oldRdn = new Rdn( "sn=small+cn=test" ); Rdn newRdn = new Rdn( "sn=big+cn=test" ); Entry entry = new DefaultEntry( dn, "objectClass: top", "objectClass: person", "cn: test", "sn: small", "sn: big", "sn: this is a test" ); List<LdifEntry> reverseds = LdifRevertor.reverseRename( entry, newRdn, LdifRevertor.DELETE_OLD_RDN ); assertNotNull( reverseds ); assertEquals( 1, reverseds.size() ); LdifEntry reversed = reverseds.get( 0 ); assertEquals( "sn=big+cn=test,ou=system", reversed.getDn().getName() ); assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); assertFalse( reversed.isDeleteOldRdn() ); assertEquals( oldRdn.getName(), reversed.getNewRdn() ); assertNull( reversed.getNewSuperior() ); } |
Unicode { public static char bytesToChar( byte[] bytes ) { return bytesToChar( bytes, 0 ); } private Unicode(); static int countBytesPerChar( byte[] bytes, int pos ); static char bytesToChar( byte[] bytes ); static char bytesToChar( byte[] bytes, int pos ); static int countNbBytesPerChar( char car ); static int countBytes( char[] chars ); static int countChars( byte[] bytes ); static byte[] charToBytes( char car ); static boolean isUnicodeSubset( String str, int pos ); static boolean isUnicodeSubset( char c ); static boolean isUnicodeSubset( byte b ); static void writeUTF( ObjectOutput objectOutput, String str ); static String readUTF( ObjectInput objectInput ); } | @Test public void testOneByteChar() { char res = Unicode.bytesToChar( new byte[] { 0x30 } ); assertEquals( '0', res ); }
@Test public void testOneByteChar00() { char res = Unicode.bytesToChar( new byte[] { 0x00 } ); assertEquals( 0x00, res ); }
@Test public void testOneByteChar7F() { char res = Unicode.bytesToChar( new byte[] { 0x7F } ); assertEquals( 0x7F, res ); }
@Test public void testTwoBytesChar() { char res = Unicode.bytesToChar( new byte[] { ( byte ) 0xCE, ( byte ) 0x91 } ); assertEquals( 0x0391, res ); }
@Test public void testThreeBytesChar() { char res = Unicode.bytesToChar( new byte[] { ( byte ) 0xE2, ( byte ) 0x89, ( byte ) 0xA2 } ); assertEquals( 0x2262, res ); } |
LdifUtils { public static boolean isLDIFSafe( String str ) { if ( Strings.isEmpty( str ) ) { return true; } char currentChar = str.charAt( 0 ); if ( ( currentChar > 127 ) || !LDIF_SAFE_STARTING_CHAR_ALPHABET[currentChar] ) { return false; } for ( int i = 1; i < str.length(); i++ ) { currentChar = str.charAt( i ); if ( ( currentChar > 127 ) || !LDIF_SAFE_OTHER_CHARS_ALPHABET[currentChar] ) { return false; } } return currentChar != ' '; } private LdifUtils(); static boolean isLDIFSafe( String str ); static String convertToLdif( Attributes attrs ); static String convertToLdif( Attributes attrs, int length ); static String convertToLdif( Attributes attrs, Dn dn, int length ); static String convertToLdif( Attributes attrs, Dn dn ); static String convertToLdif( Entry entry ); static String convertToLdif( Entry entry, boolean includeVersionInfo ); static String convertAttributesToLdif( Entry entry ); static Attributes getJndiAttributesFromLdif( String ldif ); static String convertToLdif( Entry entry, int length ); static String convertAttributesToLdif( Entry entry, int length ); static String convertToLdif( LdifEntry entry ); static String convertToLdif( LdifEntry entry, int length ); static String convertToLdif( Attribute attr ); static String convertToLdif( Attribute attr, int length ); static String stripLineToNChars( String str, int nbChars ); static Attributes createJndiAttributes( Object... avas ); } | @Test public void testIsLdifNullString() { assertTrue( LdifUtils.isLDIFSafe( null ) ); }
@Test public void testIsLdifEmptyString() { assertTrue( LdifUtils.isLDIFSafe( "" ) ); }
@Test public void testIsLdifSafeStartingWithNUL() { char c = ( char ) 0; assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); }
@Test public void testIsLdifSafeStartingWithLF() { char c = ( char ) 10; assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); }
@Test public void testIsLdifSafeStartingWithCR() { char c = ( char ) 13; assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); }
@Test public void testIsLdifSafeStartingWithSpace() { char c = ( char ) 32; assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); }
@Test public void testIsLdifSafeStartingWithColon() { char c = ( char ) 58; assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); }
@Test public void testIsLdifSafeStartingWithLessThan() { char c = ( char ) 60; assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); }
@Test public void testIsLdifSafeStartingWithCharGreaterThan127() { char c = ( char ) 127; assertTrue( LdifUtils.isLDIFSafe( c + testString ) ); }
@Test public void testIsLdifSafeStartingWithCharGreaterThan127Bis() { char c = ( char ) 222; assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); }
@Test public void testIsLdifSafeContainsNUL() { char c = ( char ) 0; assertFalse( LdifUtils.isLDIFSafe( testString + c + testString ) ); }
@Test public void testIsLdifSafeContainsLF() { char c = ( char ) 10; assertFalse( LdifUtils.isLDIFSafe( testString + c + testString ) ); }
@Test public void testIsLdifSafeContainsCR() { char c = ( char ) 13; assertFalse( LdifUtils.isLDIFSafe( testString + c + testString ) ); }
@Test public void testIsLdifSafeContainsCharGreaterThan127() { char c = ( char ) 127; assertTrue( LdifUtils.isLDIFSafe( testString + c + testString ) ); }
@Test public void testIsLdifSafeContainsCharGreaterThan127Bis() { char c = ( char ) 328; assertFalse( LdifUtils.isLDIFSafe( testString + c + testString ) ); }
@Test public void testIsLdifSafeEndingWithSpace() { char c = ( char ) 32; assertFalse( LdifUtils.isLDIFSafe( testString + c ) ); }
@Test public void testIsLdifSafeCorrectString() { assertTrue( LdifUtils.isLDIFSafe( testString ) ); } |
BitString { public boolean getBit( int pos ) { if ( pos > nbBits ) { throw new IndexOutOfBoundsException( I18n.err( I18n.ERR_00002_CANNOT_FIND_BIT, pos, nbBits ) ); } int posBytes = pos >>> 3; int bitNumber = 7 - pos % 8; byte mask = ( byte ) ( 1 << bitNumber ); int res = bytes[posBytes] & mask; return res != 0; } BitString( int length ); BitString( byte[] bytes ); void setData( byte[] data ); byte[] getData(); byte getUnusedBits(); void setBit( int pos ); void clearBit( int pos ); boolean getBit( int pos ); int size(); @Override String toString(); static final BitString EMPTY_STRING; } | @Test public void testSingleBitBitString() throws DecoderException { BitString bitString = new BitString( new byte[] { 0x07, ( byte ) 0x80 } ); assertEquals( true, bitString.getBit( 0 ) ); } |
LdifUtils { public static String stripLineToNChars( String str, int nbChars ) { int strLength = str.length(); if ( strLength <= nbChars ) { return str; } if ( nbChars < 2 ) { throw new IllegalArgumentException( I18n.err( I18n.ERR_13474_LINE_LENGTH_TOO_SHORT ) ); } int charsPerLine = nbChars - 1; int remaining = ( strLength - nbChars ) % charsPerLine; int nbLines = 1 + ( ( strLength - nbChars ) / charsPerLine ) + ( remaining == 0 ? 0 : 1 ); int nbCharsTotal = strLength + nbLines + nbLines - 2; char[] buffer = new char[nbCharsTotal]; char[] orig = str.toCharArray(); int posSrc = 0; int posDst = 0; System.arraycopy( orig, posSrc, buffer, posDst, nbChars ); posSrc += nbChars; posDst += nbChars; for ( int i = 0; i < nbLines - 2; i++ ) { buffer[posDst++] = '\n'; buffer[posDst++] = ' '; System.arraycopy( orig, posSrc, buffer, posDst, charsPerLine ); posSrc += charsPerLine; posDst += charsPerLine; } buffer[posDst++] = '\n'; buffer[posDst++] = ' '; System.arraycopy( orig, posSrc, buffer, posDst, remaining == 0 ? charsPerLine : remaining ); return new String( buffer ); } private LdifUtils(); static boolean isLDIFSafe( String str ); static String convertToLdif( Attributes attrs ); static String convertToLdif( Attributes attrs, int length ); static String convertToLdif( Attributes attrs, Dn dn, int length ); static String convertToLdif( Attributes attrs, Dn dn ); static String convertToLdif( Entry entry ); static String convertToLdif( Entry entry, boolean includeVersionInfo ); static String convertAttributesToLdif( Entry entry ); static Attributes getJndiAttributesFromLdif( String ldif ); static String convertToLdif( Entry entry, int length ); static String convertAttributesToLdif( Entry entry, int length ); static String convertToLdif( LdifEntry entry ); static String convertToLdif( LdifEntry entry, int length ); static String convertToLdif( Attribute attr ); static String convertToLdif( Attribute attr, int length ); static String stripLineToNChars( String str, int nbChars ); static Attributes createJndiAttributes( Object... avas ); } | @Test public void testStripLineToNChars() { String line = "abc"; try { LdifUtils.stripLineToNChars( line, 1 ); fail(); } catch ( IllegalArgumentException iae ) { } String res = LdifUtils.stripLineToNChars( line, 2 ); assertEquals( "ab\n c", res ); assertEquals( "abc", LdifUtils.stripLineToNChars( line, 3 ) ); }
@Test public void testStripLineTo5Chars() { assertEquals( "a", LdifUtils.stripLineToNChars( "a", 5 ) ); assertEquals( "ab", LdifUtils.stripLineToNChars( "ab", 5 ) ); assertEquals( "abc", LdifUtils.stripLineToNChars( "abc", 5 ) ); assertEquals( "abcd", LdifUtils.stripLineToNChars( "abcd", 5 ) ); assertEquals( "abcde", LdifUtils.stripLineToNChars( "abcde", 5 ) ); assertEquals( "abcde\n f", LdifUtils.stripLineToNChars( "abcdef", 5 ) ); assertEquals( "abcde\n fg", LdifUtils.stripLineToNChars( "abcdefg", 5 ) ); assertEquals( "abcde\n fgh", LdifUtils.stripLineToNChars( "abcdefgh", 5 ) ); assertEquals( "abcde\n fghi", LdifUtils.stripLineToNChars( "abcdefghi", 5 ) ); assertEquals( "abcde\n fghi\n j", LdifUtils.stripLineToNChars( "abcdefghij", 5 ) ); assertEquals( "abcde\n fghi\n jk", LdifUtils.stripLineToNChars( "abcdefghijk", 5 ) ); assertEquals( "abcde\n fghi\n jkl", LdifUtils.stripLineToNChars( "abcdefghijkl", 5 ) ); assertEquals( "abcde\n fghi\n jklm", LdifUtils.stripLineToNChars( "abcdefghijklm", 5 ) ); assertEquals( "abcde\n fghi\n jklm\n n", LdifUtils.stripLineToNChars( "abcdefghijklmn", 5 ) ); assertEquals( "abcde\n fghi\n jklm\n no", LdifUtils.stripLineToNChars( "abcdefghijklmno", 5 ) ); assertEquals( "abcde\n fghi\n jklm\n nop", LdifUtils.stripLineToNChars( "abcdefghijklmnop", 5 ) ); } |
LdifUtils { public static String convertToLdif( Attributes attrs ) throws LdapException { return convertAttributesToLdif( AttributeUtils.toEntry( attrs, null ), DEFAULT_LINE_LENGTH ); } private LdifUtils(); static boolean isLDIFSafe( String str ); static String convertToLdif( Attributes attrs ); static String convertToLdif( Attributes attrs, int length ); static String convertToLdif( Attributes attrs, Dn dn, int length ); static String convertToLdif( Attributes attrs, Dn dn ); static String convertToLdif( Entry entry ); static String convertToLdif( Entry entry, boolean includeVersionInfo ); static String convertAttributesToLdif( Entry entry ); static Attributes getJndiAttributesFromLdif( String ldif ); static String convertToLdif( Entry entry, int length ); static String convertAttributesToLdif( Entry entry, int length ); static String convertToLdif( LdifEntry entry ); static String convertToLdif( LdifEntry entry, int length ); static String convertToLdif( Attribute attr ); static String convertToLdif( Attribute attr, int length ); static String stripLineToNChars( String str, int nbChars ); static Attributes createJndiAttributes( Object... avas ); } | @Test public void testConvertToLdifEncoding() throws LdapException { Attributes attributes = new BasicAttributes( "cn", "Saarbr\u00FCcken" ); String ldif = LdifUtils.convertToLdif( attributes ); assertEquals( "cn:: U2FhcmJyw7xja2Vu\n", ldif ); }
@Test public void testConvertToLdifAttrWithNullValues() throws LdapException { Attributes attributes = new BasicAttributes( "cn", null ); String ldif = LdifUtils.convertToLdif( attributes ); assertEquals( "cn:\n", ldif ); }
@Test public void testConvertToLdif() throws LdapException { LdifEntry entry = new LdifEntry(); entry.setDn( "cn=Saarbr\u00FCcken, dc=example, dc=com" ); entry.setChangeType( ChangeType.Add ); entry.addAttribute( "objectClass", "top", "person", "inetorgPerson" ); entry.addAttribute( "cn", "Saarbr\u00FCcken" ); entry.addAttribute( "sn", "test" ); LdifUtils.convertToLdif( entry, 15 ); }
@Test public void testConvertEntryNoControls() throws Exception { LdifReader reader = new LdifReader(); String expected = "dn: ou=test\n" + "ObjectClass: top\n" + "ObjectClass: metaTop\n" + "ObjectClass: metaSyntax\n" + "m-oid: 1.2.3.4\n" + "m-description: description\n\n"; List<LdifEntry> entries = reader.parseLdif( expected ); LdifEntry expectedEntry = entries.get( 0 ); LdifEntry entry = new LdifEntry(); entry.setDn( "ou=test" ); entry.addAttribute( "ObjectClass", "top", "metaTop", "metaSyntax" ); entry.addAttribute( "m-oid", "1.2.3.4" ); entry.addAttribute( "m-description", "description" ); String converted = LdifUtils.convertToLdif( entry ); assertNotNull( converted ); entries = reader.parseLdif( converted ); LdifEntry convertedEntry = entries.get( 0 ); assertEquals( expectedEntry, convertedEntry ); reader.close(); }
@Test public void testConvertEntryOneControl() throws Exception { LdifReader reader = new LdifReader(); String expected = "dn: ou=test\n" + "control: 2.16.840.1.113730.3.4.2 false\n" + "changetype: add\n" + "ObjectClass: top\n" + "ObjectClass: metaTop\n" + "ObjectClass: metaSyntax\n" + "m-oid: 1.2.3.4\n" + "m-description: description\n\n"; List<LdifEntry> entries = reader.parseLdif( expected ); LdifEntry expectedEntry = entries.get( 0 ); LdifEntry entry = new LdifEntry(); entry.setDn( "ou=test" ); entry.addAttribute( "ObjectClass", "top", "metaTop", "metaSyntax" ); entry.addAttribute( "m-oid", "1.2.3.4" ); entry.addAttribute( "m-description", "description" ); ManageDsaITImpl control = new ManageDsaITImpl(); entry.addControl( control ); String converted = LdifUtils.convertToLdif( entry ); assertNotNull( converted ); entries = reader.parseLdif( converted ); LdifEntry convertedEntry = entries.get( 0 ); assertEquals( expectedEntry, convertedEntry ); reader.close(); } |
LdifUtils { public static Attributes createJndiAttributes( Object... avas ) throws LdapException { StringBuilder sb = new StringBuilder(); int pos = 0; boolean valueExpected = false; for ( Object ava : avas ) { if ( !valueExpected ) { if ( !( ava instanceof String ) ) { throw new LdapInvalidAttributeValueException( ResultCodeEnum.INVALID_ATTRIBUTE_SYNTAX, I18n.err( I18n.ERR_13233_ATTRIBUTE_ID_MUST_BE_A_STRING, pos + 1 ) ); } String attribute = ( String ) ava; sb.append( attribute ); if ( attribute.indexOf( ':' ) != -1 ) { sb.append( '\n' ); } else { valueExpected = true; } } else { if ( ava instanceof String ) { sb.append( ": " ).append( ( String ) ava ).append( '\n' ); } else if ( ava instanceof byte[] ) { sb.append( ":: " ); sb.append( new String( Base64.encode( ( byte[] ) ava ) ) ); sb.append( '\n' ); } else { throw new LdapInvalidAttributeValueException( ResultCodeEnum.INVALID_ATTRIBUTE_SYNTAX, I18n.err( I18n.ERR_13234_ATTRIBUTE_VAL_STRING_OR_BYTE, pos + 1 ) ); } valueExpected = false; } } if ( valueExpected ) { throw new LdapInvalidAttributeValueException( ResultCodeEnum.INVALID_ATTRIBUTE_SYNTAX, I18n .err( I18n.ERR_13234_ATTRIBUTE_VAL_STRING_OR_BYTE ) ); } try ( LdifAttributesReader reader = new LdifAttributesReader() ) { return AttributeUtils.toAttributes( reader.parseEntry( sb.toString() ) ); } catch ( IOException ioe ) { throw new LdapLdifException( ioe.getMessage(), ioe ); } } private LdifUtils(); static boolean isLDIFSafe( String str ); static String convertToLdif( Attributes attrs ); static String convertToLdif( Attributes attrs, int length ); static String convertToLdif( Attributes attrs, Dn dn, int length ); static String convertToLdif( Attributes attrs, Dn dn ); static String convertToLdif( Entry entry ); static String convertToLdif( Entry entry, boolean includeVersionInfo ); static String convertAttributesToLdif( Entry entry ); static Attributes getJndiAttributesFromLdif( String ldif ); static String convertToLdif( Entry entry, int length ); static String convertAttributesToLdif( Entry entry, int length ); static String convertToLdif( LdifEntry entry ); static String convertToLdif( LdifEntry entry, int length ); static String convertToLdif( Attribute attr ); static String convertToLdif( Attribute attr, int length ); static String stripLineToNChars( String str, int nbChars ); static Attributes createJndiAttributes( Object... avas ); } | @Test public void testCreateAttributesVarargs() throws LdapException, LdapLdifException, NamingException { String mOid = "m-oid: 1.2.3.4"; String description = "description"; Attributes attrs = LdifUtils.createJndiAttributes( "objectClass: top", "objectClass: metaTop", "objectClass: metaSyntax", mOid, "m-description", description ); assertEquals( "top", attrs.get( "objectClass" ).get( 0 ) ); assertEquals( "metaTop", attrs.get( "objectClass" ).get( 1 ) ); assertEquals( "metaSyntax", attrs.get( "objectClass" ).get( 2 ) ); assertEquals( "1.2.3.4", attrs.get( "m-oid" ).get() ); assertEquals( "description", attrs.get( "m-description" ).get() ); try { LdifUtils.createJndiAttributes( "objectClass", "top", "objectClass" ); fail(); } catch ( LdapInvalidAttributeValueException iave ) { assertTrue( true ); } } |
LdifReader implements Iterable<LdifEntry>, Closeable { public List<LdifEntry> parseLdif( String ldif ) throws LdapLdifException { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13407_STARTS_PARSING_LDIF ) ); } if ( Strings.isEmpty( ldif ) ) { return new ArrayList<>(); } try ( BufferedReader bufferReader = new BufferedReader( new StringReader( ldif ) ) ) { List<LdifEntry> entries = parseLdif( bufferReader ); if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13403_PARSED_N_ENTRIES, Integer.valueOf( entries.size() ) ) ); } return entries; } catch ( LdapLdifException ne ) { LOG.error( I18n.err( I18n.ERR_13428_CANNOT_PARSE_LDIF, ne.getLocalizedMessage() ) ); throw new LdapLdifException( I18n.err( I18n.ERR_13442_ERROR_PARSING_LDIF_BUFFER ), ne ); } catch ( LdapException le ) { throw new LdapLdifException( le.getMessage(), le ); } catch ( IOException ioe ) { throw new LdapLdifException( I18n.err( I18n.ERR_13450_CANNOT_CLOSE_FILE ), ioe ); } } LdifReader(); LdifReader( SchemaManager schemaManager ); LdifReader( String ldifFileName ); LdifReader( Reader in ); LdifReader( InputStream in ); LdifReader( File file ); LdifReader( File file, SchemaManager schemaManager ); void init(); int getVersion(); long getSizeLimit(); void setSizeLimit( long sizeLimit ); static Attribute parseAttributeValue( String line ); void parseAttributeValue( LdifEntry entry, String line, String lowerLine ); List<LdifEntry> parseLdifFile( String fileName ); List<LdifEntry> parseLdifFile( String fileName, String encoding ); List<LdifEntry> parseLdif( String ldif ); LdifEntry next(); LdifEntry fetch(); boolean hasNext(); void remove(); @Override Iterator<LdifEntry> iterator(); boolean hasError(); Exception getError(); List<LdifEntry> parseLdif( BufferedReader reader ); boolean containsEntries(); int getLineNumber(); boolean isValidateDn(); void setValidateDn( boolean validateDn ); void setSchemaManager( SchemaManager schemaManager ); @Override void close(); } | @Test public void testChangeTypeDeleteBadEntry() throws Exception { String ldif = "version: 1\n" + "dn: dc=example,dc=com\n" + "changetype: delete\n" + "attr1: test"; try ( LdifReader reader = new LdifReader() ) { assertThrows( LdapLdifException.class, () -> { reader.parseLdif( ldif ); } ); } }
@Test public void testLdifContentWithControl() throws Exception { String ldif = "version: 1\n" + "dn: dc=example,dc=com\n" + "control: 1.1.1\n" + "attr1: test"; try ( LdifReader reader = new LdifReader() ) { assertThrows( LdapLdifException.class, () -> { reader.parseLdif( ldif ); } ); } }
@Test public void testLdifParserRootDSE() throws Exception { String ldif = "version: 1\n" + "dn:\n" + "cn:: YXBwMQ==\n" + "objectClass: top\n" + "objectClass: apApplication\n" + "displayName: app1 \n" + "dependencies:\n" + "envVars:"; try ( LdifReader reader = new LdifReader() ) { List<LdifEntry> entries = reader.parseLdif( ldif ); assertNotNull( entries ); LdifEntry entry = entries.get( 0 ); assertTrue( entry.isLdifContent() ); assertEquals( "", entry.getDn().getName() ); Attribute attr = entry.get( "cn" ); assertTrue( attr.contains( "app1" ) ); attr = entry.get( "objectclass" ); assertTrue( attr.contains( "top" ) ); assertTrue( attr.contains( "apApplication" ) ); attr = entry.get( "displayname" ); assertTrue( attr.contains( "app1" ) ); attr = entry.get( "dependencies" ); assertEquals( "", attr.get().getString() ); attr = entry.get( "envvars" ); assertEquals( "", attr.get().getString() ); } }
@Test public void testLdifParserWithNullDn() throws Exception, Exception { String ldif1 = "dn: ads-authenticatorid=anonymousauthenticator,ou=authenticators,ads-interceptorId=authenticationInterceptor,ou=interceptors,ads-directoryServiceId=default,ou=config\n" + "ads-authenticatorid: anonymousauthenticator\n" + "objectclass: top\n" + "objectclass: ads-base\n" + "objectClass: ads-authenticator\n" + "objectClass: ads-authenticatorImpl\n" + "ads-authenticatorClass: org.apache.directory.server.core.authn.AnonymousAuthenticator\n" + "ads-baseDn: \n" + "ads-enabled: TRUE"; String ldif2 = "dn: ads-authenticatorid=anonymousauthenticator,ou=authenticators,ads-interceptorId=authenticationInterceptor,ou=interceptors,ads-directoryServiceId=default,ou=config\n" + "ads-authenticatorid: anonymousauthenticator\n" + "objectclass: top\n" + "objectclass: ads-base\n" + "objectClass: ads-authenticator\n" + "objectClass: ads-authenticatorImpl\n" + "ads-authenticatorClass: org.apache.directory.server.core.authn.AnonymousAuthenticator\n" + "ads-baseDn:\n" + "ads-enabled: TRUE"; try ( LdifReader reader = new LdifReader() ) { List<LdifEntry> entries1 = reader.parseLdif( ldif1 ); LdifEntry entry1 = entries1.get( 0 ); List<LdifEntry> entries2 = reader.parseLdif( ldif2 ); LdifEntry entry2 = entries2.get( 0 ); assertEquals( entry1, entry2 ); } } |
Unicode { public static byte[] charToBytes( char car ) { if ( car <= 0x007F ) { byte[] bytes = new byte[1]; bytes[0] = ( byte ) car; return bytes; } else if ( car <= 0x07FF ) { byte[] bytes = new byte[2]; bytes[0] = ( byte ) ( 0x00C0 + ( ( car & 0x07C0 ) >> 6 ) ); bytes[1] = ( byte ) ( 0x0080 + ( car & 0x3F ) ); return bytes; } else { byte[] bytes = new byte[3]; bytes[0] = ( byte ) ( 0x00E0 + ( ( car & 0xF000 ) >> 12 ) ); bytes[1] = ( byte ) ( 0x0080 + ( ( car & 0x0FC0 ) >> 6 ) ); bytes[2] = ( byte ) ( 0x0080 + ( car & 0x3F ) ); return bytes; } } private Unicode(); static int countBytesPerChar( byte[] bytes, int pos ); static char bytesToChar( byte[] bytes ); static char bytesToChar( byte[] bytes, int pos ); static int countNbBytesPerChar( char car ); static int countBytes( char[] chars ); static int countChars( byte[] bytes ); static byte[] charToBytes( char car ); static boolean isUnicodeSubset( String str, int pos ); static boolean isUnicodeSubset( char c ); static boolean isUnicodeSubset( byte b ); static void writeUTF( ObjectOutput objectOutput, String str ); static String readUTF( ObjectInput objectInput ); } | @Test public void testcharToBytesOne() { assertEquals( "0x00 ", Strings.dumpBytes( Unicode.charToBytes( ( char ) 0x0000 ) ) ); assertEquals( "0x61 ", Strings.dumpBytes( Unicode.charToBytes( 'a' ) ) ); assertEquals( "0x7F ", Strings.dumpBytes( Unicode.charToBytes( ( char ) 0x007F ) ) ); }
@Test public void testcharToBytesTwo() { assertEquals( "0xC2 0x80 ", Strings.dumpBytes( Unicode.charToBytes( ( char ) 0x0080 ) ) ); assertEquals( "0xC3 0xBF ", Strings.dumpBytes( Unicode.charToBytes( ( char ) 0x00FF ) ) ); assertEquals( "0xC4 0x80 ", Strings.dumpBytes( Unicode.charToBytes( ( char ) 0x0100 ) ) ); assertEquals( "0xDF 0xBF ", Strings.dumpBytes( Unicode.charToBytes( ( char ) 0x07FF ) ) ); }
@Test public void testcharToBytesThree() { assertEquals( "0xE0 0xA0 0x80 ", Strings.dumpBytes( Unicode.charToBytes( ( char ) 0x0800 ) ) ); assertEquals( "0xE0 0xBF 0xBF ", Strings.dumpBytes( Unicode.charToBytes( ( char ) 0x0FFF ) ) ); assertEquals( "0xE1 0x80 0x80 ", Strings.dumpBytes( Unicode.charToBytes( ( char ) 0x1000 ) ) ); assertEquals( "0xEF 0xBF 0xBF ", Strings.dumpBytes( Unicode.charToBytes( ( char ) 0xFFFF ) ) ); } |
LdapConnectionConfig { public void setTrustManagers( TrustManager... trustManagers ) { if ( ( trustManagers == null ) || ( trustManagers.length == 0 ) || ( trustManagers.length == 1 && trustManagers[0] == null ) ) { throw new IllegalArgumentException( "TrustManagers must not be null or empty" ); } this.trustManagers = trustManagers; } LdapConnectionConfig(); boolean isUseSsl(); void setUseSsl( boolean useSsl ); int getLdapPort(); void setLdapPort( int ldapPort ); String getLdapHost(); void setLdapHost( String ldapHost ); String getName(); void setName( String name ); String getCredentials(); void setCredentials( String credentials ); int getDefaultLdapPort(); int getDefaultLdapsPort(); String getDefaultLdapHost(); long getDefaultTimeout(); long getTimeout(); void setTimeout( long timeout ); int getSupportedLdapVersion(); TrustManager[] getTrustManagers(); void setTrustManagers( TrustManager... trustManagers ); String getSslProtocol(); void setSslProtocol( String sslProtocol ); KeyManager[] getKeyManagers(); void setKeyManagers( KeyManager[] keyManagers ); SecureRandom getSecureRandom(); void setSecureRandom( SecureRandom secureRandom ); String[] getEnabledCipherSuites(); void setEnabledCipherSuites( String[] enabledCipherSuites ); String[] getEnabledProtocols(); void setEnabledProtocols( String... enabledProtocols ); BinaryAttributeDetector getBinaryAttributeDetector(); void setBinaryAttributeDetector( BinaryAttributeDetector binaryAttributeDetector ); boolean isUseTls(); void setUseTls( boolean useTls ); LdapApiService getLdapApiService(); void setLdapApiService( LdapApiService ldapApiService ); static final int DEFAULT_LDAP_PORT; static final int DEFAULT_LDAPS_PORT; static final String DEFAULT_LDAP_HOST; static final int LDAP_V3; static final long DEFAULT_TIMEOUT; static final String DEFAULT_SSL_PROTOCOL; } | @Test public void testNullTrustManagers() { LdapConnectionConfig config = new LdapConnectionConfig(); Assertions.assertThrows(IllegalArgumentException.class, () -> { config.setTrustManagers((TrustManager)null); }); }
@Test public void testNullTrustManagers2() { LdapConnectionConfig config = new LdapConnectionConfig(); Assertions.assertThrows(IllegalArgumentException.class, () -> { config.setTrustManagers(null); }); } |
LdifAnonymizer { public LdifAnonymizer() { try { schemaManager = new DefaultSchemaManager(); } catch ( Exception e ) { println( "Missing a SchemaManager !" ); System.exit( -1 ); } init( null, null, null, null ); } LdifAnonymizer(); LdifAnonymizer( SchemaManager schemaManager ); void setOut( PrintStream out ); void setAttributeLatestValueMap( AttributeType attributeType, Map<Integer, ?> latestValueMap ); void addAnonAttributeType( AttributeType attributeType ); void addAnonAttributeType( AttributeType attributeType, Anonymizer<?> anonymizer ); void removeAnonAttributeType( AttributeType attributeType ); Map<String, Anonymizer> getAttributeAnonymizers(); void addNamingContext( String dn ); void anonymizeFile( String ldifFile, Writer writer ); String anonymize( String ldif ); Map<Value, Value> getValueMap(); void setValueMap( Map<Value, Value> valueMap ); Map<Integer, String> getLatestStringMap(); void setLatestStringMap( Map<Integer, String> latestStringMap ); Map<Integer, byte[]> getLatestBytesMap(); void setLatestBytesMap( Map<Integer, byte[]> latestBytesMap ); static void main( String[] args ); } | @Test public void testLdifAnonymizer() throws Exception { String ldif = "dn: cn=test,dc=example,dc=com\n" + "ObjectClass: top\n" + "objectClass: person\n" + "cn: test\n" + "sn: Test\n" + "\n" + "dn: cn=emmanuel,dc=acme,dc=com\n" + "ObjectClass: top\n" + "objectClass: person\n" + "cn: emmanuel\n" + "sn: lecharnye\n"+ "\n" + "dn: cn=emmanuel,dc=test,dc=example,dc=com\n" + "ObjectClass: top\n" + "objectClass: person\n" + "cn: emmanuel\n" + "seeAlso: cn=emmanuel,dc=acme,dc=com\n" + "sn: elecharny\n"; SchemaManager schemaManager = null; try { schemaManager = new DefaultSchemaManager(); } catch ( Exception e ) { System.out.println( "Missing a SchemaManager !" ); System.exit( -1 ); } LdifAnonymizer anonymizer = new LdifAnonymizer( schemaManager ); anonymizer.addNamingContext( "dc=example,dc=com" ); anonymizer.addNamingContext( "dc=acme,dc=com" ); anonymizer.removeAnonAttributeType( schemaManager.getAttributeType( "sn" ) ); String result = anonymizer.anonymize( ldif ); List<LdifEntry> entries = ldifReader.parseLdif( result ); assertEquals( 3, entries.size() ); LdifEntry ldifEntry = entries.get( 0 ); assertTrue( ldifEntry.isEntry() ); Entry entry = ldifEntry.getEntry(); assertEquals( 3, entry.size() ); assertEquals( "cn=AAAA,dc=example,dc=com", entry.getDn().toString() ); Attribute cn = entry.get( "cn" ); assertEquals( "AAAA", cn.getString() ); Attribute sn = entry.get( "sn" ); assertEquals( "Test", sn.getString() ); ldifEntry = entries.get( 1 ); assertTrue( ldifEntry.isEntry() ); entry = ldifEntry.getEntry(); assertEquals( 3, entry.size() ); assertEquals( "cn=AAAAAAAA,dc=acme,dc=com", entry.getDn().toString() ); cn = entry.get( "cn" ); assertEquals( "AAAAAAAA", cn.getString() ); sn = entry.get( "sn" ); assertEquals( "lecharnye", sn.getString() ); ldifEntry = entries.get( 2 ); assertTrue( ldifEntry.isEntry() ); entry = ldifEntry.getEntry(); assertEquals( 4, entry.size() ); assertEquals( "cn=AAAAAAAA,dc=AAAA,dc=example,dc=com", entry.getDn().toString() ); cn = entry.get( "cn" ); assertEquals( "AAAAAAAA", cn.getString() ); sn = entry.get( "sn" ); assertEquals( "elecharny", sn.getString() ); Attribute seeAlso = entry.get( "seeAlso" ); assertEquals( "cn=AAAAAAAA,dc=acme,dc=com", seeAlso.getString() ); } |
UnaryFilter extends AbstractFilter { public static UnaryFilter not() { return new UnaryFilter(); } private UnaryFilter(); static UnaryFilter not(); static UnaryFilter not( Filter filter ); @Override StringBuilder build( StringBuilder builder ); } | @Test public void testNot() { AttributeDescriptionFilter attributeFilter = AttributeDescriptionFilter.present( "objectClass" ); assertEquals( "(!" + attributeFilter.build().toString() + ")", UnaryFilter.not( attributeFilter ).build().toString() ); AttributeValueAssertionFilter attributeValueAssertionFilter = AttributeValueAssertionFilter.equal( "objectClass", "person" ); assertEquals( "(!" + attributeValueAssertionFilter.build().toString() + ")", UnaryFilter.not( attributeValueAssertionFilter ).build().toString() ); } |
SetOfFiltersFilter extends AbstractFilter { public static SetOfFiltersFilter and( Filter... filters ) { return new SetOfFiltersFilter( FilterOperator.AND ).addAll( filters ); } private SetOfFiltersFilter( FilterOperator operator ); SetOfFiltersFilter add( Filter filter ); SetOfFiltersFilter addAll( Filter... filters ); SetOfFiltersFilter addAll( List<Filter> filters ); static SetOfFiltersFilter and( Filter... filters ); static SetOfFiltersFilter or( Filter... filters ); @Override StringBuilder build( StringBuilder builder ); } | @Test public void testAnd() { AttributeDescriptionFilter attributeFilter = AttributeDescriptionFilter.present( "objectClass" ); AttributeValueAssertionFilter attributeValueAssertionFilter = AttributeValueAssertionFilter.equal( "objectClass", "person" ); String expected = expected( FilterOperator.AND, attributeFilter, attributeValueAssertionFilter ); assertEquals( expected, SetOfFiltersFilter.and( attributeFilter, attributeValueAssertionFilter ) .build().toString() ); assertEquals( expected, SetOfFiltersFilter.and() .add( attributeFilter ) .add( attributeValueAssertionFilter ) .build().toString() ); assertEquals( expected, SetOfFiltersFilter.and() .addAll( attributeFilter, attributeValueAssertionFilter ) .build().toString() ); assertEquals( expected, SetOfFiltersFilter.and() .addAll( Arrays.asList( ( Filter ) attributeFilter, ( Filter ) attributeValueAssertionFilter ) ) .build().toString() ); } |
SetOfFiltersFilter extends AbstractFilter { public static SetOfFiltersFilter or( Filter... filters ) { return new SetOfFiltersFilter( FilterOperator.OR ).addAll( filters ); } private SetOfFiltersFilter( FilterOperator operator ); SetOfFiltersFilter add( Filter filter ); SetOfFiltersFilter addAll( Filter... filters ); SetOfFiltersFilter addAll( List<Filter> filters ); static SetOfFiltersFilter and( Filter... filters ); static SetOfFiltersFilter or( Filter... filters ); @Override StringBuilder build( StringBuilder builder ); } | @Test public void testOr() { AttributeDescriptionFilter attributeFilter = AttributeDescriptionFilter.present( "objectClass" ); AttributeValueAssertionFilter attributeValueAssertionFilter = AttributeValueAssertionFilter.equal( "objectClass", "person" ); String expected = expected( FilterOperator.OR, attributeFilter, attributeValueAssertionFilter ); assertEquals( expected, SetOfFiltersFilter.or( attributeFilter, attributeValueAssertionFilter ) .build().toString() ); assertEquals( expected, SetOfFiltersFilter.or() .add( attributeFilter ) .add( attributeValueAssertionFilter ) .build().toString() ); assertEquals( expected, SetOfFiltersFilter.or() .addAll( attributeFilter, attributeValueAssertionFilter ) .build().toString() ); assertEquals( expected, SetOfFiltersFilter.or() .addAll( Arrays.asList( ( Filter ) attributeFilter, ( Filter ) attributeValueAssertionFilter ) ) .build().toString() ); } |
FilterBuilder { public static MatchingRuleAssertionFilterBuilder extensible( String value ) { return new MatchingRuleAssertionFilterBuilder( null, value ); } FilterBuilder( Filter filter ); static FilterBuilder and( FilterBuilder... filters ); static FilterBuilder approximatelyEqual( String attribute, String value ); static FilterBuilder equal( String attribute, String value ); static MatchingRuleAssertionFilterBuilder extensible( String value ); static MatchingRuleAssertionFilterBuilder extensible( String attribute, String value ); static FilterBuilder greaterThanOrEqual( String attribute, String value ); static FilterBuilder lessThanOrEqual( String attribute, String value ); static FilterBuilder not( FilterBuilder builder ); static FilterBuilder or( FilterBuilder... builders ); static FilterBuilder present( String attribute ); static FilterBuilder startsWith( String attribute, String... parts ); static FilterBuilder endsWith( String attribute, String... parts ); static FilterBuilder contains( String attribute, String... parts ); static FilterBuilder substring( String attribute, String... parts ); @Override String toString(); } | @Test public void testExtensible() { assertEquals( "(cn:caseExactMatch:=Fred Flintstone)", extensible( "cn", "Fred Flintstone" ) .setMatchingRule( "caseExactMatch" ).toString() ); } |
FilterBuilder { FilterBuilder( Filter filter ) { this.filter = filter; } FilterBuilder( Filter filter ); static FilterBuilder and( FilterBuilder... filters ); static FilterBuilder approximatelyEqual( String attribute, String value ); static FilterBuilder equal( String attribute, String value ); static MatchingRuleAssertionFilterBuilder extensible( String value ); static MatchingRuleAssertionFilterBuilder extensible( String attribute, String value ); static FilterBuilder greaterThanOrEqual( String attribute, String value ); static FilterBuilder lessThanOrEqual( String attribute, String value ); static FilterBuilder not( FilterBuilder builder ); static FilterBuilder or( FilterBuilder... builders ); static FilterBuilder present( String attribute ); static FilterBuilder startsWith( String attribute, String... parts ); static FilterBuilder endsWith( String attribute, String... parts ); static FilterBuilder contains( String attribute, String... parts ); static FilterBuilder substring( String attribute, String... parts ); @Override String toString(); } | @Test public void testFilterBuilder() { assertEquals( "(cn=Babs Jensen)", equal( "cn", "Babs Jensen" ).toString() ); assertEquals( "(!(cn=Tim Howes))", not( equal( "cn", "Tim Howes" ) ).toString() ); assertEquals( "(&(objectClass=Person)(|(sn=Jensen)(cn=Babs J\\2A)))", and( equal( "objectClass", "Person" ), or( equal( "sn", "Jensen" ), equal( "cn", "Babs J*" ) ) ).toString() ); assertEquals( "(o=univ\\2Aof\\2Amich\\2A)", equal( "o", "univ*of*mich*" ).toString() ); } |
MatchingRuleAssertionFilter extends AbstractFilter { public static MatchingRuleAssertionFilter extensible( String value ) { return new MatchingRuleAssertionFilter( null, value, FilterOperator.EXTENSIBLE_EQUAL ); } MatchingRuleAssertionFilter( String attribute, String value,
FilterOperator operator ); static MatchingRuleAssertionFilter extensible( String value ); static MatchingRuleAssertionFilter extensible( String attribute, String value ); MatchingRuleAssertionFilter setMatchingRule( String matchingRule ); MatchingRuleAssertionFilter useDnAttributes(); @Override StringBuilder build( StringBuilder builder ); } | @Test public void testExtensible() { assertEquals( "(cn:caseExactMatch:=Fred Flintstone)", extensible( "cn", "Fred Flintstone" ) .setMatchingRule( "caseExactMatch" ).toString() ); assertEquals( "(cn:=Betty Rubble)", extensible( "cn", "Betty Rubble" ).toString() ); assertEquals( "(sn:dn:2.4.6.8.10:=Barney Rubble)", extensible( "sn", "Barney Rubble" ) .useDnAttributes() .setMatchingRule( "2.4.6.8.10" ).toString() ); assertEquals( "(o:dn:=Ace Industry)", extensible( "o", "Ace Industry" ) .useDnAttributes().toString() ); assertEquals( "(:1.2.3:=Wilma Flintstone)", extensible( "Wilma Flintstone" ) .setMatchingRule( "1.2.3" ).toString() ); assertEquals( "(:dn:2.4.6.8.10:=Dino)", extensible( "Dino" ) .useDnAttributes() .setMatchingRule( "2.4.6.8.10" ).toString() ); } |
AttributeDescriptionFilter extends AbstractFilter { public static AttributeDescriptionFilter present( String attribute ) { return new AttributeDescriptionFilter( attribute ); } private AttributeDescriptionFilter( String attribute ); static AttributeDescriptionFilter present( String attribute ); @Override StringBuilder build( StringBuilder builder ); } | @Test public void testPresent() { assertEquals( "(objectClass=*)", AttributeDescriptionFilter.present( "objectClass" ).build().toString() ); assertEquals( "(uid=*)", AttributeDescriptionFilter.present( "uid" ).build().toString() ); assertEquals( "(userPassword=*)", AttributeDescriptionFilter.present( "userPassword" ).build().toString() ); assertEquals( "(cn=*)", AttributeDescriptionFilter.present( "cn" ).build().toString() ); } |
JarLdifSchemaLoader extends AbstractSchemaLoader { public JarLdifSchemaLoader() throws IOException, LdapException { initializeSchemas(); } JarLdifSchemaLoader(); @Override List<Entry> loadComparators( Schema... schemas ); @Override List<Entry> loadSyntaxCheckers( Schema... schemas ); @Override List<Entry> loadNormalizers( Schema... schemas ); @Override List<Entry> loadMatchingRules( Schema... schemas ); @Override List<Entry> loadSyntaxes( Schema... schemas ); @Override List<Entry> loadAttributeTypes( Schema... schemas ); @Override List<Entry> loadMatchingRuleUses( Schema... schemas ); @Override List<Entry> loadNameForms( Schema... schemas ); @Override List<Entry> loadDitContentRules( Schema... schemas ); @Override List<Entry> loadDitStructureRules( Schema... schemas ); @Override List<Entry> loadObjectClasses( Schema... schemas ); } | @Test public void testJarLdifSchemaLoader() throws Exception { JarLdifSchemaLoader loader = new JarLdifSchemaLoader(); SchemaManager sm = new DefaultSchemaManager( loader ); sm.loadWithDeps( "system" ); assertTrue( sm.getRegistries().getAttributeTypeRegistry().contains( "cn" ) ); assertFalse( sm.getRegistries().getAttributeTypeRegistry().contains( "m-aux" ) ); sm.loadWithDeps( "apachemeta" ); assertTrue( sm.getRegistries().getAttributeTypeRegistry().contains( "m-aux" ) ); } |
SchemaToLdif { public static void transform( List<Schema> schemas ) throws ParserException { if ( ( schemas == null ) || schemas.isEmpty() ) { if ( LOG.isWarnEnabled() ) { LOG.warn( I18n.msg( I18n.MSG_15000_NO_SCHEMA_DEFINED ) ); } return; } int i = 1; for ( Schema schema : schemas ) { if ( schema.getName() == null ) { String msg = I18n.err( I18n.ERR_15000_SCHEMA_ELEMENT_NAME_REQUIRED, i ); LOG.error( msg ); throw new ParserException( msg ); } } for ( Schema schema : schemas ) { try { if ( LOG.isInfoEnabled() ) { LOG.info( I18n.msg( I18n.MSG_15001_GENERATING_SCHEMA, schema.getName() ) ); } generate( schema ); } catch ( Exception e ) { throw new ParserException( I18n.err( I18n.ERR_15004_CANNOT_GENERATE_SOURCES, schema.getName(), e.getMessage() ) ); } } } private SchemaToLdif(); static void transform( List<Schema> schemas ); } | @Test public void testConvertOC() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOC, ou=schema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-name: objectClass\n" + "m-description: An objectClass\n" + "m-obsolete: TRUE\n" + "m-supObjectClass: top\n" + "m-typeObjectClass: ABSTRACT\n" + "m-must: attr1\n" + "m-must: attr2\n" + "m-may: attr3\n" + "m-may: attr4\n\n"; assertEquals( expected, transform( "testOC" ) ); }
@Test public void testConvertOCMinimal() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCMinimal, ou=s\n" + " chema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n\n"; assertEquals( expected, transform( "testOCMinimal" ) ); }
@Test public void testConvertOCNoName() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCNoName, ou=sc\n" + " hema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-description: An objectClass\n" + "m-obsolete: TRUE\n" + "m-supObjectClass: top\n" + "m-typeObjectClass: ABSTRACT\n" + "m-must: attr1\n" + "m-must: attr2\n" + "m-may: attr3\n" + "m-may: attr4\n\n"; assertEquals( expected, transform( "testOCNoName" ) ); }
@Test public void testConvertOCAbstract() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCAbstract, ou=\n" + " schema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-typeObjectClass: ABSTRACT\n\n"; assertEquals( expected, transform( "testOCAbstract" ) ); }
@Test public void testConvertOCAuxiliary() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCAuxiliary, ou\n" + " =schema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-typeObjectClass: AUXILIARY\n\n"; assertEquals( expected, transform( "testOCAuxiliary" ) ); }
@Test public void testConvertOCDesc() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCDesc, ou=sche\n" + " ma\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-description: An objectClass\n\n"; assertEquals( expected, transform( "testOCDesc" ) ); }
@Test public void testConvertOCMayOne() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCMayOne, ou=sc\n" + " hema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-may: attr1\n\n"; assertEquals( expected, transform( "testOCMayOne" ) ); }
@Test public void testConvertOCMay2() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCMay2, ou=sche\n" + " ma\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-may: attr1\n" + "m-may: attr2\n\n"; assertEquals( expected, transform( "testOCMay2" ) ); }
@Test public void testConvertOCMayMany() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCMayMany, ou=s\n" + " chema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-may: attr1\n" + "m-may: attr2\n" + "m-may: attr3\n\n"; assertEquals( expected, transform( "testOCMayMany" ) ); }
@Test public void testConvertOCMustOne() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCMustOne, ou=s\n" + " chema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-must: attr1\n\n"; assertEquals( expected, transform( "testOCMustOne" ) ); }
@Test public void testConvertOCMust2() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCMust2, ou=sch\n" + " ema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-must: attr1\n" + "m-must: attr2\n\n"; assertEquals( expected, transform( "testOCMust2" ) ); }
@Test public void testConvertOCMustMany() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCMustMany, ou=\n" + " schema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-must: attr1\n" + "m-must: attr2\n" + "m-must: attr3\n\n"; assertEquals( expected, transform( "testOCMustMany" ) ); }
@Test public void testConvertOCNameOne() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCNameOne, ou=s\n" + " chema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-name: objectClass\n\n"; assertEquals( expected, transform( "testOCNameOne" ) ); }
@Test public void testConvertOCName2() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCName2, ou=sch\n" + " ema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-name: oc\n" + "m-name: objectClass\n\n"; assertEquals( expected, transform( "testOCName2" ) ); }
@Test public void testConvertOCNameMany() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCNameMany, ou=\n" + " schema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-name: oc\n" + "m-name: objectClass\n" + "m-name: object\n\n"; assertEquals( expected, transform( "testOCNameMany" ) ); }
@Test public void testConvertOCObsolete() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCObsolete, ou=\n" + " schema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-obsolete: TRUE\n\n"; assertEquals( expected, transform( "testOCObsolete" ) ); }
@Test public void testConvertOCSupOne() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCSupOne, ou=sc\n" + " hema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-supObjectClass: top\n\n"; assertEquals( expected, transform( "testOCSupOne" ) ); }
@Test public void testConvertOCSup2() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCSup2, ou=sche\n" + " ma\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-supObjectClass: top\n" + "m-supObjectClass: 1.3.6.1.4.1.18060.0.4.2.3.15\n\n"; assertEquals( expected, transform( "testOCSup2" ) ); }
@Test public void testConvertOCSupMany() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=objectclasses, cn=testOCSupMany, ou=s\n" + " chema\n" + "objectclass: metaObjectClass\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-supObjectClass: top\n" + "m-supObjectClass: 1.3.6.1.4.1.18060.0.4.2.3.15\n" + "m-supObjectClass: metaTop\n\n"; assertEquals( expected, transform( "testOCSupMany" ) ); }
@Test public void testConvertATMinimal() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATMinimal, ou=\n" + " schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n\n"; assertEquals( expected, transform( "testATMinimal" ) ); }
@Test public void testConvertATNoName() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATNoName, ou=s\n" + " chema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n\n"; assertEquals( expected, transform( "testATNoName" ) ); }
@Test public void testConvertATNameOne() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATNameOne, ou=\n" + " schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-name: attribute\n\n"; assertEquals( expected, transform( "testATNameOne" ) ); }
@Test public void testConvertATName2() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATName2, ou=sc\n" + " hema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-name: at\n" + "m-name: attribute\n\n"; assertEquals( expected, transform( "testATName2" ) ); }
@Test public void testConvertATNameMany() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATNameMany, ou\n" + " =schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-name: at\n" + "m-name: attribute\n" + "m-name: attribute2\n\n"; assertEquals( expected, transform( "testATNameMany" ) ); }
@Test public void testConvertATDesc() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATDesc, ou=sch\n" + " ema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-description: An attributeType\n\n"; assertEquals( expected, transform( "testATDesc" ) ); }
@Test public void testConvertATDesWithEscapedChars() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATDescWithEsca\n" + " ped, ou=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-description: Some 'escaped' chars\n\n"; assertEquals( expected, transform( "testATDescWithEscaped" ) ); }
@Test public void testConvertATObsolete() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATObsolete, ou\n" + " =schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-obsolete: TRUE\n\n"; assertEquals( expected, transform( "testATObsolete" ) ); }
@Test public void testConvertATSup() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATSup, ou=sche\n" + " ma\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-supAttributeType: anotherAttribute\n\n"; assertEquals( expected, transform( "testATSup" ) ); }
@Test public void testConvertATSupOID() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATSupOID, ou=s\n" + " chema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-supAttributeType: 1.3.6.1.4.1.18060.0.4.2.3.15\n\n"; assertEquals( expected, transform( "testATSupOID" ) ); }
@Test public void testConvertATEquality() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATEquality, ou\n" + " =schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-equality: booleanMatch\n\n"; assertEquals( expected, transform( "testATEquality" ) ); }
@Test public void testConvertATEqualityOID() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATEqualityOID,\n" + " ou=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-equality: 1.3.6.1.4.1.18060.0.4.2.3.15\n\n"; assertEquals( expected, transform( "testATEqualityOID" ) ); }
@Test public void testConvertATOrdering() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATOrdering, ou\n" + " =schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-ordering: booleanMatch\n\n"; assertEquals( expected, transform( "testATOrdering" ) ); }
@Test public void testConvertATOrderingOID() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATOrderingOID,\n" + " ou=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-ordering: 1.3.6.1.4.1.18060.0.4.2.3.15\n\n"; assertEquals( expected, transform( "testATOrderingOID" ) ); }
@Test public void testConvertATSubstr() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATSubstr, ou=s\n" + " chema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-substr: booleanMatch\n\n"; assertEquals( expected, transform( "testATSubstr" ) ); }
@Test public void testConvertATSubstrOID() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATSubstrOID, o\n" + " u=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-substr: 1.3.6.1.4.1.18060.0.4.2.3.15\n\n"; assertEquals( expected, transform( "testATSubstrOID" ) ); }
@Test public void testConvertATSyntax() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATSyntax, ou=s\n" + " chema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-syntax: 1.3.6.1.4.1.18060.0.4.2.3.15\n\n"; assertEquals( expected, transform( "testATSyntax" ) ); }
@Test public void testConvertATSyntaxOidLen() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATSyntaxOidLen\n" + " , ou=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-syntax: 1.3.6.1.4.1.18060.0.4.2.3.15\n" + "m-length: 123\n\n"; assertEquals( expected, transform( "testATSyntaxOidLen" ) ); }
@Test public void testConvertATSingleValue() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATSingleValue,\n" + " ou=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-singleValue: TRUE\n\n"; assertEquals( expected, transform( "testATSingleValue" ) ); }
@Test public void testConvertATCollective() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATCollective, \n" + " ou=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-collective: TRUE\n\n"; assertEquals( expected, transform( "testATCollective" ) ); }
@Test public void testConvertATNoUserModification() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATNoUserModifi\n" + " cation, ou=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-noUserModification: TRUE\n\n"; assertEquals( expected, transform( "testATNoUserModification" ) ); }
@Test public void testConvertATUsageUserApp() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATUsageUserApp\n" + " , ou=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n\n"; assertEquals( expected, transform( "testATUsageUserApp" ) ); }
@Test public void testConvertATUsageDirOp() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATUsageDirOp, \n" + " ou=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-usage: DIRECTORY_OPERATION\n\n"; assertEquals( expected, transform( "testATUsageDirOp" ) ); }
@Test public void testConvertATUsageDistrOp() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATUsageDistrOp\n" + " , ou=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-usage: DISTRIBUTED_OPERATION\n\n"; assertEquals( expected, transform( "testATUsageDistrOp" ) ); }
@Test public void testConvertATUsageDSAOp() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.18060.0.4.2.3.14, ou=attributetypes, cn=testATUsageDsaOp, \n" + " ou=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.18060.0.4.2.3.14\n" + "m-usage: DSA_OPERATION\n\n"; assertEquals( expected, transform( "testATUsageDsaOp" ) ); }
@Test public void testConvertMozillaATWithOidLen() throws ParserException, IOException { String expected = HEADER + "dn: m-oid=1.3.6.1.4.1.13769.3.2, ou=attributetypes, cn=testMozillaATWithOidLen, \n" + " ou=schema\n" + "objectclass: metaAttributeType\n" + "objectclass: metaTop\n" + "objectclass: top\n" + "m-oid: 1.3.6.1.4.1.13769.3.2\n" + "m-name: mozillaHomeStreet2\n" + "m-equality: caseIgnoreMatch\n" + "m-substr: caseIgnoreSubstringsMatch\n" + "m-syntax: 1.3.6.1.4.1.1466.115.121.1.15\n" + "m-length: 128\n" + "m-singleValue: TRUE\n\n"; assertEquals( expected, transform( "testMozillaATWithOidLen" ) ); }
@Test public void testConvertWrongLdif() throws ParserException, IOException { assertThrows( ParserException.class, ( ) -> { transform( "testWrongLdif" ); } ); } |
Hex { public static String decodeHexString( String str ) throws InvalidNameException { if ( str == null || str.length() == 0 ) { throw new InvalidNameException( I18n.err( I18n.ERR_17037_MUST_START_WITH_SHARP ) ); } char[] chars = str.toCharArray(); if ( chars[0] != '#' ) { throw new InvalidNameException( I18n.err( I18n.ERR_17038_MUST_START_WITH_ESC_SHARP, str ) ); } byte[] decoded = new byte[( chars.length - 1 ) >> 1]; for ( int ii = 1, jj = 0; ii < chars.length; ii += 2, jj++ ) { int ch = ( HEX_VALUE[chars[ii]] << 4 ) + ( HEX_VALUE[chars[ii + 1]] & 0xff ); decoded[jj] = ( byte ) ch; } return Strings.utf8ToString( decoded ); } private Hex(); static byte getHexValue( char high, char low ); static byte getHexValue( byte high, byte low ); static byte getHexValue( char c ); static String decodeHexString( String str ); static byte[] convertEscapedHex( String str ); static char[] encodeHex( byte[] data ); } | @Test public void testDecodeHexString() throws Exception { try { assertEquals( "", Hex.decodeHexString( "" ) ); fail( "should not get here" ); } catch ( NamingException e ) { } assertEquals( "", Hex.decodeHexString( "#" ) ); assertEquals( "F", Hex.decodeHexString( "#46" ) ); try { assertEquals( "F", Hex.decodeHexString( "46" ) ); fail( "should not get here" ); } catch ( NamingException e ) { } assertEquals( "Ferry", Hex.decodeHexString( "#4665727279" ) ); } |
DnNode { public synchronized DnNode<N> add( Dn dn ) throws LdapException { return add( dn, null ); } DnNode(); DnNode( N element ); DnNode( Dn dn, N element ); synchronized boolean isLeaf(); synchronized boolean isLeaf( Dn dn ); synchronized int size(); synchronized N getElement(); synchronized N getElement( Dn dn ); synchronized boolean hasElement(); synchronized boolean hasElement( Dn dn ); synchronized boolean hasDescendantElement( Dn dn ); synchronized List<N> getDescendantElements( Dn dn ); synchronized boolean hasChildren(); synchronized boolean hasChildren( Dn dn ); synchronized Map<String, DnNode<N>> getChildren(); synchronized DnNode<N> getParent(); synchronized boolean hasParent(); synchronized boolean hasParent( Dn dn ); synchronized DnNode<N> add( Dn dn ); synchronized DnNode<N> add( Dn dn, N element ); synchronized void remove( Dn dn ); synchronized boolean contains( Rdn rdn ); synchronized DnNode<N> getChild( Rdn rdn ); synchronized Rdn getRdn(); synchronized DnNode<N> getNode( Dn dn ); synchronized boolean hasParentElement( Dn dn ); synchronized DnNode<N> getParentWithElement( Dn dn ); synchronized DnNode<N> getParentWithElement(); synchronized void rename( Rdn newRdn ); synchronized void move( Dn newParent ); @Override String toString(); synchronized Dn getDn(); } | @Test public void testAddNullDNNoElem() throws LdapException { DnNode<Dn> tree = new DnNode<Dn>(); assertThrows( LdapUnwillingToPerformException.class, () -> { tree.add( null ); } ); }
@Test public void testAdd2EqualDNsNoElem() throws LdapException { DnNode<Dn> tree = new DnNode<Dn>(); Dn dn1 = new Dn( "dc=b,dc=a" ); Dn dn2 = new Dn( "dc=b,dc=a" ); tree.add( dn1 ); assertThrows( LdapUnwillingToPerformException.class, () -> { tree.add( dn2 ); } ); }
@Test public void testAddNullDN() throws LdapException { DnNode<Dn> tree = new DnNode<Dn>(); assertThrows( LdapUnwillingToPerformException.class, () -> { tree.add( ( Dn ) null, null ); } ); }
@Test public void testAdd2EqualDNs() throws LdapException { DnNode<Dn> tree = new DnNode<Dn>(); Dn dn1 = new Dn( "dc=b,dc=a" ); Dn dn2 = new Dn( "dc=b,dc=a" ); tree.add( dn1, dn1 ); assertThrows( LdapUnwillingToPerformException.class, () -> { tree.add( dn2, dn2 ); } ); } |
DnNode { public synchronized boolean hasChildren() { return ( children != null ) && children.size() != 0; } DnNode(); DnNode( N element ); DnNode( Dn dn, N element ); synchronized boolean isLeaf(); synchronized boolean isLeaf( Dn dn ); synchronized int size(); synchronized N getElement(); synchronized N getElement( Dn dn ); synchronized boolean hasElement(); synchronized boolean hasElement( Dn dn ); synchronized boolean hasDescendantElement( Dn dn ); synchronized List<N> getDescendantElements( Dn dn ); synchronized boolean hasChildren(); synchronized boolean hasChildren( Dn dn ); synchronized Map<String, DnNode<N>> getChildren(); synchronized DnNode<N> getParent(); synchronized boolean hasParent(); synchronized boolean hasParent( Dn dn ); synchronized DnNode<N> add( Dn dn ); synchronized DnNode<N> add( Dn dn, N element ); synchronized void remove( Dn dn ); synchronized boolean contains( Rdn rdn ); synchronized DnNode<N> getChild( Rdn rdn ); synchronized Rdn getRdn(); synchronized DnNode<N> getNode( Dn dn ); synchronized boolean hasParentElement( Dn dn ); synchronized DnNode<N> getParentWithElement( Dn dn ); synchronized DnNode<N> getParentWithElement(); synchronized void rename( Rdn newRdn ); synchronized void move( Dn newParent ); @Override String toString(); synchronized Dn getDn(); } | @Test public void testHasChildren() throws Exception { DnNode<Dn> tree = new DnNode<Dn>(); Dn dn1 = new Dn( "dc=b,dc=a" ); tree.add( dn1 ); assertTrue( tree.hasChildren() ); Map<String, DnNode<Dn>> children = tree.getChildren(); assertNotNull( children ); DnNode<Dn> child = children.get( new Rdn( "dc=a" ).getNormName() ); assertTrue( child.hasChildren() ); children = child.getChildren(); child = children.get( new Rdn( "dc=b" ).getNormName() ); assertFalse( child.hasChildren() ); } |
Asn1Buffer2 { public void put( byte b ) { if ( pos == size ) { extend(); } currentBuffer.buffer[size - pos - 1] = b; pos++; } Asn1Buffer2(); int getPos(); void put( byte b ); void put( byte[] bytes ); byte[] getBytes(); int getSize(); void clear(); @Override String toString(); } | @Test @Disabled public void testBytesPerf() { long t0 = System.currentTimeMillis(); for ( int j = 0; j < 1000; j++ ) { Asn1Buffer buffer = new Asn1Buffer(); for ( int i = 0; i < 409600; i++ ) { buffer.put( new byte[] { 0x01, ( byte ) i } ); } } long t1 = System.currentTimeMillis(); System.out.println( "Delta: " + ( t1 - t0 ) ); } |
DnNode { public synchronized boolean isLeaf() { return !hasChildren(); } DnNode(); DnNode( N element ); DnNode( Dn dn, N element ); synchronized boolean isLeaf(); synchronized boolean isLeaf( Dn dn ); synchronized int size(); synchronized N getElement(); synchronized N getElement( Dn dn ); synchronized boolean hasElement(); synchronized boolean hasElement( Dn dn ); synchronized boolean hasDescendantElement( Dn dn ); synchronized List<N> getDescendantElements( Dn dn ); synchronized boolean hasChildren(); synchronized boolean hasChildren( Dn dn ); synchronized Map<String, DnNode<N>> getChildren(); synchronized DnNode<N> getParent(); synchronized boolean hasParent(); synchronized boolean hasParent( Dn dn ); synchronized DnNode<N> add( Dn dn ); synchronized DnNode<N> add( Dn dn, N element ); synchronized void remove( Dn dn ); synchronized boolean contains( Rdn rdn ); synchronized DnNode<N> getChild( Rdn rdn ); synchronized Rdn getRdn(); synchronized DnNode<N> getNode( Dn dn ); synchronized boolean hasParentElement( Dn dn ); synchronized DnNode<N> getParentWithElement( Dn dn ); synchronized DnNode<N> getParentWithElement(); synchronized void rename( Rdn newRdn ); synchronized void move( Dn newParent ); @Override String toString(); synchronized Dn getDn(); } | @Test public void testIsLeaf() throws Exception { DnNode<Dn> tree = new DnNode<Dn>(); Dn dn = new Dn( "dc=c,dc=b,dc=a" ); tree.add( dn ); assertFalse( tree.isLeaf() ); DnNode<Dn> child = tree.getChild( new Rdn( "dc=a" ) ); assertFalse( child.isLeaf() ); child = child.getChild( new Rdn( "dc=b" ) ); assertFalse( child.isLeaf() ); child = child.getChild( new Rdn( "dc=c" ) ); assertTrue( child.isLeaf() ); } |
DnNode { public synchronized N getElement() { return nodeElement; } DnNode(); DnNode( N element ); DnNode( Dn dn, N element ); synchronized boolean isLeaf(); synchronized boolean isLeaf( Dn dn ); synchronized int size(); synchronized N getElement(); synchronized N getElement( Dn dn ); synchronized boolean hasElement(); synchronized boolean hasElement( Dn dn ); synchronized boolean hasDescendantElement( Dn dn ); synchronized List<N> getDescendantElements( Dn dn ); synchronized boolean hasChildren(); synchronized boolean hasChildren( Dn dn ); synchronized Map<String, DnNode<N>> getChildren(); synchronized DnNode<N> getParent(); synchronized boolean hasParent(); synchronized boolean hasParent( Dn dn ); synchronized DnNode<N> add( Dn dn ); synchronized DnNode<N> add( Dn dn, N element ); synchronized void remove( Dn dn ); synchronized boolean contains( Rdn rdn ); synchronized DnNode<N> getChild( Rdn rdn ); synchronized Rdn getRdn(); synchronized DnNode<N> getNode( Dn dn ); synchronized boolean hasParentElement( Dn dn ); synchronized DnNode<N> getParentWithElement( Dn dn ); synchronized DnNode<N> getParentWithElement(); synchronized void rename( Rdn newRdn ); synchronized void move( Dn newParent ); @Override String toString(); synchronized Dn getDn(); } | @Test public void testGetElement() throws Exception { DnNode<Dn> tree = new DnNode<Dn>(); Dn dn = new Dn( "dc=c,dc=b,dc=a" ); tree.add( dn, dn ); assertNull( tree.getElement() ); DnNode<Dn> child = tree.getChild( new Rdn( "dc=a" ) ); assertNull( child.getElement() ); child = child.getChild( new Rdn( "dc=b" ) ); assertNull( child.getElement() ); child = child.getChild( new Rdn( "dc=c" ) ); assertEquals( dn, child.getElement() ); } |
DnNode { public synchronized boolean hasElement() { return nodeElement != null; } DnNode(); DnNode( N element ); DnNode( Dn dn, N element ); synchronized boolean isLeaf(); synchronized boolean isLeaf( Dn dn ); synchronized int size(); synchronized N getElement(); synchronized N getElement( Dn dn ); synchronized boolean hasElement(); synchronized boolean hasElement( Dn dn ); synchronized boolean hasDescendantElement( Dn dn ); synchronized List<N> getDescendantElements( Dn dn ); synchronized boolean hasChildren(); synchronized boolean hasChildren( Dn dn ); synchronized Map<String, DnNode<N>> getChildren(); synchronized DnNode<N> getParent(); synchronized boolean hasParent(); synchronized boolean hasParent( Dn dn ); synchronized DnNode<N> add( Dn dn ); synchronized DnNode<N> add( Dn dn, N element ); synchronized void remove( Dn dn ); synchronized boolean contains( Rdn rdn ); synchronized DnNode<N> getChild( Rdn rdn ); synchronized Rdn getRdn(); synchronized DnNode<N> getNode( Dn dn ); synchronized boolean hasParentElement( Dn dn ); synchronized DnNode<N> getParentWithElement( Dn dn ); synchronized DnNode<N> getParentWithElement(); synchronized void rename( Rdn newRdn ); synchronized void move( Dn newParent ); @Override String toString(); synchronized Dn getDn(); } | @Test public void testHasElement() throws Exception { DnNode<Dn> tree = new DnNode<Dn>(); Dn dn = new Dn( "dc=c,dc=b,dc=a" ); tree.add( dn, dn ); assertFalse( tree.hasElement() ); DnNode<Dn> child = tree.getChild( new Rdn( "dc=a" ) ); assertFalse( child.hasElement() ); child = child.getChild( new Rdn( "dc=b" ) ); assertFalse( child.hasElement() ); child = child.getChild( new Rdn( "dc=c" ) ); assertTrue( child.hasElement() ); } |
DnNode { public synchronized int size() { int size = 1; if ( children.size() != 0 ) { for ( DnNode<N> node : children.values() ) { size += node.size(); } } return size; } DnNode(); DnNode( N element ); DnNode( Dn dn, N element ); synchronized boolean isLeaf(); synchronized boolean isLeaf( Dn dn ); synchronized int size(); synchronized N getElement(); synchronized N getElement( Dn dn ); synchronized boolean hasElement(); synchronized boolean hasElement( Dn dn ); synchronized boolean hasDescendantElement( Dn dn ); synchronized List<N> getDescendantElements( Dn dn ); synchronized boolean hasChildren(); synchronized boolean hasChildren( Dn dn ); synchronized Map<String, DnNode<N>> getChildren(); synchronized DnNode<N> getParent(); synchronized boolean hasParent(); synchronized boolean hasParent( Dn dn ); synchronized DnNode<N> add( Dn dn ); synchronized DnNode<N> add( Dn dn, N element ); synchronized void remove( Dn dn ); synchronized boolean contains( Rdn rdn ); synchronized DnNode<N> getChild( Rdn rdn ); synchronized Rdn getRdn(); synchronized DnNode<N> getNode( Dn dn ); synchronized boolean hasParentElement( Dn dn ); synchronized DnNode<N> getParentWithElement( Dn dn ); synchronized DnNode<N> getParentWithElement(); synchronized void rename( Rdn newRdn ); synchronized void move( Dn newParent ); @Override String toString(); synchronized Dn getDn(); } | @Test public void testSize() throws LdapException { DnNode<Dn> tree = new DnNode<Dn>(); assertEquals( 1, tree.size() ); tree.add( new Dn( "dc=b,dc=a" ) ); assertEquals( 3, tree.size() ); tree.add( new Dn( "dc=f,dc=a" ) ); assertEquals( 4, tree.size() ); tree.add( new Dn( "dc=a,dc=f,dc=a" ) ); assertEquals( 5, tree.size() ); tree.add( new Dn( "dc=b,dc=f,dc=a" ) ); assertEquals( 6, tree.size() ); tree.add( new Dn( "dc=z,dc=t" ) ); assertEquals( 8, tree.size() ); } |
DnNode { public synchronized DnNode<N> getParent() { return parent; } DnNode(); DnNode( N element ); DnNode( Dn dn, N element ); synchronized boolean isLeaf(); synchronized boolean isLeaf( Dn dn ); synchronized int size(); synchronized N getElement(); synchronized N getElement( Dn dn ); synchronized boolean hasElement(); synchronized boolean hasElement( Dn dn ); synchronized boolean hasDescendantElement( Dn dn ); synchronized List<N> getDescendantElements( Dn dn ); synchronized boolean hasChildren(); synchronized boolean hasChildren( Dn dn ); synchronized Map<String, DnNode<N>> getChildren(); synchronized DnNode<N> getParent(); synchronized boolean hasParent(); synchronized boolean hasParent( Dn dn ); synchronized DnNode<N> add( Dn dn ); synchronized DnNode<N> add( Dn dn, N element ); synchronized void remove( Dn dn ); synchronized boolean contains( Rdn rdn ); synchronized DnNode<N> getChild( Rdn rdn ); synchronized Rdn getRdn(); synchronized DnNode<N> getNode( Dn dn ); synchronized boolean hasParentElement( Dn dn ); synchronized DnNode<N> getParentWithElement( Dn dn ); synchronized DnNode<N> getParentWithElement(); synchronized void rename( Rdn newRdn ); synchronized void move( Dn newParent ); @Override String toString(); synchronized Dn getDn(); } | @Test public void testGetParent() throws Exception { DnNode<Dn> tree = new DnNode<Dn>(); Dn dn = new Dn( "dc=c,dc=b,dc=a" ); tree.add( dn, dn ); assertNull( tree.getParent() ); DnNode<Dn> child = tree.getChild( new Rdn( "dc=a" ) ); assertEquals( tree, child.getParent() ); DnNode<Dn> child1 = child.getChild( new Rdn( "dc=b" ) ); assertEquals( child, child1.getParent() ); child = child1.getChild( new Rdn( "dc=c" ) ); assertEquals( child1, child.getParent() ); } |
DnNode { public synchronized boolean hasParent() { return parent != null; } DnNode(); DnNode( N element ); DnNode( Dn dn, N element ); synchronized boolean isLeaf(); synchronized boolean isLeaf( Dn dn ); synchronized int size(); synchronized N getElement(); synchronized N getElement( Dn dn ); synchronized boolean hasElement(); synchronized boolean hasElement( Dn dn ); synchronized boolean hasDescendantElement( Dn dn ); synchronized List<N> getDescendantElements( Dn dn ); synchronized boolean hasChildren(); synchronized boolean hasChildren( Dn dn ); synchronized Map<String, DnNode<N>> getChildren(); synchronized DnNode<N> getParent(); synchronized boolean hasParent(); synchronized boolean hasParent( Dn dn ); synchronized DnNode<N> add( Dn dn ); synchronized DnNode<N> add( Dn dn, N element ); synchronized void remove( Dn dn ); synchronized boolean contains( Rdn rdn ); synchronized DnNode<N> getChild( Rdn rdn ); synchronized Rdn getRdn(); synchronized DnNode<N> getNode( Dn dn ); synchronized boolean hasParentElement( Dn dn ); synchronized DnNode<N> getParentWithElement( Dn dn ); synchronized DnNode<N> getParentWithElement(); synchronized void rename( Rdn newRdn ); synchronized void move( Dn newParent ); @Override String toString(); synchronized Dn getDn(); } | @Test public void testHasParent() throws Exception { DnNode<Dn> tree = new DnNode<Dn>(); Dn dn = new Dn( "dc=c,dc=b,dc=a" ); tree.add( dn, dn ); assertFalse( tree.hasParent() ); DnNode<Dn> child = tree.getChild( new Rdn( "dc=a" ) ); assertTrue( child.hasParent() ); DnNode<Dn> child1 = child.getChild( new Rdn( "dc=b" ) ); assertTrue( child1.hasParent() ); child = child1.getChild( new Rdn( "dc=c" ) ); assertTrue( child.hasParent() ); } |
DnNode { public synchronized boolean contains( Rdn rdn ) { return children.containsKey( rdn.getNormName() ); } DnNode(); DnNode( N element ); DnNode( Dn dn, N element ); synchronized boolean isLeaf(); synchronized boolean isLeaf( Dn dn ); synchronized int size(); synchronized N getElement(); synchronized N getElement( Dn dn ); synchronized boolean hasElement(); synchronized boolean hasElement( Dn dn ); synchronized boolean hasDescendantElement( Dn dn ); synchronized List<N> getDescendantElements( Dn dn ); synchronized boolean hasChildren(); synchronized boolean hasChildren( Dn dn ); synchronized Map<String, DnNode<N>> getChildren(); synchronized DnNode<N> getParent(); synchronized boolean hasParent(); synchronized boolean hasParent( Dn dn ); synchronized DnNode<N> add( Dn dn ); synchronized DnNode<N> add( Dn dn, N element ); synchronized void remove( Dn dn ); synchronized boolean contains( Rdn rdn ); synchronized DnNode<N> getChild( Rdn rdn ); synchronized Rdn getRdn(); synchronized DnNode<N> getNode( Dn dn ); synchronized boolean hasParentElement( Dn dn ); synchronized DnNode<N> getParentWithElement( Dn dn ); synchronized DnNode<N> getParentWithElement(); synchronized void rename( Rdn newRdn ); synchronized void move( Dn newParent ); @Override String toString(); synchronized Dn getDn(); } | @Test public void testContains() throws Exception { DnNode<Dn> tree = new DnNode<Dn>(); Dn dn = new Dn( "dc=c,dc=b,dc=a" ); tree.add( dn, dn ); Rdn rdnA = new Rdn( "dc=a" ); Rdn rdnB = new Rdn( "dc=b" ); Rdn rdnC = new Rdn( "dc=c" ); assertTrue( tree.contains( rdnA ) ); assertFalse( tree.contains( rdnB ) ); assertFalse( tree.contains( rdnC ) ); DnNode<Dn> child = tree.getChild( rdnA ); assertFalse( child.contains( rdnA ) ); assertTrue( child.contains( rdnB ) ); assertFalse( child.contains( rdnC ) ); child = child.getChild( rdnB ); assertFalse( child.contains( rdnA ) ); assertFalse( child.contains( rdnB ) ); assertTrue( child.contains( rdnC ) ); } |
DnNode { public synchronized boolean hasParentElement( Dn dn ) { List<Rdn> rdns = dn.getRdns(); DnNode<N> currentNode = this; boolean hasElement = false; for ( int i = rdns.size() - 1; i >= 0; i-- ) { Rdn rdn = rdns.get( i ); if ( currentNode.hasChildren() ) { currentNode = currentNode.children.get( rdn.getNormName() ); if ( currentNode == null ) { break; } if ( currentNode.hasElement() ) { hasElement = true; } parent = currentNode; } else { break; } } return hasElement; } DnNode(); DnNode( N element ); DnNode( Dn dn, N element ); synchronized boolean isLeaf(); synchronized boolean isLeaf( Dn dn ); synchronized int size(); synchronized N getElement(); synchronized N getElement( Dn dn ); synchronized boolean hasElement(); synchronized boolean hasElement( Dn dn ); synchronized boolean hasDescendantElement( Dn dn ); synchronized List<N> getDescendantElements( Dn dn ); synchronized boolean hasChildren(); synchronized boolean hasChildren( Dn dn ); synchronized Map<String, DnNode<N>> getChildren(); synchronized DnNode<N> getParent(); synchronized boolean hasParent(); synchronized boolean hasParent( Dn dn ); synchronized DnNode<N> add( Dn dn ); synchronized DnNode<N> add( Dn dn, N element ); synchronized void remove( Dn dn ); synchronized boolean contains( Rdn rdn ); synchronized DnNode<N> getChild( Rdn rdn ); synchronized Rdn getRdn(); synchronized DnNode<N> getNode( Dn dn ); synchronized boolean hasParentElement( Dn dn ); synchronized DnNode<N> getParentWithElement( Dn dn ); synchronized DnNode<N> getParentWithElement(); synchronized void rename( Rdn newRdn ); synchronized void move( Dn newParent ); @Override String toString(); synchronized Dn getDn(); } | @Test public void testHasParentElement() throws Exception { DnNode<Dn> dnLookupTree = new DnNode<Dn>(); Dn dn1 = new Dn( "dc=directory,dc=apache,dc=org" ); Dn dn2 = new Dn( "dc=mina,dc=apache,dc=org" ); Dn dn3 = new Dn( "dc=test,dc=com" ); Dn dn4 = new Dn( "dc=acme,dc=com" ); Dn dn5 = new Dn( "dc=acme,c=us,dc=com" ); Dn dn6 = new Dn( "dc=empty" ); Dn org = new Dn( "dc=org" ); dnLookupTree.add( dn1, dn1 ); dnLookupTree.add( dn2, dn2 ); dnLookupTree.add( dn3, dn3 ); dnLookupTree.add( dn4, dn4 ); dnLookupTree.add( dn5 ); dnLookupTree.add( dn6, dn6 ); dnLookupTree.add( org, org ); assertTrue( dnLookupTree.hasParentElement( new Dn( "dc=apache,dc=org" ) ) ); assertTrue( dnLookupTree.hasDescendantElement( org ) ); assertFalse( dnLookupTree.hasDescendantElement( new Dn( "c=us,dc=com" ) ) ); Dn dn7 = new Dn( "dc=elem,dc=mina,dc=apache,dc=org" ); dnLookupTree.add( dn7, dn7 ); List<Dn> dns = dnLookupTree.getDescendantElements( org ); assertNotNull( dns ); assertEquals( 2, dns.size() ); assertTrue( dns.contains( dn1 ) ); assertTrue( dns.contains( dn2 ) ); dns = dnLookupTree.getDescendantElements( dn6 ); assertEquals( 0, dns.size() ); } |
DnNode { public synchronized void rename( Rdn newRdn ) throws LdapException { Dn temp = nodeDn.getParent(); temp = temp.add( newRdn ); Rdn oldRdn = nodeRdn; nodeRdn = temp.getRdn(); nodeDn = temp; if ( parent != null ) { parent.children.remove( oldRdn.getNormName() ); parent.children.put( nodeRdn.getNormName(), this ); } updateAfterModDn( nodeDn ); } DnNode(); DnNode( N element ); DnNode( Dn dn, N element ); synchronized boolean isLeaf(); synchronized boolean isLeaf( Dn dn ); synchronized int size(); synchronized N getElement(); synchronized N getElement( Dn dn ); synchronized boolean hasElement(); synchronized boolean hasElement( Dn dn ); synchronized boolean hasDescendantElement( Dn dn ); synchronized List<N> getDescendantElements( Dn dn ); synchronized boolean hasChildren(); synchronized boolean hasChildren( Dn dn ); synchronized Map<String, DnNode<N>> getChildren(); synchronized DnNode<N> getParent(); synchronized boolean hasParent(); synchronized boolean hasParent( Dn dn ); synchronized DnNode<N> add( Dn dn ); synchronized DnNode<N> add( Dn dn, N element ); synchronized void remove( Dn dn ); synchronized boolean contains( Rdn rdn ); synchronized DnNode<N> getChild( Rdn rdn ); synchronized Rdn getRdn(); synchronized DnNode<N> getNode( Dn dn ); synchronized boolean hasParentElement( Dn dn ); synchronized DnNode<N> getParentWithElement( Dn dn ); synchronized DnNode<N> getParentWithElement(); synchronized void rename( Rdn newRdn ); synchronized void move( Dn newParent ); @Override String toString(); synchronized Dn getDn(); } | @Test public void testRename() throws Exception { DnNode<Dn> rootNode = new DnNode<Dn>(); Dn dn = new Dn( "dc=directory,dc=apache,dc=org" ); rootNode.add( dn ); Rdn childRdn = new Rdn( "dc=org" ); DnNode<Dn> child = rootNode.getChild( childRdn ); assertNotNull( child ); Rdn newChildRdn = new Rdn( "dc=neworg" ); child.rename( newChildRdn ); assertNull( rootNode.getChild( childRdn ) ); assertEquals( new Dn( "dc=neworg" ), child.getDn() ); DnNode<Dn> child2 = child.getChild( new Rdn( "dc=apache" ) ); assertEquals( new Dn( "dc=apache,dc=neworg" ), child2.getDn() ); assertEquals( new Dn( "dc=directory,dc=apache,dc=neworg" ), child2.getChild( new Rdn( "dc=directory" ) ) .getDn() ); assertNotNull( rootNode.getChild( newChildRdn ) ); } |
TriggerSpecificationParser { public synchronized TriggerSpecification parse( String spec ) throws ParseException { TriggerSpecification triggerSpecification; if ( Strings.isEmpty( spec ) ) { return null; } reset( spec ); try { triggerSpecification = this.parser.wrapperEntryPoint(); } catch ( TokenStreamException e ) { String msg = I18n.err( I18n.ERR_11002_TRIGGER_SPECIFICATION_PARSER_FAILURE, spec, e.getLocalizedMessage() ); throw new ParseException( msg, 0 ); } catch ( RecognitionException e ) { String msg = I18n.err( I18n.ERR_11002_TRIGGER_SPECIFICATION_PARSER_FAILURE, spec, e.getLocalizedMessage() ); throw new ParseException( msg, e.getColumn() ); } return triggerSpecification; } TriggerSpecificationParser(); TriggerSpecificationParser( NormalizerMappingResolver<Normalizer> resolver ); synchronized TriggerSpecification parse( String spec ); boolean isNormizing(); } | @Test public void testWithOperationParameters() throws Exception { TriggerSpecification triggerSpecification = null; String spec = "AFTER Delete CALL \"BackupUtilities.backupDeletedEntry\" ($name, $deletedEntry);"; triggerSpecification = parser.parse( spec ); assertNotNull( triggerSpecification ); assertEquals( triggerSpecification.getActionTime(), ActionTime.AFTER ); assertEquals( triggerSpecification.getLdapOperation(), LdapOperation.DELETE ); List<SPSpec> spSpecs = triggerSpecification.getSPSpecs(); assertTrue( spSpecs != null ); assertTrue( spSpecs.size() == 1 ); SPSpec theSpec = spSpecs.get( 0 ); assertEquals( theSpec.getName(), "BackupUtilities.backupDeletedEntry" ); assertEquals( theSpec.getOptions().size(), 0 ); assertEquals( theSpec.getParameters().size(), 2 ); assertTrue( theSpec.getParameters().contains( StoredProcedureParameter.Delete_NAME.instance() ) ); assertTrue( theSpec.getParameters().contains( StoredProcedureParameter.Delete_DELETED_ENTRY.instance() ) ); }
@Test public void testWithGenericParameters() throws Exception { TriggerSpecification triggerSpecification = null; String spec = "AFTER Add CALL \"Logger.logAddOperation\" ($entry, $attributes, $operationPrincipal);"; triggerSpecification = parser.parse( spec ); assertNotNull( triggerSpecification ); assertEquals( triggerSpecification.getActionTime(), ActionTime.AFTER ); assertEquals( triggerSpecification.getLdapOperation(), LdapOperation.ADD ); List<SPSpec> spSpecs = triggerSpecification.getSPSpecs(); assertTrue( spSpecs != null ); assertTrue( spSpecs.size() == 1 ); SPSpec theSpec = spSpecs.get( 0 ); assertEquals( theSpec.getName(), "Logger.logAddOperation" ); assertEquals( theSpec.getOptions().size(), 0 ); assertEquals( theSpec.getParameters().size(), 3 ); assertTrue( theSpec.getParameters().contains( StoredProcedureParameter.Add_ENTRY.instance() ) ); assertTrue( theSpec.getParameters().contains( StoredProcedureParameter.Add_ATTRIBUTES.instance() ) ); assertTrue( theSpec.getParameters().contains( StoredProcedureParameter.Generic_OPERATION_PRINCIPAL.instance() ) ); }
@Test public void testWithLanguageSchemeOption() throws Exception { TriggerSpecification triggerSpecification = null; String spec = "AFTER Modify CALL \"Logger.logModifyOperation\" {languageScheme \"Java\"}();"; triggerSpecification = parser.parse( spec ); assertNotNull( triggerSpecification ); assertEquals( triggerSpecification.getActionTime(), ActionTime.AFTER ); assertEquals( triggerSpecification.getLdapOperation(), LdapOperation.MODIFY ); List<SPSpec> spSpecs = triggerSpecification.getSPSpecs(); assertTrue( spSpecs != null ); assertTrue( spSpecs.size() == 1 ); SPSpec theSpec = spSpecs.get( 0 ); assertEquals( theSpec.getName(), "Logger.logModifyOperation" ); assertEquals( theSpec.getOptions().size(), 1 ); assertTrue( theSpec.getOptions().contains( new StoredProcedureLanguageSchemeOption( "Java" ) ) ); assertEquals( theSpec.getParameters().size(), 0 ); }
@Test public void testWithSearchContextOption() throws Exception { TriggerSpecification triggerSpecification = null; String spec = "AFTER ModifyDN.Rename CALL \"Logger.logModifyDNRenameOperation\" \n" + "{ searchContext { scope one } \"cn=Logger,ou=Stored Procedures,ou=system\" } \n" + "($entry, $newrdn); # Stored Procedure Parameter(s)"; triggerSpecification = parser.parse( spec ); assertNotNull( triggerSpecification ); assertEquals( triggerSpecification.getActionTime(), ActionTime.AFTER ); assertEquals( triggerSpecification.getLdapOperation(), LdapOperation.MODIFYDN_RENAME ); List<SPSpec> spSpecs = triggerSpecification.getSPSpecs(); assertTrue( spSpecs != null ); assertTrue( spSpecs.size() == 1 ); SPSpec theSpec = spSpecs.get( 0 ); assertEquals( theSpec.getName(), "Logger.logModifyDNRenameOperation" ); assertEquals( theSpec.getOptions().size(), 1 ); assertTrue( theSpec.getOptions().contains( new StoredProcedureSearchContextOption( new Dn( "cn=Logger,ou=Stored Procedures,ou=system" ), SearchScope.ONELEVEL ) ) ); assertEquals( theSpec.getParameters().size(), 2 ); assertTrue( theSpec.getParameters().contains( StoredProcedureParameter.ModifyDN_ENTRY.instance() ) ); assertTrue( theSpec.getParameters().contains( StoredProcedureParameter.ModifyDN_NEW_RDN.instance() ) ); }
@Test public void testWithLdapContextParameter() throws Exception { TriggerSpecification triggerSpecification = null; String spec = "AFTER Delete CALL \"BackupUtilities.backupDeletedEntry\" ($ldapContext \"ou=Backup,ou=System\", $name, $deletedEntry);"; triggerSpecification = parser.parse( spec ); assertNotNull( triggerSpecification ); assertEquals( triggerSpecification.getActionTime(), ActionTime.AFTER ); assertEquals( triggerSpecification.getLdapOperation(), LdapOperation.DELETE ); List<SPSpec> spSpecs = triggerSpecification.getSPSpecs(); assertTrue( spSpecs != null ); assertTrue( spSpecs.size() == 1 ); SPSpec theSpec = spSpecs.get( 0 ); assertEquals( theSpec.getName(), "BackupUtilities.backupDeletedEntry" ); assertEquals( theSpec.getOptions().size(), 0 ); assertEquals( theSpec.getParameters().size(), 3 ); assertTrue( theSpec.getParameters().contains( StoredProcedureParameter.Delete_NAME.instance() ) ); assertTrue( theSpec.getParameters().contains( StoredProcedureParameter.Delete_DELETED_ENTRY.instance() ) ); assertTrue( theSpec.getParameters().contains( StoredProcedureParameter.Generic_LDAP_CONTEXT.instance( new Dn( "ou=Backup,ou=System" ) ) ) ); }
@Test public void testMultipleSPCalls() throws Exception { TriggerSpecification triggerSpecification = null; String spec = "AFTER Delete " + "CALL \"BackupUtilities.backupDeletedEntry\" ($ldapContext \"ou=Backup,ou=System\", $name, $deletedEntry); " + "CALL \"BackupUtilities.recreateDeletedEntry\" ($name, $deletedEntry);"; triggerSpecification = parser.parse( spec ); assertNotNull( triggerSpecification ); assertEquals( triggerSpecification.getActionTime(), ActionTime.AFTER ); assertEquals( triggerSpecification.getLdapOperation(), LdapOperation.DELETE ); List<SPSpec> spSpecs = triggerSpecification.getSPSpecs(); assertTrue( spSpecs != null ); assertTrue( spSpecs.size() == 2 ); SPSpec firstSpec = spSpecs.get( 0 ); assertEquals( firstSpec.getName(), "BackupUtilities.backupDeletedEntry" ); assertEquals( firstSpec.getOptions().size(), 0 ); assertEquals( firstSpec.getParameters().size(), 3 ); assertTrue( firstSpec.getParameters().contains( StoredProcedureParameter.Delete_NAME.instance() ) ); assertTrue( firstSpec.getParameters().contains( StoredProcedureParameter.Delete_DELETED_ENTRY.instance() ) ); assertTrue( firstSpec.getParameters().contains( StoredProcedureParameter.Generic_LDAP_CONTEXT.instance( new Dn( "ou=Backup,ou=System" ) ) ) ); SPSpec secondSpec = spSpecs.get( 1 ); assertEquals( secondSpec.getName(), "BackupUtilities.recreateDeletedEntry" ); assertEquals( secondSpec.getOptions().size(), 0 ); assertEquals( secondSpec.getParameters().size(), 2 ); assertTrue( secondSpec.getParameters().contains( StoredProcedureParameter.Delete_NAME.instance() ) ); assertTrue( secondSpec.getParameters().contains( StoredProcedureParameter.Delete_DELETED_ENTRY.instance() ) ); } |
MaxValueCountItem extends ProtectedItem { @Override public int hashCode() { int hash = 37; if ( items != null ) { for ( MaxValueCountElem item : items ) { if ( item != null ) { hash = hash * 17 + item.hashCode(); } else { hash = hash * 17 + 37; } } } return hash; } MaxValueCountItem( Set<MaxValueCountElem> items ); Iterator<MaxValueCountElem> iterator(); @Override int hashCode(); @Override boolean equals( Object o ); @Override String toString(); } | @Test public void testHashCodeReflexive() throws Exception { assertEquals( maxValueCountItemA.hashCode(), maxValueCountItemA.hashCode() ); }
@Test public void testHashCodeSymmetric() throws Exception { assertEquals( maxValueCountItemA.hashCode(), maxValueCountItemACopy.hashCode() ); assertEquals( maxValueCountItemACopy.hashCode(), maxValueCountItemA.hashCode() ); }
@Test public void testHashCodeTransitive() throws Exception { assertEquals( maxValueCountItemA.hashCode(), maxValueCountItemACopy.hashCode() ); assertEquals( maxValueCountItemACopy.hashCode(), maxValueCountItemB.hashCode() ); assertEquals( maxValueCountItemA.hashCode(), maxValueCountItemB.hashCode() ); } |
RemoteFlowApiClient implements CompleterClient { @Override public FlowId createFlow(String functionId) { try { APIModel.CreateGraphRequest createGraphRequest = new APIModel.CreateGraphRequest(functionId); ObjectMapper objectMapper = FlowRuntimeGlobals.getObjectMapper(); byte[] body = objectMapper.writeValueAsBytes(createGraphRequest); HttpClient.HttpRequest request = preparePost(apiUrlBase + "/flows").withBody(body); try (HttpClient.HttpResponse resp = httpClient.execute(request)) { validateSuccessful(resp); APIModel.CreateGraphResponse createGraphResponse = objectMapper.readValue(resp.body, APIModel.CreateGraphResponse.class); return new FlowId(createGraphResponse.flowId); } catch (Exception e) { throw new PlatformCommunicationException("Failed to create flow ", e); } } catch (IOException e) { throw new PlatformCommunicationException("Failed to create CreateGraphRequest"); } } RemoteFlowApiClient(String apiUrlBase, BlobStoreClient blobClient, HttpClient httpClient); @Override FlowId createFlow(String functionId); @Override CompletionId supply(FlowId flowId, Serializable supplier, CodeLocation codeLocation); @Override CompletionId thenApply(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenCompose(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId whenComplete(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenAccept(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenRun(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId acceptEither(FlowId flowId, CompletionId completionId, CompletionId alternate, Serializable fn, CodeLocation codeLocation); @Override CompletionId applyToEither(FlowId flowId, CompletionId completionId, CompletionId alternate, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenAcceptBoth(FlowId flowId, CompletionId completionId, CompletionId alternate, Serializable fn, CodeLocation codeLocation); @Override CompletionId createCompletion(FlowId flowId, CodeLocation codeLocation); @Override CompletionId invokeFunction(FlowId flowId, String functionId, byte[] data, HttpMethod method, Headers headers, CodeLocation codeLocation); @Override CompletionId completedValue(FlowId flowId, boolean success, Object value, CodeLocation codeLocation); @Override CompletionId allOf(FlowId flowId, List<CompletionId> cids, CodeLocation codeLocation); @Override CompletionId handle(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId exceptionally(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId exceptionallyCompose(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenCombine(FlowId flowId, CompletionId completionId, Serializable fn, CompletionId alternate, CodeLocation codeLocation); @Override boolean complete(FlowId flowId, CompletionId completionId, Object value, CodeLocation codeLocation); @Override boolean completeExceptionally(FlowId flowId, CompletionId completionId, Throwable value, CodeLocation codeLocation); @Override CompletionId anyOf(FlowId flowId, List<CompletionId> cids, CodeLocation codeLocation); @Override CompletionId delay(FlowId flowId, long l, CodeLocation codeLocation); @Override Object waitForCompletion(FlowId flowId, CompletionId id, ClassLoader ignored, long timeout, TimeUnit unit); @Override Object waitForCompletion(FlowId flowId, CompletionId id, ClassLoader ignored); void commit(FlowId flowId); @Override void addTerminationHook(FlowId flowId, Serializable code, CodeLocation codeLocation); static final String CONTENT_TYPE_HEADER; static final String CONTENT_TYPE_JAVA_OBJECT; static final String CONTENT_TYPE_OCTET_STREAM; } | @Test public void createFlow() throws Exception { String functionId = "functionId"; HttpClient.HttpResponse response = responseWithCreateGraphResponse(testFlowId); when(mockHttpClient.execute(requestContainingFunctionId(functionId))).thenReturn(response); FlowId flowId = completerClient.createFlow(functionId); assertNotNull(flowId); assertEquals(flowId.getId(), testFlowId); } |
SpringCloudFunctionInvoker implements FunctionInvoker, Closeable { @Override public Optional<OutputEvent> tryInvoke(InvocationContext ctx, InputEvent evt) { SpringCloudMethod method = loader.getFunction(); Object[] userFunctionParams = coerceParameters(ctx, method, evt); Object result = tryInvoke(method, userFunctionParams); return coerceReturnValue(ctx, method, result); } SpringCloudFunctionInvoker(SpringCloudFunctionLoader loader); SpringCloudFunctionInvoker(Class<?> configClass); @Override Optional<OutputEvent> tryInvoke(InvocationContext ctx, InputEvent evt); @Override void close(); } | @Test public void invokesFunctionWithFluxOfMultipleItems() { SpringCloudFunction fnWrapper = new SpringCloudFunction(x -> x, new SimpleFunctionInspector()); Object result = invoker.tryInvoke(fnWrapper, new Object[]{ Arrays.asList("hello", "world") }); assertThat(result).isInstanceOf(List.class); assertThat((List) result).containsSequence("hello", "world"); }
@Test public void invokesFunctionWithEmptyFlux() { SpringCloudFunction fnWrapper = new SpringCloudFunction(x -> x, new SimpleFunctionInspector()); Object result = invoker.tryInvoke(fnWrapper, new Object[0]); assertThat(result).isNull(); }
@Test public void invokesFunctionWithFluxOfSingleItem() { SpringCloudFunction fnWrapper = new SpringCloudFunction(x -> x, new SimpleFunctionInspector()); Object result = invoker.tryInvoke(fnWrapper, new Object[]{ "hello" }); assertThat(result).isInstanceOf(String.class); assertThat(result).isEqualTo("hello"); } |
RemoteFlowApiClient implements CompleterClient { @Override public CompletionId supply(FlowId flowId, Serializable supplier, CodeLocation codeLocation) { return addStageWithClosure(APIModel.CompletionOperation.SUPPLY, flowId, supplier, codeLocation, Collections.emptyList()); } RemoteFlowApiClient(String apiUrlBase, BlobStoreClient blobClient, HttpClient httpClient); @Override FlowId createFlow(String functionId); @Override CompletionId supply(FlowId flowId, Serializable supplier, CodeLocation codeLocation); @Override CompletionId thenApply(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenCompose(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId whenComplete(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenAccept(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenRun(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId acceptEither(FlowId flowId, CompletionId completionId, CompletionId alternate, Serializable fn, CodeLocation codeLocation); @Override CompletionId applyToEither(FlowId flowId, CompletionId completionId, CompletionId alternate, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenAcceptBoth(FlowId flowId, CompletionId completionId, CompletionId alternate, Serializable fn, CodeLocation codeLocation); @Override CompletionId createCompletion(FlowId flowId, CodeLocation codeLocation); @Override CompletionId invokeFunction(FlowId flowId, String functionId, byte[] data, HttpMethod method, Headers headers, CodeLocation codeLocation); @Override CompletionId completedValue(FlowId flowId, boolean success, Object value, CodeLocation codeLocation); @Override CompletionId allOf(FlowId flowId, List<CompletionId> cids, CodeLocation codeLocation); @Override CompletionId handle(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId exceptionally(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId exceptionallyCompose(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenCombine(FlowId flowId, CompletionId completionId, Serializable fn, CompletionId alternate, CodeLocation codeLocation); @Override boolean complete(FlowId flowId, CompletionId completionId, Object value, CodeLocation codeLocation); @Override boolean completeExceptionally(FlowId flowId, CompletionId completionId, Throwable value, CodeLocation codeLocation); @Override CompletionId anyOf(FlowId flowId, List<CompletionId> cids, CodeLocation codeLocation); @Override CompletionId delay(FlowId flowId, long l, CodeLocation codeLocation); @Override Object waitForCompletion(FlowId flowId, CompletionId id, ClassLoader ignored, long timeout, TimeUnit unit); @Override Object waitForCompletion(FlowId flowId, CompletionId id, ClassLoader ignored); void commit(FlowId flowId); @Override void addTerminationHook(FlowId flowId, Serializable code, CodeLocation codeLocation); static final String CONTENT_TYPE_HEADER; static final String CONTENT_TYPE_JAVA_OBJECT; static final String CONTENT_TYPE_OCTET_STREAM; } | @Test public void supply() throws Exception { String contentType = "application/java-serialized-object"; String testBlobId = "BLOBID"; BlobResponse blobResponse = makeBlobResponse(lambdaBytes, contentType, testBlobId); when(blobStoreClient.writeBlob(testFlowId, lambdaBytes, contentType)).thenReturn(blobResponse); HttpClient.HttpResponse response = responseWithAddStageResponse(testFlowId, testStageId); when(mockHttpClient.execute(requestContainingAddStageRequest(blobResponse.blobId, Collections.emptyList()))).thenReturn(response); CompletionId completionId = completerClient.supply(new FlowId(testFlowId), serializableLambda, codeLocation); assertNotNull(completionId); assertEquals(completionId.getId(), testStageId); } |
RemoteFlowApiClient implements CompleterClient { @Override public CompletionId invokeFunction(FlowId flowId, String functionId, byte[] data, HttpMethod method, Headers headers, CodeLocation codeLocation) { APIModel.HTTPReq httpReq = new APIModel.HTTPReq(); if (headers != null) { if (data.length > 0) { BlobResponse blobResponse = blobStoreClient.writeBlob(flowId.getId(), data, headers.get(CONTENT_TYPE_HEADER).orElse(CONTENT_TYPE_OCTET_STREAM)); httpReq.body = APIModel.Blob.fromBlobResponse(blobResponse); } httpReq.headers = new ArrayList<>(); headers.asMap().forEach((k, vs) -> vs.forEach(v -> httpReq.headers.add(APIModel.HTTPHeader.create(k, v)))); Map<String, List<String>> headersMap = headers.asMap(); headersMap.forEach((key, values) -> values.forEach(value -> httpReq.headers.add(APIModel.HTTPHeader.create(key, value)))); } httpReq.method = APIModel.HTTPMethod.fromFlow(method); APIModel.AddInvokeFunctionStageRequest addInvokeFunctionStageRequest = new APIModel.AddInvokeFunctionStageRequest(); addInvokeFunctionStageRequest.arg = httpReq; addInvokeFunctionStageRequest.codeLocation = codeLocation.getLocation(); addInvokeFunctionStageRequest.callerId = FlowRuntimeGlobals.getCurrentCompletionId().map(CompletionId::getId).orElse(null); addInvokeFunctionStageRequest.functionId = functionId; try { return executeAddInvokeFunctionStageRequest(flowId, addInvokeFunctionStageRequest); } catch (IOException e) { throw new PlatformCommunicationException("Failed to create invokeFunction stage", e); } } RemoteFlowApiClient(String apiUrlBase, BlobStoreClient blobClient, HttpClient httpClient); @Override FlowId createFlow(String functionId); @Override CompletionId supply(FlowId flowId, Serializable supplier, CodeLocation codeLocation); @Override CompletionId thenApply(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenCompose(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId whenComplete(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenAccept(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenRun(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId acceptEither(FlowId flowId, CompletionId completionId, CompletionId alternate, Serializable fn, CodeLocation codeLocation); @Override CompletionId applyToEither(FlowId flowId, CompletionId completionId, CompletionId alternate, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenAcceptBoth(FlowId flowId, CompletionId completionId, CompletionId alternate, Serializable fn, CodeLocation codeLocation); @Override CompletionId createCompletion(FlowId flowId, CodeLocation codeLocation); @Override CompletionId invokeFunction(FlowId flowId, String functionId, byte[] data, HttpMethod method, Headers headers, CodeLocation codeLocation); @Override CompletionId completedValue(FlowId flowId, boolean success, Object value, CodeLocation codeLocation); @Override CompletionId allOf(FlowId flowId, List<CompletionId> cids, CodeLocation codeLocation); @Override CompletionId handle(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId exceptionally(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId exceptionallyCompose(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenCombine(FlowId flowId, CompletionId completionId, Serializable fn, CompletionId alternate, CodeLocation codeLocation); @Override boolean complete(FlowId flowId, CompletionId completionId, Object value, CodeLocation codeLocation); @Override boolean completeExceptionally(FlowId flowId, CompletionId completionId, Throwable value, CodeLocation codeLocation); @Override CompletionId anyOf(FlowId flowId, List<CompletionId> cids, CodeLocation codeLocation); @Override CompletionId delay(FlowId flowId, long l, CodeLocation codeLocation); @Override Object waitForCompletion(FlowId flowId, CompletionId id, ClassLoader ignored, long timeout, TimeUnit unit); @Override Object waitForCompletion(FlowId flowId, CompletionId id, ClassLoader ignored); void commit(FlowId flowId); @Override void addTerminationHook(FlowId flowId, Serializable code, CodeLocation codeLocation); static final String CONTENT_TYPE_HEADER; static final String CONTENT_TYPE_JAVA_OBJECT; static final String CONTENT_TYPE_OCTET_STREAM; } | @Test public void invokeFunctionNormally() throws Exception { String testFunctionId = "TESTFUNCTION"; String blobid = "BLOBID"; byte[] invokeBody = "INPUTDATA".getBytes(); String contentType = "text/plain"; BlobResponse blobResponse = makeBlobResponse(invokeBody, contentType, blobid); when(blobStoreClient.writeBlob(eq(testFlowId), eq(invokeBody), eq(contentType))).thenReturn(blobResponse); HttpClient.HttpResponse response = responseWithAddStageResponse(testFlowId, testStageId); when(mockHttpClient.execute(requestContainingAddInvokeFunctionStageRequest(testFunctionId, APIModel.HTTPMethod.Post))).thenReturn(response); CompletionId completionId = completerClient.invokeFunction(new FlowId(testFlowId), testFunctionId, invokeBody, HttpMethod.POST, Headers.fromMap(Collections.singletonMap("Content-type", contentType)), CodeLocation.unknownLocation()); assertNotNull(completionId); assertEquals(completionId.getId(), testStageId); }
@Test public void invokeFunctionWithInvalidFunctionId() throws Exception { String testFunctionId = "INVALIDFUNCTIONID"; byte[] invokeBody = "INPUTDATA".getBytes(); String contentType = "text/plain"; BlobResponse blobResponse = makeBlobResponse(invokeBody, contentType, "BLOBID"); when(blobStoreClient.writeBlob(testFlowId, invokeBody, contentType)).thenReturn(blobResponse); when(mockHttpClient.execute(requestContainingAddInvokeFunctionStageRequest(testFunctionId, APIModel.HTTPMethod.Post))).thenReturn(new HttpClient.HttpResponse(400)); thrown.expect(PlatformCommunicationException.class); thrown.expectMessage("Failed to add stage"); Map headersMap = Collections.singletonMap("Content-type", contentType); Headers headers = Headers.fromMap(headersMap); completerClient.invokeFunction(new FlowId(testFlowId), testFunctionId, invokeBody, HttpMethod.POST, headers, locationFn()); } |
RemoteFlowApiClient implements CompleterClient { @Override public Object waitForCompletion(FlowId flowId, CompletionId id, ClassLoader ignored, long timeout, TimeUnit unit) throws TimeoutException { long msTimeout = TimeUnit.MILLISECONDS.convert(timeout, unit); long start = System.currentTimeMillis(); do { long lastStart = System.currentTimeMillis(); long remainingTimeout = Math.max(1, start + msTimeout - lastStart); try (HttpClient.HttpResponse response = httpClient.execute(prepareGet(apiUrlBase + "/flows/" + flowId.getId() + "/stages/" + id.getId() + "/await?timeout_ms=" + remainingTimeout))) { if (response.getStatusCode() == 200) { APIModel.AwaitStageResponse resp = FlowRuntimeGlobals.getObjectMapper().readValue(response.getContentStream(), APIModel.AwaitStageResponse.class); if (resp.result.successful) { return resp.result.toJava(flowId, blobStoreClient, getClass().getClassLoader()); } else { throw new FlowCompletionException((Throwable) resp.result.toJava(flowId, blobStoreClient, getClass().getClassLoader())); } } else if (response.getStatusCode() == 408) { } else { throw asError(response); } try { Thread.sleep(Math.max(0, 500 - (System.currentTimeMillis() - lastStart))); } catch (InterruptedException e) { throw new PlatformCommunicationException("Interrupted", e); } } catch (IOException e) { throw new PlatformCommunicationException("Error fetching result", e); } } while (System.currentTimeMillis() - start < msTimeout); throw new TimeoutException("Stage did not completed before timeout "); } RemoteFlowApiClient(String apiUrlBase, BlobStoreClient blobClient, HttpClient httpClient); @Override FlowId createFlow(String functionId); @Override CompletionId supply(FlowId flowId, Serializable supplier, CodeLocation codeLocation); @Override CompletionId thenApply(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenCompose(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId whenComplete(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenAccept(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenRun(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId acceptEither(FlowId flowId, CompletionId completionId, CompletionId alternate, Serializable fn, CodeLocation codeLocation); @Override CompletionId applyToEither(FlowId flowId, CompletionId completionId, CompletionId alternate, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenAcceptBoth(FlowId flowId, CompletionId completionId, CompletionId alternate, Serializable fn, CodeLocation codeLocation); @Override CompletionId createCompletion(FlowId flowId, CodeLocation codeLocation); @Override CompletionId invokeFunction(FlowId flowId, String functionId, byte[] data, HttpMethod method, Headers headers, CodeLocation codeLocation); @Override CompletionId completedValue(FlowId flowId, boolean success, Object value, CodeLocation codeLocation); @Override CompletionId allOf(FlowId flowId, List<CompletionId> cids, CodeLocation codeLocation); @Override CompletionId handle(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId exceptionally(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId exceptionallyCompose(FlowId flowId, CompletionId completionId, Serializable fn, CodeLocation codeLocation); @Override CompletionId thenCombine(FlowId flowId, CompletionId completionId, Serializable fn, CompletionId alternate, CodeLocation codeLocation); @Override boolean complete(FlowId flowId, CompletionId completionId, Object value, CodeLocation codeLocation); @Override boolean completeExceptionally(FlowId flowId, CompletionId completionId, Throwable value, CodeLocation codeLocation); @Override CompletionId anyOf(FlowId flowId, List<CompletionId> cids, CodeLocation codeLocation); @Override CompletionId delay(FlowId flowId, long l, CodeLocation codeLocation); @Override Object waitForCompletion(FlowId flowId, CompletionId id, ClassLoader ignored, long timeout, TimeUnit unit); @Override Object waitForCompletion(FlowId flowId, CompletionId id, ClassLoader ignored); void commit(FlowId flowId); @Override void addTerminationHook(FlowId flowId, Serializable code, CodeLocation codeLocation); static final String CONTENT_TYPE_HEADER; static final String CONTENT_TYPE_JAVA_OBJECT; static final String CONTENT_TYPE_OCTET_STREAM; } | @Test public void waitForCompletionNormally() throws Exception { String testBlobId = "BLOBID"; String testContentType = "application/java-serialized-object"; APIModel.Blob blob = new APIModel.Blob(); blob.blobId = testBlobId; blob.contentType = testContentType; APIModel.CompletionResult completionResult = APIModel.CompletionResult.success(APIModel.BlobDatum.fromBlob(blob)); when(mockHttpClient.execute(requestForAwaitStageResult())).thenReturn(responseWithAwaitStageResponse(completionResult)); when(blobStoreClient.readBlob(eq(testFlowId), eq("BLOBID"), any(), eq("application/java-serialized-object"))).thenReturn(1); Object result = completerClient.waitForCompletion(new FlowId(testFlowId), new CompletionId(testStageId), null); assertEquals(result, 1); }
@Test public void waitForCompletionOnExceptionallyCompletedStage() throws Exception { String testBlobId = "BLOBID"; String testContentType = "application/java-serialized-object"; APIModel.Blob blob = new APIModel.Blob(); blob.blobId = testBlobId; blob.contentType = testContentType; APIModel.CompletionResult completionResult = APIModel.CompletionResult.failure(APIModel.BlobDatum.fromBlob(blob)); when(mockHttpClient.execute(requestForAwaitStageResult())).thenReturn(responseWithAwaitStageResponse(completionResult)); class MyException extends RuntimeException {} MyException myException = new MyException(); when(blobStoreClient.readBlob(eq(testFlowId), eq(testBlobId), any(), eq(testContentType))).thenReturn(myException); thrown.expect(new BaseMatcher<Object>() { @Override public void describeTo(Description description) { description.appendText("an exception of type FlowCompletionException, containing a cause of type MyException"); } @Override public boolean matches(Object o) { if(o instanceof FlowCompletionException) { FlowCompletionException flowCompletionException = (FlowCompletionException) o; if(flowCompletionException.getCause().equals(myException)) { return true; } } return false; } }); completerClient.waitForCompletion(new FlowId(testFlowId), new CompletionId(testStageId), null); }
@Test public void waitForCompletionUnknownStage() throws Exception { when(mockHttpClient.execute(requestForAwaitStageResult())).thenReturn(new HttpClient.HttpResponse(404)); thrown.expect(PlatformCommunicationException.class); thrown.expectMessage(contains("unexpected response")); completerClient.waitForCompletion(new FlowId(testFlowId), new CompletionId(testStageId), null); } |
Headers implements Serializable { public static String canonicalKey(String key) { if (!headerName.matcher(key).matches()) { return key; } String parts[] = key.split("-", -1); for (int i = 0; i < parts.length; i++) { String p = parts[i]; if (p.length() > 0) { parts[i] = p.substring(0, 1).toUpperCase() + p.substring(1).toLowerCase(); } } return String.join("-", parts); } private Headers(Map<String, List<String>> headersIn); Map getAll(); static String canonicalKey(String key); static Headers fromMap(Map<String, String> headers); static Headers fromMultiHeaderMap(Map<String, List<String>> headers); static Headers emptyHeaders(); Headers setHeaders(Map<String, List<String>> vals); Headers addHeader(String key, String v1, String... vs); Headers setHeader(String key, String v1, String... vs); Headers setHeader(String key, Collection<String> vs); Headers removeHeader(String key); Optional<String> get(String key); Collection<String> keys(); Map<String, List<String>> asMap(); List<String> getAllValues(String key); int hashCode(); boolean equals(Object other); @Override String toString(); } | @Test public void shouldCanonicalizeHeaders(){ for (String[] v : new String[][] { {"",""}, {"a","A"}, {"fn-ID-","Fn-Id-"}, {"myHeader-VaLue","Myheader-Value"}, {" Not a Header "," Not a Header "}, {"-","-"}, {"--","--"}, {"a-","A-"}, {"-a","-A"} }){ assertThat(Headers.canonicalKey(v[0])).isEqualTo(v[1]); } } |
InputHandler { Map<String, InterceptorInstance> resolveInputInterceptors(String algorithmClassName) { Map<String,InterceptorInstance> result = new HashMap<String, InterceptorInstance>(); Class<?> clazz; try { clazz = Class.forName(algorithmClassName, false, getClass().getClassLoader()); } catch (ClassNotFoundException e) { LOGGER.warn("Could not find class {}", algorithmClassName); return result; } DataInputInterceptorImplementations annotation = clazz.getAnnotation(DataInputInterceptors.DataInputInterceptorImplementations.class); if (annotation != null) { Class<?> interceptorClazz; try { interceptorClazz = Class.forName(annotation.value()); } catch (ClassNotFoundException e) { LOGGER.warn("Could not find class "+ annotation.value(), e); return result; } if (DataInputInterceptors.class.isAssignableFrom(interceptorClazz)) { DataInputInterceptors instance; try { instance = (DataInputInterceptors) interceptorClazz.newInstance(); } catch (InstantiationException e) { LOGGER.warn("Could not instantiate class "+ interceptorClazz, e); return result; } catch (IllegalAccessException e) { LOGGER.warn("Could not access class "+ interceptorClazz, e); return result; } return instance.getInterceptors(); } } return result; } private InputHandler(Builder builder); Map<String, List<IData>> getParsedInputData(); } | @Test public void testInputHandlerResolveInputInterceptors() throws ExceptionReport, XmlException, IOException { System.out.println("Testing testInputHandlerResolveInputInterceptors..."); InputHandler instance = new InputHandler.Builder(simpleBufferAlgorithmInputArray, "org.n52.wps.server.algorithm.SimpleBufferAlgorithm").build(); Map<String, InterceptorInstance> resolveInputInterceptors = instance.resolveInputInterceptors("org.n52.wps.server.algorithm.SimpleBufferAlgorithm"); assertThat(resolveInputInterceptors.size(), equalTo(0)); instance = new InputHandler.Builder(dummyTestClassAlgorithmInputArray, "org.n52.wps.server.algorithm.test.DummyTestClass").build(); resolveInputInterceptors = instance.resolveInputInterceptors("org.n52.wps.server.algorithm.SimpleBufferAlgorithm"); assertThat(resolveInputInterceptors.size(), equalTo(0)); } |
ExecuteResponseBuilder { public String getMimeType() { return getMimeType(null); } ExecuteResponseBuilder(ExecuteRequest request); void update(); String getMimeType(); String getMimeType(OutputDefinitionType def); InputStream getAsStream(); void setStatus(StatusType status); } | @Test public void testGetMimeTypeComplexOutputResponseDoc() { try { String sampleFileName = "src/test/resources/DTCExecuteComplexOutputResponseDocMimeTiff.xml"; File sampleFile = new File(sampleFileName); FileInputStream is; is = new FileInputStream(sampleFile); Document doc; doc = fac.newDocumentBuilder().parse(is); is.close(); executeRequest = new ExecuteRequest(doc); OutputDefinitionType definition = executeRequest.getExecute().getResponseForm().getResponseDocument().getOutputArray(0); String originalMimeType = definition.getMimeType(); String mimeType = executeRequest.getExecuteResponseBuilder() .getMimeType(definition); assertTrue(mimeType.equals(originalMimeType)); } catch (Exception e) { fail(e.getMessage()); } }
@Test public void testGetMimeTypeMultipleComplexOutputsResponseDocPerm1() { try { String sampleFileName = "src/test/resources/MCIODTCExecuteComplexOutputResponseDocPerm1.xml"; File sampleFile = new File(sampleFileName); FileInputStream is; is = new FileInputStream(sampleFile); Document doc; doc = fac.newDocumentBuilder().parse(is); is.close(); executeRequest = new ExecuteRequest(doc); DocumentOutputDefinitionType[] outputs = executeRequest.getExecute().getResponseForm().getResponseDocument().getOutputArray(); for (DocumentOutputDefinitionType documentOutputDefinitionType : outputs) { String identifier = documentOutputDefinitionType.getIdentifier().getStringValue(); String originalMimeType = documentOutputDefinitionType.getMimeType(); String mimeType = executeRequest.getExecuteResponseBuilder() .getMimeType(documentOutputDefinitionType); if(identifier.contains("Complex")){ assertTrue(mimeType.equals(originalMimeType)); }else{ assertTrue(mimeType.equals("text/plain") || mimeType.equals("text/xml")); } } } catch (Exception e) { fail(e.getMessage()); } }
@Test public void testGetMimeTypeMultipleComplexOutputsResponseDocPerm2() { try { String sampleFileName = "src/test/resources/MCIODTCExecuteComplexOutputResponseDocPerm2.xml"; File sampleFile = new File(sampleFileName); FileInputStream is; is = new FileInputStream(sampleFile); Document doc; doc = fac.newDocumentBuilder().parse(is); is.close(); executeRequest = new ExecuteRequest(doc); DocumentOutputDefinitionType[] outputs = executeRequest.getExecute().getResponseForm().getResponseDocument().getOutputArray(); for (DocumentOutputDefinitionType documentOutputDefinitionType : outputs) { String identifier = documentOutputDefinitionType.getIdentifier().getStringValue(); String originalMimeType = documentOutputDefinitionType.getMimeType(); String mimeType = executeRequest.getExecuteResponseBuilder() .getMimeType(documentOutputDefinitionType); if(identifier.contains("Complex")){ assertTrue(mimeType.equals(originalMimeType)); }else{ assertTrue(mimeType.equals("text/plain") || mimeType.equals("text/xml")); } } } catch (Exception e) { fail(e.getMessage()); } }
@Test public void testGetMimeTypeBBOXOutputResponseDoc() { try { String sampleFileName = "src/test/resources/DTCExecuteBBOXOutputResponseDoc.xml"; File sampleFile = new File(sampleFileName); FileInputStream is; is = new FileInputStream(sampleFile); Document doc; doc = fac.newDocumentBuilder().parse(is); is.close(); executeRequest = new ExecuteRequest(doc); OutputDefinitionType definition = executeRequest.getExecute().getResponseForm().getResponseDocument().getOutputArray(0); String mimeType = executeRequest.getExecuteResponseBuilder() .getMimeType(definition); assertTrue(mimeType.equals("text/xml")); } catch (Exception e) { fail(e.getMessage()); } }
@Test public void testGetMimeTypeBBOXOutputRawData() { try { String sampleFileName = "src/test/resources/DTCExecuteBBOXOutputRawData.xml"; File sampleFile = new File(sampleFileName); FileInputStream is; is = new FileInputStream(sampleFile); Document doc; doc = fac.newDocumentBuilder().parse(is); is.close(); executeRequest = new ExecuteRequest(doc); OutputDefinitionType definition = executeRequest.getExecute().getResponseForm().getRawDataOutput(); String mimeType = executeRequest.getExecuteResponseBuilder() .getMimeType(definition); assertTrue(mimeType.equals("text/xml")); } catch (Exception e) { fail(e.getMessage()); } }
@Test public void testGetMimeTypeLiteralOutputResponseDoc() { try { String sampleFileName = "src/test/resources/DTCExecuteLiteralOutputResponseDoc.xml"; File sampleFile = new File(sampleFileName); FileInputStream is = new FileInputStream(sampleFile); Document doc = fac.newDocumentBuilder().parse(is); is.close(); executeRequest = new ExecuteRequest(doc); OutputDefinitionType definition = executeRequest.getExecute().getResponseForm().getResponseDocument().getOutputArray(0); String mimeType = executeRequest.getExecuteResponseBuilder() .getMimeType(definition); assertTrue(mimeType.equals("text/plain")); } catch (Exception e) { fail(e.getMessage()); } }
@Test public void testGetMimeTypeLiteralOutputRawData() { try { String sampleFileName = "src/test/resources/DTCExecuteLiteralOutputRawData.xml"; File sampleFile = new File(sampleFileName); FileInputStream is = new FileInputStream(sampleFile); Document doc = fac.newDocumentBuilder().parse(is); is.close(); executeRequest = new ExecuteRequest(doc); OutputDefinitionType definition = executeRequest.getExecute().getResponseForm().getRawDataOutput(); String mimeType = executeRequest.getExecuteResponseBuilder() .getMimeType(definition); assertTrue(mimeType.equals("text/plain")); } catch (Exception e) { fail(e.getMessage()); } }
@Test public void testGetMimeTypeComplexOutputRawData() { try { String sampleFileName = "src/test/resources/DTCExecuteComplexOutputRawDataMimeTiff.xml"; File sampleFile = new File(sampleFileName); FileInputStream is; is = new FileInputStream(sampleFile); Document doc; doc = fac.newDocumentBuilder().parse(is); is.close(); executeRequest = new ExecuteRequest(doc); OutputDefinitionType definition = executeRequest.getExecute().getResponseForm().getRawDataOutput(); String originalMimeType = definition.getMimeType(); String mimeType = executeRequest.getExecuteResponseBuilder() .getMimeType(definition); assertTrue(mimeType.equals(originalMimeType)); } catch (Exception e) { fail(e.getMessage()); } } |
ExecutionContext { public List<OutputDefinitionType> getOutputs() { return this.outputDefinitionTypes; } ExecutionContext(); ExecutionContext(OutputDefinitionType output); ExecutionContext(List< ? extends OutputDefinitionType> outputs); String getTempDirectoryPath(); List<OutputDefinitionType> getOutputs(); } | @Test public void testConstructor() { ExecutionContext ec; ec = new ExecutionContext((OutputDefinitionType)null); assertNotNull(ec.getOutputs()); assertEquals(0, ec.getOutputs().size()); ec = new ExecutionContext(Arrays.asList(new OutputDefinitionType[0])); assertNotNull(ec.getOutputs()); assertEquals(0, ec.getOutputs().size()); ec = new ExecutionContext(Arrays.asList(new OutputDefinitionType[1])); assertNotNull(ec.getOutputs()); assertEquals(1, ec.getOutputs().size()); ec = new ExecutionContext((List<OutputDefinitionType>)null); assertNotNull(ec.getOutputs()); assertEquals(0, ec.getOutputs().size()); ec = new ExecutionContext(OutputDefinitionType.Factory.newInstance()); assertNotNull(ec.getOutputs()); assertEquals(1, ec.getOutputs().size()); ec = new ExecutionContext(); assertNotNull(ec.getOutputs()); assertEquals(0, ec.getOutputs().size()); } |
InputHandler { InputDescriptionType getInputReferenceDescriptionType(String inputId) { for (InputDescriptionType tempDesc : this.processDesc.getDataInputs().getInputArray()) { if (inputId.equals(tempDesc.getIdentifier().getStringValue())) { return tempDesc; } } return null; } private InputHandler(Builder builder); Map<String, List<IData>> getParsedInputData(); } | @Test public void testInputHandlerResolveInputDescriptionTypes() throws ExceptionReport, XmlException, IOException { System.out.println("Testing testInputHandlerResolveInputDescriptionTypes..."); InputHandler instance = new InputHandler.Builder(simpleBufferAlgorithmInputArray, "org.n52.wps.server.algorithm.SimpleBufferAlgorithm").build(); InputDescriptionType idt = instance.getInputReferenceDescriptionType("data"); assertThat(idt, is(notNullValue())); assertThat(idt.getMaxOccurs().intValue(), equalTo(1)); assertThat(idt.getMinOccurs().intValue(), equalTo(1)); instance = new InputHandler.Builder(dummyTestClassAlgorithmInputArray, "org.n52.wps.server.algorithm.test.DummyTestClass").build(); idt = instance.getInputReferenceDescriptionType("BBOXInputData"); assertThat(idt, is(notNullValue())); assertThat(idt.getMaxOccurs().intValue(), equalTo(1)); assertThat(idt.getMinOccurs().intValue(), equalTo(0)); } |
InputHandler { protected String getComplexValueNodeString(Node complexValueNode) { String complexValue; try { if(complexValueNode.getChildNodes().getLength() > 1){ complexValue = complexValueNode.getChildNodes().item(1).getNodeValue(); if(complexValue == null){ return XMLUtil.nodeToString(complexValueNode.getChildNodes().item(1)); } }else{ complexValue = complexValueNode.getFirstChild().getNodeValue(); } if(complexValue == null){ return XMLUtil.nodeToString(complexValueNode.getFirstChild()); } } catch (TransformerFactoryConfigurationError e1) { throw new TransformerFactoryConfigurationError("Could not parse inline data. Reason " + e1); } catch (TransformerException e1) { throw new TransformerFactoryConfigurationError("Could not parse inline data. Reason " + e1); } return complexValue; } private InputHandler(Builder builder); Map<String, List<IData>> getParsedInputData(); } | @Test public void testInputHandlerGetComplexValueNodeString() throws ExceptionReport, XmlException, IOException { System.out.println("Testing testInputHandlerGetComplexValueNodeString..."); InputHandler instance = new InputHandler.Builder(simpleBufferAlgorithmInputArray, "org.n52.wps.server.algorithm.SimpleBufferAlgorithm").build(); String result = instance.getComplexValueNodeString(simpleBufferAlgorithmInputArray[0].getData().getComplexData().getDomNode()); assertThat(result, not(isEmptyOrNullString())); assertThat(result, containsString("147.25674400000003 -42.778393 147.22018400000002 -42.824776 147.179596 -42.82143 147.11132800000001 -42.795731 147.057098 -42.741581 147.00347900000003 -42.704803 146.91909800000002 -42.622734 146.91053799999997 -42.610928 146.88998400000003 -42.585396 146.83844 -42.572792 146.78569 -42.539352 146.724335 -42.485966 146.695023 -42.469582 146.64987200000002 -42.450371 146.604965 -42.432274 146.578781 -42.408531 146.539307 -42.364208 146.525055 -42.30883 146.558044 -42.275948 146.57624800000002 -42.23777 146.58146699999998 -42.203426 146.490005 -42.180222 146.3797 -42.146332 146.33406100000002 -42.138741 146.270966 -42.165703 146.197296 -42.224072 146.167908 -42.244835 146.16493200000002 -42.245171 146.111023 -42.265202 146.03747600000003 -42.239738 145.981628 -42.187851 145.85391199999998 -42.133492 145.819611 -42.129154 145.72052000000002 -42.104084 145.61857600000002 -42.056023 145.541718 -42.027241 145.48628200000002 -41.983326 145.452744 -41.926544 145.494034 -41.896477 145.59173600000003 -41.860214 145.64211999999998 -41.838398 145.669449 -41.830734 145.680923 -41.795753 145.68296800000002 -41.743221 145.67515600000002 -41.710377 145.680115 -41.688908 145.70106500000003 -41.648228 145.71479799999997 -41.609509 145.62919599999998 -41.462051 145.64889499999998 -41.470337 145.633423 -41.420902 145.631866 -41.36528 145.640854 -41.301533 145.700424 -41.242611 145.77242999999999 -41.193897 145.80233800000002 -41.161488 145.856018 -41.08007")); instance = new InputHandler.Builder(dummyTestClassAlgorithmInputArray, "org.n52.wps.server.algorithm.test.DummyTestClass").build(); result = instance.getComplexValueNodeString(dummyTestClassAlgorithmInputArray[0].getData().getBoundingBoxData().getDomNode()); assertThat(result, not(isEmptyOrNullString())); assertThat(result, containsString("46.75 13.05")); } |
ExecuteRequest extends Request implements IObserver { public void updateStatusError(String errorMessage) { StatusType status = StatusType.Factory.newInstance(); net.opengis.ows.x11.ExceptionReportDocument.ExceptionReport excRep = status .addNewProcessFailed().addNewExceptionReport(); excRep.setVersion("1.0.0"); ExceptionType excType = excRep.addNewException(); excType.addNewExceptionText().setStringValue(errorMessage); excType.setExceptionCode(ExceptionReport.NO_APPLICABLE_CODE); updateStatus(status); } ExecuteRequest(Document doc); ExecuteRequest(CaseInsensitiveMap ciMap); void getKVPDataInputs(); boolean validate(); Response call(); String getAlgorithmIdentifier(); Execute getExecute(); Map<String, IData> getAttachedResult(); boolean isStoreResponse(); boolean isQuickStatus(); ExecuteResponseBuilder getExecuteResponseBuilder(); boolean isRawData(); void update(ISubject subject); void updateStatusAccepted(); void updateStatusStarted(); void updateStatusSuccess(); void updateStatusError(String errorMessage); } | @Test public void testUpdateStatusError() throws ExceptionReport, XmlException, IOException, SAXException, ParserConfigurationException { FileInputStream fis = new FileInputStream(new File("src/test/resources/LRDTCCorruptInputResponseDocStatusTrue.xml")); Document doc = fac.newDocumentBuilder().parse(fis); ExecuteRequest request = new ExecuteRequest(doc); String exceptionText = "TestError"; request.updateStatusError(exceptionText); File response = DatabaseFactory.getDatabase().lookupResponseAsFile(request.getUniqueId().toString()); ExecuteResponseDocument responseDoc = ExecuteResponseDocument.Factory.parse(response); StatusType statusType = responseDoc.getExecuteResponse().getStatus(); assertTrue(validateExecuteResponse(responseDoc)); assertTrue(statusType.isSetProcessFailed()); assertTrue(statusType.getProcessFailed().getExceptionReport().getExceptionArray(0).getExceptionTextArray(0).equals(exceptionText)); } |
OutputDataItem extends ResponseData { public void updateResponseForLiteralData(ExecuteResponseDocument res, String dataTypeReference){ OutputDataType output = prepareOutput(res); String processValue = BasicXMLTypeFactory.getStringRepresentation(dataTypeReference, obj); LiteralDataType literalData = output.addNewData().addNewLiteralData(); if (dataTypeReference != null) { literalData.setDataType(dataTypeReference); } literalData.setStringValue(processValue); if(obj instanceof AbstractLiteralDataBinding){ String uom = ((AbstractLiteralDataBinding)obj).getUnitOfMeasurement(); if(uom != null && !uom.equals("")){ literalData.setUom(uom); } } } OutputDataItem(IData obj, String id, String schema, String encoding,
String mimeType, LanguageStringType title, String algorithmIdentifier, ProcessDescriptionType description); void updateResponseForInlineComplexData(ExecuteResponseDocument res); void updateResponseForLiteralData(ExecuteResponseDocument res, String dataTypeReference); void updateResponseAsReference(ExecuteResponseDocument res, String reqID, String mimeType); void updateResponseForBBOXData(ExecuteResponseDocument res, IBBOXData bbox); } | @Test public void testUpdateResponseForLiteralData() { for (ILiteralData literalData : literalDataList) { try { testLiteralOutput(literalData); } catch (Exception e) { System.out.println("Test failed for " + literalData.getClass() + " " + e); } mockupResponseDocument.getExecuteResponse().getProcessOutputs() .removeOutput(0); } } |
RawData extends ResponseData { public InputStream getAsStream() throws ExceptionReport { try { if(obj instanceof ILiteralData){ return new ByteArrayInputStream(String.valueOf(obj.getPayload()).getBytes(Charsets.UTF_8)); } if(obj instanceof IBBOXData){ IBBOXData bbox = (IBBOXData) obj; StringBuilder builder = new StringBuilder(); builder.append("<wps:BoundingBoxData"); appendAttr(builder, "xmlns:ows", XMLBeansHelper.NS_OWS_1_1); appendAttr(builder, "xmlns:wps", XMLBeansHelper.NS_WPS_1_0_0); if (bbox.getCRS() != null) { appendAttr(builder, "crs", escape(bbox.getCRS())); } appendAttr(builder, "dimensions", bbox.getDimension()); builder.append(">"); builder.append("\n\t"); builder.append("<ows:LowerCorner>"); SPACE_JOINER.appendTo(builder, Doubles.asList(bbox.getLowerCorner())); builder.append("</ows:LowerCorner>"); builder.append("\n\t"); builder.append("<ows:UpperCorner>"); SPACE_JOINER.appendTo(builder, Doubles.asList(bbox.getUpperCorner())); builder.append("</ows:UpperCorner>"); builder.append("\n"); builder.append("</wps:BoundingBoxData>"); return new ByteArrayInputStream(builder.toString().getBytes(Charsets.UTF_8)); } if(encoding == null || "".equals(encoding) || encoding.equalsIgnoreCase(IOHandler.DEFAULT_ENCODING)){ return generator.generateStream(obj, mimeType, schema); } else if(encoding.equalsIgnoreCase(IOHandler.ENCODING_BASE64)){ return generator.generateBase64Stream(obj, mimeType, schema); } } catch (IOException e) { throw new ExceptionReport("Error while generating Complex Data out of the process result", ExceptionReport.NO_APPLICABLE_CODE, e); } throw new ExceptionReport("Could not determine encoding. Use default (=not set) or base64", ExceptionReport.NO_APPLICABLE_CODE); } RawData(IData obj, String id, String schema, String encoding,
String mimeType, String algorithmIdentifier,
ProcessDescriptionType description); InputStream getAsStream(); static final Joiner SPACE_JOINER; } | @Test public void testBBoxRawDataOutputCRS(){ IData envelope = new BoundingBoxData( new double[] { 46, 102 }, new double[] { 47, 103 }, "EPSG:4326"); InputStream is; try { RawData bboxRawData = new RawData(envelope, "BBOXOutputData", null, null, null, identifier, processDescription); is = bboxRawData.getAsStream(); XmlObject bboxXMLObject = XmlObject.Factory.parse(is); assertTrue(bboxXMLObject != null); assertTrue(bboxXMLObject.getDomNode().getFirstChild().getNodeName().equals("wps:BoundingBoxData")); } catch (Exception e) { fail(e.getMessage()); } }
@Test public void testBBoxRawDataOutput(){ IData envelope = new BoundingBoxData( new double[] { 46, 102 }, new double[] { 47, 103 }, null); InputStream is; try { RawData bboxRawData = new RawData(envelope, "BBOXOutputData", null, null, null, identifier, processDescription); is = bboxRawData.getAsStream(); XmlObject bboxXMLObject = XmlObject.Factory.parse(is); assertTrue(bboxXMLObject != null); assertTrue(bboxXMLObject.getDomNode().getFirstChild().getNodeName().equals("wps:BoundingBoxData")); } catch (Exception e) { fail(e.getMessage()); } } |
MainViewModel extends AndroidViewModel { void init() { rmConnector.connect(getApplication()); rmConnector.setOnDataReceiveListener(event -> receiveColourMessage(event)); rmConnector.setOnPeerChangedListener(event -> liveDataPeerChangedEvent.postValue(event)); rmConnector.setOnConnectSuccessListener(meshId -> liveDataMyMeshId.setValue(meshId)); } MainViewModel(@NonNull Application application); void setRightMeshConnector(RightMeshConnector rmConnector); } | @Test public void init_isCalled() { spyViewModel.init(); verify(rightMeshConnector).setOnConnectSuccessListener(any()); verify(rightMeshConnector).setOnPeerChangedListener(any()); verify(rightMeshConnector).setOnDataReceiveListener(any()); verify(spyViewModel).init(); } |
MainViewModel extends AndroidViewModel { void toRightMeshWalletActivty() { try { rmConnector.toRightMeshWalletActivty(); } catch (RightMeshException e) { Log.e(TAG, e.toString()); } } MainViewModel(@NonNull Application application); void setRightMeshConnector(RightMeshConnector rmConnector); } | @Test public void toRightMeshWalletActivty_isCalled() throws RightMeshException { spyViewModel.toRightMeshWalletActivty(); verify(rightMeshConnector).toRightMeshWalletActivty(); verify(spyViewModel).toRightMeshWalletActivty(); } |
MainViewModel extends AndroidViewModel { void sendColorMsg(MeshId targetMeshId, Colour msgColor) { try { if (targetMeshId != null) { String payload = targetMeshId.toString() + ":" + msgColor.toString(); rmConnector.sendDataReliable(targetMeshId, payload); } } catch (RightMeshException.RightMeshServiceDisconnectedException sde) { Log.e(TAG, "Service disconnected while sending data, with message: " + sde.getMessage()); liveDataNotification.setValue(sde.getMessage()); } catch (RightMeshRuntimeException.RightMeshLicenseException le) { Log.e(TAG, le.getMessage()); liveDataNotification.setValue(le.getMessage()); } catch (RightMeshException rme) { Log.e(TAG, "Unable to find next hop to peer, with message: " + rme.getMessage()); liveDataNotification.setValue(rme.getMessage()); } } MainViewModel(@NonNull Application application); void setRightMeshConnector(RightMeshConnector rmConnector); } | @Test public void sendColorMsg_nullTargetMeshId() throws RightMeshException { MeshId targetId = null; Colour msgColor = Colour.RED; String payload = String.valueOf(targetId) + ":" + msgColor; spyViewModel.sendColorMsg(targetId, msgColor); verify(rightMeshConnector, never()).sendDataReliable(targetId, payload); verify(spyViewModel).sendColorMsg(targetId, msgColor); }
@Test public void sendColorMsg_targetMeshId() throws RightMeshException { MeshId targetId = mockMeshId; Colour msgColor = Colour.RED; String payload = String.valueOf(targetId) + ":" + msgColor; spyViewModel.sendColorMsg(targetId, msgColor); verify(rightMeshConnector).sendDataReliable(targetId, payload); verify(spyViewModel).sendColorMsg(targetId, msgColor); } |
MainViewModel extends AndroidViewModel { @Override protected void onCleared() { try { rmConnector.stop(); } catch (RightMeshException.RightMeshServiceDisconnectedException e) { Log.e(TAG, "Service disconnected before stopping AndroidMeshManager with message" + e.getMessage()); } } MainViewModel(@NonNull Application application); void setRightMeshConnector(RightMeshConnector rmConnector); } | @Test public void onCleared_isCalled() throws RightMeshException { spyViewModel.onCleared(); verify(rightMeshConnector).stop(); verify(spyViewModel).onCleared(); } |
RightMeshConnector implements MeshStateListener { @Override public void meshStateChanged(MeshId meshId, int state) { if (state == SUCCESS) { try { androidMeshManager.bind(meshPort); if (connectSuccessListener != null) { connectSuccessListener.onConnectSuccess(meshId); } androidMeshManager.on(DATA_RECEIVED, event -> { if (dataReceiveListener != null) { dataReceiveListener.onDataReceive(event); } }); androidMeshManager.on(PEER_CHANGED, event -> { if (peerchangedListener != null) { peerchangedListener.onPeerChange(event); } }); } catch (RightMeshException.RightMeshServiceDisconnectedException sde) { Log.e(TAG, "Service disconnected while binding, with message: " + sde.getMessage()); } catch (RightMeshException rme) { Log.e(TAG, "MeshPort already bound, with message: " + rme.getMessage()); } } } RightMeshConnector(int meshPort); void connect(Context context); @Override void meshStateChanged(MeshId meshId, int state); void stop(); void setOnDataReceiveListener(OnDataReceiveListener listener); void setOnPeerChangedListener(OnPeerChangedListener listener); void setOnConnectSuccessListener(OnConnectSuccessListener listener); void toRightMeshWalletActivty(); void sendDataReliable(MeshId targetMeshId, String payload); void setAndroidMeshManager(AndroidMeshManager androidMeshManager); } | @Test public void meshStateChanged_successEvent() throws RightMeshException, ClassNotFoundException { spyRightMeshConnector.meshStateChanged(meshId, MeshStateListener.SUCCESS); verify(androidMeshManager).bind(MESH_PORT); verify(spyRightMeshConnector).meshStateChanged(meshId, MeshStateListener.SUCCESS); } |
RightMeshConnector implements MeshStateListener { public void stop() throws RightMeshException.RightMeshServiceDisconnectedException { androidMeshManager.stop(); } RightMeshConnector(int meshPort); void connect(Context context); @Override void meshStateChanged(MeshId meshId, int state); void stop(); void setOnDataReceiveListener(OnDataReceiveListener listener); void setOnPeerChangedListener(OnPeerChangedListener listener); void setOnConnectSuccessListener(OnConnectSuccessListener listener); void toRightMeshWalletActivty(); void sendDataReliable(MeshId targetMeshId, String payload); void setAndroidMeshManager(AndroidMeshManager androidMeshManager); } | @Test public void stop_isCalled() throws RightMeshException.RightMeshServiceDisconnectedException { spyRightMeshConnector.stop(); verify(androidMeshManager).stop(); verify(spyRightMeshConnector).stop(); } |
RightMeshConnector implements MeshStateListener { public void toRightMeshWalletActivty() throws RightMeshException { this.androidMeshManager.showSettingsActivity(); } RightMeshConnector(int meshPort); void connect(Context context); @Override void meshStateChanged(MeshId meshId, int state); void stop(); void setOnDataReceiveListener(OnDataReceiveListener listener); void setOnPeerChangedListener(OnPeerChangedListener listener); void setOnConnectSuccessListener(OnConnectSuccessListener listener); void toRightMeshWalletActivty(); void sendDataReliable(MeshId targetMeshId, String payload); void setAndroidMeshManager(AndroidMeshManager androidMeshManager); } | @Test public void toRightMeshWalletActivty_isCalled() throws RightMeshException { spyRightMeshConnector.toRightMeshWalletActivty(); verify(androidMeshManager).showSettingsActivity(); verify(spyRightMeshConnector).toRightMeshWalletActivty(); } |
RightMeshConnector implements MeshStateListener { public void sendDataReliable(MeshId targetMeshId, String payload) throws RightMeshException, RightMeshException.RightMeshServiceDisconnectedException { androidMeshManager.sendDataReliable(androidMeshManager.getNextHopPeer(targetMeshId), meshPort, payload.getBytes(Charset.forName("UTF-8"))); } RightMeshConnector(int meshPort); void connect(Context context); @Override void meshStateChanged(MeshId meshId, int state); void stop(); void setOnDataReceiveListener(OnDataReceiveListener listener); void setOnPeerChangedListener(OnPeerChangedListener listener); void setOnConnectSuccessListener(OnConnectSuccessListener listener); void toRightMeshWalletActivty(); void sendDataReliable(MeshId targetMeshId, String payload); void setAndroidMeshManager(AndroidMeshManager androidMeshManager); } | @Test public void sendDataReliable_isCalled() throws RightMeshException { String payload = "abc"; spyRightMeshConnector.sendDataReliable(meshId, payload); verify(spyRightMeshConnector).sendDataReliable(any(), eq(payload)); } |
ParseBoolean { public int parse() { String expression = " if(" + _input + "){" + "returnValue = VALUEA;" + "}" + " else { returnValue = VALUEB; }"; expression = expression.replaceAll("0", " false " ); expression = expression.replaceAll("1", " true " ); expression = expression.replaceAll("\\*", " && " ); expression = expression.replaceAll("\\+", " || " ); expression = expression.replace("VALUEA", " \"1\" " ); expression = expression.replace("VALUEB", " \"0\" " ); System.out.println(expression); ScriptEngineManager manager = new ScriptEngineManager(); ScriptEngine engine = manager.getEngineByName("js"); Object result = null; try { result = engine.eval(expression); } catch (ScriptException e) { } return result == null ? 0 :Integer.parseInt(result.toString()); } ParseBoolean(String input); int parse(); } | @Test public void test1() { String input = "(1+0*1)"; ParseBoolean tester = new ParseBoolean(input); int testResults = tester.parse(); assertEquals("Result",1, testResults ); }
@Test public void test2() { String input = "(!0)"; ParseBoolean tester = new ParseBoolean(input); int testResults = tester.parse(); assertEquals("Result",1, testResults ); }
@Test public void test3() { String input = "0"; ParseBoolean tester = new ParseBoolean(input); int testResults = tester.parse(); assertEquals("Result",0, testResults ); }
@Test public void test4() { String input = "0 * 1 * 1"; ParseBoolean tester = new ParseBoolean(input); int testResults = tester.parse(); assertEquals("Result",0, testResults ); }
@Test public void test5() { String input = "(1+0)"; ParseBoolean tester = new ParseBoolean(input); int testResults = tester.parse(); assertEquals("Result",1, testResults ); }
@Test public void test6() { String input = "!0 * 0 + 1"; ParseBoolean tester = new ParseBoolean(input); int testResults = tester.parse(); assertEquals("Result",1, testResults ); }
@Test public void test7() { String input = "(0+1) * (1+0)"; ParseBoolean tester = new ParseBoolean(input); int testResults = tester.parse(); assertEquals("Result",1, testResults ); }
@Test public void test8() { String input = "((0+0+(1+!1+!(0 + !(0*1+0*1*1+1*0)+1)+0*1)+1*0*0)+0*1)"; ParseBoolean tester = new ParseBoolean(input); int testResults = tester.parse(); assertEquals("Result",1, testResults ); } |
ParseBooleanOriginal { public int process() { _input = _input.replaceAll(" ", ""); _input = _input.replaceAll("!1", "0"); _input = _input.replaceAll("!0", "1"); Matcher m = p.matcher(_input); if(m.find()) { _input = _input.substring(1,_input.length()-1); } Matcher m1 = p1.matcher(_input); Matcher m2 = p2.matcher(_input); if(m1.find() || m2.find()) { return 1; } Matcher m4 = p4.matcher(_input); String foundInnerLogic; String parsed; while (m4.find()) { foundInnerLogic = m4.group(); if(foundInnerLogic != null){ parsed = parseInnerLogic(foundInnerLogic); String matched = foundInnerLogic; _input = _input.replace(matched, parsed); _input = _input.replace("!0", "1"); _input = _input.replace("!1", "0"); m4 = p4.matcher(_input); } } _input = parseInnerLogic(_input); return Integer.parseInt(_input); } ParseBooleanOriginal(String input); int process(); static void main(String[] args); } | @Test public void test3() { String input = "0"; ParseBooleanOriginal tester = new ParseBooleanOriginal(input); int testResults = tester.process(); assertEquals("Result",0, testResults ); }
@Test public void test4() { String input = "0 * 1 * 1"; ParseBooleanOriginal tester = new ParseBooleanOriginal(input); int testResults = tester.process(); assertEquals("Result",0, testResults ); }
@Test public void test5() { String input = "(1+0)"; ParseBooleanOriginal tester = new ParseBooleanOriginal(input); int testResults = tester.process(); assertEquals("Result",1, testResults ); }
@Test public void test6() { String input = "!0 * 0 + 1"; ParseBooleanOriginal tester = new ParseBooleanOriginal(input); int testResults = tester.process(); assertEquals("Result",1, testResults ); }
@Test public void test7() { String input = "(0+1) * (1+0)"; ParseBooleanOriginal tester = new ParseBooleanOriginal(input); int testResults = tester.process(); assertEquals("Result",1, testResults ); }
@Test public void test8() { String input = "((0+0+(1+!1+!(0 + !(0*1+0*1*1+1*0)+1)+0*1)+1*0*0)+0*1)"; ParseBooleanOriginal tester = new ParseBooleanOriginal(input); int testResults = tester.process(); assertEquals("Result",1, testResults ); }
@Test public void test1() { String input = "(1+0*1)"; ParseBooleanOriginal tester = new ParseBooleanOriginal(input); int testResults = tester.process(); assertEquals("Result",1, testResults ); }
@Test public void test2() { String input = "(!0)"; ParseBooleanOriginal tester = new ParseBooleanOriginal(input); int testResults = tester.process(); assertEquals("Result",1, testResults ); } |
SecretSantaFinder { public Map<String, String> pair() { List<Family> families = new ArrayList<Family>(); if(2*maxFamilyMembers > totalNames){ return null; } for(String key: familyMembers.keySet()) { families.add(familyMembers.get(key)) ; } Collections.sort(families); List<String> receiveList = new ArrayList<String>(totalNames); List<String> sendList = new ArrayList<String>(totalNames); List<String> largestFamilyMembers = new ArrayList<String>(); Map<String, String> secretList = new HashMap<String,String>(); for(int i=0;i < families.size();i++) { List<String> names = families.get(i).members; receiveList.addAll(names); if(i== 0) { largestFamilyMembers = names; } else { sendList.addAll(names); } } sendList.addAll(largestFamilyMembers); for(int i=0;i < sendList.size();i++) { secretList.put(sendList.get(i), receiveList.get(i)); } return secretList; } SecretSantaFinder(String[] lists); Map<String, String> pair(); static void main(String[] args); } | @Test public void testTooManyInAFamily() { String names = "A Smith, B Smith, C Smith, D Andersen, E Andersen"; String[] nameList = names.split(","); SecretSantaFinder ssf = new SecretSantaFinder(nameList); assertEquals(ssf.pair(), null); }
@Test public void testUnique() { String names = "A Smith, B Smith, C Smith, D Andersen, E Andersen,F Andersen, G Jackson"; String[] nameList = names.split(","); SecretSantaFinder ssf = new SecretSantaFinder(nameList); Map<String,String> pairs = ssf.pair(); assertEquals(pairs.size(), 7); for(String key: pairs.keySet()) { assertFalse(key.equals(pairs.get(key))); String[] giver = key.split(" "); String[] receiver = pairs.get(key).split(" "); assertFalse(giver[1].equals(receiver[1])); } } |
CyclicWordsKata { public List<List<String>> process() { List<List<String>> processed = new ArrayList<List<String>>(); Map<Integer,List<String>> buckets ; List<List<String>> returnArray ; buckets = separateInputBySize(_input); if(buckets == null) return processed; for(int size: buckets.keySet()) { List<String> elements = buckets.get(size); System.out.println("size " + size); while(elements != null && elements.size() > 0) { returnArray = processSameSizeArray(elements); elements = returnArray.get(1) ; processed.add(returnArray.get(0)); } } return processed; } CyclicWordsKata(String[] input); List<List<String>> process(); Map<Integer,List<String>> separateInputBySize(String[] input); String joinStringArray(List<String> arrayList, String connector); static void main(String[] args); } | @Test public void testOneCyclicPair() { String[] input = {"abc","acb", "cab"}; CyclicWordsKata tester = new CyclicWordsKata(input); List<List<String>> results = tester.process(); assertEquals("Result", 2, results.size()); }
@Test public void testNull() { String[] input = null; CyclicWordsKata tester = new CyclicWordsKata(input); List<List<String>> results = tester.process(); assertNull("results", results); } |
ParseRomanNumerals { public String parse() { String returnValue = ""; String prefix = ""; String suffix = ""; while(_input/1000 > 0 ) { int current = _input/1000; int toBeParsed = _input%1000; returnValue = prefix + parseUnder1000(toBeParsed) + suffix + returnValue; _input = current; prefix += "("; suffix += ")"; } returnValue = prefix + parseUnder1000(_input) + suffix + returnValue; returnValue = returnValue.replaceAll("\\(I\\)", "M"); returnValue = returnValue.replaceAll("\\(II\\)", "MM"); returnValue = returnValue.replaceAll("\\(III\\)", "MMM"); return returnValue; } ParseRomanNumerals(int input); String parse(); static void main(String[] args); } | @Test public void test1() { int input = 1879; ParseRomanNumerals tester = new ParseRomanNumerals(input); String testResults = tester.parse(); assertEquals("Result","MDCCCLXXIX", testResults ); }
@Test public void test2() { int input = 1; ParseRomanNumerals tester = new ParseRomanNumerals(input); String testResults = tester.parse(); assertEquals("Result","I", testResults ); }
@Test public void test3() { int input = 2010; ParseRomanNumerals tester = new ParseRomanNumerals(input); String testResults = tester.parse(); assertEquals("Result","MMX", testResults ); }
@Test public void test4() { int input = 47; ParseRomanNumerals tester = new ParseRomanNumerals(input); String testResults = tester.parse(); assertEquals("Result","XLVII", testResults ); }
@Test public void test5() { int input = 3888; ParseRomanNumerals tester = new ParseRomanNumerals(input); String testResults = tester.parse(); assertEquals("Result","MMMDCCCLXXXVIII", testResults ); } |
StateMachine { public String execute(String input) { String startState = entryState; for(int i = 0; i < input.length();i++){ char event = input.charAt(i) ; if(_symbols.indexOf(event) < 0) { return null; } String key = startState + "_" + event; if (endStates.containsKey(key)) { startState = endStates.get(key); } } if (states.containsKey(startState)) { return states.get(startState); } return null; } StateMachine(String symbols, String statesIn, String transitions); String execute(String input); static void main(String[] args); } | @Test public void test1 () { StateMachine fsm = new StateMachine("0,1", "EVEN:pass,ODD:fail,BAD:fail", "EVEN:ODD:1,ODD:EVEN:1,ODD:BAD:0"); assertEquals("pass", fsm.execute("00110")); assertEquals("fail", fsm.execute("00111")); assertEquals("fail", fsm.execute("001110000110011")); assertEquals("fail", null,fsm.execute("0011100001130011")); } |
ShellMode { public static ShellMode from(String... arguments) { if (runInBatchMode(arguments)) { return new BatchMode(extractCommand(arguments)); } return new InteractiveMode(); } static String usage(); static ShellMode from(String... arguments); static ShellMode batch(String command); static ShellMode interactive(); abstract void start(); @Override final boolean equals(Object object); @Override abstract String toString(); } | @Test(expected = IllegalArgumentException.class) public void illegalFlagsShouldBeDetected() { ShellMode mode = ShellMode.from("--interactive --foo"); } |
Script extends ShellCommand implements Iterable<ShellCommand> { public Script(List<ShellCommand> commands) { this.commands = new ArrayList<ShellCommand>(commands); } Script(List<ShellCommand> commands); @Override void execute(ShellCommandHandler handler); Iterator<ShellCommand> iterator(); @Override int hashCode(); @Override String toString(); } | @Test public void toFileShouldCreateANonEmptyFile() throws FileNotFoundException { final ShellCommand script = script(history(), version(), exit()); final String destination = "test.txt"; script.toFile(destination); File file = new File(destination); assertThat("no file generated!", file.exists()); assertThat("empty file generated!", file.length(), is(greaterThan(0L))); file.delete(); }
@Test public void generatedScriptsShouldBeReadble() throws Exception { final String destination = "test.txt"; final ShellCommand script = script(history(), version(), exit()); try { script.toFile(destination); final ShellCommand script2 = fromFile(destination); assertThat("Different files", script2, is(equalTo(script))); } catch (Exception e) { throw e; } finally { File file = new File(destination); file.delete(); } } |
AuthResource { public TempTokenResponse temporaryAuthToken(String scope) throws StorageException, UnsupportedEncodingException { if (Strings.isNullOrEmpty(scope)) { scope = "all"; } String tempToken = sessionManager.storeNewTempToken(); String xanauthURL = "xanauth: + URLEncoder.encode(scope, "UTF-8"); TempTokenResponse tempTokenResponse = new TempTokenResponse(); tempTokenResponse.xanauth = xanauthURL; tempTokenResponse.token = tempToken; return tempTokenResponse; } AuthResource(SessionManager sessionManager, ObjectMapper mapper, String host); SessionResponse getSessionToken(String header64, String claim64, String sig64); TempTokenResponse temporaryAuthToken(String scope); } | @Test public void temporaryAuthToken() throws Exception { SessionManager mockManager = mock(SessionManager.class); when(mockManager.storeNewTempToken()).thenReturn("dummyToken"); AuthResource resource = new AuthResource(mockManager, null, "localhost"); TempTokenResponse response = resource.temporaryAuthToken("doc"); assertNotNull(response.token); assertEquals("xanauth: } |
RopeUtils { public static <T extends StreamElement> long addWeightsOfRightLeaningChildNodes(Node<T> x) { if (x == null || x.right == null) { return 0; } return x.right.weight + addWeightsOfRightLeaningChildNodes(x.right); } static long addWeightsOfRightLeaningChildNodes(Node<T> x); static long addWeightsOfRightLeaningParentNodes(Node<T> child); static void adjustWeightOfLeftLeaningParents(Node<T> startNode, long weight); static long characterCount(Node<T> x); static void collectLeafNodes(Node<T> x, Queue<Node<T>> queue); static Node<T> concat(List<Node<T>> orphans); static Node<T> concat(Node<T> left, Node<T> right); static void cutLeftNode(Node<T> x, List<Node<T>> orphans); static void cutRightNode(Node<T> x, List<Node<T>> orphans); static Node<T> findRoot(Node<T> child); static Node<T> findSearchNode(Node<T> x, long weight, Node<T> root); static NodeIndex<T> index(long characterPosition, Node<T> x, long disp); static boolean intersects(long start, long end, long start2, long end2); static Node<T> rebalance(Node<T> x); } | @Test public void addWeightsOfRightLeaningChildNodesNoChildren() throws Exception { Node<InvariantSpan> x = new Node<>(new InvariantSpan(1, 1, documentHash)); assertEquals(0, RopeUtils.addWeightsOfRightLeaningChildNodes(x)); }
@Test public void addWeightsOfRightLeaningChildNodesNullNode() throws Exception { assertEquals(0, RopeUtils.addWeightsOfRightLeaningChildNodes(null)); }
@Test public void addWeightsOfRightLeaningChildNodesSimple() throws Exception { Node<InvariantSpan> right = new Node<>(new InvariantSpan(1, 10, documentHash)); Node<InvariantSpan> x = new Node.Builder<InvariantSpan>(0).right(right).build(); assertEquals(10, RopeUtils.addWeightsOfRightLeaningChildNodes(x)); }
@Test public void addWeightsOfRightLeaningChildNodesChained() throws Exception { Node<InvariantSpan> right = new Node<>(new InvariantSpan(1, 10, documentHash)); Node<InvariantSpan> right2 = new Node<>(new InvariantSpan(1, 20, documentHash)); right.right = right2; Node<InvariantSpan> x = new Node.Builder<InvariantSpan>(0).right(right).build(); assertEquals(30, RopeUtils.addWeightsOfRightLeaningChildNodes(x)); }
@Test public void addWeightsOfRightLeaningChildNodesLeftOnly() throws Exception { Node<InvariantSpan> left = new Node<>(new InvariantSpan(1, 1, documentHash)); Node<InvariantSpan> x = new Node.Builder<InvariantSpan>(1).left(left).build(); assertEquals(0, RopeUtils.addWeightsOfRightLeaningChildNodes(x)); } |
RopeUtils { public static <T extends StreamElement> long addWeightsOfRightLeaningParentNodes(Node<T> child) { if (child == null) { throw new IllegalStateException("child node can't be null"); } if (child.parent == null) { return 0; } return (child.isRightNode() ? child.parent.weight : 0) + addWeightsOfRightLeaningParentNodes(child.parent); } static long addWeightsOfRightLeaningChildNodes(Node<T> x); static long addWeightsOfRightLeaningParentNodes(Node<T> child); static void adjustWeightOfLeftLeaningParents(Node<T> startNode, long weight); static long characterCount(Node<T> x); static void collectLeafNodes(Node<T> x, Queue<Node<T>> queue); static Node<T> concat(List<Node<T>> orphans); static Node<T> concat(Node<T> left, Node<T> right); static void cutLeftNode(Node<T> x, List<Node<T>> orphans); static void cutRightNode(Node<T> x, List<Node<T>> orphans); static Node<T> findRoot(Node<T> child); static Node<T> findSearchNode(Node<T> x, long weight, Node<T> root); static NodeIndex<T> index(long characterPosition, Node<T> x, long disp); static boolean intersects(long start, long end, long start2, long end2); static Node<T> rebalance(Node<T> x); } | @Test public void addWeightsOfRightLeaningParentNodesChainedRight() throws Exception { Node<InvariantSpan> right2 = new Node<>(new InvariantSpan(1, 3, documentHash)); Node<InvariantSpan> right = new Node.Builder<InvariantSpan>(1).right(right2).build(); new Node.Builder<InvariantSpan>(1).right(right).build(); assertEquals(2, RopeUtils.addWeightsOfRightLeaningParentNodes(right2)); }
@Test public void addWeightsOfRightLeaningParentNodesLeftNodeChild() throws Exception { Node<InvariantSpan> left = new Node<>(new InvariantSpan(1, 1, documentHash)); new Node.Builder<InvariantSpan>(1).left(left).build(); assertEquals(0, RopeUtils.addWeightsOfRightLeaningParentNodes(left)); }
@Test(expected = IllegalStateException.class) public void addWeightsOfRightLeaningParentNodesNull() throws Exception { RopeUtils.addWeightsOfRightLeaningParentNodes(null); }
@Test public void addWeightsOfRightLeaningParentNodesNullParent() throws Exception { Node<InvariantSpan> x = new Node<>(new InvariantSpan(1, 1, documentHash)); assertEquals(0, RopeUtils.addWeightsOfRightLeaningParentNodes(x)); }
@Test public void addWeightsOfRightLeaningParentNodesRightNodeChild() throws Exception { Node<InvariantSpan> right = new Node<>(new InvariantSpan(1, 1, documentHash)); new Node.Builder<InvariantSpan>(1).right(right).build(); assertEquals(1, RopeUtils.addWeightsOfRightLeaningParentNodes(right)); } |
RopeUtils { public static <T extends StreamElement> long characterCount(Node<T> x) { if (x == null) { return 0; } if (x.isLeaf()) { return x.value.getWidth(); } return x.weight + addWeightsOfRightLeaningChildNodes(x); } static long addWeightsOfRightLeaningChildNodes(Node<T> x); static long addWeightsOfRightLeaningParentNodes(Node<T> child); static void adjustWeightOfLeftLeaningParents(Node<T> startNode, long weight); static long characterCount(Node<T> x); static void collectLeafNodes(Node<T> x, Queue<Node<T>> queue); static Node<T> concat(List<Node<T>> orphans); static Node<T> concat(Node<T> left, Node<T> right); static void cutLeftNode(Node<T> x, List<Node<T>> orphans); static void cutRightNode(Node<T> x, List<Node<T>> orphans); static Node<T> findRoot(Node<T> child); static Node<T> findSearchNode(Node<T> x, long weight, Node<T> root); static NodeIndex<T> index(long characterPosition, Node<T> x, long disp); static boolean intersects(long start, long end, long start2, long end2); static Node<T> rebalance(Node<T> x); } | @Test public void characterCount() throws Exception { Node<InvariantSpan> right = new Node<>(new InvariantSpan(1, 10, documentHash)); Node<InvariantSpan> right2 = new Node<>(new InvariantSpan(1, 20, documentHash)); right.right = right2; Node<InvariantSpan> x = new Node.Builder<InvariantSpan>(10).right(right).build(); assertEquals(40, RopeUtils.characterCount(x)); }
@Test public void characterCountLeafNode() throws Exception { assertEquals(3, RopeUtils.characterCount(new Node<>(new InvariantSpan(1, 3, documentHash)))); }
@Test public void characterCountNullNode() throws Exception { assertEquals(0, RopeUtils.characterCount(null)); } |
ApplyOverlayOp extends Op { @Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) return false; ApplyOverlayOp other = (ApplyOverlayOp) obj; if (!linkTypes.equals(other.linkTypes)) return false; if (!variantSpan.equals(other.variantSpan)) return false; return true; } ApplyOverlayOp(DataInputStream dis); ApplyOverlayOp(VariantSpan variantSpan, Set<Integer> linkTypes); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final Set<Integer> linkTypes; final VariantSpan variantSpan; } | @Test public void equalsTrue() throws Exception { ApplyOverlayOp op1 = new ApplyOverlayOp(new VariantSpan(1, 100), Sets.newHashSet(1, 10)); ApplyOverlayOp op2 = new ApplyOverlayOp(new VariantSpan(1, 100), Sets.newHashSet(1, 10)); assertTrue(op1.equals(op2)); assertTrue(op2.equals(op1)); }
@Test public void equalsVariantsFalse() throws Exception { ApplyOverlayOp op1 = new ApplyOverlayOp(new VariantSpan(1, 100), Sets.newHashSet(1, 10)); ApplyOverlayOp op2 = new ApplyOverlayOp(new VariantSpan(2, 100), Sets.newHashSet(1, 10)); assertFalse(op1.equals(op2)); assertFalse(op2.equals(op1)); }
@Test public void equalsLinkTypesFalse() throws Exception { ApplyOverlayOp op1 = new ApplyOverlayOp(new VariantSpan(1, 100), Sets.newHashSet(1)); ApplyOverlayOp op2 = new ApplyOverlayOp(new VariantSpan(1, 100), Sets.newHashSet(1, 10)); assertFalse(op1.equals(op2)); assertFalse(op2.equals(op1)); } |
RopeUtils { public static <T extends StreamElement> Node<T> concat(List<Node<T>> orphans) { Iterator<Node<T>> it = orphans.iterator(); Node<T> orphan = it.next(); while (it.hasNext()) { orphan = RopeUtils.concat(orphan, it.next()); } return orphan; } static long addWeightsOfRightLeaningChildNodes(Node<T> x); static long addWeightsOfRightLeaningParentNodes(Node<T> child); static void adjustWeightOfLeftLeaningParents(Node<T> startNode, long weight); static long characterCount(Node<T> x); static void collectLeafNodes(Node<T> x, Queue<Node<T>> queue); static Node<T> concat(List<Node<T>> orphans); static Node<T> concat(Node<T> left, Node<T> right); static void cutLeftNode(Node<T> x, List<Node<T>> orphans); static void cutRightNode(Node<T> x, List<Node<T>> orphans); static Node<T> findRoot(Node<T> child); static Node<T> findSearchNode(Node<T> x, long weight, Node<T> root); static NodeIndex<T> index(long characterPosition, Node<T> x, long disp); static boolean intersects(long start, long end, long start2, long end2); static Node<T> rebalance(Node<T> x); } | @Test public void concatLeft() throws Exception { Node<InvariantSpan> left = new Node<>(new InvariantSpan(1, 10, documentHash)); Node<InvariantSpan> parent = RopeUtils.concat(left, null); assertEquals(10, parent.weight); assertNotNull(left.parent); }
@Test public void concatNullLeftNullRight() throws Exception { assertEquals(0, RopeUtils.concat(null, null).weight); }
@Test public void concatRight() throws Exception { Node<InvariantSpan> right = new Node<>(new InvariantSpan(1, 10, documentHash)); Node<InvariantSpan> parent = RopeUtils.concat(null, right); assertEquals(0, parent.weight); assertNotNull(right.parent); } |
RopeUtils { public static <T extends StreamElement> Node<T> findSearchNode(Node<T> x, long weight, Node<T> root) { if (root == null) { throw new IllegalArgumentException("root is null"); } if (x == null) { return root; } if (x.weight > weight) { return x; } return findSearchNode(x.parent, weight, root); } static long addWeightsOfRightLeaningChildNodes(Node<T> x); static long addWeightsOfRightLeaningParentNodes(Node<T> child); static void adjustWeightOfLeftLeaningParents(Node<T> startNode, long weight); static long characterCount(Node<T> x); static void collectLeafNodes(Node<T> x, Queue<Node<T>> queue); static Node<T> concat(List<Node<T>> orphans); static Node<T> concat(Node<T> left, Node<T> right); static void cutLeftNode(Node<T> x, List<Node<T>> orphans); static void cutRightNode(Node<T> x, List<Node<T>> orphans); static Node<T> findRoot(Node<T> child); static Node<T> findSearchNode(Node<T> x, long weight, Node<T> root); static NodeIndex<T> index(long characterPosition, Node<T> x, long disp); static boolean intersects(long start, long end, long start2, long end2); static Node<T> rebalance(Node<T> x); } | @Test public void findSearchNode() throws Exception { } |
RopeUtils { public static <T extends StreamElement> NodeIndex<T> index(long characterPosition, Node<T> x, long disp) { if (x == null) { throw new IllegalArgumentException("node is null"); } if (characterPosition < 1) { throw new IndexOutOfBoundsException("characterPosition must be greater than 0"); } if (x.isLeaf()) { return new NodeIndex<T>(x, disp); } if (x.weight < characterPosition) { if (x.right == null) { throw new IndexOutOfBoundsException("Can't find node at position = " + (characterPosition + disp)); } if (x.weight > 0) { disp += x.weight; x.isRed = true; } return index(characterPosition - x.weight, x.right, disp); } else { if (x.left == null) { throw new IndexOutOfBoundsException("Can't find node at position = " + (characterPosition + disp)); } return index(characterPosition, x.left, disp); } } static long addWeightsOfRightLeaningChildNodes(Node<T> x); static long addWeightsOfRightLeaningParentNodes(Node<T> child); static void adjustWeightOfLeftLeaningParents(Node<T> startNode, long weight); static long characterCount(Node<T> x); static void collectLeafNodes(Node<T> x, Queue<Node<T>> queue); static Node<T> concat(List<Node<T>> orphans); static Node<T> concat(Node<T> left, Node<T> right); static void cutLeftNode(Node<T> x, List<Node<T>> orphans); static void cutRightNode(Node<T> x, List<Node<T>> orphans); static Node<T> findRoot(Node<T> child); static Node<T> findSearchNode(Node<T> x, long weight, Node<T> root); static NodeIndex<T> index(long characterPosition, Node<T> x, long disp); static boolean intersects(long start, long end, long start2, long end2); static Node<T> rebalance(Node<T> x); } | @Test public void indexDisplacement() throws Exception { Node<InvariantSpan> left = new Node<>(new InvariantSpan(1, 1, documentHash)); Node<InvariantSpan> right = new Node<>(new InvariantSpan(2, 3, documentHash)); Node<InvariantSpan> root = new Node.Builder<InvariantSpan>(1).left(left).right(right).build(); NodeIndex<InvariantSpan> index = RopeUtils.index(2, root, 0); assertEquals(1, index.displacement); }
@Test public void indexLeft() throws Exception { Node<InvariantSpan> left = new Node<>(new InvariantSpan(1, 10, documentHash)); Node<InvariantSpan> root = new Node.Builder<InvariantSpan>(10).left(left).build(); NodeIndex<InvariantSpan> index = RopeUtils.index(5, root, 0); assertEquals(new InvariantSpan(1, 10, documentHash), index.node.value); assertEquals(0, index.displacement); }
@Test public void indexLeftLeftChain() throws Exception { Node<InvariantSpan> left2 = new Node<>(new InvariantSpan(100, 10, documentHash)); Node<InvariantSpan> right2 = new Node<>(new InvariantSpan(200, 5, documentHash)); Node<InvariantSpan> left1 = new Node.Builder<InvariantSpan>(10).left(left2).right(right2).build(); Node<InvariantSpan> root = new Node.Builder<InvariantSpan>(15).left(left1).build(); NodeIndex<InvariantSpan> index = RopeUtils.index(10, root, 0); assertEquals(new InvariantSpan(100, 10, documentHash), index.node.value); assertEquals(0, index.displacement); }
@Test public void indexLeftLower() throws Exception { Node<InvariantSpan> left = new Node<>(new InvariantSpan(1, 10, documentHash)); Node<InvariantSpan> root = new Node.Builder<InvariantSpan>(10).left(left).build(); NodeIndex<InvariantSpan> index = RopeUtils.index(1, root, 0); assertEquals(new InvariantSpan(1, 10, documentHash), index.node.value); assertEquals(0, index.displacement); }
@Test public void indexLeftRightChain() throws Exception { Node<InvariantSpan> left2 = new Node<>(new InvariantSpan(100, 10, documentHash)); Node<InvariantSpan> right2 = new Node<>(new InvariantSpan(200, 5, documentHash)); Node<InvariantSpan> left1 = new Node.Builder<InvariantSpan>(10).left(left2).right(right2).build(); Node<InvariantSpan> root = new Node.Builder<InvariantSpan>(15).left(left1).build(); NodeIndex<InvariantSpan> index = RopeUtils.index(11, root, 0); assertEquals(new InvariantSpan(200, 5, documentHash), index.node.value); assertEquals(10, index.displacement); }
@Test(expected = IndexOutOfBoundsException.class) public void indexLeftTooHigh() throws Exception { Node<InvariantSpan> left = new Node<>(new InvariantSpan(1, 10, documentHash)); Node<InvariantSpan> root = new Node.Builder<InvariantSpan>(10).left(left).build(); RopeUtils.index(11, root, 0); }
@Test(expected = IndexOutOfBoundsException.class) public void indexLeftTooLow() throws Exception { Node<InvariantSpan> left = new Node<>(new InvariantSpan(1, 10, documentHash)); Node<InvariantSpan> root = new Node.Builder<InvariantSpan>(10).left(left).build(); RopeUtils.index(0, root, 0); }
@Test public void indexLeftUpper() throws Exception { Node<InvariantSpan> left = new Node<>(new InvariantSpan(1, 10, documentHash)); Node<InvariantSpan> root = new Node.Builder<InvariantSpan>(10).left(left).build(); NodeIndex<InvariantSpan> index = RopeUtils.index(10, root, 0); assertEquals(new InvariantSpan(1, 10, documentHash), index.node.value); assertEquals(0, index.displacement); }
@Test(expected = IndexOutOfBoundsException.class) public void indexOutOutBoundsRight() throws Exception { Node<InvariantSpan> left2 = new Node<>(new InvariantSpan(100, 10, documentHash)); Node<InvariantSpan> right2 = new Node<>(new InvariantSpan(200, 5, documentHash)); Node<InvariantSpan> left1 = new Node.Builder<InvariantSpan>(10).left(left2).right(right2).build(); Node<InvariantSpan> root = new Node.Builder<InvariantSpan>(15).left(left1).build(); RopeUtils.index(20, root, 0); }
@Test public void indexRight() throws Exception { Node<InvariantSpan> left = new Node<>(new InvariantSpan(1, 10, documentHash)); Node<InvariantSpan> right = new Node<>(new InvariantSpan(1, 20, documentHash)); Node<InvariantSpan> root = new Node.Builder<InvariantSpan>(10).left(left).right(right).build(); NodeIndex<InvariantSpan> index = RopeUtils.index(15, root, 0); assertEquals(new InvariantSpan(1, 20, documentHash), index.node.value); assertEquals(10, index.displacement); } |
DefaultOulipoMachine implements OulipoMachine { @Override public InvariantSpan append(String text) throws IOException, MalformedSpanException { return iStream.append(text); } DefaultOulipoMachine(StreamLoader stream, RemoteFileManager remoteFileManager, String documentHash,
Key privateKey); static DefaultOulipoMachine createWritableMachine(StreamLoader loader, RemoteFileManager remoteFileManager,
String documentHash); @Override InvariantSpan append(String text); @Override void applyOverlays(VariantSpan variantSpan, Set<Overlay> links); @Override void copyVariant(long to, VariantSpan variantSpan); @Override void deleteVariant(VariantSpan variantSpan); @Override void flush(); @Override String getDocumentHash(); @Override List<Invariant> getInvariants(); @Override List<Invariant> getInvariants(VariantSpan variantSpan); @Override String getText(InvariantSpan invariantSpan); @Override List<VariantSpan> getVariantSpans(InvariantSpan invariantSpan); @Override Invariant index(long characterPosition); @Override void insert(long to, String text); @Override void insertEncrypted(long to, String text); @Override void loadDocument(String hash); @Override void moveVariant(long to, VariantSpan variantSpan); @Override void putInvariant(long to, Invariant invariant); @Override void putOverlay(long to, OverlayStream overlayStream); @Override void swapVariants(VariantSpan v1, VariantSpan v2); @Override void toggleOverlay(VariantSpan variantSpan, Overlay link); } | @Test public void append() throws Exception { DefaultOulipoMachine som = DefaultOulipoMachine.createWritableMachine(streamLoader, new MockRemoteFileManager(), documentHash); InvariantSpan span = som.append("Hello"); assertEquals(span.getStart(), 1); assertEquals(span.getWidth(), 5); span = som.append("World"); assertEquals(span.getStart(), 6); assertEquals(span.getWidth(), 5); } |
DefaultOulipoMachine implements OulipoMachine { @Override public String getText(InvariantSpan invariantSpan) throws IOException { assertSpanNotNull(invariantSpan); return iStream.getText(invariantSpan); } DefaultOulipoMachine(StreamLoader stream, RemoteFileManager remoteFileManager, String documentHash,
Key privateKey); static DefaultOulipoMachine createWritableMachine(StreamLoader loader, RemoteFileManager remoteFileManager,
String documentHash); @Override InvariantSpan append(String text); @Override void applyOverlays(VariantSpan variantSpan, Set<Overlay> links); @Override void copyVariant(long to, VariantSpan variantSpan); @Override void deleteVariant(VariantSpan variantSpan); @Override void flush(); @Override String getDocumentHash(); @Override List<Invariant> getInvariants(); @Override List<Invariant> getInvariants(VariantSpan variantSpan); @Override String getText(InvariantSpan invariantSpan); @Override List<VariantSpan> getVariantSpans(InvariantSpan invariantSpan); @Override Invariant index(long characterPosition); @Override void insert(long to, String text); @Override void insertEncrypted(long to, String text); @Override void loadDocument(String hash); @Override void moveVariant(long to, VariantSpan variantSpan); @Override void putInvariant(long to, Invariant invariant); @Override void putOverlay(long to, OverlayStream overlayStream); @Override void swapVariants(VariantSpan v1, VariantSpan v2); @Override void toggleOverlay(VariantSpan variantSpan, Overlay link); } | @Test public void getText() throws Exception { DefaultOulipoMachine som = DefaultOulipoMachine.createWritableMachine(streamLoader, new MockRemoteFileManager(), documentHash); som.append("Hello"); som.append("World"); String result = som.getText(new InvariantSpan(5, 5, documentHash)); assertEquals("oWorl", result); } |
DefaultOulipoMachine implements OulipoMachine { @Override public void moveVariant(long to, VariantSpan variantSpan) throws MalformedSpanException, IOException { assertGreaterThanZero(to); assertSpanNotNull(variantSpan); vStream.move(to, variantSpan); oStream.move(to, variantSpan); if (writeDocFile) { documentBuilder.moveVariant(to, variantSpan); } } DefaultOulipoMachine(StreamLoader stream, RemoteFileManager remoteFileManager, String documentHash,
Key privateKey); static DefaultOulipoMachine createWritableMachine(StreamLoader loader, RemoteFileManager remoteFileManager,
String documentHash); @Override InvariantSpan append(String text); @Override void applyOverlays(VariantSpan variantSpan, Set<Overlay> links); @Override void copyVariant(long to, VariantSpan variantSpan); @Override void deleteVariant(VariantSpan variantSpan); @Override void flush(); @Override String getDocumentHash(); @Override List<Invariant> getInvariants(); @Override List<Invariant> getInvariants(VariantSpan variantSpan); @Override String getText(InvariantSpan invariantSpan); @Override List<VariantSpan> getVariantSpans(InvariantSpan invariantSpan); @Override Invariant index(long characterPosition); @Override void insert(long to, String text); @Override void insertEncrypted(long to, String text); @Override void loadDocument(String hash); @Override void moveVariant(long to, VariantSpan variantSpan); @Override void putInvariant(long to, Invariant invariant); @Override void putOverlay(long to, OverlayStream overlayStream); @Override void swapVariants(VariantSpan v1, VariantSpan v2); @Override void toggleOverlay(VariantSpan variantSpan, Overlay link); } | @Test public void moveVariant() throws Exception { DefaultOulipoMachine machine = DefaultOulipoMachine.createWritableMachine(streamLoader, new MockRemoteFileManager(), documentHash); machine.insert(1, "My first document"); assertEquals("My first document", getText(machine)); machine.moveVariant(1, new VariantSpan(4, 6)); assertEquals("first My document", getText(machine)); } |
ApplyOverlayOp extends Op { @Override public int hashCode() { final int prime = 31; int result = super.hashCode(); result = prime * result + linkTypes.hashCode(); result = prime * result + variantSpan.hashCode(); return result; } ApplyOverlayOp(DataInputStream dis); ApplyOverlayOp(VariantSpan variantSpan, Set<Integer> linkTypes); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final Set<Integer> linkTypes; final VariantSpan variantSpan; } | @Test public void hashTrue() throws Exception { ApplyOverlayOp op1 = new ApplyOverlayOp(new VariantSpan(1, 100), Sets.newHashSet(1, 10)); ApplyOverlayOp op2 = new ApplyOverlayOp(new VariantSpan(1, 100), Sets.newHashSet(1, 10)); assertEquals(op1.hashCode(), op2.hashCode()); ; } |
SwapVariantOp extends Op { @Override public byte[] encode() throws IOException { ByteArrayOutputStream os = new ByteArrayOutputStream(); try (DataOutputStream dos = new DataOutputStream(os)) { dos.writeByte(Op.SWAP); dos.writeLong(v1.start); dos.writeLong(v1.width); dos.writeLong(v2.start); dos.writeLong(v2.width); } os.flush(); return os.toByteArray(); } SwapVariantOp(DataInputStream dis); SwapVariantOp(VariantSpan v1, VariantSpan v2); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final VariantSpan v1; final VariantSpan v2; } | @Test public void encodeDecode() throws Exception { SwapVariantOp op = new SwapVariantOp(new VariantSpan(100, 1), new VariantSpan(200, 1)); byte[] data = op.encode(); DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data)); assertEquals(Op.SWAP, dis.readByte()); SwapVariantOp decoded = new SwapVariantOp(dis); assertEquals(op, decoded); } |
SwapVariantOp extends Op { @Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) return false; SwapVariantOp other = (SwapVariantOp) obj; if (!v1.equals(other.v1)) return false; if (!v2.equals(other.v2)) return false; return true; } SwapVariantOp(DataInputStream dis); SwapVariantOp(VariantSpan v1, VariantSpan v2); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final VariantSpan v1; final VariantSpan v2; } | @Test public void equalsFalse() throws Exception { SwapVariantOp op1 = new SwapVariantOp(new VariantSpan(100, 1), new VariantSpan(200, 1)); SwapVariantOp op2 = new SwapVariantOp(new VariantSpan(100, 10), new VariantSpan(200, 1)); assertFalse(op1.equals(op2)); assertFalse(op2.equals(op1)); } |
SwapVariantOp extends Op { @Override public int hashCode() { final int prime = 31; int result = super.hashCode(); result = prime * result + v1.hashCode(); result = prime * result + v2.hashCode(); return result; } SwapVariantOp(DataInputStream dis); SwapVariantOp(VariantSpan v1, VariantSpan v2); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final VariantSpan v1; final VariantSpan v2; } | @Test public void hashFalse() throws Exception { SwapVariantOp op1 = new SwapVariantOp(new VariantSpan(100, 10), new VariantSpan(200, 1)); SwapVariantOp op2 = new SwapVariantOp(new VariantSpan(100, 1), new VariantSpan(200, 1)); assertFalse(op1.hashCode() == op2.hashCode()); ; }
@Test public void hashTrue() throws Exception { SwapVariantOp op1 = new SwapVariantOp(new VariantSpan(100, 1), new VariantSpan(200, 1)); SwapVariantOp op2 = new SwapVariantOp(new VariantSpan(100, 1), new VariantSpan(200, 1)); assertEquals(op1.hashCode(), op2.hashCode()); ; } |
PutOverlayMediaOp extends Op { @Override public byte[] encode() throws IOException { ByteArrayOutputStream os = new ByteArrayOutputStream(); try (DataOutputStream dos = new DataOutputStream(os)) { dos.writeByte(Op.PUT_OVERLAY_MEDIA); dos.writeLong(to); dos.writeInt(hash); dos.writeInt(linkTypes.size()); for (Integer i : linkTypes) { dos.writeInt(i); } } os.flush(); return os.toByteArray(); } PutOverlayMediaOp(DataInputStream dis); PutOverlayMediaOp(long to, int hash, Set<Integer> linkTypes); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final int hash; final Set<Integer> linkTypes; final long to; } | @Test public void encodeDecode() throws Exception { PutOverlayMediaOp op = new PutOverlayMediaOp(1, 1, Sets.newSet(10, 5)); byte[] data = op.encode(); DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data)); assertEquals(Op.PUT_OVERLAY_MEDIA, dis.readByte()); PutOverlayMediaOp decoded = new PutOverlayMediaOp(dis); assertEquals(op, decoded); } |
PutOverlayMediaOp extends Op { @Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) return false; PutOverlayMediaOp other = (PutOverlayMediaOp) obj; if (hash != other.hash) return false; if (!linkTypes.equals(other.linkTypes)) return false; if (to != other.to) return false; return true; } PutOverlayMediaOp(DataInputStream dis); PutOverlayMediaOp(long to, int hash, Set<Integer> linkTypes); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final int hash; final Set<Integer> linkTypes; final long to; } | @Test public void equalsFalse() throws Exception { PutOverlayMediaOp op1 = new PutOverlayMediaOp(1, 1, Sets.newSet(10, 5)); PutOverlayMediaOp op2 = new PutOverlayMediaOp(2, 1, Sets.newSet(10, 5)); assertFalse(op1.equals(op2)); assertFalse(op2.equals(op1)); } |
PutOverlayMediaOp extends Op { @Override public int hashCode() { final int prime = 31; int result = super.hashCode(); result = prime * result + hash; result = prime * result + ((linkTypes == null) ? 0 : linkTypes.hashCode()); result = prime * result + (int) (to ^ (to >>> 32)); return result; } PutOverlayMediaOp(DataInputStream dis); PutOverlayMediaOp(long to, int hash, Set<Integer> linkTypes); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final int hash; final Set<Integer> linkTypes; final long to; } | @Test public void hashFalse() throws Exception { PutOverlayMediaOp op1 = new PutOverlayMediaOp(1, 1, Sets.newSet(10, 5)); PutOverlayMediaOp op2 = new PutOverlayMediaOp(2, 1, Sets.newSet(10, 5)); assertFalse(op1.hashCode() == op2.hashCode()); }
@Test public void hashTrue() throws Exception { PutOverlayMediaOp op1 = new PutOverlayMediaOp(1, 0, Sets.newSet(10, 5)); PutOverlayMediaOp op2 = new PutOverlayMediaOp(1, 0, Sets.newSet(10, 5)); assertEquals(op1.hashCode(), op2.hashCode()); ; } |
StorageService { public <T> void delete(String id, Class<T> clazz) throws StorageException { if (Strings.isNullOrEmpty(id)) { throw new IllegalArgumentException("Id is null"); } if (clazz == null) { throw new IllegalArgumentException("Class is null"); } String key = id + "!" + clazz.getName(); Field[] fields = clazz.getDeclaredFields(); for (Field field : fields) { field.setAccessible(true); db.delete(bytes(key + "!" + field.getName())); } } protected StorageService(DB db); StorageService(String name); void close(); void delete(String id, Class<T> clazz); byte[] get(byte[] key); Collection<T> getAll(Class<T> clazz); T load(String id, Class<T> clazz); void put(byte[] key, byte[] value); void save(Object entity); } | @Test public void delete() throws Exception { TestObject to1 = new TestObject("1", "456"); TestObject to2 = new TestObject("2", "abc"); TestObject to3 = new TestObject("3", "xyz"); service.save(to1); service.save(to2); service.save(to3); service.delete("1", TestObject.class); service.delete("3", TestObject.class); Collection<TestObject> results = service.getAll(TestObject.class); assertEquals(1, results.size()); assertFalse(results.contains(to1)); assertTrue(results.contains(to2)); assertFalse(results.contains(to3)); } |
DeleteVariantOp extends Op { @Override public byte[] encode() throws IOException { ByteArrayOutputStream os = new ByteArrayOutputStream(); try (DataOutputStream dos = new DataOutputStream(os)) { dos.writeByte(Op.DELETE); dos.writeLong(variantSpan.start); dos.writeLong(variantSpan.width); } os.flush(); return os.toByteArray(); } DeleteVariantOp(DataInputStream dis); DeleteVariantOp(VariantSpan variantSpan); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final VariantSpan variantSpan; } | @Test public void encode() throws Exception { DeleteVariantOp op = new DeleteVariantOp(new VariantSpan(1, 100)); byte[] data = op.encode(); DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data)); assertEquals(Op.DELETE, dis.read()); assertEquals(1, dis.readLong()); assertEquals(100, dis.readLong()); } |
DeleteVariantOp extends Op { @Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) return false; DeleteVariantOp other = (DeleteVariantOp) obj; if (!variantSpan.equals(other.variantSpan)) return false; return true; } DeleteVariantOp(DataInputStream dis); DeleteVariantOp(VariantSpan variantSpan); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final VariantSpan variantSpan; } | @Test public void equalsVariantsFalse() throws Exception { DeleteVariantOp op1 = new DeleteVariantOp(new VariantSpan(1, 100)); DeleteVariantOp op2 = new DeleteVariantOp(new VariantSpan(2, 100)); assertFalse(op1.equals(op2)); assertFalse(op2.equals(op1)); } |
DeleteVariantOp extends Op { @Override public int hashCode() { final int prime = 31; int result = super.hashCode(); result = prime * result + variantSpan.hashCode(); return result; } DeleteVariantOp(DataInputStream dis); DeleteVariantOp(VariantSpan variantSpan); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final VariantSpan variantSpan; } | @Test public void hashFalse() throws Exception { DeleteVariantOp op1 = new DeleteVariantOp(new VariantSpan(1, 100)); DeleteVariantOp op2 = new DeleteVariantOp(new VariantSpan(2, 100)); assertFalse(op1.hashCode() == op2.hashCode()); ; }
@Test public void hashTrue() throws Exception { DeleteVariantOp op1 = new DeleteVariantOp(new VariantSpan(1, 100)); DeleteVariantOp op2 = new DeleteVariantOp(new VariantSpan(1, 100)); assertEquals(op1.hashCode(), op2.hashCode()); ; } |
CopyVariantOp extends Op { @Override public byte[] encode() throws IOException { ByteArrayOutputStream os = new ByteArrayOutputStream(); try (DataOutputStream dos = new DataOutputStream(os)) { dos.writeByte(Op.COPY); dos.writeLong(to); dos.writeLong(variantSpan.start); dos.writeLong(variantSpan.width); } os.flush(); return os.toByteArray(); } CopyVariantOp(DataInputStream dis); CopyVariantOp(long to, VariantSpan variantSpan); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final long to; final VariantSpan variantSpan; } | @Test public void encodeDecode() throws Exception { CopyVariantOp op = new CopyVariantOp(100, new VariantSpan(50, 75)); byte[] data = op.encode(); DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data)); assertEquals(Op.COPY, dis.readByte()); CopyVariantOp decoded = new CopyVariantOp(dis); assertEquals(op, decoded); } |
CopyVariantOp extends Op { @Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) return false; CopyVariantOp other = (CopyVariantOp) obj; if (to != other.to) return false; if (!variantSpan.equals(other.variantSpan)) return false; return true; } CopyVariantOp(DataInputStream dis); CopyVariantOp(long to, VariantSpan variantSpan); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final long to; final VariantSpan variantSpan; } | @Test public void equalsPositionsFalse() throws Exception { CopyVariantOp op1 = new CopyVariantOp(1, new VariantSpan(1, 100)); CopyVariantOp op2 = new CopyVariantOp(2, new VariantSpan(1, 100)); assertFalse(op1.equals(op2)); assertFalse(op2.equals(op1)); }
@Test public void equalsVariantsFalse() throws Exception { CopyVariantOp op1 = new CopyVariantOp(1, new VariantSpan(1, 100)); CopyVariantOp op2 = new CopyVariantOp(1, new VariantSpan(2, 100)); assertFalse(op1.equals(op2)); assertFalse(op2.equals(op1)); } |
CopyVariantOp extends Op { @Override public int hashCode() { final int prime = 31; int result = super.hashCode(); result = prime * result + (int) (to ^ (to >>> 32)); result = prime * result + variantSpan.hashCode(); return result; } CopyVariantOp(DataInputStream dis); CopyVariantOp(long to, VariantSpan variantSpan); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final long to; final VariantSpan variantSpan; } | @Test public void hashTrue() throws Exception { CopyVariantOp op1 = new CopyVariantOp(1, new VariantSpan(1, 100)); CopyVariantOp op2 = new CopyVariantOp(1, new VariantSpan(1, 100)); assertEquals(op1.hashCode(), op2.hashCode()); ; } |
MoveVariantOp extends Op { @Override public byte[] encode() throws IOException { ByteArrayOutputStream os = new ByteArrayOutputStream(); try (DataOutputStream dos = new DataOutputStream(os)) { dos.writeByte(Op.MOVE); dos.writeLong(to); dos.writeLong(variantSpan.start); dos.writeLong(variantSpan.width); } os.flush(); return os.toByteArray(); } MoveVariantOp(DataInputStream dis); MoveVariantOp(long to, VariantSpan variantSpan); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final long to; final VariantSpan variantSpan; } | @Test public void encodeDecode() throws Exception { MoveVariantOp op = new MoveVariantOp(100, new VariantSpan(50, 75)); byte[] data = op.encode(); DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data)); assertEquals(Op.MOVE, dis.readByte()); MoveVariantOp decoded = new MoveVariantOp(dis); assertEquals(op, decoded); } |
StorageService { public <T> Collection<T> getAll(Class<T> clazz) throws ClassNotFoundException, StorageException, IOException { List<T> c = new ArrayList<>(); Map<String, String> ids = new HashMap<>(); try (DBIterator it = db.iterator()) { it.seekToFirst(); String prevId = null; while (it.hasNext()) { String key = new String(it.next().getKey()); String[] tokens = key.split("!"); String id = tokens[0]; String className = tokens[1]; if (!id.equals(prevId)) { if (clazz.getName().equals(className)) { ids.put(id, className); } prevId = id; } } for (Map.Entry<String, String> id : ids.entrySet()) { T o = (T) load(id.getKey(), Class.forName(id.getValue())); c.add(o); } } return c; } protected StorageService(DB db); StorageService(String name); void close(); void delete(String id, Class<T> clazz); byte[] get(byte[] key); Collection<T> getAll(Class<T> clazz); T load(String id, Class<T> clazz); void put(byte[] key, byte[] value); void save(Object entity); } | @Test public void getAll() throws Exception { TestObject to1 = new TestObject("1", "456"); TestObject to2 = new TestObject("2", "abc"); TestObject to3 = new TestObject("3", "xyz"); service.save(to1); service.save(to2); service.save(to3); Collection<TestObject> results = service.getAll(TestObject.class); assertEquals(3, results.size()); assertTrue(results.contains(to1)); assertTrue(results.contains(to2)); assertTrue(results.contains(to3)); } |
MoveVariantOp extends Op { @Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) return false; MoveVariantOp other = (MoveVariantOp) obj; if (to != other.to) return false; if (!variantSpan.equals(other.variantSpan)) return false; return true; } MoveVariantOp(DataInputStream dis); MoveVariantOp(long to, VariantSpan variantSpan); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final long to; final VariantSpan variantSpan; } | @Test public void equalsVariantsFalse() throws Exception { MoveVariantOp op1 = new MoveVariantOp(1, new VariantSpan(1, 100)); MoveVariantOp op2 = new MoveVariantOp(1, new VariantSpan(2, 100)); assertFalse(op1.equals(op2)); assertFalse(op2.equals(op1)); } |
MoveVariantOp extends Op { @Override public int hashCode() { final int prime = 31; int result = super.hashCode(); result = prime * result + (int) (to ^ (to >>> 32)); result = prime * result + variantSpan.hashCode(); return result; } MoveVariantOp(DataInputStream dis); MoveVariantOp(long to, VariantSpan variantSpan); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final long to; final VariantSpan variantSpan; } | @Test public void hashFalse() throws Exception { MoveVariantOp op1 = new MoveVariantOp(1, new VariantSpan(1, 100)); MoveVariantOp op2 = new MoveVariantOp(1, new VariantSpan(2, 100)); assertFalse(op1.hashCode() == op2.hashCode()); ; }
@Test public void hashFalse2() throws Exception { MoveVariantOp op1 = new MoveVariantOp(1, new VariantSpan(1, 100)); MoveVariantOp op2 = new MoveVariantOp(2, new VariantSpan(1, 100)); assertFalse(op1.hashCode() == op2.hashCode()); ; }
@Test public void hashTrue() throws Exception { MoveVariantOp op1 = new MoveVariantOp(1, new VariantSpan(1, 100)); MoveVariantOp op2 = new MoveVariantOp(1, new VariantSpan(1, 100)); assertEquals(op1.hashCode(), op2.hashCode()); ; } |
PutInvariantSpanOp extends Op { @Override public byte[] encode() throws IOException { ByteArrayOutputStream os = new ByteArrayOutputStream(); try (DataOutputStream dos = new DataOutputStream(os)) { dos.writeByte(Op.PUT_INVARIANT_SPAN); dos.writeLong(to); dos.writeLong(invariantStart); dos.writeLong(width); dos.writeInt(ripIndex); } os.flush(); return os.toByteArray(); } PutInvariantSpanOp(DataInputStream dis); PutInvariantSpanOp(long to, long invariantStart, long width, int ripIndex); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final long invariantStart; final int ripIndex; final long to; final long width; } | @Test public void encodeDecode() throws Exception { PutInvariantSpanOp op = new PutInvariantSpanOp(100, 50, 1, 0); byte[] data = op.encode(); DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data)); assertEquals(Op.PUT_INVARIANT_SPAN, dis.readByte()); PutInvariantSpanOp decoded = new PutInvariantSpanOp(dis); assertEquals(op, decoded); } |
PutInvariantSpanOp extends Op { @Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) return false; PutInvariantSpanOp other = (PutInvariantSpanOp) obj; if (ripIndex != other.ripIndex) return false; if (invariantStart != other.invariantStart) return false; if (to != other.to) return false; if (width != other.width) return false; return true; } PutInvariantSpanOp(DataInputStream dis); PutInvariantSpanOp(long to, long invariantStart, long width, int ripIndex); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final long invariantStart; final int ripIndex; final long to; final long width; } | @Test public void equalsFalse() throws Exception { PutInvariantSpanOp op1 = new PutInvariantSpanOp(100, 50, 1, 0); PutInvariantSpanOp op2 = new PutInvariantSpanOp(101, 50, 1, 0); assertFalse(op1.equals(op2)); assertFalse(op2.equals(op1)); } |
PutInvariantSpanOp extends Op { @Override public int hashCode() { final int prime = 31; int result = super.hashCode(); result = prime * result + ripIndex; result = prime * result + (int) (invariantStart ^ (invariantStart >>> 32)); result = prime * result + (int) (to ^ (to >>> 32)); result = prime * result + (int) (width ^ (width >>> 32)); return result; } PutInvariantSpanOp(DataInputStream dis); PutInvariantSpanOp(long to, long invariantStart, long width, int ripIndex); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final long invariantStart; final int ripIndex; final long to; final long width; } | @Test public void hashFalse() throws Exception { PutInvariantSpanOp op1 = new PutInvariantSpanOp(100, 50, 1, 0); PutInvariantSpanOp op2 = new PutInvariantSpanOp(101, 50, 1, 0); assertFalse(op1.hashCode() == op2.hashCode()); ; }
@Test public void hashTrue() throws Exception { PutInvariantSpanOp op1 = new PutInvariantSpanOp(100, 50, 1, 0); PutInvariantSpanOp op2 = new PutInvariantSpanOp(100, 50, 1, 0); assertEquals(op1.hashCode(), op2.hashCode()); ; } |
PutInvariantMediaOp extends Op { @Override public byte[] encode() throws IOException { ByteArrayOutputStream os = new ByteArrayOutputStream(); try (DataOutputStream dos = new DataOutputStream(os)) { dos.writeByte(Op.PUT_INVARIANT_MEDIA); dos.writeLong(to); dos.writeInt(ripIndex); } os.flush(); return os.toByteArray(); } PutInvariantMediaOp(DataInputStream dis); PutInvariantMediaOp(long to, int ripIndex); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final int ripIndex; final long to; } | @Test public void encodeDecode() throws Exception { PutInvariantMediaOp op = new PutInvariantMediaOp(100, 1); byte[] data = op.encode(); DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data)); assertEquals(Op.PUT_INVARIANT_MEDIA, dis.readByte()); PutInvariantMediaOp decoded = new PutInvariantMediaOp(dis); assertEquals(op, decoded); } |
PutInvariantMediaOp extends Op { @Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) return false; PutInvariantMediaOp other = (PutInvariantMediaOp) obj; if (ripIndex != other.ripIndex) return false; if (to != other.to) return false; return true; } PutInvariantMediaOp(DataInputStream dis); PutInvariantMediaOp(long to, int ripIndex); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final int ripIndex; final long to; } | @Test public void equalsFalse() throws Exception { PutInvariantMediaOp op1 = new PutInvariantMediaOp(1, 2); PutInvariantMediaOp op2 = new PutInvariantMediaOp(2, 2); assertFalse(op1.equals(op2)); assertFalse(op2.equals(op1)); } |
Subsets and Splits