Datasets:
Minata
/
512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
method2testcases
stringlengths
118
3.08k
### Question: GeneralizedTime implements Comparable<GeneralizedTime> { public Date getDate() { return calendar.getTime(); } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( String generalizedTime ); String toGeneralizedTime(); String toGeneralizedTimeWithoutFraction(); String toGeneralizedTime( Format format, FractionDelimiter fractionDelimiter, int fractionLength, TimeZoneFormat timeZoneFormat ); Calendar getCalendar(); @Override String toString(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override int compareTo( GeneralizedTime other ); long getTime(); Date getDate(); int getYear(); int getMonth(); int getDay(); int getHour(); int getMinutes(); int getSeconds(); int getFraction(); static Date getDate( String zuluTime ); }### Answer: @Test public void fractionCloseToOne() throws ParseException { GeneralizedTime close = new GeneralizedTime( "20000101000000.9994Z" ); assertThat( close.getDate(), is( equalTo( format.parse( "01/01/2000 00:00:00.999 GMT" ) ) ) ); GeneralizedTime closer = new GeneralizedTime( "20000101000000.9995Z" ); assertThat( closer.getDate(), is( equalTo( format.parse( "01/01/2000 00:00:00.999 GMT" ) ) ) ); GeneralizedTime larger = new GeneralizedTime( "20000101000000.9Z" ); assertThat( larger.getDate(), is( equalTo( format.parse( "01/01/2000 00:00:00.900 GMT" ) ) ) ); }
### Question: ObjectClass extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } ObjectClass( String oid ); List<String> getMayAttributeTypeOids(); List<AttributeType> getMayAttributeTypes(); void addMayAttributeTypeOids( String... oids ); void addMayAttributeTypes( AttributeType... attributeTypes ); void setMayAttributeTypeOids( List<String> mayAttributeTypeOids ); void setMayAttributeTypes( List<AttributeType> mayAttributeTypes ); List<String> getMustAttributeTypeOids(); List<AttributeType> getMustAttributeTypes(); void addMustAttributeTypeOids( String... oids ); void addMustAttributeTypes( AttributeType... attributeTypes ); void setMustAttributeTypeOids( List<String> mustAttributeTypeOids ); void setMustAttributeTypes( List<AttributeType> mustAttributeTypes ); List<ObjectClass> getSuperiors(); List<String> getSuperiorOids(); void addSuperiorOids( String... oids ); void addSuperior( ObjectClass... objectClasses ); void setSuperiors( List<ObjectClass> superiors ); void setSuperiorOids( List<String> superiorOids ); ObjectClassTypeEnum getType(); void setType( ObjectClassTypeEnum objectClassType ); boolean isStructural(); boolean isAbstract(); boolean isAuxiliary(); @Override String toString(); @Override ObjectClass copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; }### Answer: @Test public void testToString() throws Exception { String string = objectClass.toString(); assertNotNull( string ); assertTrue( string.startsWith( "objectclass (" ) ); assertTrue( string.contains( " NAME " ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tSUP " ) ); assertTrue( string.contains( "\n\tSTRUCTURAL" ) ); assertTrue( string.contains( "\n\tMUST" ) ); assertTrue( string.contains( "\n\tMAY" ) ); assertTrue( string.endsWith( " )" ) ); }
### Question: OidRegistry implements Iterable<T> { public OidRegistry<T> copy() { OidRegistry<T> copy = new OidRegistry<>(); copy.byOid = new HashMap<>(); return copy; } boolean contains( String oid ); String getPrimaryName( String oid ); T getSchemaObject( String oid ); List<String> getNameSet( String oid ); Iterator<String> iteratorOids(); @Override Iterator<T> iterator(); boolean isRelaxed(); boolean isStrict(); void setRelaxed(); void setStrict(); SchemaErrorHandler getErrorHandler(); void setErrorHandler( SchemaErrorHandler errorHandler ); void register( T schemaObject ); void unregister( String oid ); OidRegistry<T> copy(); int size(); void clear(); @Override String toString(); }### Answer: @Test public void testCopy() throws Exception { }
### Question: DitStructureRule extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } DitStructureRule( int ruleId ); String getForm(); void setForm( String form ); int getRuleId(); void setRuleId( int ruleId ); List<Integer> getSuperRules(); void setSuperRules( List<Integer> superRules ); void addSuperRule( Integer superRule ); @Override String getOid(); @Override String toString(); @Override DitStructureRule copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; }### Answer: @Test public void testToString() throws Exception { String string = ditStructureRule.toString(); assertNotNull( string ); assertTrue( string.startsWith( "ditstructurerule (" ) ); assertTrue( string.contains( " NAME " ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tFORM " ) ); assertTrue( string.contains( "\n\tSUP" ) ); }
### Question: BooleanNormalizer extends Normalizer { @Override public String normalize( String value ) throws LdapInvalidDnException { if ( value == null ) { return null; } return Strings.upperCase( value.trim() ); } BooleanNormalizer(); @Override String normalize( String value ); @Override String normalize( String value, PrepareString.AssertionType assertionType ); }### Answer: @Test public void testNormalizeNullValue() throws Exception { assertNull( normalizer.normalize( null ) ); } @Test public void testNormalizeNonNullValue() throws Exception { assertEquals( "TRUE", normalizer.normalize( "true" ) ); assertEquals( "ABC", normalizer.normalize( "aBc" ) ); assertEquals( "FALSE", normalizer.normalize( "falsE" ) ); } @Test public void testNormalizeValueWithSpaces() throws Exception { assertEquals( "TRUE", normalizer.normalize( " tRuE " ) ); }
### Question: SyntaxChecker extends LoadableSchemaObject { @Override public boolean equals( Object o ) { if ( !super.equals( o ) ) { return false; } return o instanceof SyntaxChecker; } protected SyntaxChecker( String oid ); protected SyntaxChecker(); boolean isValidSyntax( Object value ); void setSchemaManager( SchemaManager schemaManager ); @Override boolean equals( Object o ); @Override String toString(); static final long serialVersionUID; }### Answer: @Test public void testEqualsNull() throws Exception { assertFalse( objectClassA.equals( null ) ); } @Test public void testNotEqualDiffValue() throws Exception { assertFalse( objectClassA.equals( objectClassC ) ); assertFalse( objectClassC.equals( objectClassA ) ); }
### Question: PrepareString { public static String normalize( String value ) { if ( !Normalizer.isNormalized( value, Normalizer.Form.NFKC ) ) { return Normalizer.normalize( value, Normalizer.Form.NFKC ); } else { return value; } } private PrepareString(); static String transcode( byte[] bytes ); static String normalize( String value ); static String mapCaseSensitive( String unicode ); static void checkProhibited( char[] value ); static String insignificantNumericStringHandling( char[] source ); static String insignificantTelephoneNumberStringHandling( char[] source ); static String insignificantSpacesStringValue( char[] origin ); static String insignificantSpacesStringInitial( char[] origin ); static String insignificantSpacesStringAny( char[] origin ); static String insignificantSpacesStringFinal( char[] origin ); static String mapIgnoreCase( String unicode ); static final boolean CASE_SENSITIVE; static final boolean IGNORE_CASE; }### Answer: @Test public void testEscapeBackSlash() throws IOException { String result = PrepareString.normalize( "C:\\a\\b\\c" ); System.out.println( result ); }
### Question: MatchingRuleUse extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } MatchingRuleUse( String oid ); List<String> getApplicableAttributeOids(); List<AttributeType> getApplicableAttributes(); void setApplicableAttributeOids( List<String> applicableAttributeOids ); void setApplicableAttributes( List<AttributeType> applicableAttributes ); void addApplicableAttributeOids( String oid ); void addApplicableAttribute( AttributeType attributeType ); @Override String toString(); @Override MatchingRuleUse copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; }### Answer: @Test public void testToString() throws Exception { String string = matchingRuleUse.toString(); assertNotNull( string ); assertTrue( string.startsWith( "matchingruleuse (" ) ); assertTrue( string.contains( " NAME " ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tAPPLIES " ) ); }
### Question: Ava implements Externalizable, Cloneable, Comparable<Ava> { public String getName() { return upName; } Ava(); Ava( SchemaManager schemaManager ); Ava( SchemaManager schemaManager, Ava ava ); Ava( String upType, byte[] upValue ); Ava( SchemaManager schemaManager, String upType, byte[] upValue ); Ava( SchemaManager schemaManager, String upType, String upName, byte[] upValue ); Ava( String upType, String upValue ); Ava( SchemaManager schemaManager, String upType, String upValue ); Ava( SchemaManager schemaManager, String upType, String upName, String upValue ); Ava( String upType, String normType, Value value, String upName ); Ava( AttributeType attributeType, String upType, String normType, Value value, String upName ); Ava( SchemaManager schemaManager, String upType, String normType, Value value ); String getNormType(); String getType(); Value getValue(); String getName(); String getEscaped(); @Override Ava clone(); @Override int hashCode(); @Override boolean equals( Object obj ); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); boolean isSchemaAware(); AttributeType getAttributeType(); @Override int compareTo( Ava that ); @Override String toString(); }### Answer: @Test public void testNormalize() throws LdapException { Ava atav = new Ava( schemaManager, " A ", "a" ); assertEquals( " A =a", atav.getName() ); }
### Question: Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable<Rdn> { @Override public String toString() { return upName == null ? "" : upName; } Rdn(); Rdn( SchemaManager schemaManager ); Rdn( SchemaManager schemaManager, String rdn ); Rdn( String rdn ); Rdn( SchemaManager schemaManager, String upType, String upValue ); Rdn( String upType, String upValue ); Rdn( SchemaManager schemaManager, Ava... avas ); Rdn( Ava... avas ); Rdn( Rdn rdn ); Rdn( SchemaManager schemaManager, Rdn rdn ); Object getValue( String type ); Ava getAva( String type ); @Override Iterator<Ava> iterator(); @Override Rdn clone(); String getName(); String getNormName(); Ava getAva(); Ava getAva( int pos ); String getType(); String getNormType(); String getValue(); @Override boolean equals( Object that ); int size(); static Object unescapeValue( String value ); static String escapeValue( String value ); String getEscaped(); static String escapeValue( byte[] attrValue ); boolean isSchemaAware(); static boolean isValid( String dn ); static boolean isValid( SchemaManager schemaManager, String dn ); @Override int hashCode(); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); @Override int compareTo( Rdn otherRdn ); @Override String toString(); static final Rdn EMPTY_RDN; static final int UNDEFINED; static final int SUPERIOR; static final int INFERIOR; static final int EQUAL; }### Answer: @Test public void testRdnNull() { assertEquals( "", new Rdn().toString() ); } @Test public void testRdnEmpty() throws LdapException { assertEquals( "", new Rdn( "" ).toString() ); }
### Question: Oid { public static boolean isOid( String oidString ) { try { Oid.fromString( oidString ); return true; } catch ( DecoderException e ) { return false; } } private Oid( String oidString, byte[] oidBytes ); @Override boolean equals( Object other ); static Oid fromBytes( byte[] oidBytes ); static Oid fromString( String oidString ); int getEncodedLength(); @Override int hashCode(); static boolean isOid( String oidString ); byte[] toBytes(); @Override String toString(); void writeBytesTo( ByteBuffer buffer ); void writeBytesTo( OutputStream outputStream ); }### Answer: @Test public void testNewOidStringBad() { assertFalse( Oid.isOid( "0" ) ); assertFalse( Oid.isOid( "1" ) ); assertFalse( Oid.isOid( "0." ) ); assertFalse( Oid.isOid( "1." ) ); assertFalse( Oid.isOid( "2." ) ); assertFalse( Oid.isOid( "2." ) ); assertFalse( Oid.isOid( "." ) ); assertFalse( Oid.isOid( "0.1.2." ) ); assertFalse( Oid.isOid( "3.1" ) ); assertFalse( Oid.isOid( "0..1" ) ); assertFalse( Oid.isOid( "0..12" ) ); assertFalse( Oid.isOid( "0.a.2" ) ); assertFalse( Oid.isOid( "0.40" ) ); assertFalse( Oid.isOid( "0.51" ) ); assertFalse( Oid.isOid( "0.01" ) ); assertFalse( Oid.isOid( "0.123456" ) ); assertFalse( Oid.isOid( "1.123456" ) ); }
### Question: Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable<Rdn> { public String getType() { switch ( nbAvas ) { case 0: return null; case 1: return ava.getType(); default: return avas.get( 0 ).getType(); } } Rdn(); Rdn( SchemaManager schemaManager ); Rdn( SchemaManager schemaManager, String rdn ); Rdn( String rdn ); Rdn( SchemaManager schemaManager, String upType, String upValue ); Rdn( String upType, String upValue ); Rdn( SchemaManager schemaManager, Ava... avas ); Rdn( Ava... avas ); Rdn( Rdn rdn ); Rdn( SchemaManager schemaManager, Rdn rdn ); Object getValue( String type ); Ava getAva( String type ); @Override Iterator<Ava> iterator(); @Override Rdn clone(); String getName(); String getNormName(); Ava getAva(); Ava getAva( int pos ); String getType(); String getNormType(); String getValue(); @Override boolean equals( Object that ); int size(); static Object unescapeValue( String value ); static String escapeValue( String value ); String getEscaped(); static String escapeValue( byte[] attrValue ); boolean isSchemaAware(); static boolean isValid( String dn ); static boolean isValid( SchemaManager schemaManager, String dn ); @Override int hashCode(); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); @Override int compareTo( Rdn otherRdn ); @Override String toString(); static final Rdn EMPTY_RDN; static final int UNDEFINED; static final int SUPERIOR; static final int INFERIOR; static final int EQUAL; }### Answer: @Test public void testGetType() throws LdapException { Rdn rdn = new Rdn( " a = b + b = f + g = h + c = d " ); assertEquals( "a", rdn.getNormType() ); }
### Question: Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable<Rdn> { public int size() { return nbAvas; } Rdn(); Rdn( SchemaManager schemaManager ); Rdn( SchemaManager schemaManager, String rdn ); Rdn( String rdn ); Rdn( SchemaManager schemaManager, String upType, String upValue ); Rdn( String upType, String upValue ); Rdn( SchemaManager schemaManager, Ava... avas ); Rdn( Ava... avas ); Rdn( Rdn rdn ); Rdn( SchemaManager schemaManager, Rdn rdn ); Object getValue( String type ); Ava getAva( String type ); @Override Iterator<Ava> iterator(); @Override Rdn clone(); String getName(); String getNormName(); Ava getAva(); Ava getAva( int pos ); String getType(); String getNormType(); String getValue(); @Override boolean equals( Object that ); int size(); static Object unescapeValue( String value ); static String escapeValue( String value ); String getEscaped(); static String escapeValue( byte[] attrValue ); boolean isSchemaAware(); static boolean isValid( String dn ); static boolean isValid( SchemaManager schemaManager, String dn ); @Override int hashCode(); int serialize( byte[] buffer, int pos ); int deserialize( byte[] buffer, int pos ); @Override void writeExternal( ObjectOutput out ); @Override void readExternal( ObjectInput in ); @Override int compareTo( Rdn otherRdn ); @Override String toString(); static final Rdn EMPTY_RDN; static final int UNDEFINED; static final int SUPERIOR; static final int INFERIOR; static final int EQUAL; }### Answer: @Test public void testGetSize() throws LdapException { Rdn rdn = new Rdn( " a = b + b = f + g = h + c = d " ); assertEquals( 4, rdn.size() ); } @Test public void testGetSize0() { Rdn rdn = new Rdn(); assertEquals( 0, rdn.size() ); }
### Question: LdifRevertor { public static LdifEntry reverseAdd( Dn dn ) { LdifEntry entry = new LdifEntry(); entry.setChangeType( ChangeType.Delete ); entry.setDn( dn ); return entry; } private LdifRevertor(); static LdifEntry reverseAdd( Dn dn ); static LdifEntry reverseDel( Dn dn, Entry deletedEntry ); static LdifEntry reverseModify( Dn dn, List<Modification> forwardModifications, Entry modifiedEntry ); static LdifEntry reverseMove( Dn newSuperiorDn, Dn modifiedDn ); static List<LdifEntry> reverseRename( Entry entry, Rdn newRdn, boolean deleteOldRdn ); static List<LdifEntry> reverseMoveAndRename( Entry entry, Dn newSuperior, Rdn newRdn, boolean deleteOldRdn ); static final boolean DELETE_OLD_RDN; static final boolean KEEP_OLD_RDN; }### Answer: @Test public void testReverseAdd() throws LdapInvalidDnException { Dn dn = new Dn( "dc=apache, dc=com" ); LdifEntry reversed = LdifRevertor.reverseAdd( dn ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Delete, reversed.getChangeType() ); assertNull( reversed.getEntry() ); } @Test public void testReverseAddBase64DN() throws LdapException { Dn dn = new Dn( "dc=Emmanuel L\u00c9charny" ); LdifEntry reversed = LdifRevertor.reverseAdd( dn ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Delete, reversed.getChangeType() ); assertNull( reversed.getEntry() ); }
### Question: LdifRevertor { public static LdifEntry reverseDel( Dn dn, Entry deletedEntry ) throws LdapException { LdifEntry entry = new LdifEntry(); entry.setDn( dn ); entry.setChangeType( ChangeType.Add ); for ( Attribute attribute : deletedEntry ) { entry.addAttribute( attribute ); } return entry; } private LdifRevertor(); static LdifEntry reverseAdd( Dn dn ); static LdifEntry reverseDel( Dn dn, Entry deletedEntry ); static LdifEntry reverseModify( Dn dn, List<Modification> forwardModifications, Entry modifiedEntry ); static LdifEntry reverseMove( Dn newSuperiorDn, Dn modifiedDn ); static List<LdifEntry> reverseRename( Entry entry, Rdn newRdn, boolean deleteOldRdn ); static List<LdifEntry> reverseMoveAndRename( Entry entry, Dn newSuperior, Rdn newRdn, boolean deleteOldRdn ); static final boolean DELETE_OLD_RDN; static final boolean KEEP_OLD_RDN; }### Answer: @Test public void testReverseDel() throws LdapException { Dn dn = new Dn( "dc=apache, dc=com" ); Entry deletedEntry = new DefaultEntry( dn , "objectClass: top", "objectClass: person", "cn: test", "sn: apache", "dc: apache" ); LdifEntry reversed = LdifRevertor.reverseDel( dn, deletedEntry ); assertNotNull( reversed ); assertEquals( dn.getName(), reversed.getDn().getName() ); assertEquals( ChangeType.Add, reversed.getChangeType() ); assertNotNull( reversed.getEntry() ); assertEquals( deletedEntry, reversed.getEntry() ); }
### Question: OsgiUtils { public static Set<String> getAllBundleExports( FileFilter filter, Set<String> pkgs ) { if ( pkgs == null ) { pkgs = new HashSet<>(); } Set<File> candidates = getClasspathCandidates( filter ); for ( File candidate : candidates ) { String exports = getBundleExports( candidate ); if ( exports == null ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_17000_NO_EXPORT_FOUND, candidate ) ); } continue; } if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_17001_PROCESSING_EXPORTS, candidate, exports ) ); } splitIntoPackages( exports, pkgs ); } return pkgs; } private OsgiUtils(); static Set<String> getAllBundleExports( FileFilter filter, Set<String> pkgs ); static Set<String> splitIntoPackages( String exports, Set<String> pkgs ); static Set<File> getClasspathCandidates( FileFilter filter ); static String getBundleExports( File bundle ); }### Answer: @Test public void testGetAllBundleExports() { OsgiUtils.getAllBundleExports( null, null ); }
### Question: 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 ); }### Answer: @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 ); }
### Question: 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; }### Answer: @Test public void testSingleBitBitString() throws DecoderException { BitString bitString = new BitString( new byte[] { 0x07, ( byte ) 0x80 } ); assertEquals( true, bitString.getBit( 0 ) ); }
### Question: 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 ); }### Answer: @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() ); }
### Question: 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 ); }### Answer: @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() ); }
### Question: 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 ); }### Answer: @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() ); }
### Question: 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(); }### Answer: @Test public void testExtensible() { assertEquals( "(cn:caseExactMatch:=Fred Flintstone)", extensible( "cn", "Fred Flintstone" ) .setMatchingRule( "caseExactMatch" ).toString() ); }
### Question: 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(); }### Answer: @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() ); }
### Question: 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 ); }### Answer: @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() ); }
### Question: 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 ); }### Answer: @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() ); }
### Question: 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 ); }### Answer: @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" ) ); }
### Question: 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 ); }### Answer: @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" ) ); }
### Question: 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(); }### Answer: @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 ) ); }
### Question: 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(); }### Answer: @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() ); }
### Question: 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(); }### Answer: @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() ); }
### Question: 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(); }### Answer: @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() ); }
### Question: 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(); }### Answer: @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() ); }
### Question: 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(); }### Answer: @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() ); }
### Question: 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(); }### Answer: @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"); }
### Question: 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(); }### Answer: @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]); } }
### Question: ExecutionContext { public List<OutputDefinitionType> getOutputs() { return this.outputDefinitionTypes; } ExecutionContext(); ExecutionContext(OutputDefinitionType output); ExecutionContext(List< ? extends OutputDefinitionType> outputs); String getTempDirectoryPath(); List<OutputDefinitionType> getOutputs(); }### Answer: @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()); }
### Question: 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(); }### Answer: @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)); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @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); } }
### Question: 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); }### Answer: @Test public void init_isCalled() { spyViewModel.init(); verify(rightMeshConnector).setOnConnectSuccessListener(any()); verify(rightMeshConnector).setOnPeerChangedListener(any()); verify(rightMeshConnector).setOnDataReceiveListener(any()); verify(spyViewModel).init(); }
### Question: MainViewModel extends AndroidViewModel { void toRightMeshWalletActivty() { try { rmConnector.toRightMeshWalletActivty(); } catch (RightMeshException e) { Log.e(TAG, e.toString()); } } MainViewModel(@NonNull Application application); void setRightMeshConnector(RightMeshConnector rmConnector); }### Answer: @Test public void toRightMeshWalletActivty_isCalled() throws RightMeshException { spyViewModel.toRightMeshWalletActivty(); verify(rightMeshConnector).toRightMeshWalletActivty(); verify(spyViewModel).toRightMeshWalletActivty(); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @Test public void onCleared_isCalled() throws RightMeshException { spyViewModel.onCleared(); verify(rightMeshConnector).stop(); verify(spyViewModel).onCleared(); }
### Question: 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); }### Answer: @Test public void meshStateChanged_successEvent() throws RightMeshException, ClassNotFoundException { spyRightMeshConnector.meshStateChanged(meshId, MeshStateListener.SUCCESS); verify(androidMeshManager).bind(MESH_PORT); verify(spyRightMeshConnector).meshStateChanged(meshId, MeshStateListener.SUCCESS); }
### Question: 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); }### Answer: @Test public void stop_isCalled() throws RightMeshException.RightMeshServiceDisconnectedException { spyRightMeshConnector.stop(); verify(androidMeshManager).stop(); verify(spyRightMeshConnector).stop(); }
### Question: 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); }### Answer: @Test public void toRightMeshWalletActivty_isCalled() throws RightMeshException { spyRightMeshConnector.toRightMeshWalletActivty(); verify(androidMeshManager).showSettingsActivity(); verify(spyRightMeshConnector).toRightMeshWalletActivty(); }
### Question: 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); }### Answer: @Test public void sendDataReliable_isCalled() throws RightMeshException { String payload = "abc"; spyRightMeshConnector.sendDataReliable(meshId, payload); verify(spyRightMeshConnector).sendDataReliable(any(), eq(payload)); }
### Question: 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); }### Answer: @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])); } }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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 ); }
### Question: 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); }### Answer: @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")); }
### Question: 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(); }### Answer: @Test(expected = IllegalArgumentException.class) public void illegalFlagsShouldBeDetected() { ShellMode mode = ShellMode.from("--interactive --foo"); }
### Question: 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(); }### Answer: @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(); } }
### Question: 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); }### Answer: @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: }
### Question: 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; }### Answer: @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)); }
### Question: 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); }### Answer: @Test public void findSearchNode() throws Exception { }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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)); }
### Question: 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; }### Answer: @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()); ; }
### Question: 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; }### Answer: @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); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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()); ; }
### Question: 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; }### Answer: @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); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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()); ; }
### Question: 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); }### Answer: @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)); }
### Question: 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; }### Answer: @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()); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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()); ; }
### Question: 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; }### Answer: @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); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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()); ; }
### Question: 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; }### Answer: @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); }
### Question: 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); }### Answer: @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)); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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()); ; }
### Question: 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; }### Answer: @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); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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()); ; }
### Question: 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; }### Answer: @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); }
### Question: 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; }### Answer: @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)); }
### Question: DocumentFile { public String getInvariantStream() { return invariantStream; } private DocumentFile(); static org.oulipo.streams.Compiler<DocumentFile> compiler(); static Decompiler<DocumentFile> decompiler(); Map<Integer, String> get(); String getDocumentHash(); String getEncyptedInvariantStream(); String getGenesisHash(); String getHashPreviousBlock(); String getInvariantStream(); int getMajorVersion(); int getMinorVersion(); List<Op> getOps(); Overlay getOverlay(int overlayIndex); Map<Integer, Overlay> getOverlayPool(); Set<Overlay> getOverlays(Set<Integer> indicies); String getString(int stringPoolIndex); long getTimestamp(); boolean hasEncryptedInvariantStream(); boolean hasGenesisHash(); boolean hasHashPreviousBlock(); boolean hasInvariantStream(); int operationCount(); int overlayPoolSize(); int stringPoolSize(); static final byte[] MAGIC; }### Answer: @Test public void addText() throws Exception { DocumentFile.Builder builder = new DocumentFile.Builder("fakeHash"); builder.appendText("Xanadu"); builder.appendText("Green"); DocumentFile file = builder.build(); assertEquals("XanaduGreen", file.getInvariantStream()); }
### Question: PutInvariantMediaOp extends Op { @Override public int hashCode() { final int prime = 31; int result = super.hashCode(); result = prime * result + ripIndex; result = prime * result + (int) (to ^ (to >>> 32)); return result; } 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; }### Answer: @Test public void hashFalse() throws Exception { PutInvariantMediaOp op1 = new PutInvariantMediaOp(1, 2); PutInvariantMediaOp op2 = new PutInvariantMediaOp(2, 2); assertFalse(op1.hashCode() == op2.hashCode()); ; } @Test public void hashTrue() throws Exception { PutInvariantMediaOp op1 = new PutInvariantMediaOp(1, 2); PutInvariantMediaOp op2 = new PutInvariantMediaOp(1, 2); assertEquals(op1.hashCode(), op2.hashCode()); ; }
### Question: PutOverlayOp extends Op { @Override public byte[] encode() throws IOException { ByteArrayOutputStream os = new ByteArrayOutputStream(); try (DataOutputStream dos = new DataOutputStream(os)) { dos.writeByte(Op.PUT_OVERLAY); dos.writeLong(variantSpan.start); dos.writeLong(variantSpan.width); dos.writeInt(linkTypes.size()); for (Integer i : linkTypes) { dos.writeInt(i); } } os.flush(); return os.toByteArray(); } PutOverlayOp(DataInputStream dis); PutOverlayOp(VariantSpan variantSpan, Set<Integer> linkTypes); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); final Set<Integer> linkTypes; final VariantSpan variantSpan; }### Answer: @Test public void encodeDecode() throws Exception { PutOverlayOp op = new PutOverlayOp(new VariantSpan(100, 1), Sets.newSet(10, 5)); byte[] data = op.encode(); DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data)); assertEquals(Op.PUT_OVERLAY, dis.readByte()); PutOverlayOp decoded = new PutOverlayOp(dis); assertEquals(op, decoded); }
### Question: VariantSpan { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; VariantSpan other = (VariantSpan) obj; if (documentHash == null) { if (other.documentHash != null) return false; } else if (!documentHash.equals(other.documentHash)) return false; if (start != other.start) return false; if (width != other.width) return false; return true; } private VariantSpan(); VariantSpan(DataInputStream dis); VariantSpan(long start, long width); VariantSpan(long start, long width, String documentHash); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); public String documentHash; public long start; public long width; }### Answer: @Test public void homeNoMatch() throws Exception { assertFalse(new VariantSpan(1, 9, "fakeHash").equals(new VariantSpan(1, 10))); } @Test public void startNoMatch() throws MalformedSpanException { assertFalse(new VariantSpan(1, 10).equals(new VariantSpan(2, 10))); } @Test public void widthNoMatch() throws MalformedSpanException { assertFalse(new VariantSpan(1, 9).equals(new VariantSpan(1, 10))); }
### Question: InvariantSpan implements Invariant { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; InvariantSpan other = (InvariantSpan) obj; if (documentHash == null) { if (other.documentHash != null) return false; } else if (!documentHash.equals(other.documentHash)) return false; if (start != other.start) return false; if (width != other.width) return false; return true; } InvariantSpan(); InvariantSpan(long start, long width, String documentHash); @Override InvariantSpan copy(); @Override boolean equals(Object obj); String getDocumentHash(); long getStart(); @Override long getWidth(); @Override int hashCode(); boolean hashDocumentHash(); void setStart(long start); @Override void setWidth(long width); @Override StreamElementPartition<InvariantSpan> split(long leftPartitionWidth); @Override String toString(); }### Answer: @Test public void inequality() throws Exception { InvariantSpan s1 = new InvariantSpan(10, 60, "ted: InvariantSpan s2 = new InvariantSpan(10, 50, "ted: assertFalse(s1.equals(s2)); }
### Question: DocumentFile { public String getHashPreviousBlock() { return hashPreviousBlock; } private DocumentFile(); static org.oulipo.streams.Compiler<DocumentFile> compiler(); static Decompiler<DocumentFile> decompiler(); Map<Integer, String> get(); String getDocumentHash(); String getEncyptedInvariantStream(); String getGenesisHash(); String getHashPreviousBlock(); String getInvariantStream(); int getMajorVersion(); int getMinorVersion(); List<Op> getOps(); Overlay getOverlay(int overlayIndex); Map<Integer, Overlay> getOverlayPool(); Set<Overlay> getOverlays(Set<Integer> indicies); String getString(int stringPoolIndex); long getTimestamp(); boolean hasEncryptedInvariantStream(); boolean hasGenesisHash(); boolean hasHashPreviousBlock(); boolean hasInvariantStream(); int operationCount(); int overlayPoolSize(); int stringPoolSize(); static final byte[] MAGIC; }### Answer: @Test public void hashBlock() throws Exception { DocumentFile.Builder builder = new DocumentFile.Builder("fakeHash"); builder.previousHashBlock("sadasdsad"); DocumentFile file = builder.build(); assertEquals("sadasdsad", file.getHashPreviousBlock()); }
### Question: Node { public boolean isRoot() { return parent == null; } Node(long weight); Node(T value); long characterCount(); boolean isLeaf(); boolean isRightNode(); boolean isRoot(); Node<T> split(long leftPartitionWidth); @Override String toString(); public boolean isRed; public Node<T> left; public Node<T> parent; public Node<T> right; public String tag; final T value; public long weight; }### Answer: @Test public void root() throws Exception { assertTrue(new Node<InvariantSpan>(10).isRoot()); }
### Question: FileInvariantStream implements InvariantStream { @Override public InvariantSpan append(String text) throws IOException, MalformedSpanException { if (Strings.isNullOrEmpty(text)) { throw new MalformedSpanException("No text - span length is 0"); } FileLock lock = channel.lock(); try { InvariantSpan span = new InvariantSpan(channel.position() + 1, text.length(), documentHash); buffer.clear(); buffer.put(text.getBytes()); buffer.flip(); while (buffer.hasRemaining()) { channel.write(buffer); } channel.force(true); return span; } finally { lock.release(); } } FileInvariantStream(File file, File encryptedFile, String documentHash, Key key); @Override InvariantSpan append(String text); @Override String getText(InvariantSpan ispan); }### Answer: @Test public void streamLoadable() throws Exception { File file = new File("target/streams-junit/FileInvariantStream-" + System.currentTimeMillis() + ".txt"); InvariantStream stream = new FileInvariantStream(file, null, "fakeHash", null); stream.append("Hello"); stream.append("Xanadu"); }
### Question: ToggleOverlayOp extends Op { @Override public byte[] encode() throws IOException { ByteArrayOutputStream os = new ByteArrayOutputStream(); try (DataOutputStream dos = new DataOutputStream(os)) { dos.writeByte(Op.TOGGLE_OVERLAY); dos.writeLong(variantSpan.start); dos.writeLong(variantSpan.width); dos.writeInt(linkTypeIndex); } os.flush(); return os.toByteArray(); } ToggleOverlayOp(DataInputStream dis); ToggleOverlayOp(VariantSpan variantSpan, int linkTypeIndex); @Override byte[] encode(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final int linkTypeIndex; final VariantSpan variantSpan; }### Answer: @Test public void encodeDecode() throws Exception { ToggleOverlayOp op = new ToggleOverlayOp(new VariantSpan(100, 1), 10); byte[] data = op.encode(); DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data)); assertEquals(Op.TOGGLE_OVERLAY, dis.readByte()); ToggleOverlayOp decoded = new ToggleOverlayOp(dis); assertEquals(op, decoded); }
### Question: ApplyOverlayOp extends Op { @Override public byte[] encode() throws IOException { ByteArrayOutputStream os = new ByteArrayOutputStream(); try (DataOutputStream dos = new DataOutputStream(os)) { dos.writeByte(Op.APPLY_OVERLAY); dos.writeLong(variantSpan.start); dos.writeLong(variantSpan.width); dos.writeInt(linkTypes.size()); for (Integer i : linkTypes) { if (i < 0) { throw new IOException("Tumbler pool index must be 0 or greater: " + i); } dos.writeInt(i); } } os.flush(); return os.toByteArray(); } 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; }### Answer: @Test public void encode() throws Exception { ApplyOverlayOp op = new ApplyOverlayOp(new VariantSpan(1, 100), Sets.newHashSet(1, 10)); byte[] data = op.encode(); DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data)); assertEquals(Op.APPLY_OVERLAY, dis.read()); assertEquals(1, dis.readLong()); assertEquals(100, dis.readLong()); assertEquals(2, dis.readInt()); assertEquals(1, dis.readInt()); assertEquals(10, dis.readInt()); } @Test public void encodeDecode() throws Exception { ApplyOverlayOp op = new ApplyOverlayOp(new VariantSpan(1, 100), Sets.newHashSet(1, 10)); byte[] data = op.encode(); DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data)); assertEquals(Op.APPLY_OVERLAY, dis.readByte()); ApplyOverlayOp decoded = new ApplyOverlayOp(dis); assertEquals(op, decoded); }
### Question: RopeVariantStream implements VariantStream<T> { @Override public void copy(long characterPosition, VariantSpan variantSpan) throws MalformedSpanException, IOException { putElements(characterPosition, getStreamElements(variantSpan)); } RopeVariantStream(String documentHash); RopeVariantStream(String documentHash, Node<T> root); @Override void copy(long characterPosition, VariantSpan variantSpan); @Override void delete(VariantSpan variantSpan); @Override String getDocumentHash(); @Override List<T> getStreamElements(); @Override List<T> getStreamElements(VariantSpan variantSpan); @Override List<VariantSpan> getVariantSpans(InvariantSpan targetSpan); @Override T index(long characterPosition); @Override void move(long to, VariantSpan v1); @Override void put(long characterPosition, T val); @Override void rebalance(); void save(OutputStream os); @Override void swap(VariantSpan v1, VariantSpan v2); @Override void toggleOverlay(VariantSpan variantSpan, Overlay linkType); }### Answer: @Test public void copy() throws Exception { VariantStream<InvariantSpan> stream = new RopeVariantStream<>(documentHash, getA()); stream.copy(2, new VariantSpan(12, 3)); List<InvariantSpan> spans = stream.getStreamElements(); assertEquals(new InvariantSpan(100, 1, documentHash), spans.get(0)); assertEquals(new InvariantSpan(301, 3, documentHash), spans.get(1)); assertEquals(new InvariantSpan(200, 3, documentHash), spans.get(3)); assertEquals(new InvariantSpan(250, 2, documentHash), spans.get(4)); assertEquals(new InvariantSpan(300, 4, documentHash), spans.get(5)); assertEquals(new InvariantSpan(350, 1, documentHash), spans.get(6)); assertEquals(new InvariantSpan(360, 6, documentHash), spans.get(7)); }
### Question: RopeVariantStream implements VariantStream<T> { @Override public void delete(VariantSpan variantSpan) throws MalformedSpanException { if (variantSpan == null) { throw new MalformedSpanException("Variant span is null for delete operation"); } deleteRange(variantSpan); } RopeVariantStream(String documentHash); RopeVariantStream(String documentHash, Node<T> root); @Override void copy(long characterPosition, VariantSpan variantSpan); @Override void delete(VariantSpan variantSpan); @Override String getDocumentHash(); @Override List<T> getStreamElements(); @Override List<T> getStreamElements(VariantSpan variantSpan); @Override List<VariantSpan> getVariantSpans(InvariantSpan targetSpan); @Override T index(long characterPosition); @Override void move(long to, VariantSpan v1); @Override void put(long characterPosition, T val); @Override void rebalance(); void save(OutputStream os); @Override void swap(VariantSpan v1, VariantSpan v2); @Override void toggleOverlay(VariantSpan variantSpan, Overlay linkType); }### Answer: @Test public void delete() throws Exception { VariantStream<InvariantSpan> stream = new RopeVariantStream<>(documentHash, getA()); stream.delete(new VariantSpan(12, 4)); List<InvariantSpan> spans = stream.getStreamElements(); assertEquals(new InvariantSpan(100, 6, documentHash), spans.get(0)); assertEquals(new InvariantSpan(200, 3, documentHash), spans.get(1)); assertEquals(new InvariantSpan(250, 2, documentHash), spans.get(2)); assertEquals(new InvariantSpan(350, 1, documentHash), spans.get(3)); assertEquals(new InvariantSpan(360, 6, documentHash), spans.get(4)); assertEquals(5, spans.size()); }
### Question: RopeVariantStream implements VariantStream<T> { @Override public T index(long characterPosition) { if (root == null) { throw new IllegalStateException("Stream is empty"); } return RopeUtils.index(characterPosition, root, 0).node.value; } RopeVariantStream(String documentHash); RopeVariantStream(String documentHash, Node<T> root); @Override void copy(long characterPosition, VariantSpan variantSpan); @Override void delete(VariantSpan variantSpan); @Override String getDocumentHash(); @Override List<T> getStreamElements(); @Override List<T> getStreamElements(VariantSpan variantSpan); @Override List<VariantSpan> getVariantSpans(InvariantSpan targetSpan); @Override T index(long characterPosition); @Override void move(long to, VariantSpan v1); @Override void put(long characterPosition, T val); @Override void rebalance(); void save(OutputStream os); @Override void swap(VariantSpan v1, VariantSpan v2); @Override void toggleOverlay(VariantSpan variantSpan, Overlay linkType); }### Answer: @Test public void index() throws Exception { VariantStream<InvariantSpan> stream = new RopeVariantStream<>(documentHash, getA()); InvariantSpan span = stream.index(12); assertEquals(new InvariantSpan(300, 4, documentHash), span); } @Test public void index11() throws Exception { VariantStream<InvariantSpan> stream = new RopeVariantStream<>(documentHash, getA()); InvariantSpan span = stream.index(11); assertEquals(new InvariantSpan(250, 2, documentHash), span); span = stream.index(10); assertEquals(new InvariantSpan(250, 2, documentHash), span); } @Test(expected = IndexOutOfBoundsException.class) public void indexNull() throws Exception { VariantStream<InvariantSpan> stream = new RopeVariantStream<>(documentHash, getA()); InvariantSpan span = stream.index(100); assertNull(span); }
### Question: SlotKeySerDes { protected static Granularity granularityFromSlotKey(String s) { String field = s.split(",", -1)[0]; for (Granularity g : Granularity.granularities()) if (g.name().startsWith(field)) return g; return null; } static SlotKey deserialize(String stateStr); String serialize(SlotKey slotKey); String serialize(Granularity gran, int slot, int shard); }### Answer: @Test public void testGranularityFromSlotKey() { Granularity expected = Granularity.MIN_5; Granularity myGranularity = SlotKeySerDes.granularityFromSlotKey(SlotKey.of(expected, 1, 1).toString()); Assert.assertNotNull(myGranularity); Assert.assertEquals(myGranularity, expected); myGranularity = SlotKeySerDes.granularityFromSlotKey("FULL"); Assert.assertNull(myGranularity); }
### Question: Emitter { public Emitter once(final String event, final Listener<T> fn) { Listener on = new Listener<T>() { @Override public void call(T... args) { Emitter.this.off(event, this); fn.call(args); } }; this.onceCallbacks.put(fn, on); this.on(event, on); return this; } Emitter on(String event, Listener fn); Emitter once(final String event, final Listener<T> fn); Emitter off(); Emitter off(String event); Emitter off(String event, Listener fn); Future emit(String event, T... args); List<Listener> listeners(String event); boolean hasListeners(String event); }### Answer: @Test public void testOnce() { emitter.once(testEventName, listener); emitter.emit(testEventName, new RollupEvent(null, null, "payload1", "gran", 0)); Assert.assertEquals(store.size(), 1); store.clear(); emitter.emit(testEventName, new RollupEvent(null, null, "payload1", "gran", 0)); Assert.assertEquals(store.size(), 0); }
### Question: Emitter { public Emitter on(String event, Listener fn) { ConcurrentLinkedQueue<Listener> callbacks = this.callbacks.get(event); if (callbacks == null) { callbacks = new ConcurrentLinkedQueue<Listener>(); ConcurrentLinkedQueue<Listener> _callbacks = this.callbacks.putIfAbsent(event, callbacks); if (_callbacks != null) { callbacks = _callbacks; } } callbacks.add(fn); return this; } Emitter on(String event, Listener fn); Emitter once(final String event, final Listener<T> fn); Emitter off(); Emitter off(String event); Emitter off(String event, Listener fn); Future emit(String event, T... args); List<Listener> listeners(String event); boolean hasListeners(String event); }### Answer: @Test public void testOn() { emitter.on(testEventName, listener); Assert.assertEquals(0, store.size()); emitter.emit(testEventName, event1); Assert.assertEquals(1, store.size()); Assert.assertSame(event1, store.get(0)); emitter.emit(testEventName, event2); Assert.assertEquals(2, store.size()); Assert.assertSame(event1, store.get(0)); Assert.assertSame(event2, store.get(1)); }
### Question: RollupEvent { public Locator getLocator() { return locator; } RollupEvent(Locator loc, Rollup rollup, String unit, String gran, long ts); Rollup getRollup(); Locator getLocator(); String getUnit(); String getGranularityName(); long getTimestamp(); void setUnit(String unit); }### Answer: @Test public void locatorGetsSetInConstructor() { Assert.assertSame(locator, event.getLocator()); }
### Question: RollupEvent { public Rollup getRollup() { return rollup; } RollupEvent(Locator loc, Rollup rollup, String unit, String gran, long ts); Rollup getRollup(); Locator getLocator(); String getUnit(); String getGranularityName(); long getTimestamp(); void setUnit(String unit); }### Answer: @Test public void rollupGetsSetInConstructor() { Assert.assertSame(rollup, event.getRollup()); }