Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: ShortString implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof ShortString) && (Arrays.equals(content, ((ShortString) obj).content)); } @SuppressFBWarnings("EI_EXPOSE_REP2") ShortString(long length, byte[] content); long getSize(); void write(ByteBuf buf); static ShortString parse(ByteBuf buf); static ShortString parseString(String data); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); boolean isEmpty(); }### Answer: @Test public void testEquals() throws Exception { ShortString other = ShortString.parseString("different string"); ShortString similar = ShortString.parseString(DEFAULT_DATA_STRING); Assert.assertTrue(DEFAULT_TEST_OBJECT.equals(DEFAULT_TEST_OBJECT), "equals() should return true for similar objects"); Assert.assertTrue(DEFAULT_TEST_OBJECT.equals(similar), "equals() should return true for similar objects"); Assert.assertFalse(DEFAULT_TEST_OBJECT.equals(other), "equals() should return false for different objects"); Assert.assertFalse(DEFAULT_TEST_OBJECT.equals(DEFAULT_DATA_STRING), "equals() should return false for different objects"); }
### Question: ShortString implements EncodableData { @Override public int hashCode() { return Arrays.hashCode(content); } @SuppressFBWarnings("EI_EXPOSE_REP2") ShortString(long length, byte[] content); long getSize(); void write(ByteBuf buf); static ShortString parse(ByteBuf buf); static ShortString parseString(String data); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); boolean isEmpty(); }### Answer: @Test public void testHashCode() throws Exception { ShortString similar = ShortString.parseString(DEFAULT_DATA_STRING); Assert.assertEquals(similar.hashCode(), DEFAULT_TEST_OBJECT.hashCode(), "Hashcode should match for similar " + "data"); }
### Question: ShortShortInt implements EncodableData { @Override public long getSize() { return 1L; } private ShortShortInt(byte value); @Override long getSize(); @Override void write(ByteBuf buf); static ShortShortInt parse(ByteBuf buf); static ShortShortInt parse(byte value); byte getByte(); static ShortShortInt parseByte(byte value); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testGetSize() { Assert.assertEquals(TEST_OBJECT.getSize(), 1, "Size of short-short-int should be 1"); }
### Question: ShortShortInt implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof ShortShortInt) && (value == ((ShortShortInt) obj).value); } private ShortShortInt(byte value); @Override long getSize(); @Override void write(ByteBuf buf); static ShortShortInt parse(ByteBuf buf); static ShortShortInt parse(byte value); byte getByte(); static ShortShortInt parseByte(byte value); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testEquals() { ShortShortInt other = ShortShortInt.parse((byte) 3); ShortShortInt similar = ShortShortInt.parse(DATA_VALUE); Assert.assertTrue(TEST_OBJECT.equals(TEST_OBJECT), "equals() should return true for similar objects"); Assert.assertTrue(TEST_OBJECT.equals(similar), "equals() should return true for similar objects"); Assert.assertFalse(TEST_OBJECT.equals(other), "equals() should return false for different objects"); Assert.assertFalse(TEST_OBJECT.equals(DATA_VALUE), "equals() should return false for different objects"); }
### Question: ShortShortInt implements EncodableData { @Override public int hashCode() { return (int) value; } private ShortShortInt(byte value); @Override long getSize(); @Override void write(ByteBuf buf); static ShortShortInt parse(ByteBuf buf); static ShortShortInt parse(byte value); byte getByte(); static ShortShortInt parseByte(byte value); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testHashCode() { ShortShortInt similar = ShortShortInt.parse(DATA_VALUE); Assert.assertEquals(similar.hashCode(), TEST_OBJECT.hashCode(), "Hashcode should match for similar data"); }
### Question: ShortShortInt implements EncodableData { public static ShortShortInt parse(ByteBuf buf) { return new ShortShortInt(buf.readByte()); } private ShortShortInt(byte value); @Override long getSize(); @Override void write(ByteBuf buf); static ShortShortInt parse(ByteBuf buf); static ShortShortInt parse(byte value); byte getByte(); static ShortShortInt parseByte(byte value); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testParse() { ByteBuf buf = Unpooled.buffer(1); TEST_OBJECT.write(buf); ShortShortInt parsedObject = ShortShortInt.parse(buf); Assert.assertEquals(parsedObject, TEST_OBJECT, "Encoding and decoding should result in the same object"); }
### Question: ExchangeRegistry { void declareExchange(String exchangeName, String type, boolean passive, boolean durable) throws ValidationException, BrokerException { if (exchangeName.isEmpty()) { throw new ValidationException("Exchange name cannot be empty."); } Exchange exchange = exchangeMap.get(exchangeName); if (passive) { if (Objects.isNull(exchange)) { throw new ValidationException("Exchange [ " + exchangeName + " ] doesn't exists. Passive parameter " + "is set, hence not creating the exchange."); } } else { createExchange(exchangeName, Exchange.Type.from(type), durable); } } ExchangeRegistry(ExchangeDao exchangeDao, BindingDao bindingDao); void createExchange(String exchangeName, Exchange.Type type, boolean durable); Exchange getDefaultExchange(); void retrieveFromStore(QueueRegistry queueRegistry); Collection<Exchange> getAllExchanges(); static final String DEFAULT_DEAD_LETTER_EXCHANGE; }### Answer: @Test(description = "Test frequently used exchanges types are defined", expectedExceptions = ValidationException.class) public void testDeclareExchangesWithEmptyName() throws ValidationException, BrokerException { exchangeRegistry.declareExchange("", DIRECT.toString(), false, true); } @Test(dataProvider = "exchangeNames", description = "declare a existing exchange with passive parameter set") public void testDeclareExistingExchangesWithPassiveParameter(String exchangeName) throws BrokerException, ValidationException { exchangeRegistry.declareExchange(exchangeName, null, true, true); exchangeRegistry.declareExchange(exchangeName, "", true, false); exchangeRegistry.declareExchange(exchangeName, DIRECT.toString(), true, true); } @Test(description = "Declare a non-existing exchange with passive parameter set", expectedExceptions = ValidationException.class) public void testDeclareNonExistingExchangesWithPassiveParameter() throws BrokerException, ValidationException { exchangeRegistry.declareExchange(NON_EXISTING_EXCHANGE, DIRECT.toString(), true, false); Assert.fail("Declaring a non existing exchange with passive parameter set should throw a error."); }
### Question: ShortInt implements EncodableData { @Override public long getSize() { return 2L; } private ShortInt(short value); @Override long getSize(); @Override void write(ByteBuf buf); short getShort(); @Override int hashCode(); @Override boolean equals(Object obj); static ShortInt parse(ByteBuf buf); static ShortInt parse(short value); @Override String toString(); }### Answer: @Test public void testGetSize() { Assert.assertEquals(TEST_OBJECT.getSize(), 2, "Size of short-int should be 2"); }
### Question: ShortInt implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof ShortInt) && (value == ((ShortInt) obj).value); } private ShortInt(short value); @Override long getSize(); @Override void write(ByteBuf buf); short getShort(); @Override int hashCode(); @Override boolean equals(Object obj); static ShortInt parse(ByteBuf buf); static ShortInt parse(short value); @Override String toString(); }### Answer: @Test public void testEquals() { ShortInt other = ShortInt.parse((short) 3); ShortInt similar = ShortInt.parse(DATA_VALUE); Assert.assertTrue(TEST_OBJECT.equals(TEST_OBJECT), "equals() should return true for similar objects"); Assert.assertTrue(TEST_OBJECT.equals(similar), "equals() should return true for similar objects"); Assert.assertFalse(TEST_OBJECT.equals(other), "equals() should return false for different objects"); Assert.assertFalse(TEST_OBJECT.equals(DATA_VALUE), "equals() should return false for different objects"); }
### Question: ShortInt implements EncodableData { @Override public int hashCode() { return value; } private ShortInt(short value); @Override long getSize(); @Override void write(ByteBuf buf); short getShort(); @Override int hashCode(); @Override boolean equals(Object obj); static ShortInt parse(ByteBuf buf); static ShortInt parse(short value); @Override String toString(); }### Answer: @Test public void testHashCode() { ShortInt similar = ShortInt.parse(DATA_VALUE); Assert.assertEquals(similar.hashCode(), TEST_OBJECT.hashCode(), "Hashcode should match for similar data"); }
### Question: ShortInt implements EncodableData { public static ShortInt parse(ByteBuf buf) { return new ShortInt(buf.readShort()); } private ShortInt(short value); @Override long getSize(); @Override void write(ByteBuf buf); short getShort(); @Override int hashCode(); @Override boolean equals(Object obj); static ShortInt parse(ByteBuf buf); static ShortInt parse(short value); @Override String toString(); }### Answer: @Test public void testParse() { ByteBuf buf = Unpooled.buffer(1); TEST_OBJECT.write(buf); ShortInt parsedObject = ShortInt.parse(buf); Assert.assertEquals(parsedObject, TEST_OBJECT, "Encoding and decoding should result in the same object"); }
### Question: LongInt implements EncodableData { @Override public long getSize() { return 4L; } private LongInt(int value); @Override long getSize(); @Override void write(ByteBuf buf); int getInt(); @Override int hashCode(); @Override boolean equals(Object obj); static LongInt parse(ByteBuf buf); static LongInt parse(int value); @Override String toString(); }### Answer: @Test public void testGetSize() { Assert.assertEquals(TEST_OBJECT.getSize(), 4, "Size of long-int should be 4"); }
### Question: LongInt implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof LongInt) && (value == ((LongInt) obj).value); } private LongInt(int value); @Override long getSize(); @Override void write(ByteBuf buf); int getInt(); @Override int hashCode(); @Override boolean equals(Object obj); static LongInt parse(ByteBuf buf); static LongInt parse(int value); @Override String toString(); }### Answer: @Test public void testEquals() { LongInt other = LongInt.parse(3); LongInt similar = LongInt.parse(DATA_VALUE); Assert.assertTrue(TEST_OBJECT.equals(TEST_OBJECT), "equals() should return true for similar objects"); Assert.assertTrue(TEST_OBJECT.equals(similar), "equals() should return true for similar objects"); Assert.assertFalse(TEST_OBJECT.equals(other), "equals() should return false for different objects"); Assert.assertFalse(TEST_OBJECT.equals(DATA_VALUE), "equals() should return false for different objects"); }
### Question: LongInt implements EncodableData { @Override public int hashCode() { return value; } private LongInt(int value); @Override long getSize(); @Override void write(ByteBuf buf); int getInt(); @Override int hashCode(); @Override boolean equals(Object obj); static LongInt parse(ByteBuf buf); static LongInt parse(int value); @Override String toString(); }### Answer: @Test public void testHashCode() { LongInt similar = LongInt.parse(DATA_VALUE); Assert.assertEquals(similar.hashCode(), TEST_OBJECT.hashCode(), "Hashcode should match for similar data"); }
### Question: LongInt implements EncodableData { public static LongInt parse(ByteBuf buf) { return new LongInt(buf.readInt()); } private LongInt(int value); @Override long getSize(); @Override void write(ByteBuf buf); int getInt(); @Override int hashCode(); @Override boolean equals(Object obj); static LongInt parse(ByteBuf buf); static LongInt parse(int value); @Override String toString(); }### Answer: @Test public void testParse() { ByteBuf buf = Unpooled.buffer(4); TEST_OBJECT.write(buf); LongInt parsedObject = LongInt.parse(buf); Assert.assertEquals(parsedObject, TEST_OBJECT, "Encoding and decoding should result in the same object"); }
### Question: Float implements EncodableData { @Override public long getSize() { return 4L; } private Float(float value); @Override long getSize(); @Override void write(ByteBuf buf); static Float parse(float value); static Float parse(ByteBuf buf); float getFloat(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testGetSize() { Assert.assertEquals(TEST_OBJECT.getSize(), 4, "Size of float should be 4"); }
### Question: Float implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof Float) && (value == ((Float) obj).value); } private Float(float value); @Override long getSize(); @Override void write(ByteBuf buf); static Float parse(float value); static Float parse(ByteBuf buf); float getFloat(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testEquals() { Float other = Float.parse(3.0f); Float similar = Float.parse(DATA_VALUE); Assert.assertTrue(TEST_OBJECT.equals(TEST_OBJECT), "equals() should return true for similar objects"); Assert.assertTrue(TEST_OBJECT.equals(similar), "equals() should return true for similar objects"); Assert.assertFalse(TEST_OBJECT.equals(other), "equals() should return false for different objects"); Assert.assertFalse(TEST_OBJECT.equals(DATA_VALUE), "equals() should return false for different objects"); }
### Question: Float implements EncodableData { @Override public int hashCode() { return Objects.hashCode(value); } private Float(float value); @Override long getSize(); @Override void write(ByteBuf buf); static Float parse(float value); static Float parse(ByteBuf buf); float getFloat(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testHashCode() { Float similar = Float.parse(DATA_VALUE); Assert.assertEquals(similar.hashCode(), TEST_OBJECT.hashCode(), "Hashcode should match for similar data"); }
### Question: Float implements EncodableData { public static Float parse(float value) { return new Float(value); } private Float(float value); @Override long getSize(); @Override void write(ByteBuf buf); static Float parse(float value); static Float parse(ByteBuf buf); float getFloat(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testParse() { ByteBuf buf = Unpooled.buffer(8); TEST_OBJECT.write(buf); Float parsedObject = Float.parse(buf); Assert.assertEquals(parsedObject, TEST_OBJECT, "Encoding and decoding should result in the same object"); }
### Question: Double implements EncodableData { @Override public long getSize() { return 8L; } private Double(double value); @Override long getSize(); @Override void write(ByteBuf buf); static Double parse(double value); static Double parse(ByteBuf buf); double getDouble(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testGetSize() { Assert.assertEquals(TEST_OBJECT.getSize(), 8, "Size of double should be 8"); }
### Question: Double implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof Double) && (value == ((Double) obj).value); } private Double(double value); @Override long getSize(); @Override void write(ByteBuf buf); static Double parse(double value); static Double parse(ByteBuf buf); double getDouble(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testEquals() { Double other = Double.parse(3.0d); Double similar = Double.parse(DATA_VALUE); Assert.assertTrue(TEST_OBJECT.equals(TEST_OBJECT), "equals() should return true for similar objects"); Assert.assertTrue(TEST_OBJECT.equals(similar), "equals() should return true for similar objects"); Assert.assertFalse(TEST_OBJECT.equals(other), "equals() should return false for different objects"); Assert.assertFalse(TEST_OBJECT.equals(DATA_VALUE), "equals() should return false for different objects"); }
### Question: Double implements EncodableData { @Override public int hashCode() { return Objects.hashCode(value); } private Double(double value); @Override long getSize(); @Override void write(ByteBuf buf); static Double parse(double value); static Double parse(ByteBuf buf); double getDouble(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testHashCode() { Double similar = Double.parse(DATA_VALUE); Assert.assertEquals(similar.hashCode(), TEST_OBJECT.hashCode(), "Hashcode should match for similar data"); }
### Question: Double implements EncodableData { public static Double parse(double value) { return new Double(value); } private Double(double value); @Override long getSize(); @Override void write(ByteBuf buf); static Double parse(double value); static Double parse(ByteBuf buf); double getDouble(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testParse() { ByteBuf buf = Unpooled.buffer(8); TEST_OBJECT.write(buf); Double parsedObject = Double.parse(buf); Assert.assertEquals(parsedObject, TEST_OBJECT, "Encoding and decoding should result in the same object"); }
### Question: Decimal implements EncodableData { @Override public long getSize() { return 1L + 4L; } private Decimal(BigDecimal value); @Override long getSize(); @Override void write(ByteBuf buf); static Decimal parse(BigDecimal value); static Decimal parse(ByteBuf buf); BigDecimal getDecimal(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testGetSize() { Assert.assertEquals(TEST_OBJECT.getSize(), 5, "Size of Decimal should be 5"); }
### Question: Decimal implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof Decimal) && (value.equals(((Decimal) obj).value)); } private Decimal(BigDecimal value); @Override long getSize(); @Override void write(ByteBuf buf); static Decimal parse(BigDecimal value); static Decimal parse(ByteBuf buf); BigDecimal getDecimal(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testEquals() { Decimal other = Decimal.parse(new BigDecimal(3.0d)); Decimal similar = Decimal.parse(DATA_VALUE); Assert.assertTrue(TEST_OBJECT.equals(TEST_OBJECT), "equals() should return true for similar objects"); Assert.assertTrue(TEST_OBJECT.equals(similar), "equals() should return true for similar objects"); Assert.assertFalse(TEST_OBJECT.equals(other), "equals() should return false for different objects"); Assert.assertFalse(TEST_OBJECT.equals(DATA_VALUE), "equals() should return false for different objects"); }
### Question: Decimal implements EncodableData { @Override public int hashCode() { return Objects.hashCode(value); } private Decimal(BigDecimal value); @Override long getSize(); @Override void write(ByteBuf buf); static Decimal parse(BigDecimal value); static Decimal parse(ByteBuf buf); BigDecimal getDecimal(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testHashCode() { Decimal similar = Decimal.parse(DATA_VALUE); Assert.assertEquals(similar.hashCode(), TEST_OBJECT.hashCode(), "Hashcode should match for similar data"); }
### Question: Decimal implements EncodableData { public static Decimal parse(BigDecimal value) { return new Decimal(value); } private Decimal(BigDecimal value); @Override long getSize(); @Override void write(ByteBuf buf); static Decimal parse(BigDecimal value); static Decimal parse(ByteBuf buf); BigDecimal getDecimal(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testParse() { ByteBuf buf = Unpooled.buffer(8); TEST_OBJECT.write(buf); Decimal parsedObject = Decimal.parse(buf); Assert.assertEquals(parsedObject, TEST_OBJECT, "Encoding and decoding should result in the same object"); }
### Question: FieldTable implements EncodableData { public long getSize() { long tableEntrySize = 0L; for (Map.Entry<ShortString, FieldValue> fieldEntry : properties.entrySet()) { tableEntrySize = tableEntrySize + fieldEntry.getKey().getSize() + fieldEntry.getValue().getSize(); } size = tableEntrySize; return 4L + tableEntrySize; } FieldTable(Map<ShortString, FieldValue> properties); FieldTable(); long getSize(); void write(ByteBuf buf); void add(ShortString propertyName, FieldValue value); @Override int hashCode(); @Override boolean equals(Object obj); static FieldTable parse(ByteBuf buf); FieldValue getValue(ShortString propertyName); static final FieldTable EMPTY_TABLE; }### Answer: @Test public void testGetSize() throws Exception { Assert.assertEquals(testFieldTable.getSize(), 4 + testKey.getSize() + testValue.getSize(), "Empty table should have size 4"); }
### Question: FieldTable implements EncodableData { public static FieldTable parse(ByteBuf buf) throws Exception { long size = buf.readUnsignedInt(); long readBytes = 0L; Map<ShortString, FieldValue> properties = new HashMap<>(); while (readBytes < size) { ShortString key = ShortString.parse(buf); FieldValue value = FieldValue.parse(buf); properties.put(key, value); readBytes = readBytes + key.getSize() + value.getSize(); } return new FieldTable(properties); } FieldTable(Map<ShortString, FieldValue> properties); FieldTable(); long getSize(); void write(ByteBuf buf); void add(ShortString propertyName, FieldValue value); @Override int hashCode(); @Override boolean equals(Object obj); static FieldTable parse(ByteBuf buf); FieldValue getValue(ShortString propertyName); static final FieldTable EMPTY_TABLE; }### Answer: @Test public void testParse() throws Exception { ByteBuf buf = Unpooled.buffer((int) testFieldTable.getSize()); testFieldTable.write(buf); FieldTable parsedTable = FieldTable.parse(buf); Assert.assertEquals(parsedTable, testFieldTable, "Encoding and decoding should result in the same object"); }
### Question: FieldTable implements EncodableData { @Override public int hashCode() { return properties.hashCode(); } FieldTable(Map<ShortString, FieldValue> properties); FieldTable(); long getSize(); void write(ByteBuf buf); void add(ShortString propertyName, FieldValue value); @Override int hashCode(); @Override boolean equals(Object obj); static FieldTable parse(ByteBuf buf); FieldValue getValue(ShortString propertyName); static final FieldTable EMPTY_TABLE; }### Answer: @Test public void testHashCode() throws Exception { Map<ShortString, FieldValue> properties = new HashMap<>(); properties.put(testKey, testValue); FieldTable similar = new FieldTable(properties); Assert.assertEquals(similar.hashCode(), testFieldTable.hashCode(), "Hashcode should match for similar " + "data"); }
### Question: FieldTable implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof FieldTable) && properties.equals(((FieldTable) obj).properties); } FieldTable(Map<ShortString, FieldValue> properties); FieldTable(); long getSize(); void write(ByteBuf buf); void add(ShortString propertyName, FieldValue value); @Override int hashCode(); @Override boolean equals(Object obj); static FieldTable parse(ByteBuf buf); FieldValue getValue(ShortString propertyName); static final FieldTable EMPTY_TABLE; }### Answer: @Test public void testEquals() throws Exception { FieldValue otherType = FieldValue.parseLongString("Test"); Map<ShortString, FieldValue> properties = new HashMap<>(); properties.put(testKey, testValue); FieldTable similar = new FieldTable(properties); Assert.assertTrue(testFieldTable.equals(testFieldTable), "equals() should return true for similar objects"); Assert.assertTrue(testFieldTable.equals(similar), "equals() should return true for similar objects"); Assert.assertFalse(testFieldTable.equals(new FieldTable(Collections.emptyMap())), "equals() should return false for different objects"); Assert.assertFalse(testFieldTable.equals(otherType), "equals() should return false for different objects"); }
### Question: ShortUint implements EncodableData { @Override public long getSize() { return 2L; } private ShortUint(int value); @Override long getSize(); @Override void write(ByteBuf buf); int getShort(); @Override int hashCode(); @Override boolean equals(Object obj); static ShortUint parse(ByteBuf buf); static ShortUint parse(int value); @Override String toString(); }### Answer: @Test public void testGetSize() { Assert.assertEquals(TEST_OBJECT.getSize(), 2, "Size of short-uint should be 2"); }
### Question: ShortUint implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof ShortUint) && (value == ((ShortUint) obj).value); } private ShortUint(int value); @Override long getSize(); @Override void write(ByteBuf buf); int getShort(); @Override int hashCode(); @Override boolean equals(Object obj); static ShortUint parse(ByteBuf buf); static ShortUint parse(int value); @Override String toString(); }### Answer: @Test public void testEquals() { ShortUint other = ShortUint.parse(3); ShortUint similar = ShortUint.parse(DATA_VALUE); Assert.assertTrue(TEST_OBJECT.equals(TEST_OBJECT), "equals() should return true for similar objects"); Assert.assertTrue(TEST_OBJECT.equals(similar), "equals() should return true for similar objects"); Assert.assertFalse(TEST_OBJECT.equals(other), "equals() should return false for different objects"); Assert.assertFalse(TEST_OBJECT.equals(DATA_VALUE), "equals() should return false for different objects"); }
### Question: ShortUint implements EncodableData { @Override public int hashCode() { return value; } private ShortUint(int value); @Override long getSize(); @Override void write(ByteBuf buf); int getShort(); @Override int hashCode(); @Override boolean equals(Object obj); static ShortUint parse(ByteBuf buf); static ShortUint parse(int value); @Override String toString(); }### Answer: @Test public void testHashCode() { ShortUint similar = ShortUint.parse(DATA_VALUE); Assert.assertEquals(similar.hashCode(), TEST_OBJECT.hashCode(), "Hashcode should match for similar data"); }
### Question: ShortUint implements EncodableData { public static ShortUint parse(ByteBuf buf) { return new ShortUint(buf.readUnsignedShort()); } private ShortUint(int value); @Override long getSize(); @Override void write(ByteBuf buf); int getShort(); @Override int hashCode(); @Override boolean equals(Object obj); static ShortUint parse(ByteBuf buf); static ShortUint parse(int value); @Override String toString(); }### Answer: @Test public void testParse() { ByteBuf buf = Unpooled.buffer(1); TEST_OBJECT.write(buf); ShortUint parsedObject = ShortUint.parse(buf); Assert.assertEquals(parsedObject, TEST_OBJECT, "Encoding and decoding should result in the same object"); }
### Question: FieldValue implements EncodableData { public long getSize() { return 1 + value.getSize(); } private FieldValue(Type type, EncodableData value); long getSize(); long getValueSize(); @Override void write(ByteBuf buf); static FieldValue parse(ByteBuf buf); Type getType(); EncodableData getValue(); static FieldValue parseLongInt(int value); static FieldValue parseLongInt(LongInt value); static FieldValue parseLongString(String value); static FieldValue parseLongString(LongString value); static FieldValue parseShortString(String value); static FieldValue parseShortString(ShortString value); static FieldValue parseBoolean(io.ballerina.messaging.broker.common.data.types.Boolean amqpBoolean); static FieldValue parseShortShortInt(byte value); static FieldValue parseShortShortInt(ShortShortInt value); static FieldValue parseLongLongInt(long value); static FieldValue parseLongLongInt(LongLongInt value); static FieldValue parseFieldTable(FieldTable fieldTable); static FieldValue parseShortInt(ShortInt value); static FieldValue parseFloat(Float value); static FieldValue parseDouble(Double value); static FieldValue parseDecimal(Decimal value); static FieldValue parseShortShortUint(ShortShortUint value); static FieldValue parseShortUint(ShortUint value); static FieldValue parseLongUint(LongUint value); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testGetSize() throws Exception { Assert.assertEquals(TEST_OBJECT.getSize(), 1 + 4); }
### Question: FieldValue implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof FieldValue) && type == ((FieldValue) obj).type && (value.equals(((FieldValue) obj).value)); } private FieldValue(Type type, EncodableData value); long getSize(); long getValueSize(); @Override void write(ByteBuf buf); static FieldValue parse(ByteBuf buf); Type getType(); EncodableData getValue(); static FieldValue parseLongInt(int value); static FieldValue parseLongInt(LongInt value); static FieldValue parseLongString(String value); static FieldValue parseLongString(LongString value); static FieldValue parseShortString(String value); static FieldValue parseShortString(ShortString value); static FieldValue parseBoolean(io.ballerina.messaging.broker.common.data.types.Boolean amqpBoolean); static FieldValue parseShortShortInt(byte value); static FieldValue parseShortShortInt(ShortShortInt value); static FieldValue parseLongLongInt(long value); static FieldValue parseLongLongInt(LongLongInt value); static FieldValue parseFieldTable(FieldTable fieldTable); static FieldValue parseShortInt(ShortInt value); static FieldValue parseFloat(Float value); static FieldValue parseDouble(Double value); static FieldValue parseDecimal(Decimal value); static FieldValue parseShortShortUint(ShortShortUint value); static FieldValue parseShortUint(ShortUint value); static FieldValue parseLongUint(LongUint value); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testEquals() throws Exception { FieldValue otherSameType = FieldValue.parseLongInt(3); FieldValue otherType = FieldValue.parseLongString("Test"); FieldValue similar = FieldValue.parseLongInt(DATA_VALUE); Assert.assertTrue(TEST_OBJECT.equals(TEST_OBJECT), "equals() should return true for similar objects"); Assert.assertTrue(TEST_OBJECT.equals(similar), "equals() should return true for similar objects"); Assert.assertFalse(TEST_OBJECT.equals(otherSameType), "equals() should return false for different objects"); Assert.assertFalse(TEST_OBJECT.equals(otherType), "equals() should return false for different objects"); Assert.assertFalse(TEST_OBJECT.equals(DATA_VALUE), "equals() should return false for different objects"); }
### Question: ExchangeRegistry { boolean deleteExchange(String exchangeName, boolean ifUnused) throws BrokerException, ValidationException { Exchange exchange = exchangeMap.get(exchangeName); if (Objects.isNull(exchange)) { return false; } if (!isBuiltInExchange(exchange)) { if (!ifUnused \|\| exchange.isUnused()) { if (exchange.isDurable()) { exchangeDao.delete(exchange); } exchangeMap.remove(exchangeName); return true; } else { throw new ValidationException("Cannot delete exchange. Exchange " + exchangeName + " has bindings."); } } else { throw new ValidationException("Cannot delete built in exchange '" + exchangeName + "'"); } } ExchangeRegistry(ExchangeDao exchangeDao, BindingDao bindingDao); void createExchange(String exchangeName, Exchange.Type type, boolean durable); Exchange getDefaultExchange(); void retrieveFromStore(QueueRegistry queueRegistry); Collection<Exchange> getAllExchanges(); static final String DEFAULT_DEAD_LETTER_EXCHANGE; }### Answer: @Test(description = "Test exchange delete operation") public void testDeleteExchange() throws BrokerException, ValidationException { exchangeRegistry.declareExchange(NON_EXISTING_EXCHANGE, DIRECT.toString(), false, false); exchangeRegistry.deleteExchange(NON_EXISTING_EXCHANGE, true); Exchange deletedExchange = exchangeRegistry.getExchange(NON_EXISTING_EXCHANGE); Assert.assertNull(deletedExchange, "deleted exchange cannot exist"); } @Test(dataProvider = "exchangeNames", description = "try to delete built in exchanges", expectedExceptions = ValidationException.class) public void testDeleteBuiltInExchanges(String exchangeName) throws BrokerException, ValidationException { exchangeRegistry.deleteExchange(exchangeName, true); Assert.fail("built in exchange type - " + exchangeName + " shouldn't be allowed to delete"); }
### Question: FieldValue implements EncodableData { @Override public int hashCode() { int hash = value.hashCode(); hash += type.getChar(); return hash; } private FieldValue(Type type, EncodableData value); long getSize(); long getValueSize(); @Override void write(ByteBuf buf); static FieldValue parse(ByteBuf buf); Type getType(); EncodableData getValue(); static FieldValue parseLongInt(int value); static FieldValue parseLongInt(LongInt value); static FieldValue parseLongString(String value); static FieldValue parseLongString(LongString value); static FieldValue parseShortString(String value); static FieldValue parseShortString(ShortString value); static FieldValue parseBoolean(io.ballerina.messaging.broker.common.data.types.Boolean amqpBoolean); static FieldValue parseShortShortInt(byte value); static FieldValue parseShortShortInt(ShortShortInt value); static FieldValue parseLongLongInt(long value); static FieldValue parseLongLongInt(LongLongInt value); static FieldValue parseFieldTable(FieldTable fieldTable); static FieldValue parseShortInt(ShortInt value); static FieldValue parseFloat(Float value); static FieldValue parseDouble(Double value); static FieldValue parseDecimal(Decimal value); static FieldValue parseShortShortUint(ShortShortUint value); static FieldValue parseShortUint(ShortUint value); static FieldValue parseLongUint(LongUint value); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testHashCode() throws Exception { FieldValue similar = FieldValue.parseLongInt(DATA_VALUE); Assert.assertEquals(similar.hashCode(), TEST_OBJECT.hashCode(), "Hashcode should match for similar " + "data"); }
### Question: FieldValue implements EncodableData { public static FieldValue parse(ByteBuf buf) throws Exception { Type type = Type.valueOf((char) buf.readByte()); switch (type) { case BOOLEAN: return FieldValue.parseBoolean(io.ballerina.messaging.broker.common.data.types.Boolean.parse(buf)); case SHORT_SHORT_INT: return FieldValue.parseShortShortInt(ShortShortInt.parse(buf)); case SHORT_SHORT_UINT: return FieldValue.parseShortShortUint(ShortShortUint.parse(buf)); case SHORT_INT: return FieldValue.parseShortInt(ShortInt.parse(buf)); case SHORT_UINT: return FieldValue.parseShortUint(ShortUint.parse(buf)); case LONG_INT: return FieldValue.parseLongInt(LongInt.parse(buf)); case LONG_UINT: return FieldValue.parseLongUint(LongUint.parse(buf)); case LONG_LONG_INT: return FieldValue.parseLongLongInt(LongLongInt.parse(buf)); case FLOAT: return FieldValue.parseFloat(Float.parse(buf)); case DOUBLE: return FieldValue.parseDouble(Double.parse(buf)); case DECIMAL: return FieldValue.parseDecimal(Decimal.parse(buf)); case LONG_STRING: return FieldValue.parseLongString(LongString.parse(buf)); case FIELD_TABLE: return FieldValue.parseFieldTable(FieldTable.parse(buf)); case SHORT_STRING: return FieldValue.parseShortString(ShortString.parse(buf)); default: throw new Exception("Unsupported AMQP field value type " + type); } } private FieldValue(Type type, EncodableData value); long getSize(); long getValueSize(); @Override void write(ByteBuf buf); static FieldValue parse(ByteBuf buf); Type getType(); EncodableData getValue(); static FieldValue parseLongInt(int value); static FieldValue parseLongInt(LongInt value); static FieldValue parseLongString(String value); static FieldValue parseLongString(LongString value); static FieldValue parseShortString(String value); static FieldValue parseShortString(ShortString value); static FieldValue parseBoolean(io.ballerina.messaging.broker.common.data.types.Boolean amqpBoolean); static FieldValue parseShortShortInt(byte value); static FieldValue parseShortShortInt(ShortShortInt value); static FieldValue parseLongLongInt(long value); static FieldValue parseLongLongInt(LongLongInt value); static FieldValue parseFieldTable(FieldTable fieldTable); static FieldValue parseShortInt(ShortInt value); static FieldValue parseFloat(Float value); static FieldValue parseDouble(Double value); static FieldValue parseDecimal(Decimal value); static FieldValue parseShortShortUint(ShortShortUint value); static FieldValue parseShortUint(ShortUint value); static FieldValue parseLongUint(LongUint value); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expectedExceptions = Exception.class) public void testInvalidType() throws Exception { ByteBuf buf = Unpooled.buffer(1 + 4); buf.writeByte('Z'); FieldValue.parse(buf); }
### Question: LongLongInt implements EncodableData { @Override public long getSize() { return 8L; } private LongLongInt(long value); @Override long getSize(); @Override void write(ByteBuf buf); static LongLongInt parse(long value); static LongLongInt parse(ByteBuf buf); long getLong(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testGetSize() { Assert.assertEquals(TEST_OBJECT.getSize(), 8, "Size of long-long-int should be 4"); }
### Question: LongLongInt implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof LongLongInt) && (value == ((LongLongInt) obj).value); } private LongLongInt(long value); @Override long getSize(); @Override void write(ByteBuf buf); static LongLongInt parse(long value); static LongLongInt parse(ByteBuf buf); long getLong(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testEquals() { LongLongInt other = LongLongInt.parse(3); LongLongInt similar = LongLongInt.parse(DATA_VALUE); Assert.assertTrue(TEST_OBJECT.equals(TEST_OBJECT), "equals() should return true for similar objects"); Assert.assertTrue(TEST_OBJECT.equals(similar), "equals() should return true for similar objects"); Assert.assertFalse(TEST_OBJECT.equals(other), "equals() should return false for different objects"); Assert.assertFalse(TEST_OBJECT.equals(DATA_VALUE), "equals() should return false for different objects"); }
### Question: LongLongInt implements EncodableData { @Override public int hashCode() { return (int) (value ^ (value >>> 32)); } private LongLongInt(long value); @Override long getSize(); @Override void write(ByteBuf buf); static LongLongInt parse(long value); static LongLongInt parse(ByteBuf buf); long getLong(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testHashCode() { LongLongInt similar = LongLongInt.parse(DATA_VALUE); Assert.assertEquals(similar.hashCode(), TEST_OBJECT.hashCode(), "Hashcode should match for similar data"); }
### Question: LongLongInt implements EncodableData { public static LongLongInt parse(long value) { return new LongLongInt(value); } private LongLongInt(long value); @Override long getSize(); @Override void write(ByteBuf buf); static LongLongInt parse(long value); static LongLongInt parse(ByteBuf buf); long getLong(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testParse() { ByteBuf buf = Unpooled.buffer(8); TEST_OBJECT.write(buf); LongLongInt parsedObject = LongLongInt.parse(buf); Assert.assertEquals(parsedObject, TEST_OBJECT, "Encoding and decoding should result in the same object"); }
### Question: PlainSaslServer implements SaslServer { @Override public byte[] evaluateResponse(byte[] response) throws SaslException { int authzidNullPosition = Bytes.indexOf(response, (byte) 0); if (authzidNullPosition < 0) { throw new SaslException("Invalid SASL/PLAIN response due to authzid null separator not found"); } int authcidNullPosition = Bytes .indexOf(Arrays.copyOfRange(response, authzidNullPosition + 1, response.length), (byte) 0); if (authcidNullPosition < 0) { throw new SaslException("Invalid SASL/PLAIN response due to authcid null separator not found"); } String userName = new String(response, authzidNullPosition + 1, authcidNullPosition, StandardCharsets.UTF_8); int counter = authzidNullPosition + authcidNullPosition + 1; int passwordLen = response.length - counter - 1; password = new char[passwordLen]; for (int i = 0; i < passwordLen; i++) { password[i] = (char) response[++counter]; } try { AuthResult authResult = authenticator.authenticate(userName, password); authenticationId = authResult.getUserId(); isComplete = authResult.isAuthenticated(); return new byte[0]; } catch (AuthException e) { throw new SaslException("Error while authenticating user with authenticator", e); } finally { clearCredentials(); } } PlainSaslServer(Authenticator authenticator); @Override String getMechanismName(); @Override byte[] evaluateResponse(byte[] response); @Override boolean isComplete(); @Override String getAuthorizationID(); @Override byte[] unwrap(byte[] incoming, int offset, int len); @Override byte[] wrap(byte[] outgoing, int offset, int len); @Override Object getNegotiatedProperty(String propName); @Override void dispose(); }### Answer: @Test(expectedExceptions = { SaslException.class }, description = "Test evaluate empty response", expectedExceptionsMessageRegExp = ".Invalid SASL/PLAIN response due to authzid null separator not found.") public void testEvaluateEmptyResponse() throws Exception { plainSaslServer.evaluateResponse(new byte[0]); } @Test(expectedExceptions = SaslException.class, description = "Test evaluate response without authorization separator", expectedExceptionsMessageRegExp = ".Invalid SASL/PLAIN response due to authzid null separator not found.") public void testEvaluateResponseWithoutAuthorizationSeparator() throws Exception { plainSaslServer.evaluateResponse(new byte[] { (byte) 'a', (byte) 'u', (byte) 't', (byte) 'h' }); } @Test(expectedExceptions = SaslException.class, description = "Test evaluate response without username separator", expectedExceptionsMessageRegExp = ".Invalid SASL/PLAIN response due to authcid null separator not found.") public void testEvaluateResponseWithoutUsernameSeparator() throws Exception { plainSaslServer .evaluateResponse(new byte[] { (byte) 'a', (byte) 0, (byte) 'u', (byte) 's', (byte) 'e', (byte) 'r' }); }
### Question: AuthResourceRdbmsDao implements AuthResourceDao { @Override public void persist(AuthResource authResource) throws AuthServerException { transaction(connection -> { authResourceCrudOperationsDao.storeResource(connection, authResource); authResourceCrudOperationsDao.persistUserGroupMappings(connection, authResource.getResourceType(), authResource.getResourceName(), authResource.getActionsUserGroupsMap()); }); } AuthResourceRdbmsDao(DataSource dataSource); @Override void persist(AuthResource authResource); @Override void update(AuthResource authResource); @Override boolean delete(String resourceType, String resource); @Override AuthResource read(String resourceType, String resourceName); @Override List<AuthResource> readAll(String resourceType, String ownerId); @Override List<AuthResource> readAll(String resourceType, String action, String ownerId, List<String> userGroups); @Override boolean isExists(String resourceType, String resource); @Override boolean updateOwner(String resourceType, String resourceName, String newOwner); @Override boolean addGroups(String resourceType, String resourceName, String action, List<String> groups); @Override boolean removeGroup(String resourceType, String resourceName, String action, String group); }### Answer: @Test(expectedExceptions = AuthServerException.class) public void testDuplicate() throws AuthServerException { AuthResource queue = new AuthResource(ResourceType.QUEUE.toString(), "queue1", true, "customer"); authResourceDao.persist(queue); }
### Question: AuthResourceRdbmsDao implements AuthResourceDao { @Override public AuthResource read(String resourceType, String resourceName) throws AuthServerException { return selectOperation(connection -> authResourceCrudOperationsDao.read(connection, resourceType, resourceName)); } AuthResourceRdbmsDao(DataSource dataSource); @Override void persist(AuthResource authResource); @Override void update(AuthResource authResource); @Override boolean delete(String resourceType, String resource); @Override AuthResource read(String resourceType, String resourceName); @Override List<AuthResource> readAll(String resourceType, String ownerId); @Override List<AuthResource> readAll(String resourceType, String action, String ownerId, List<String> userGroups); @Override boolean isExists(String resourceType, String resource); @Override boolean updateOwner(String resourceType, String resourceName, String newOwner); @Override boolean addGroups(String resourceType, String resourceName, String action, List<String> groups); @Override boolean removeGroup(String resourceType, String resourceName, String action, String group); }### Answer: @Test public void testRead() throws AuthServerException { AuthResource queue = authResourceDao.read(ResourceType.QUEUE.toString(), "queue1"); Assert.assertEquals(queue.getOwner(), "customer"); Assert.assertEquals(queue.getActionsUserGroupsMap().size(), 0); AuthResource exchange = authResourceDao.read(ResourceType.EXCHANGE.toString(), "exchange1"); Assert.assertEquals(exchange.getOwner(), "manager"); AuthResource exchange2 = authResourceDao.read(ResourceType.EXCHANGE.toString(), "exchange2"); Assert.assertEquals(exchange.getOwner(), "manager"); Assert.assertEquals(exchange2.getOwner(), "manager"); Assert.assertEquals(exchange.getActionsUserGroupsMap().get("bind").size(), 2); Assert.assertEquals(exchange2.getActionsUserGroupsMap().get("bind").size(), 1); }
### Question: AuthResourceRdbmsDao implements AuthResourceDao { @Override public List<AuthResource> readAll(String resourceType, String ownerId) throws AuthServerException { return selectOperation((ThrowingFunction<Connection, List<AuthResource>, Exception>) connection -> authResourceCrudOperationsDao.readAll(connection, resourceType, ownerId)); } AuthResourceRdbmsDao(DataSource dataSource); @Override void persist(AuthResource authResource); @Override void update(AuthResource authResource); @Override boolean delete(String resourceType, String resource); @Override AuthResource read(String resourceType, String resourceName); @Override List<AuthResource> readAll(String resourceType, String ownerId); @Override List<AuthResource> readAll(String resourceType, String action, String ownerId, List<String> userGroups); @Override boolean isExists(String resourceType, String resource); @Override boolean updateOwner(String resourceType, String resourceName, String newOwner); @Override boolean addGroups(String resourceType, String resourceName, String action, List<String> groups); @Override boolean removeGroup(String resourceType, String resourceName, String action, String group); }### Answer: @Test public void testReadAll() throws AuthServerException { List<AuthResource> customer = authResourceDao.readAll(ResourceType.QUEUE.toString(), "customer"); List<AuthResource> customerExchange = authResourceDao.readAll(ResourceType.EXCHANGE.toString(), "customer"); List<AuthResource> manager = authResourceDao.readAll(ResourceType.EXCHANGE.toString(), "manager"); List<AuthResource> developer = authResourceDao.readAll(ResourceType.EXCHANGE.toString(), "developer"); Assert.assertEquals(customer.size(), 1); Assert.assertEquals(customerExchange.size(), 0); Assert.assertEquals(manager.size(), 2); Assert.assertEquals(developer.size(), 0); } @Test public void testReadAllByGroups() throws AuthServerException { List<AuthResource> exchanges = authResourceDao.readAll(ResourceType.EXCHANGE.toString(), "bind", "customer", Collections.singletonList("developer")); List<AuthResource> queues = authResourceDao.readAll(ResourceType.QUEUE.toString(), "bind", "customer", Arrays.asList("architect", "designer")); Assert.assertEquals(exchanges.size(), 1); Assert.assertEquals(queues.size(), 1); }
### Question: AuthResourceRdbmsDao implements AuthResourceDao { @Override public boolean isExists(String resourceType, String resource) throws AuthServerException { return selectOperation(connection -> authResourceCrudOperationsDao.isExists(connection, resourceType, resource) ); } AuthResourceRdbmsDao(DataSource dataSource); @Override void persist(AuthResource authResource); @Override void update(AuthResource authResource); @Override boolean delete(String resourceType, String resource); @Override AuthResource read(String resourceType, String resourceName); @Override List<AuthResource> readAll(String resourceType, String ownerId); @Override List<AuthResource> readAll(String resourceType, String action, String ownerId, List<String> userGroups); @Override boolean isExists(String resourceType, String resource); @Override boolean updateOwner(String resourceType, String resourceName, String newOwner); @Override boolean addGroups(String resourceType, String resourceName, String action, List<String> groups); @Override boolean removeGroup(String resourceType, String resourceName, String action, String group); }### Answer: @Test public void testIsExists() throws AuthServerException { boolean queue1 = authResourceDao.isExists(ResourceType.QUEUE.toString(), "queue1"); boolean queue11 = authResourceDao.isExists(ResourceType.QUEUE.toString(), "queue11"); Assert.assertEquals(queue1, true); Assert.assertEquals(queue11, false); }
### Question: AuthResourceRdbmsDao implements AuthResourceDao { @Override public void update(AuthResource authResource) throws AuthServerException { transaction(connection -> { authResourceCrudOperationsDao.updateOwner(connection, authResource.getResourceType(), authResource.getResourceName(), authResource.getOwner()); authResourceCrudOperationsDao.deleteUserGroupMappings(connection, authResource.getResourceType(), authResource.getResourceName()); authResourceCrudOperationsDao.persistUserGroupMappings(connection, authResource.getResourceType(), authResource.getResourceName(), authResource.getActionsUserGroupsMap()); }); } AuthResourceRdbmsDao(DataSource dataSource); @Override void persist(AuthResource authResource); @Override void update(AuthResource authResource); @Override boolean delete(String resourceType, String resource); @Override AuthResource read(String resourceType, String resourceName); @Override List<AuthResource> readAll(String resourceType, String ownerId); @Override List<AuthResource> readAll(String resourceType, String action, String ownerId, List<String> userGroups); @Override boolean isExists(String resourceType, String resource); @Override boolean updateOwner(String resourceType, String resourceName, String newOwner); @Override boolean addGroups(String resourceType, String resourceName, String action, List<String> groups); @Override boolean removeGroup(String resourceType, String resourceName, String action, String group); }### Answer: @Test(dependsOnMethods = {"testIsExists", "testReadAllByGroups", "testReadAll", "testRead", "testDuplicate"}) public void testUpdate() throws AuthServerException { Map<String, Set<String>> actionsUserGroupsMap = new HashMap<>(); actionsUserGroupsMap.put("publish", new HashSet<>(Arrays.asList("architect", "customer", "manager"))); AuthResource exchange = new AuthResource(ResourceType.EXCHANGE.toString(), "exchange1", true, "developer", actionsUserGroupsMap); authResourceDao.update(exchange); List<AuthResource> manager = authResourceDao.readAll(ResourceType.EXCHANGE.toString(), "manager"); List<AuthResource> developer = authResourceDao.readAll(ResourceType.EXCHANGE.toString(), "developer"); Assert.assertEquals(manager.size(), 1); Assert.assertEquals(developer.size(), 1); AuthResource exchange1 = authResourceDao.read(ResourceType.EXCHANGE.toString(), "exchange1"); Assert.assertEquals(exchange1.getOwner(), "developer"); List<AuthResource> exchanges = authResourceDao.readAll(ResourceType.EXCHANGE.toString(), "publish", "manager", Collections.singletonList("manager")); Assert.assertEquals(exchanges.size(), 2); }
### Question: AuthResourceRdbmsDao implements AuthResourceDao { @Override public boolean delete(String resourceType, String resource) throws AuthServerException { return transaction((ThrowingFunction<Connection, Boolean, Exception>) connection -> authResourceCrudOperationsDao.deleteResource(connection, resourceType, resource)); } AuthResourceRdbmsDao(DataSource dataSource); @Override void persist(AuthResource authResource); @Override void update(AuthResource authResource); @Override boolean delete(String resourceType, String resource); @Override AuthResource read(String resourceType, String resourceName); @Override List<AuthResource> readAll(String resourceType, String ownerId); @Override List<AuthResource> readAll(String resourceType, String action, String ownerId, List<String> userGroups); @Override boolean isExists(String resourceType, String resource); @Override boolean updateOwner(String resourceType, String resourceName, String newOwner); @Override boolean addGroups(String resourceType, String resourceName, String action, List<String> groups); @Override boolean removeGroup(String resourceType, String resourceName, String action, String group); }### Answer: @Test(dependsOnMethods = "testUpdate") public void testDelete() throws AuthServerException { authResourceDao.delete(ResourceType.EXCHANGE.toString(), "exchange1"); authResourceDao.delete(ResourceType.EXCHANGE.toString(), "exchange1"); List<AuthResource> manager = authResourceDao.readAll(ResourceType.EXCHANGE.toString(), "manager"); List<AuthResource> developer = authResourceDao.readAll(ResourceType.EXCHANGE.toString(), "developer"); Assert.assertEquals(manager.size(), 1); Assert.assertEquals(developer.size(), 0); boolean exchange1 = authResourceDao.isExists(ResourceType.EXCHANGE.toString(), "exchange1"); boolean exchange2 = authResourceDao.isExists(ResourceType.EXCHANGE.toString(), "exchange2"); Assert.assertEquals(exchange1, false); Assert.assertEquals(exchange2, true); }
### Question: AuthResourceInMemoryDao implements AuthResourceDao { @Override public void persist(AuthResource authResource) throws AuthServerException { String resourceType = authResource.getResourceType(); String resourceName = authResource.getResourceName(); if (!inMemoryResourceMap.contains(resourceType, resourceName)) { inMemoryResourceMap.put(resourceType, resourceName, authResource); } else { throw new AuthServerException( "Auth resource already exists [" + resourceType + ", " + resourceName + "]"); } } @Override void persist(AuthResource authResource); @Override void update(AuthResource authResource); @Override boolean delete(String resourceType, String resource); @Override AuthResource read(String resourceType, String resource); @Override List<AuthResource> readAll(String resourceType, String ownerId); @Override List<AuthResource> readAll(String resourceType, String action, String ownerId, List<String> userGroups); @Override boolean isExists(String resourceType, String resourceName); @Override boolean updateOwner(String resourceType, String resourceName, String newOwner); @Override boolean addGroups(String resourceType, String resourceName, String action, List<String> groups); @Override boolean removeGroup(String resourceType, String resourceName, String action, String group); }### Answer: @Test public void testPersist() throws AuthServerException { AuthResource queue = new AuthResource(ResourceType.QUEUE.toString(), "queue1", true, "customer"); authResourceDao.persist(queue); Map<String, Set<String>> actionsUserGroupsMap = new HashMap<>(); actionsUserGroupsMap.put("bind", new HashSet<>(Arrays.asList("architect", "developer"))); AuthResource exchange = new AuthResource(ResourceType.EXCHANGE.toString(), "exchange1", true, "manager", actionsUserGroupsMap); actionsUserGroupsMap = new HashMap<>(); actionsUserGroupsMap.put("bind", new HashSet<>(Collections.singletonList("architect"))); AuthResource exchange2 = new AuthResource(ResourceType.EXCHANGE.toString(), "exchange2", true, "manager", actionsUserGroupsMap); authResourceDao.persist(exchange); authResourceDao.persist(exchange2); } @Test(priority = 1, expectedExceptions = AuthServerException.class) public void testDuplicate() throws AuthServerException { AuthResource queue = new AuthResource(ResourceType.QUEUE.toString(), "queue1", true, "customer"); authResourceDao.persist(queue); }
### Question: AuthResourceInMemoryDao implements AuthResourceDao { @Override public AuthResource read(String resourceType, String resource) { return inMemoryResourceMap.get(resourceType, resource); } @Override void persist(AuthResource authResource); @Override void update(AuthResource authResource); @Override boolean delete(String resourceType, String resource); @Override AuthResource read(String resourceType, String resource); @Override List<AuthResource> readAll(String resourceType, String ownerId); @Override List<AuthResource> readAll(String resourceType, String action, String ownerId, List<String> userGroups); @Override boolean isExists(String resourceType, String resourceName); @Override boolean updateOwner(String resourceType, String resourceName, String newOwner); @Override boolean addGroups(String resourceType, String resourceName, String action, List<String> groups); @Override boolean removeGroup(String resourceType, String resourceName, String action, String group); }### Answer: @Test(priority = 1) public void testRead() throws AuthServerException { AuthResource queue = authResourceDao.read(ResourceType.QUEUE.toString(), "queue1"); Assert.assertEquals(queue.getOwner(), "customer"); Assert.assertEquals(queue.getActionsUserGroupsMap().size(), 0); AuthResource exchange = authResourceDao.read(ResourceType.EXCHANGE.toString(), "exchange1"); Assert.assertEquals(exchange.getOwner(), "manager"); AuthResource exchange2 = authResourceDao.read(ResourceType.EXCHANGE.toString(), "exchange2"); Assert.assertEquals(exchange.getOwner(), "manager"); Assert.assertEquals(exchange2.getOwner(), "manager"); Assert.assertEquals(exchange.getActionsUserGroupsMap().get("bind").size(), 2); Assert.assertEquals(exchange2.getActionsUserGroupsMap().get("bind").size(), 1); }
### Question: ExchangeDaoImpl extends BaseDao implements ExchangeDao { @Override public void persist(Exchange exchange) throws BrokerException { Connection connection = null; PreparedStatement statement = null; try { connection = getConnection(); statement = connection.prepareStatement(RDBMSConstants.PS_INSERT_EXCHANGE); statement.setString(1, exchange.getName()); statement.setString(2, exchange.getType().toString()); statement.executeUpdate(); connection.commit(); } catch (SQLException e) { String message = "Error occurred while storing exchange " + exchange; rollback(connection, message); throw new BrokerException(message, e); } finally { close(connection, statement); } } ExchangeDaoImpl(DataSource dataSource); @Override void persist(Exchange exchange); @Override void delete(Exchange exchange); @Override void retrieveAll(ExchangeCollector exchangeCollector); }### Answer: @Test(dataProvider = "exchangeData", description = "Test duplicate exchange persistence" , expectedExceptions = BrokerException.class) public void testDuplicatePersistence(String name, String type) throws Exception { Exchange exchange = ExchangeRegistry.ExchangeFactory.newInstance(name, Exchange.Type.from(type), bindingDao); exchangeDao.persist(exchange); exchangeDao.persist(exchange); }
### Question: Main { void execute(String[] args) throws UnsupportedEncodingException { initOptions(args); if (terminated) { return; } OcrParameters params = transformOptions(); if (terminated) { return; } String validationMessage = paramValidator.validateParameters(params); if ("OK".equals(validationMessage)) { out.println("Starting OCR..."); engineStarter.startOcrWithParams(params); out.println("Finished OCR."); } else { out.println("Illegal options: " + validationMessage); } } static void main(String[] args); }### Answer: @Test public void shouldPrintHelp() throws UnsupportedEncodingException { main.execute(new String[]{"-help"}); String outString = new String(baos.toByteArray()); assertThat(outString, containsString("usage: java -jar")); assertThat(outString, containsString("-help")); } @Test public void shouldDenyWrongArgument() throws UnsupportedEncodingException { main.execute(new String[]{"-wrongargument"}); String outString = new String(baos.toByteArray()); assertThat(outString, containsString("Illegal arguments. Use -help.")); } @Test public void shouldPassAllParams() throws UnsupportedEncodingException { ArgumentCaptor<OcrParameters> captor = ArgumentCaptor.forClass(OcrParameters.class); when(validatorMock.validateParameters(any(OcrParameters.class))).thenReturn("OK"); main.execute(validOptions()); verify(validatorMock).validateParameters(captor.capture()); OcrParameters param = captor.getValue(); assertEquals("/tmp/in", param.inputFolder); assertEquals("tif", param.inputFormats[0]); assertEquals("jpg", param.inputFormats[1]); assertEquals("normal", param.inputTextType); assertEquals("de", param.inputLanguages[0]); assertEquals("en", param.inputLanguages[1]); assertEquals("/tmp/out", param.outputFolder); assertEquals("pdf", param.outputFormats[0]); assertEquals("xml", param.outputFormats[1]); assertEquals("2", param.priority); assertEquals("abbyy", param.ocrEngine); assertEquals("me", param.props.get("user")); assertEquals("pass", param.props.get("password")); } @Test public void shouldComplainAboutMissingOptions() throws UnsupportedEncodingException { main.execute(new String[]{"-indir", "/tmp"}); String outString = new String(baos.toByteArray()); assertThat(outString, containsString("Required options are missing. Use -help.")); } @Test public void shouldStartEngine() throws UnsupportedEncodingException { when(validatorMock.validateParameters(any(OcrParameters.class))).thenReturn("OK"); main.execute(validOptions()); verify(engineStarterMock).startOcrWithParams(any(OcrParameters.class)); } @Test public void shouldNotStartEngine() throws UnsupportedEncodingException { when(validatorMock.validateParameters(any(OcrParameters.class))).thenReturn("Input folder does not exist"); main.execute(validOptions()); verify(engineStarterMock, times(0)).startOcrWithParams(any(OcrParameters.class)); String outString = new String(baos.toByteArray()); assertThat(outString, containsString("Illegal options: Input folder does not exist")); } @Test public void shouldSetDefaultValues() throws UnsupportedEncodingException { ArgumentCaptor<OcrParameters> captor = ArgumentCaptor.forClass(OcrParameters.class); main.execute(onlyRequiredOptions()); verify(validatorMock).validateParameters(captor.capture()); OcrParameters param = captor.getValue(); assertEquals("tif", param.inputFormats[0]); assertEquals("jpg", param.inputFormats[1]); assertEquals("gif", param.inputFormats[2]); assertEquals("0", param.priority); assertEquals("abbyy", param.ocrEngine); assertNotNull(param.props); }
### Question: OcrEngineStarter { public void startOcrWithParams(OcrParameters params) { OcrFactory factory = factoryProvider.createFactory(params.ocrEngine, params.props); engine = factory.createEngine(); FileAccess fileAccess = beanProvider.getFileAccess(); File[] allBookFolders = fileAccess.getAllFolders(params.inputFolder, params.inputFormats); for (File bookFolder : allBookFolders) { OcrProcess process = factory.createProcess(); process.setName(bookFolder.getName()); process.setOutputDir(new File(params.outputFolder)); File[] allPages = fileAccess.getAllImagesFromFolder(bookFolder, params.inputFormats); for (File page : allPages) { process.addImage(page.toURI()); } for (String outFormat : params.outputFormats) { OcrFormat ocrFormat = OcrFormat.valueOf(outFormat.toUpperCase()); process.addOutput(ocrFormat); } for (String lang : params.inputLanguages) { process.addLanguage(new Locale(lang)); } process.setPriority(OcrPriority.fromValue(params.priority)); process.setTextType(OcrTextType.valueOf(params.inputTextType.toUpperCase())); process.setQuality(OcrQuality.BEST); engine.addOcrProcess(process); } Mailer mailer = null; String mailAddress = params.props.getProperty("email"); if (mailAddress != null) { int estimatedExecTime = engine.getEstimatedDurationInSeconds(); mailer = beanProvider.getMailer(); mailer.sendStarted(mailAddress, estimatedExecTime); } engine.recognize(); if (mailAddress != null) { mailer.sendFinished(mailAddress, params.outputFolder); } } void startOcrWithParams(OcrParameters params); }### Answer: @Test(expected=IllegalArgumentException.class) public void shouldRejectIllegalOutputFormat() { prepareOneBookWithOneImage(); OcrParameters params = validParams(); params.outputFormats = new String[]{"illegal"}; starterSut.startOcrWithParams(params); } @Test(expected=IllegalArgumentException.class) public void shouldRejectIllegalTextType() { prepareOneBookWithOneImage(); OcrParameters params = validParams(); params.inputTextType = "illegal"; starterSut.startOcrWithParams(params); } @Test(expected=IllegalArgumentException.class) public void shouldRejectIllegalPriority() { prepareOneBookWithOneImage(); OcrParameters params = validParams(); params.priority = "-10"; starterSut.startOcrWithParams(params); } @Test public void shouldStartEngineDespiteNoFolders() { when(fileAccessMock.getAllFolders(anyString(), any(String[].class))).thenReturn(new File[]{}); starterSut.startOcrWithParams(validParams()); verify(engineMock).recognize(); } @Test public void shouldStartWithBookAndImage() { prepareOneBookWithOneImage(); starterSut.startOcrWithParams(validParams()); verify(processMock).setName("book1"); verify(engineMock).recognize(); } @Test public void shouldStartAndSendMails() { prepareOneBookWithOneImage(); OcrParameters params = validParams(); when(engineMock.getEstimatedDurationInSeconds()).thenReturn(1); starterSut.startOcrWithParams(params); verify(mailerMock).sendStarted("[email protected]", 1); verify(engineMock).recognize(); verify(mailerMock).sendFinished("[email protected]", "tmp/output"); }
### Question: Validator { public String validateParameters(OcrParameters params) { fileAccess = beanProvider.getFileAccess(); String validationMessage = ""; if (!isReadable(params.inputFolder)) { validationMessage += inputFolderError(); } if (isEmpty(params.inputTextType)) { validationMessage += noInputTextType(); } if (isEmpty(params.inputLanguages)) { validationMessage += noInputLanguages(); } if (!isWritable(params.outputFolder)) { validationMessage += outputFolderError(); } if (isEmpty(params.outputFormats)) { validationMessage += noOutputFormats(); } if (isEmpty(params.inputFormats)) { validationMessage += noInputFormats(); } if (isEmpty(params.priority)) { validationMessage += noPriority(); } if (isEmpty(params.ocrEngine)) { validationMessage += noOcrEngine(); } if (params.props == null) { validationMessage += nullProperties(); } if (validationMessage.isEmpty()) { return "OK"; } else { return validationMessage; } } String validateParameters(OcrParameters params); }### Answer: @Test public void happyPath() { whenAskedThenFindFolders(); OcrParameters params = validParams(); String validation = validatorSut.validateParameters(params); verify(fileAccessMock).isReadableFolder("/tmp/input"); assertEquals("OK", validation); } @Test public void shouldNotFindInputFolder() { when(fileAccessMock.isReadableFolder("/tmp/input")).thenReturn(false); when(fileAccessMock.isWritableFolder("/tmp/output")).thenReturn(true); OcrParameters params = validParams(); String validation = validatorSut.validateParameters(params); assertThat(validation, containsString("Input folder not found")); } @Test public void shouldNotFindOutputFolder() { when(fileAccessMock.isReadableFolder("/tmp/input")).thenReturn(true); when(fileAccessMock.isWritableFolder("/tmp/output")).thenReturn(false); OcrParameters params = validParams(); String validation = validatorSut.validateParameters(params); assertThat(validation, containsString("Output folder not found or it is not writable")); } @Test public void shouldDetectMissingInputFormats() { whenAskedThenFindFolders(); OcrParameters params = validParams(); params.inputFormats = new String[]{}; String validation = validatorSut.validateParameters(params); assertEquals("No input formats. ", validation); } @Test public void shouldDetectMissingInputTextType() { whenAskedThenFindFolders(); OcrParameters params = validParams(); params.inputTextType = " "; String validation = validatorSut.validateParameters(params); assertEquals("No input text type. ", validation); } @Test public void shouldDetectMissingLanguages() { whenAskedThenFindFolders(); OcrParameters params = validParams(); params.inputLanguages = null; String validation = validatorSut.validateParameters(params); assertEquals("No input languages. ", validation); } @Test public void shouldDetectMissingOutputFormats() { whenAskedThenFindFolders(); OcrParameters params = validParams(); params.outputFormats = null; String validation = validatorSut.validateParameters(params); assertEquals("No output formats. ", validation); } @Test public void shouldDetectMissingPriority() { whenAskedThenFindFolders(); OcrParameters params = validParams(); params.priority = ""; String validation = validatorSut.validateParameters(params); assertEquals("No priority. ", validation); } @Test public void shouldDetectMissingOcrEngine() { whenAskedThenFindFolders(); OcrParameters params = validParams(); params.ocrEngine = null; String validation = validatorSut.validateParameters(params); assertEquals("No OCR engine. ", validation); } @Test public void shouldDetectNullOptions() { whenAskedThenFindFolders(); OcrParameters params = validParams(); params.props = null; String validation = validatorSut.validateParameters(params); assertEquals("Properties may not be null. ", validation); }
### Question: TesseractProcess extends AbstractProcess implements OcrProcess { @Override public void addImage(URI localUri) { if (!localUri.getScheme().equals("file")) { throw new IllegalArgumentException("Only local files can be processed. Path was: " + localUri); } OcrImage image = new AbstractImage() {}; image.setLocalUri(localUri); ocrImages.add(image); } @Override void addImage(URI localUri); @Override void addOutput(OcrFormat format); void start(); }### Answer: @Test public void shouldAddOneImage() throws Exception { assertEquals("Number of images", 0, processSpy.getNumberOfImages()); processSpy.addImage(new URI("file:/test.tif")); assertEquals("Number of images", 1, processSpy.getNumberOfImages()); } @Test(expected=IllegalArgumentException.class) public void shouldRejectRemoteUriForImage() throws Exception { processSpy.addImage(new URI("http: }
### Question: TesseractProcess extends AbstractProcess implements OcrProcess { @Override public void addOutput(OcrFormat format) { if (!formats.keySet().contains(format)) { throw new IllegalArgumentException("Format is not supported by tesseract: " + format); } OcrOutput output = new AbstractOutput() {}; output.setLocalUri(constructLocalUri(format)); output.setFormat(format); ocrOutputs.add(output); } @Override void addImage(URI localUri); @Override void addOutput(OcrFormat format); void start(); }### Answer: @Test public void shouldAddOneOutput() throws Exception { assertEquals("Number of outputs", 0, processSpy.getAllOutputFormats().size()); processSpy.addOutput(OcrFormat.HOCR); assertEquals("Number of outputs", 1, processSpy.getAllOutputFormats().size()); } @Test(expected=IllegalArgumentException.class) public void shouldRejectUnsupportedFormatForOutput() throws Exception { processSpy.addOutput(OcrFormat.PDF); }
### Question: AbbyyEngine extends AbstractEngine implements OcrEngine { @Override public int getEstimatedDurationInSeconds() { long durationInMillis = 0; for (OcrProcess process : processesQueue) { long imagesInProcess = process.getNumberOfImages(); durationInMillis += imagesInProcess * Integer.parseInt(props.getProperty("minMillisPerFile")); } return (int) (durationInMillis / 1000); } void initialize(Properties initProps); @Override void addOcrProcess(OcrProcess process); @Override void recognize(); @Override int getEstimatedDurationInSeconds(); }### Answer: @Test public void shouldBeZeroSecondsWhenUnititialized() { assertEquals("Estimated time", 0, engineSut.getEstimatedDurationInSeconds()); }
### Question: XmlParser { public String readErrorFromResultXml(InputStream errorResultXml, String bookIdentifier) throws IOException { String error = null; XMLInputFactory factory = XMLInputFactory.newInstance(); try { XMLStreamReader xmlStreamReader = factory.createXMLStreamReader(errorResultXml); while (xmlStreamReader.hasNext()) { int event = xmlStreamReader.next(); if (event == XMLStreamConstants.START_ELEMENT) { if (xmlStreamReader.getName().toString().equals("Error")) { error = xmlStreamReader.getElementText(); break; } } } xmlStreamReader.close(); } catch (XMLStreamException e) { throw new IOException(e); } logger.error("Book: " + bookIdentifier + ", Error: " + error); return error; } String readErrorFromResultXml(InputStream errorResultXml, String bookIdentifier); }### Answer: @Test public void shouldParseOutErrorMessage() throws IOException { XmlParser parserSut = new XmlParser(); String errorXml = "<XmlResult><Error>An error has occurred</Error></XmlResult>"; ByteArrayInputStream baos = new ByteArrayInputStream(errorXml.getBytes()); String errorMessage = parserSut.readErrorFromResultXml(baos, "testId"); assertEquals("Message", "An error has occurred", errorMessage); }
### Question: ProcessMergingObserver { public synchronized void update(AbbyyProcess finishedSubProcess) { finishedSubProcess.setFinished(); for (AbbyyProcess sub : subProcesses) { boolean currentFinished = sub.hasFinished(); if (!currentFinished) { return; } } for (AbbyyProcess sub : subProcesses) { if(sub.hasFailed()) { logger.error("Could not merge process: " + parentProcess.getName()); throw new IllegalStateException("Subprocess failed: " + sub.getName()); } } fileAccess = beanProvider.getFileAccess(); mergeAllFormats(); } void setParentProcess(AbbyyProcess process); void addSubProcess(AbbyyProcess subProcess); synchronized void update(AbbyyProcess finishedSubProcess); }### Answer: @Test public void shouldDoNothingWhenAllSubprocessesNotFinished() { when(subProcessMock1.hasFinished()).thenReturn(false); when(subProcessMock2.hasFinished()).thenReturn(false); observerSut.update(subProcessMock2); verifyZeroInteractions(parentProcessMock, mergerMock, fileAccessMock); } @Test public void shouldDoNothingWhenOneSubprocessNotFinished() { when(subProcessMock1.hasFinished()).thenReturn(false); when(subProcessMock2.hasFinished()).thenReturn(true); observerSut.update(subProcessMock2); verifyZeroInteractions(parentProcessMock, mergerMock, fileAccessMock); } @Test(expected=IllegalStateException.class) public void shouldBreakUpWhenOneFails() { when(subProcessMock1.hasFailed()).thenReturn(true); observerSut.update(subProcessMock1); } @SuppressWarnings("unchecked") @Test public void shouldMergeIntoOneAndDeleteTheParts() throws URISyntaxException, IOException { Set<OcrFormat> formats = new HashSet<OcrFormat>(); formats.add(OcrFormat.TXT); when(parentProcessMock.getAllOutputFormats()).thenReturn(formats); when(subProcessMock1.getOutputUriForFormat(OcrFormat.TXT)).thenReturn(new URI("file:/part1.txt")); when(subProcessMock2.getOutputUriForFormat(OcrFormat.TXT)).thenReturn(new URI("file:/part2.txt")); when(parentProcessMock.getOutputUriForFormat(OcrFormat.TXT)).thenReturn(new URI("file:/result.txt")); observerSut.update(subProcessMock2); verify(mergerMock).mergeBuffered(any(List.class), any(OutputStream.class)); verify(fileAccessMock).deleteFile(new File("/part1.txt")); verify(fileAccessMock).deleteFile(new File("/part2.txt")); }
### Question: LockFileHandler { public void createOrOverwriteLock(boolean overwriteLock) { synchronized(monitor) { try { if (overwriteLock) { hotfolder.deleteIfExists(lockUri); } boolean lockExists = hotfolder.exists(lockUri); if (lockExists) { throw new ConcurrentModificationException("Another client instance is running! See the lock file at " + lockUri); } writeLockFile(); } catch (IOException e) { logger.error("Error with server lock file: " + lockUri, e); } } } void initConnection(String serverUrl, String user, String password); void createOrOverwriteLock(boolean overwriteLock); void deleteLockAndCleanUp(); }### Answer: @Test public void shouldCreateNewLock() throws IOException { when(hotfolderMock.exists(lockUri)).thenReturn(false); when(hotfolderMock.createTmpFile(anyString())).thenReturn(new ByteArrayOutputStream()); lockHandlerSut.createOrOverwriteLock(false); verify(hotfolderMock, never()).deleteIfExists(lockUri); verify(hotfolderMock).copyTmpFile("lock", lockUri); } @Test(expected=ConcurrentModificationException.class) public void shouldCancelWhenLockIsPresent() throws IOException { when(hotfolderMock.exists(lockUri)).thenReturn(true); lockHandlerSut.createOrOverwriteLock(false); } @Test public void shouldOverwriteLock() throws IOException { when(hotfolderMock.exists(lockUri)).thenReturn(false); when(hotfolderMock.createTmpFile(anyString())).thenReturn(new ByteArrayOutputStream()); lockHandlerSut.createOrOverwriteLock(true); verify(hotfolderMock).deleteIfExists(lockUri); verify(hotfolderMock).copyTmpFile("lock", lockUri); }
### Question: LockFileHandler { public void deleteLockAndCleanUp() { synchronized(monitor) { try { hotfolder.deleteIfExists(lockUri); } catch (IOException e) { logger.error("Error while deleting lock file: " + lockUri, e); } } } void initConnection(String serverUrl, String user, String password); void createOrOverwriteLock(boolean overwriteLock); void deleteLockAndCleanUp(); }### Answer: @Test public void shouldDeleteLock() throws IOException { lockHandlerSut.deleteLockAndCleanUp(); verify(hotfolderMock).deleteIfExists(lockUri); }
### Question: JackrabbitHotfolder extends ServerHotfolder implements Hotfolder, Serializable { @Override public void upload(URI fromLocal, URI toRemote) throws IOException { File sourceFile = new File(fromLocal); String targetUri = toRemote.toString(); if (!fileAccess.fileExists(sourceFile)) { log.error("File " + sourceFile + " doesn't exist."); throw new IllegalArgumentException("File " + sourceFile + " doesn't exist."); } PutMethod putMethod = new PutMethod(targetUri); String mimeType = URLConnection.guessContentTypeFromName(sourceFile.getPath()); putMethod.setRequestEntity(new FileRequestEntity(sourceFile, mimeType)); try { execute(putMethod); } finally { putMethod.releaseConnection(); } } void configureConnection(String serverUrl, String username, String password); @Override void upload(URI fromLocal, URI toRemote); @Override void download(URI fromRemote, URI toLocal); @Override void delete(URI uri); @Override boolean exists(URI uri); @Override long getUsedSpace(URI uri); @Override byte[] getResponse(URI uri); }### Answer: @Test public void shouldUploadToRemote() throws IOException, URISyntaxException { jackrabbitSut.upload(new URI("file:/test.jpg"), new URI("http: verify(httpClientMock).executeMethod(any(PutMethod.class)); } @Test(expected=IllegalArgumentException.class) public void shouldFailWithNotExistingFile() throws IOException, URISyntaxException { when(fileAccessMock.fileExists(any(File.class))).thenReturn(false); jackrabbitSut.upload(new URI("file:/test.jpg"), new URI("http: } @Test(expected=IllegalStateException.class) public void shouldFailWhenIllegalStatusCode() throws IOException, URISyntaxException { when(httpClientMock.executeMethod(any(HttpMethod.class))).thenReturn(403); jackrabbitSut.upload(new URI("file:/test.jpg"), new URI("http: } @Test public void shouldIgnoreOneIllegalStatusCode() throws IOException, URISyntaxException { when(httpClientMock.executeMethod(any(HttpMethod.class))).thenReturn(403, 200); jackrabbitSut.upload(new URI("file:/test.jpg"), new URI("http: verify(httpClientMock, times(2)).executeMethod(any(PutMethod.class)); }
### Question: JackrabbitHotfolder extends ServerHotfolder implements Hotfolder, Serializable { @Override public void download(URI fromRemote, URI toLocal) throws IOException { String sourceUri = fromRemote.toString(); File targetFile = new File(toLocal); GetMethod getMethod = new GetMethod(sourceUri); InputStream responseStream = null; try { responseStream = execute(getMethod); fileAccess.copyStreamToFile(responseStream, targetFile); } finally { responseStream.close(); getMethod.releaseConnection(); } } void configureConnection(String serverUrl, String username, String password); @Override void upload(URI fromLocal, URI toRemote); @Override void download(URI fromRemote, URI toLocal); @Override void delete(URI uri); @Override boolean exists(URI uri); @Override long getUsedSpace(URI uri); @Override byte[] getResponse(URI uri); }### Answer: @Test public void shouldDownloadToLocal() throws IOException, URISyntaxException { jackrabbitSut.download(new URI("http: verify(httpClientMock).executeMethod(any(GetMethod.class)); verify(fileAccessMock).copyStreamToFile(any(InputStream.class), any(File.class)); }
### Question: JackrabbitHotfolder extends ServerHotfolder implements Hotfolder, Serializable { @Override public void delete(URI uri) throws IOException { DeleteMethod delMethod = new DeleteMethod(uri.toString()); try { execute(delMethod); } finally { delMethod.releaseConnection(); } } void configureConnection(String serverUrl, String username, String password); @Override void upload(URI fromLocal, URI toRemote); @Override void download(URI fromRemote, URI toLocal); @Override void delete(URI uri); @Override boolean exists(URI uri); @Override long getUsedSpace(URI uri); @Override byte[] getResponse(URI uri); }### Answer: @Test public void shouldDelete() throws IOException, URISyntaxException { jackrabbitSut.delete(new URI("http: verify(httpClientMock).executeMethod(any(DeleteMethod.class)); }
### Question: JackrabbitHotfolder extends ServerHotfolder implements Hotfolder, Serializable { @Override public boolean exists(URI uri) throws IOException { HeadMethod headMethod = new HeadMethod(uri.toString()); try { headMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(10, false)); int responseCode = client.executeMethod(headMethod); if (responseCode == HttpStatus.SC_OK) { return true; } return false; } finally { headMethod.releaseConnection(); } } void configureConnection(String serverUrl, String username, String password); @Override void upload(URI fromLocal, URI toRemote); @Override void download(URI fromRemote, URI toLocal); @Override void delete(URI uri); @Override boolean exists(URI uri); @Override long getUsedSpace(URI uri); @Override byte[] getResponse(URI uri); }### Answer: @Test public void uriShouldExist() throws HttpException, IOException, URISyntaxException { when(httpClientMock.executeMethod(any(HeadMethod.class))).thenReturn(200); assertTrue("URI must exist", jackrabbitSut.exists(new URI("http: } @Test public void uriShouldNotExist() throws HttpException, IOException, URISyntaxException { when(httpClientMock.executeMethod(any(HeadMethod.class))).thenReturn(401); assertFalse("URI must not exist", jackrabbitSut.exists(new URI("http: }
### Question: JackrabbitHotfolder extends ServerHotfolder implements Hotfolder, Serializable { @Override public byte[] getResponse(URI uri) throws IOException { GetMethod getMethod = new GetMethod(uri.toString()); InputStream responseStream = null; try { responseStream = execute(getMethod); byte[] responseBytes = IOUtils.toByteArray(responseStream); return responseBytes; } finally { responseStream.close(); getMethod.releaseConnection(); } } void configureConnection(String serverUrl, String username, String password); @Override void upload(URI fromLocal, URI toRemote); @Override void download(URI fromRemote, URI toLocal); @Override void delete(URI uri); @Override boolean exists(URI uri); @Override long getUsedSpace(URI uri); @Override byte[] getResponse(URI uri); }### Answer: @Test public void shouldTryToGetResponse() throws IOException, URISyntaxException { byte[] response = jackrabbitSut.getResponse(new URI("http: verify(httpClientMock).executeMethod(any(GetMethod.class)); assertFalse("Response may not be null", response == null); assertTrue("Response should be empty", response.length == 0); }
### Question: AbbyyProcess extends AbstractProcess implements OcrProcess,Serializable,Cloneable, Runnable { public void initialize(Properties initProps) { props = initProps; hotfolderManager = createHotfolderManager(); abbyyTicket = createAbbyyTicket(this); processId = java.util.UUID.randomUUID().toString(); windowsPathForServer = props.getProperty("serverOutputLocation"); try { URI serverUri = new URI(props.getProperty("serverUrl")); inputDavUri = new URI(serverUri + props.getProperty("inputFolder") + "/"); outputDavUri = new URI(serverUri + props.getProperty("outputFolder") + "/"); errorDavUri = new URI(serverUri + props.getProperty("errorFolder") + "/"); resultXmlDavUri = new URI(serverUri + props.getProperty("resultXmlFolder") + "/"); abbyyTicket.setRemoteInputFolder(inputDavUri); abbyyTicket.setRemoteErrorFolder(errorDavUri); } catch (URISyntaxException e) { logger.error("Can't setup server uris (" + getName() + ")"); throw new IllegalArgumentException(e); } } void initialize(Properties initProps); String getWindowsPathForServer(); @Override void run(); @Override void addImage(URI localUri); boolean hasFailed(); boolean hasEnoughSpaceForExecution(); @Override void addOutput(OcrFormat format); void setMerger(ProcessMergingObserver newMerger); String getProcessId(); void setProcessId(String processId); boolean hasFinished(); void setFinished(); List<String> getRemoteImageNames(); AbbyyProcess createSubProcess(); Long getStartedAt(); void setStartedAt(long time); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void shouldInitializeTicket() throws URISyntaxException { processSut.initialize(validProps()); verify(ticketMock).setRemoteInputFolder(new URI("http: } @Test(expected=IllegalArgumentException.class) public void shouldNotAcceptIllegalUri() throws URISyntaxException { Properties props = validProps(); props.setProperty("serverUrl", ">not-a-url"); processSut.initialize(props); }
### Question: AbbyyFactory extends OcrFactoryWithProperties { protected Properties getCombinedProps() { String configFile = userProperties.getProperty("abbyy.config", "gbv-antiqua.properties"); FileAccess fileAccess = beanProvider.getFileAccess(); Properties fileProps = fileAccess.getPropertiesFromFile(configFile); Properties combinedProps = new Properties(fileProps); for (String userKey : userProperties.stringPropertyNames()) { combinedProps.setProperty(userKey, userProperties.getProperty(userKey)); } return combinedProps; } AbbyyFactory(Properties userProperties); @Override OcrEngine createEngine(); @Override OcrProcess createProcess(); }### Answer: @Test public void shouldCombineProperties() { Properties combinedProps = factorySut.getCombinedProps(); assertEquals("userValue", combinedProps.getProperty("userKey")); assertEquals("fileValue", combinedProps.getProperty("fileKey")); } @Test public void shouldUseDefaultConfigFile() { factorySut.getCombinedProps(); verify(fileAccessMock).getPropertiesFromFile("gbv-antiqua.properties"); }
### Question: HotfolderManager { public void deleteOutputs(List<OcrOutput> outputs) throws IOException { for (OcrOutput out : outputs) { AbbyyOutput abbyyOut = (AbbyyOutput) out; URI remoteUri = abbyyOut.getRemoteUri(); hotfolder.deleteIfExists(remoteUri); } } HotfolderManager(String serverUrl, String user, String password); HotfolderManager(Hotfolder initHotfolder); void deleteOutputs(List<OcrOutput> outputs); void deleteImages(List<OcrImage> images); void copyImagesToHotfolder(List<OcrImage> ocrImages); void retrieveResults(List<OcrOutput> ocrOutputs); void createAndSendTicket(AbbyyTicket abbyyTicket, String name); void waitForResults(long timeout, long waitInterval, List<OcrOutput> outputs, URI errorResultXmlUri); boolean enoughSpaceAvailable(long maxSpace, URI inputFolder, URI outputFolder, URI errorFolder); void deleteTicket(AbbyyTicket abbyyTicket); String readFromErrorFile(URI errorResultUri, String processName); }### Answer: @Test public void shouldDeleteRemoteOutputs() throws URISyntaxException, IOException { List<OcrOutput> outputsToDelete = validOutputs(); managerSut.deleteOutputs(outputsToDelete); verify(hotfolderMock, times(2)).deleteIfExists(any(URI.class)); }
### Question: HotfolderManager { public void deleteImages(List<OcrImage> images) throws IOException { for (OcrImage ocrImage : images) { AbbyyImage image = (AbbyyImage) ocrImage; URI remoteUri = image.getRemoteUri(); hotfolder.deleteIfExists(remoteUri); URI errorImageUri = image.getErrorUri(); hotfolder.deleteIfExists(errorImageUri); } } HotfolderManager(String serverUrl, String user, String password); HotfolderManager(Hotfolder initHotfolder); void deleteOutputs(List<OcrOutput> outputs); void deleteImages(List<OcrImage> images); void copyImagesToHotfolder(List<OcrImage> ocrImages); void retrieveResults(List<OcrOutput> ocrOutputs); void createAndSendTicket(AbbyyTicket abbyyTicket, String name); void waitForResults(long timeout, long waitInterval, List<OcrOutput> outputs, URI errorResultXmlUri); boolean enoughSpaceAvailable(long maxSpace, URI inputFolder, URI outputFolder, URI errorFolder); void deleteTicket(AbbyyTicket abbyyTicket); String readFromErrorFile(URI errorResultUri, String processName); }### Answer: @Test public void shouldDeleteRemoteImages() throws URISyntaxException, IOException { List<OcrImage> imagesToDelete = validImages(); managerSut.deleteImages(imagesToDelete); verify(hotfolderMock, times(4)).deleteIfExists(any(URI.class)); }
### Question: HotfolderManager { public void copyImagesToHotfolder(List<OcrImage> ocrImages) throws IOException { for (OcrImage ocrImage : ocrImages) { AbbyyImage image = (AbbyyImage) ocrImage; URI fromUri = image.getLocalUri(); URI toUri = image.getRemoteUri(); hotfolder.upload(fromUri, toUri); } } HotfolderManager(String serverUrl, String user, String password); HotfolderManager(Hotfolder initHotfolder); void deleteOutputs(List<OcrOutput> outputs); void deleteImages(List<OcrImage> images); void copyImagesToHotfolder(List<OcrImage> ocrImages); void retrieveResults(List<OcrOutput> ocrOutputs); void createAndSendTicket(AbbyyTicket abbyyTicket, String name); void waitForResults(long timeout, long waitInterval, List<OcrOutput> outputs, URI errorResultXmlUri); boolean enoughSpaceAvailable(long maxSpace, URI inputFolder, URI outputFolder, URI errorFolder); void deleteTicket(AbbyyTicket abbyyTicket); String readFromErrorFile(URI errorResultUri, String processName); }### Answer: @Test public void shouldUploadImages() throws URISyntaxException, IOException { List<OcrImage> imagesToCopy = validImages(); managerSut.copyImagesToHotfolder(imagesToCopy); verify(hotfolderMock).upload(new URI("file:/01.tif"), new URI("http: verify(hotfolderMock).upload(new URI("file:/02.tif"), new URI("http: }
### Question: HotfolderManager { public void retrieveResults(List<OcrOutput> ocrOutputs) throws IOException { for (OcrOutput entry : ocrOutputs) { AbbyyOutput o = (AbbyyOutput) entry; URI remoteUri = o.getRemoteUri(); URI localUri = o.getLocalUri(); hotfolder.download(remoteUri, localUri); hotfolder.deleteIfExists(remoteUri); } } HotfolderManager(String serverUrl, String user, String password); HotfolderManager(Hotfolder initHotfolder); void deleteOutputs(List<OcrOutput> outputs); void deleteImages(List<OcrImage> images); void copyImagesToHotfolder(List<OcrImage> ocrImages); void retrieveResults(List<OcrOutput> ocrOutputs); void createAndSendTicket(AbbyyTicket abbyyTicket, String name); void waitForResults(long timeout, long waitInterval, List<OcrOutput> outputs, URI errorResultXmlUri); boolean enoughSpaceAvailable(long maxSpace, URI inputFolder, URI outputFolder, URI errorFolder); void deleteTicket(AbbyyTicket abbyyTicket); String readFromErrorFile(URI errorResultUri, String processName); }### Answer: @Test public void shouldDownloadResultOutputs() throws URISyntaxException, IOException { List<OcrOutput> outputsToMove = validOutputs(); managerSut.retrieveResults(outputsToMove); verify(hotfolderMock).download(new URI("http: verify(hotfolderMock).deleteIfExists(new URI("http: verify(hotfolderMock).download(new URI("http: verify(hotfolderMock).deleteIfExists(new URI("http: }
### Question: HotfolderManager { public void createAndSendTicket(AbbyyTicket abbyyTicket, String name) throws IOException, URISyntaxException { String ticketFileName = name + ".xml"; URI inputTicketUri = abbyyTicket.getRemoteInputUri(); OutputStream os = hotfolder.createTmpFile(ticketFileName); abbyyTicket.write(os); if (os != null) os.close(); hotfolder.copyTmpFile(ticketFileName, inputTicketUri); hotfolder.deleteTmpFile(ticketFileName); } HotfolderManager(String serverUrl, String user, String password); HotfolderManager(Hotfolder initHotfolder); void deleteOutputs(List<OcrOutput> outputs); void deleteImages(List<OcrImage> images); void copyImagesToHotfolder(List<OcrImage> ocrImages); void retrieveResults(List<OcrOutput> ocrOutputs); void createAndSendTicket(AbbyyTicket abbyyTicket, String name); void waitForResults(long timeout, long waitInterval, List<OcrOutput> outputs, URI errorResultXmlUri); boolean enoughSpaceAvailable(long maxSpace, URI inputFolder, URI outputFolder, URI errorFolder); void deleteTicket(AbbyyTicket abbyyTicket); String readFromErrorFile(URI errorResultUri, String processName); }### Answer: @Test public void shouldSendTicket() throws URISyntaxException, IOException { AbbyyTicket ticketMock = mock(AbbyyTicket.class); when(ticketMock.getRemoteInputUri()).thenReturn(new URI("http: managerSut.createAndSendTicket(ticketMock, "ticket"); verify(hotfolderMock).copyTmpFile("ticket.xml", new URI("http: }
### Question: HotfolderManager { public void waitForResults(long timeout, long waitInterval, List<OcrOutput> outputs, URI errorResultXmlUri) throws TimeoutException, IOException { long start = System.currentTimeMillis(); List<URI> mustBeThereUris = extractFromOutputs(outputs); outerLoop: while (true) { checkIfError(start, timeout, errorResultXmlUri); for (URI expectedUri : mustBeThereUris) { if (!hotfolder.exists(expectedUri)) { logger.debug(expectedUri.toString() + " is not yet available"); waitALittle(waitInterval); continue outerLoop; } } logger.debug("Got all files."); break; } } HotfolderManager(String serverUrl, String user, String password); HotfolderManager(Hotfolder initHotfolder); void deleteOutputs(List<OcrOutput> outputs); void deleteImages(List<OcrImage> images); void copyImagesToHotfolder(List<OcrImage> ocrImages); void retrieveResults(List<OcrOutput> ocrOutputs); void createAndSendTicket(AbbyyTicket abbyyTicket, String name); void waitForResults(long timeout, long waitInterval, List<OcrOutput> outputs, URI errorResultXmlUri); boolean enoughSpaceAvailable(long maxSpace, URI inputFolder, URI outputFolder, URI errorFolder); void deleteTicket(AbbyyTicket abbyyTicket); String readFromErrorFile(URI errorResultUri, String processName); }### Answer: @Test public void shouldWaitForResultsVeryShort() throws URISyntaxException, TimeoutException, IOException { List<OcrOutput> outputsToWaitFor = validOutputs(); when(hotfolderMock.exists(any(URI.class))).thenReturn(true); when(hotfolderMock.exists(new URI("http: managerSut.waitForResults(10, 1, outputsToWaitFor, new URI("http: verify(pauseMock, never()).forMilliseconds(anyLong()); } @Test public void shouldWaitOneIterationForEachFile() throws URISyntaxException, IOException, TimeoutException { List<OcrOutput> outputsToWaitFor = validOutputs(); when(hotfolderMock.exists(new URI("http: when(hotfolderMock.exists(new URI("http: when(hotfolderMock.exists(new URI("http: managerSut.waitForResults(10, 1, outputsToWaitFor, new URI("http: verify(pauseMock, times(2)).forMilliseconds(1); } @Test(expected=TimeoutException.class) public void shouldProvokeTimeout() throws URISyntaxException, IOException, TimeoutException { List<OcrOutput> outputsToWaitFor = validOutputs(); when(hotfolderMock.exists(new URI("http: managerSut.waitForResults(1, 1, outputsToWaitFor, new URI("http: } @Test(expected=IOException.class) public void shouldFindErrorFile() throws URISyntaxException, IOException, TimeoutException { List<OcrOutput> outputsToWaitFor = validOutputs(); when(hotfolderMock.exists(new URI("http: managerSut.waitForResults(1, 1, outputsToWaitFor, new URI("http: }
### Question: HotfolderManager { public boolean enoughSpaceAvailable(long maxSpace, URI inputFolder, URI outputFolder, URI errorFolder) throws IOException { long totalFileSize = hotfolder.getUsedSpace(inputFolder) + hotfolder.getUsedSpace(outputFolder) + hotfolder.getUsedSpace(errorFolder); logger.debug("TotalFileSize = " + totalFileSize); if (totalFileSize >= maxSpace) { logger.warn("Size of files is too high. Allowed space for all files is " + maxSpace + ". Size of files in hotfolder: " + totalFileSize + "."); return false; } else { return true; } } HotfolderManager(String serverUrl, String user, String password); HotfolderManager(Hotfolder initHotfolder); void deleteOutputs(List<OcrOutput> outputs); void deleteImages(List<OcrImage> images); void copyImagesToHotfolder(List<OcrImage> ocrImages); void retrieveResults(List<OcrOutput> ocrOutputs); void createAndSendTicket(AbbyyTicket abbyyTicket, String name); void waitForResults(long timeout, long waitInterval, List<OcrOutput> outputs, URI errorResultXmlUri); boolean enoughSpaceAvailable(long maxSpace, URI inputFolder, URI outputFolder, URI errorFolder); void deleteTicket(AbbyyTicket abbyyTicket); String readFromErrorFile(URI errorResultUri, String processName); }### Answer: @Test public void shouldAcceptMaxSizeOfAllFiles() throws IOException, URISyntaxException { when(hotfolderMock.getUsedSpace(any(URI.class))).thenReturn(1L).thenReturn(2L).thenReturn(3L); boolean enoughSpace = managerSut.enoughSpaceAvailable(7, new URI("http: assertTrue("There should be enough space.", enoughSpace); } @Test public void shouldHaveTooLittleSpace() throws IOException, URISyntaxException { when(hotfolderMock.getUsedSpace(any(URI.class))).thenReturn(1L).thenReturn(2L).thenReturn(3L); boolean enoughSpace = managerSut.enoughSpaceAvailable(5, new URI("http: assertFalse("There should be too little space", enoughSpace); }
### Question: ProcessSplitter { public List<AbbyyProcess> split(AbbyyProcess process, int splitSize) { if (process.getNumberOfImages() == 0) { throw new IllegalArgumentException("Cannot split the process, it has no images: " + process.getName()); } if (process.getNumberOfImages() <= splitSize) { List<AbbyyProcess> sp = new ArrayList<AbbyyProcess>(); sp.add(process); return sp; } else { mergingObserver.setParentProcess(process); List<AbbyyProcess> subProcesses = createSubProcesses(process, splitSize); for(AbbyyProcess subProcess : subProcesses){ subProcess.setMerger(mergingObserver); mergingObserver.addSubProcess(subProcess); } return subProcesses; } } List<AbbyyProcess> split(AbbyyProcess process, int splitSize); }### Answer: @Test public void shouldNotSplitBecauseOfFewImages() { when(processMock.getNumberOfImages()).thenReturn(2); List<AbbyyProcess> splitResults = splitterSut.split(processMock, 2); assertEquals("Should not split a small process", processMock, splitResults.get(0)); } @Test(expected=IllegalArgumentException.class) public void shouldRejectProcessWithoutImages() { when(processMock.getNumberOfImages()).thenReturn(0); splitterSut.split(processMock, 1); } @Test public void shouldSplitOneProcessIntoTwo() throws URISyntaxException { when(processMock.getNumberOfImages()).thenReturn(2); when(processMock.getImages()).thenReturn(testImages()); when(processMock.getName()).thenReturn("testMock"); AbbyyProcess subProcessMock1 = mock(AbbyyProcess.class); AbbyyProcess subProcessMock2 = mock(AbbyyProcess.class); when(processMock.createSubProcess()).thenReturn(subProcessMock1, subProcessMock2); List<AbbyyProcess> splitResults = splitterSut.split(processMock, 1); assertEquals("Number of split subprocesses", 2, splitResults.size()); assertSame("First subprocess", subProcessMock1, splitResults.get(0)); assertSame("Second subprocess", subProcessMock2, splitResults.get(1)); verify(subProcessMock1).setName("testMock_1of2"); verify(subProcessMock2).setName("testMock_2of2"); }
### Question: OcrExecutor extends ThreadPoolExecutor implements Executor { void setWaitingTime(long newTime) { waitingTimeInMillis = newTime; } OcrExecutor(int maxParallelThreads); }### Answer: @Test public void shouldWakeUpAfterClearingSpace() throws IOException, InterruptedException { when(processMock1.hasEnoughSpaceForExecution()).thenReturn(false, true); executorSut.setWaitingTime(10); executorSut.execute(processMock1); shutdownExecutor(); verify(processMock1).run(); } @Test public void shouldWaitTooLong() throws IOException, InterruptedException { when(processMock1.hasEnoughSpaceForExecution()).thenReturn(false); executorSut.setWaitingTime(50); executorSut.execute(processMock1); shutdownExecutor(); verify(processMock1, never()).run(); } @Test public void secondProcessShouldWakeTheFirst() throws IOException, InterruptedException { executorSut.setWaitingTime(VERY_LONG); when(processMock1.hasEnoughSpaceForExecution()).thenReturn(false, true); when(processMock2.hasEnoughSpaceForExecution()).thenReturn(true); executorSut.execute(processMock1); Thread.sleep(10); executorSut.execute(processMock2); shutdownExecutor(); verify(processMock1).run(); verify(processMock2).run(); } @Test public void firstProcessShouldWakeTheSecond() throws IOException, InterruptedException { executorSut.setWaitingTime(VERY_LONG); when(processMock1.hasEnoughSpaceForExecution()).thenReturn(true); when(processMock2.hasEnoughSpaceForExecution()).thenReturn(false, true); doAnswer(withShortPause).when(processMock1).run(); executorSut.execute(processMock1); Thread.sleep(5); executorSut.execute(processMock2); shutdownExecutor(); verify(processMock1).run(); verify(processMock2).run(); }
### Question: HazelcastLockFileHandler extends LockFileHandler { @Override public void createOrOverwriteLock(boolean overwriteLock) { boolean threwException = false; Lock monitor = hazelcast.getLock("monitor"); monitor.lock(); try { if (overwriteLock) { hotfolder.deleteIfExists(lockUri); } Set<String> lockRegisteringSet = hazelcast.getSet("lockSet"); boolean lockExists = hotfolder.exists(lockUri); if (!lockExists) { writeLockFile(); lockRegisteringSet.add("lockEntry"); } else if (lockExists && !lockRegisteringSet.contains("lockEntry")) { threwException = true; throw new ConcurrentModificationException("Another client instance is running! See the lock file at " + lockUri); } } catch (IOException e) { logger.error("Error with server lock file: " + lockUri, e); } finally { monitor.unlock(); if (threwException) { hazelcast.getLifecycleService().shutdown(); } } } HazelcastLockFileHandler(HazelcastInstance hazelcast); @Override void createOrOverwriteLock(boolean overwriteLock); @Override void deleteLockAndCleanUp(); }### Answer: @Test public void shouldCreateNewLock() throws IOException { when(hotfolderMock.exists(lockUri)).thenReturn(false); when(hotfolderMock.createTmpFile(anyString())).thenReturn(new ByteArrayOutputStream()); lockHandlerSut.createOrOverwriteLock(false); verify(hotfolderMock, never()).deleteIfExists(lockUri); verify(hotfolderMock).copyTmpFile("lock", lockUri); } @Test(expected=ConcurrentModificationException.class) public void shouldCancelWhenLockIsPresentButNotRegistered() throws IOException { when(hotfolderMock.exists(lockUri)).thenReturn(true); when(registeringSetMock.contains(anyObject())).thenReturn(false); lockHandlerSut.createOrOverwriteLock(false); } @Test public void shouldIgnoreLockIfPresentAndRegistered() throws IOException { when(hotfolderMock.exists(lockUri)).thenReturn(true); when(registeringSetMock.contains(anyObject())).thenReturn(true); lockHandlerSut.createOrOverwriteLock(false); verify(hotfolderMock, never()).deleteIfExists(lockUri); verify(hotfolderMock, never()).copyTmpFile("lock", lockUri); } @Test public void shouldOverwriteLock() throws IOException { when(hotfolderMock.exists(lockUri)).thenReturn(false); when(hotfolderMock.createTmpFile(anyString())).thenReturn(new ByteArrayOutputStream()); lockHandlerSut.createOrOverwriteLock(true); verify(hotfolderMock).deleteIfExists(lockUri); verify(hotfolderMock).copyTmpFile("lock", lockUri); }
### Question: HazelcastLockFileHandler extends LockFileHandler { @Override public void deleteLockAndCleanUp() { Lock monitor = hazelcast.getLock("monitor"); monitor.lock(); try { if (hazelcast.getCluster().getMembers().size() == 1) { hotfolder.delete(lockUri); } } catch (IOException e) { logger.error("Error while deleting lock file: " + lockUri, e); } finally { monitor.unlock(); hazelcast.getLifecycleService().shutdown(); } } HazelcastLockFileHandler(HazelcastInstance hazelcast); @Override void createOrOverwriteLock(boolean overwriteLock); @Override void deleteLockAndCleanUp(); }### Answer: @Test public void shouldDeleteLock() throws IOException { when(hazelMock.getCluster().getMembers().size()).thenReturn(1); lockHandlerSut.deleteLockAndCleanUp(); verify(hotfolderMock).delete(lockUri); } @Test public void shouldNotDeleteLock() throws IOException { when(hazelMock.getCluster().getMembers().size()).thenReturn(2); lockHandlerSut.deleteLockAndCleanUp(); verify(hotfolderMock, never()).delete(lockUri); }
### Question: HazelcastExecutor extends ThreadPoolExecutor implements Executor { void setWaitingTime(long newTime) { waitingTimeInMillis = newTime; } HazelcastExecutor(int maxParallelThreads, HazelcastInstance hazelcast); }### Answer: @Test public void shouldWakeUpByItself() throws InterruptedException { configureProcessMock(processMockA1, "book1", OcrPriority.NORMAL, 1L, NOT_ENOUGH_SPACE, ENOUGH_SPACE); executorSutA.setWaitingTime(10); executorSutA.execute(processMockA1); shutdownExecutors(); verify(processMockA1).run(); } @Test public void shouldNeverWakeUp() throws InterruptedException { configureProcessMock(processMockA1, "book1", OcrPriority.NORMAL, 1L, NOT_ENOUGH_SPACE); executorSutA.setWaitingTime(10); executorSutA.execute(processMockA1); shutdownExecutors(); verify(processMockA1, never()).run(); } @Test public void secondShouldFreeFirst() throws InterruptedException { configureProcessMock(processMockA1, "book1", OcrPriority.NORMAL, 1L, NOT_ENOUGH_SPACE, ENOUGH_SPACE); configureProcessMock(processMockA2, "book2", OcrPriority.ABOVENORMAL, 2L, ENOUGH_SPACE); executorSutA.setWaitingTime(VERY_LONG); executorSutA.execute(processMockA1); Thread.sleep(10); executorSutA.execute(processMockA2); shutdownExecutors(); verify(processMockA1).run(); verify(processMockA2).run(); }
### Question: HazelcastExecutor extends ThreadPoolExecutor implements Executor { long getStartedLastProcessAt() { return startedExecutingAt; } HazelcastExecutor(int maxParallelThreads, HazelcastInstance hazelcast); }### Answer: @Test public void shouldPreferHigherPriority() throws InterruptedException { executorSutA = initSut(1); executorSutB = initSut(1); executorSutC = initSut(1); configureProcessMock(processMockA1, "bookA1", OcrPriority.NORMAL, 1L, ENOUGH_SPACE); doAnswer(withShortPause).when(processMockA1).run(); configureProcessMock(processMockB1, "bookB1", OcrPriority.NORMAL, 4L, ENOUGH_SPACE); configureProcessMock(processMockC1, "bookC1", OcrPriority.ABOVENORMAL, 5L, ENOUGH_SPACE); executorSutA.execute(processMockA1); Thread.sleep(3); executorSutB.execute(processMockB1); Thread.sleep(3); executorSutC.execute(processMockC1); shutdownExecutors(); verify(processMockA1).run(); verify(processMockB1).run(); verify(processMockC1).run(); boolean lastWasPrioritized = executorSutC.getStartedLastProcessAt() < executorSutB.getStartedLastProcessAt(); assertTrue("The last process should move up the queue", lastWasPrioritized); } @Test public void shouldPreferSmallerTimestamp() throws InterruptedException { executorSutA = initSut(1); executorSutB = initSut(1); executorSutC = initSut(1); configureProcessMock(processMockA1, "bookA1", OcrPriority.NORMAL, 1L, ENOUGH_SPACE); doAnswer(withShortPause).when(processMockA1).run(); configureProcessMock(processMockB1, "bookB1", OcrPriority.NORMAL, 4L, ENOUGH_SPACE); configureProcessMock(processMockC1, "bookC1", OcrPriority.NORMAL, 5L, ENOUGH_SPACE); executorSutA.execute(processMockA1); Thread.sleep(3); executorSutC.execute(processMockC1); executorSutB.execute(processMockB1); shutdownExecutors(); verify(processMockA1).run(); verify(processMockB1).run(); verify(processMockC1).run(); boolean orderedByTimestamp = executorSutB.getStartedLastProcessAt() < executorSutC.getStartedLastProcessAt(); assertTrue("The processes should have been ordered by timestamp", orderedByTimestamp); }
### Question: Http { public String submitPost(String url, byte[] postData) { String response = ""; try { URL u = new URL(url); HttpURLConnection connection = (HttpURLConnection) u.openConnection(); connection.setDoOutput(true); connection.setDoInput(true); connection.setRequestMethod("POST"); setupAuthorization(connection); connection.setRequestProperty("Content-Type", "applicaton/octet-stream"); connection.setRequestProperty("Content-Length", Integer.toString(postData.length)); connection.getOutputStream().write(postData); InputStream is = getResponseFrom(connection); response = IOUtils.toString(is); } catch (IOException e) { throw new RuntimeException("Error with connection.", e); } return response; } Http(String user, String password); String submitPost(String url, byte[] postData); String submitGet(String url); InputStream submitGetWithoutAuthentication(String url); }### Answer: @Test public void sendingPost() throws Exception { Http http = new Http("", ""); String response = http.submitPost("http: assertThat(response, containsString("<httpMethod>POST</httpMethod>")); } @Test public void serverMustReceiveCredentials() throws Exception { Http http = new Http("user", "pw"); String response = http.submitPost("http: assertThat(response, containsString("<basicAuth>user:pw</basicAuth>")); } @Test public void serverMustReceivePostData() throws Exception { Http http = new Http("", ""); byte[] bytesToSend = {4, 2}; String response = http.submitPost("http: assertThat(response, containsString("<contentLength>2</contentLength>")); assertThat(response, containsString("<content>42</content>")); } @Test(expected=RuntimeException.class) public void sendingPostToUnauthorized() throws Exception { Http http = new Http("", ""); http.submitPost("http: } @Test(expected=RuntimeException.class) public void sendingPostToUnreachable() throws Exception { Http http = new Http("", ""); http.submitPost("http: }
### Question: Http { public String submitGet(String url) { String response = ""; try { URL u = new URL(url); HttpURLConnection connection = (HttpURLConnection) u.openConnection(); setupAuthorization(connection); InputStream is = getResponseFrom(connection); response = IOUtils.toString(is); } catch (IOException e) { throw new RuntimeException("Error with connection.", e); } return response; } Http(String user, String password); String submitPost(String url, byte[] postData); String submitGet(String url); InputStream submitGetWithoutAuthentication(String url); }### Answer: @Test public void sendingGet() throws Exception { Http http = new Http("", ""); String response = http.submitGet("http: assertThat(response, containsString("<httpMethod>GET</httpMethod>")); } @Test(expected=RuntimeException.class) public void sendingGetToUnauthorized() throws Exception { Http http = new Http("", ""); http.submitGet("http: } @Test(expected=RuntimeException.class) public void sendingGetToUnreachable() throws Exception { Http http = new Http("", ""); http.submitGet("http: }
### Question: Http { public InputStream submitGetWithoutAuthentication(String url) { InputStream response = null; try { URL u = new URL(url); HttpURLConnection connection = (HttpURLConnection) u.openConnection(); response = getResponseFrom(connection); } catch (IOException e) { throw new RuntimeException("Error with connection.", e); } return response; } Http(String user, String password); String submitPost(String url, byte[] postData); String submitGet(String url); InputStream submitGetWithoutAuthentication(String url); }### Answer: @Test public void sendingGetWithoutAuthentication() throws Exception { Http http = new Http("user", "pw"); InputStream is = http.submitGetWithoutAuthentication("http: String response = IOUtils.toString(is); assertThat(response, containsString("<httpMethod>GET</httpMethod>")); assertThat(response, containsString("<basicAuth>none</basicAuth>")); }
### Question: OcrsdkClient { public void submitImage(byte[] imageBytes) { String returnedXml = http.submitPost(submitImageUrl(), imageBytes); if (taskId == null) { Element task = getTaskElement(returnedXml); taskId = task.getAttribute("id"); } } OcrsdkClient(String username, String password); void submitImage(byte[] imageBytes); void addLanguage(String lang); void addExportFormat(String format); void addTextType(String textType); void processDocument(); InputStream getResultForFormat(String format); }### Answer: @Test public void submittingOneImage() { client.submitImage(fakeImage); verify(httpMock, times(1)).submitPost(sdkServer + "submitImage", fakeImage); } @Test public void submittingTwoImages() { client.submitImage(fakeImage); client.submitImage(fakeImage); verify(httpMock, times(1)).submitPost(sdkServer + "submitImage", fakeImage); verify(httpMock, times(1)).submitPost(sdkServer + "submitImage?taskId=some-id", fakeImage); } @Test public void submittingThreeImages() { client.submitImage(fakeImage); client.submitImage(fakeImage); client.submitImage(fakeImage); verify(httpMock, times(1)).submitPost(sdkServer + "submitImage", fakeImage); verify(httpMock, times(2)).submitPost(sdkServer + "submitImage?taskId=some-id", fakeImage); }
### Question: OcrsdkClient { public void addExportFormat(String format) { if (formatsToUse.size() == 3) { throw new IllegalStateException("Max 3 result formats allowed!"); } formatsToUse.add(format); } OcrsdkClient(String username, String password); void submitImage(byte[] imageBytes); void addLanguage(String lang); void addExportFormat(String format); void addTextType(String textType); void processDocument(); InputStream getResultForFormat(String format); }### Answer: @Test(expected=IllegalStateException.class) public void processingWithFourExportFormats() { client.addExportFormat("xml"); client.addExportFormat("txt"); client.addExportFormat("docx"); client.addExportFormat("pdfa"); }
### Question: SelectPostgisLayerJDialog extends CancellableDialogAdapter { public String getPassword() { char[] chars = getPasswordInputField().getValue(); if (chars == null) return null; return new String(chars); } SelectPostgisLayerJDialog(Component parentWindowComponent); @Override boolean okClose(); String getHost(); String getPort(); String getDb(); String getUsername(); String getLayer(); String getPassword(); @Override void cancel(); boolean close(); }### Answer: @Test public void testGui() throws Throwable { if (!isInteractive()) return; SelectPostgisLayerJDialog selectPostgisLayerJDialog = new SelectPostgisLayerJDialog( null); TestingUtil.testGui(selectPostgisLayerJDialog); System.out.println(selectPostgisLayerJDialog.getPassword()); }
### Question: CliOptions extends Options { public void printHelp() { HelpFormatter formatter = new HelpFormatter(); formatter.printHelp("geopublisher", this); } CliOptions(); CommandLine parse(String[] args); void printHelp(); static int performArgs(final String[] args); static final String VERBOSE; static final String HELP; static final String EXPORT; static final String AWCFOLDER; static final String FORCE; static final String DISK; static final String JWS; }### Answer: @Test public void testPrintHelp() { new CliOptions().printHelp(); }
### Question: ACETranslationPrinter { private void printGroup(Group g, String... wayToHere) { LangUtil.extendArray(wayToHere, R("GroupTree.Action.Edit")); for (int gi = 0; gi < g.getChildCount(); gi++) { TreeNode child = g.getChildAt(gi); if (!child.isLeaf()) { Group subg = (Group) child; String[] longWay = LangUtil.extendArray(wayToHere, subg.getTitle().toString()); printWayH2(longWay); printTranslation(subg.getTitle(), "GroupTree.Edit.TranslateTitle"); printTranslation(subg.getDesc(), "GroupTree.Edit.TranslateDescription"); printTranslation(subg.getKeywords(), "GroupTree.Edit.TranslateKeywords"); printGroup(subg, longWay); } } } ACETranslationPrinter(AtlasConfigEditable ace); String printAllTranslations(); String R(String key, Object... values); }### Answer: @Test public void testPrintGroup() { }
### Question: GpHosterClient { public boolean userExists() throws IOException { return userExists(getUserName()); } GpHosterClient(GpHosterServerSettings serverDesc); GpHosterClient(); void setUserName(String userName); String getUserName(); void setPassword(String password); String getPassword(); boolean userExists(); boolean atlasBasenameFree(String baseName); boolean userDelete(String delUser, String delUserPassword); boolean userDelete(); CREATE_USER_RESULT userCreate(String username, String email); AtlasFingerprint informAboutUploadedZipFile(String atlasBasename, File zipFile); boolean canEditAtlas(String atlasBasename); AtlasFingerprint informAboutUploadedZipFile(String atlasBasename, File zipFile, String username, String password); String sendRESTstring(String method, String url, String xmlPostContent, String username, String password); String sendRESTstring(String method, String urlEncoded, String postData, String contentType, String accept, String username, String password); boolean userExists(String checkUsername); AtlasFingerprint atlasFingerprint(String atlasBasename); SERVICE_STATUS checkService(); String getFtpHostname(); void setFtpHostname(String ftphostname); GpHosterServerSettings getServerSettings(); boolean validateCredentials(); String getUrlForAtlas(String basename); static final String DEFAULT_GPHOSTER_REST_URL; static final String DEFAULT_GPHOSTER_FTP_HOSTNAME; static final String DEFAULt_GPHOSTER_FTP_URL; }### Answer: @Test @Ignore public void testUserExists() throws IOException { if (gphc.checkService() != SERVICE_STATUS.OK) return; assertFalse(gphc.userExists("asd")); assertTrue(gphc.userExists("w2")); }
### Question: GpHosterClient { public CREATE_USER_RESULT userCreate(String username, String email) throws IOException { SwingUtil.checkNotOnEDT(); int code = sendRESTint(METHOD.GET.toString(), CREATE_USER_PATH + username + "?email=" + email, null, MASTUSER, MASTPASSWD); if (code == SC_OK) return CREATE_USER_RESULT.CREATED_PWDSENT; if (code == 401) return CREATE_USER_RESULT.EXITSALREADY_PWDSENT; return CREATE_USER_RESULT.ERROR; } GpHosterClient(GpHosterServerSettings serverDesc); GpHosterClient(); void setUserName(String userName); String getUserName(); void setPassword(String password); String getPassword(); boolean userExists(); boolean atlasBasenameFree(String baseName); boolean userDelete(String delUser, String delUserPassword); boolean userDelete(); CREATE_USER_RESULT userCreate(String username, String email); AtlasFingerprint informAboutUploadedZipFile(String atlasBasename, File zipFile); boolean canEditAtlas(String atlasBasename); AtlasFingerprint informAboutUploadedZipFile(String atlasBasename, File zipFile, String username, String password); String sendRESTstring(String method, String url, String xmlPostContent, String username, String password); String sendRESTstring(String method, String urlEncoded, String postData, String contentType, String accept, String username, String password); boolean userExists(String checkUsername); AtlasFingerprint atlasFingerprint(String atlasBasename); SERVICE_STATUS checkService(); String getFtpHostname(); void setFtpHostname(String ftphostname); GpHosterServerSettings getServerSettings(); boolean validateCredentials(); String getUrlForAtlas(String basename); static final String DEFAULT_GPHOSTER_REST_URL; static final String DEFAULT_GPHOSTER_FTP_HOSTNAME; static final String DEFAULt_GPHOSTER_FTP_URL; }### Answer: @Test public void testUserCreate() throws IOException { if (gphc.checkService() != SERVICE_STATUS.OK) return; final String testUsername = "testUser" + System.currentTimeMillis(); assertFalse(gphc.userExists(testUsername)); assertEquals(CREATE_USER_RESULT.CREATED_PWDSENT, gphc.userCreate(testUsername, "[email protected]")); assertTrue(gphc.userExists(testUsername)); assertEquals("On the second try the username is not free anymore", CREATE_USER_RESULT.EXITSALREADY_PWDSENT, gphc.userCreate(testUsername, "[email protected]")); }
### Question: GpHosterClient { public boolean atlasBasenameFree(String baseName) throws IOException { return SC_OK == sendRESTint(METHOD.GET.toString(), CHECKFREE_ATLASNAME_PATH + baseName, null, null, null); } GpHosterClient(GpHosterServerSettings serverDesc); GpHosterClient(); void setUserName(String userName); String getUserName(); void setPassword(String password); String getPassword(); boolean userExists(); boolean atlasBasenameFree(String baseName); boolean userDelete(String delUser, String delUserPassword); boolean userDelete(); CREATE_USER_RESULT userCreate(String username, String email); AtlasFingerprint informAboutUploadedZipFile(String atlasBasename, File zipFile); boolean canEditAtlas(String atlasBasename); AtlasFingerprint informAboutUploadedZipFile(String atlasBasename, File zipFile, String username, String password); String sendRESTstring(String method, String url, String xmlPostContent, String username, String password); String sendRESTstring(String method, String urlEncoded, String postData, String contentType, String accept, String username, String password); boolean userExists(String checkUsername); AtlasFingerprint atlasFingerprint(String atlasBasename); SERVICE_STATUS checkService(); String getFtpHostname(); void setFtpHostname(String ftphostname); GpHosterServerSettings getServerSettings(); boolean validateCredentials(); String getUrlForAtlas(String basename); static final String DEFAULT_GPHOSTER_REST_URL; static final String DEFAULT_GPHOSTER_FTP_HOSTNAME; static final String DEFAULt_GPHOSTER_FTP_URL; }### Answer: @Test @Ignore public void testAtlasBasenameFree() throws IOException { assertTrue(gphc.atlasBasenameFree("33234534")); }
### Question: DpLayerVectorFeatureSourceShapefileEd extends DpLayerVectorFeatureSourceShapefile implements DpEditableInterface { static List<String> checkAttributeNames(URL url) throws IOException { ArrayList<String> illegalAttributeNames = new ArrayList<String>(); ShapefileDataStore store = new ShapefileDataStore(url); try { SimpleFeatureType schema2 = store.getSchema(); for (int aindex = 0; aindex < schema2.getAttributeCount(); aindex++) { AttributeDescriptor ad = schema2.getDescriptor(aindex); String localName = ad.getLocalName(); boolean ok = FeatureUtil .checkAttributeNameRestrictions(localName); if (!ok) illegalAttributeNames.add(aindex + ":" + localName); } } finally { store.dispose(); } return illegalAttributeNames; } DpLayerVectorFeatureSourceShapefileEd(AtlasConfig ac, URL url, Component owner); @Override File getSldFile(); @Override void setSldFile(File sldFile); @Override void copyFiles(URL urlToShape, Component owner, File targetDir, AtlasStatusDialogInterface status); AtlasConfigEditable getAce(); }### Answer: @Test public void testImportArabicInHeader() throws AtlasException, FactoryException, TransformException, SAXException, IOException, ParserConfigurationException { URL url = GpTestingUtil.TestDatasetsVector.arabicInHeader.getUrl(); List<String> illegalAtts = DpLayerVectorFeatureSourceShapefileEd .checkAttributeNames(url); assertEquals(1, illegalAtts.size()); assertTrue(illegalAtts.get(0).startsWith("3:")); }
### Question: JarExportUtil extends AbstractAtlasExporter { public File getTempDir() { return tempDir; } JarExportUtil(final AtlasConfigEditable ace_, ResultProgressHandle progress, final File exportDirectory, final Boolean toDisk, final Boolean toJws, final Boolean copyJRE); JarExportUtil(final AtlasConfigEditable ace_, final File exportDirectory, final Boolean toDisk, final Boolean toJws, final Boolean copyJRE); File getTargetDirJWS(); void setTargetDirJWS(File targetDirJWS); void addToJar(final File targetJar, final File baseDir, final String what); URL findJarUrl(String libName); File createJarFromDpe(final DpEntry<?> dpe); void createJSmooth(final File atlasDir); void export(); void zipDiskDir(File targetDirDISK2); File getTempDir(); boolean isZipDiskAfterExport(); void setZipDiskAfterExport(boolean zipDiskAfterExport); void setOverwriteJnlpBaseUrl(URL jwsUrl); boolean isFilterUnused(); void setFilterUnused(boolean filterUnused); static final String JWS; static final String DISK; static final String JSMOOTH_PROJEKT_RESOURCE; static final String JSMOOTH_SKEL_AD_RESOURCE1; static final String JSMOOTH_SKEL_AD_RESOURCE2; static final String JSMOOTH_SKEL_AD_RESOURCE3; final static String ARJAR_FILENAME; static final String JNLP_FILENAME; static final String DISK_SUB_DIR; static final String SCHMITZM_JARNAME1; static final String SCHMITZM_JARNAME2; static final String SCHMITZM_JARNAME3; static final String SCHMITZM_JARNAME4; static final String SCHMITZM_JARNAME5; static final String GSRCJ_JARNAME; static final String GPSYNC_JARNAME; static final String GPCORE_JARNAME; static final String AVSWINGGUI_JARNAME; static final String ASCORE_JARNAME; static final String MAIN_CLASS; }### Answer: @Test public void testJarExecutables() throws IOException { JarExportUtil jeu = new JarExportUtil(atlasConfig, atlasExportTesttDir, true, true, false); FileUtils.deleteDirectory(jeu.getTempDir()); }
### Question: ManageChartsForMapDialog extends CancellableDialogAdapter { public ManageChartsForMapDialog(Component owner, DpLayerVectorFeatureSource dplv, AtlasMapLegend mapLegend) { super(owner, GeopublisherGUI.R( "ManageChartsForMapDialog.TitleForDPLayer", dplv.getTitle() .toString())); this.dplv = dplv; this.atlasConfigEditable = (AtlasConfigEditable) dplv.getAtlasConfig(); this.map = mapLegend.getMap(); this.mapLegend = mapLegend; this.setVisibleChartIDs(map.getAvailableChartIDsFor(dplv.getId())); this.allChartIDs = dplv.getCharts(); backup_AvailableChartIDsFor.addAll(map.getAvailableChartIDsFor(dplv .getId())); backup_Charts.addAll(dplv.getCharts()); initGUI(); pack(); SwingUtil.setRelativeFramePosition(this, owner, SwingUtil.BOUNDS_OUTER, SwingUtil.NORTHWEST); SwingUtilities.invokeLater(new Runnable() { @Override public void run() { if (backup_Charts.size() == 0) getAddButton().getAction().actionPerformed(null); } }); } ManageChartsForMapDialog(Component owner, DpLayerVectorFeatureSource dplv, AtlasMapLegend mapLegend); void cancel(); @Override boolean okClose(); JTable getChartsJTable(); void openDesignChartDialog(final FeatureChartStyle chartStyle); JButton getUpJButton(); JButton getDownJButton(); JButton getDelButton(); JButton getEditButton(); JButton getAddButton(); void setVisibleChartIDs(ArrayList<String> visibleChartIDs); ArrayList<String> getVisibleChartIDs(); }### Answer: @Test public void testManageChartsForMapDialog() throws Throwable { Map map = null; DpLayerVectorFeatureSource dplv = null; AtlasConfigEditable ace = GpTestingUtil.getAtlasConfigE(TestAtlas.small); for (Map m : ace.getMapPool().values()) { for (DpRef<DpLayer<?, ? extends ChartStyle>> dpe : m.getLayers()) { if (dpe.getTarget() instanceof DpLayerVectorFeatureSource && dpe.getTarget().getCharts().size() > 0) { map = m; dplv = (DpLayerVectorFeatureSource) dpe.getTarget(); continue; } } if (map != null) continue; } assertNotNull("At least one vector layer with charts should be in the chart demo atlas", dplv); if (TestingUtil.INTERACTIVE) { AtlasMapLegend mapLegend = new AtlasMapLegend(new GeoMapPane(), map, ace, null); ManageChartsForMapDialog manageChartsForMapDialog = new ManageChartsForMapDialog( null, dplv, mapLegend); TestingUtil.testGui(manageChartsForMapDialog); } ace.deleteAtlas(); }
### Question: MapPoolDuplicateAction extends AbstractAction { @Override public void actionPerformed(ActionEvent e) { int idx = mapPoolJTable.getSelectedRow(); final Map map = mapPool.get(mapPoolJTable.convertRowIndexToModel(idx)); actionPerformed(map); } MapPoolDuplicateAction(MapPoolJTable mapPoolJTable); @Override void actionPerformed(ActionEvent e); Map actionPerformed(final Map map); }### Answer: @Test public void testDuplicateMap() throws AtlasException, FactoryException, TransformException, SAXException, IOException, ParserConfigurationException { AtlasConfigEditable ace = GpTestingUtil .getAtlasConfigE(TestAtlas.small); Map map1 = ace.getMapPool().get(0); File htmlDir1 = ace.getHtmlDirFor(map1); int count1 = htmlDir1.list().length; long size1 = FileUtils.sizeOfDirectory(htmlDir1); assertTrue("map html dir may not be empty for this test", count1 > 0); MapPoolDuplicateAction mapPoolDuplicateAction = new MapPoolDuplicateAction( new MapPoolJTable(ace)); if (TestingUtil.INTERACTIVE) { Map map2 = mapPoolDuplicateAction.actionPerformed(map1); assertFalse(map1.equals(map2)); File htmlDir2 = ace.getHtmlDirFor(map2); assertFalse(htmlDir1.equals(htmlDir2)); long size2 = FileUtils.sizeOfDirectory(htmlDir2); int count2 = htmlDir2.list().length; assertEquals(size1, size2); assertEquals(count1, count2); assertFalse("SVN files should have been omitted during copy", new File(htmlDir2, ".svn").exists()); FileUtils.deleteDirectory(htmlDir2); } ace.deleteAtlas(); }
### Question: DpEntry implements Comparable<DpEntry<? extends ChartStyle>>, Serializable, ExportableLayer { public Double getQuality() { if (isBroken()) return 0.; if (quality == null \|\| (System.currentTimeMillis() - qualityLastTimeCalculated) > 500) { qualityLastTimeCalculated = System.currentTimeMillis(); final List<String> languages = getAtlasConfig().getLanguages(); Double averageChartQuality = 1.; if (getCharts().size() > 0) { averageChartQuality = getAverageChartQuality(); } quality = (I18NUtil.qmTranslation(languages, getTitle()) * 4. + I18NUtil.qmTranslation(languages, getDesc()) * 2. + I18NUtil.qmTranslation(languages, getKeywords()) * 1. + averageChartQuality * 3.) / 10.; } return quality; } DpEntry(AtlasConfig ac); boolean isBroken(); void setBrokenException(Exception e); Exception getBrokenException(); List<CHART_STYLE_IMPL> getCharts(); CHART_STYLE_IMPL getChartForID(String chartId); void uncache(); void setDataDirname(String folder); String getDataDirname(); @Override String toString(); @Override int compareTo(DpEntry dpe2); abstract boolean isLayer(); final String getId(); final void setId(String id); final Translation getTitle(); final void setTitle(Translation title); final Translation getDesc(); final void setDesc(Translation desc); final String getFilename(); final String getBaseFilename(); final void setFilename(File file); final void setFilename(String filename); final AtlasConfig getAtlasConfig(); final void setAtlasConfig(AtlasConfig ac); Translation getKeywords(); void setKeywords(Translation keywords); boolean isDisposed(); ImageIcon getImageIcon(); void setImageIcon(ImageIcon imageIcon); @Override Boolean isExportable(); void setExportable(boolean b); static void cleanupTemp(); boolean isDownloadedAndVisible(); Double getQuality(); Double getAverageChartQuality(); Double getChartQuality(ChartStyle Chart); final void setType(DpEntryType type); final DpEntryType getType(); Charset getCharset(); void setCharset(Charset newCharset); @Deprecated URL getUrl(); @Override boolean equals(Object obj); @Override int hashCode(); void setLocalTempFile(File localTempFile); File getLocalTempFile(); abstract String getInternalLink(); abstract String getInternalLink(String lang); public URL url; final static DataFlavor INFO_FLAVOR; }### Answer: @Test public void testGetQuality() throws AtlasException, FactoryException, TransformException, SAXException, IOException, ParserConfigurationException { AtlasConfigEditable atlasConfig = GpTestingUtil .getAtlasConfigE(GpTestingUtil.TestAtlas.small); DataPool dataPool = atlasConfig.getDataPool(); int dpeWithChartCount = 0; for (DpEntry<? extends ChartStyle> dpe : dataPool.values()) { if (dpe.getCharts().size() > 0) { dpeWithChartCount++; Double quality = dpe.getQuality(); assertTrue("quality has to be between 0 and 1", quality >= 0.); assertTrue("quality has to be between 0 and 1", quality <= 1.); dpe.getCharts().clear(); Double quality2 = dpe.getQuality(); assertTrue(quality != quality2); } } assertEquals("The chart demo atlas contains one layer with charts ", 1, dpeWithChartCount); atlasConfig.deleteAtlas(); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.