Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: AmqpConsumer extends Consumer { public Properties getTransportProperties() { return transportProperties; } AmqpConsumer(ChannelHandlerContext ctx, Broker broker, AmqpChannel channel, String queueName, ShortString consumerTag, boolean isExclusive); @Override void send(Message message); @Override String getQueueName(); @Override void close(); @Override boolean isExclusive(); void enableConsume(); ShortString getConsumerTag(); @Override boolean isReady(); @Override String toString(); Properties getTransportProperties(); static final String CONSUMER_TAG_FIELD_NAME; }### Answer: @Test public void testGetTransportProperties() throws Exception { AmqpChannel amqpChannel = Mockito.mock(AmqpChannel.class); ChannelHandlerContext context = Mockito.mock(ChannelHandlerContext.class); Broker broker = Mockito.mock(Broker.class); Mockito.when(amqpChannel.getChannelId()).thenReturn(5); Mockito.when(amqpChannel.getConnectionId()).thenReturn(7); AmqpConsumer consumer = new AmqpConsumer(context, broker, amqpChannel, "queue", new ShortString(0, new byte[0]), true); Properties transportProperties = consumer.getTransportProperties(); Assert.assertEquals(transportProperties.get(AmqConstant.TRANSPORT_PROPERTY_CHANNEL_ID), 5, "Incorrect channel id set"); Assert.assertEquals(transportProperties.get(AmqConstant.TRANSPORT_PROPERTY_CONNECTION_ID), 7, "Incorrect connection id set"); }
### Question: BindingsRegistry { void bind(QueueHandler queueHandler, String bindingKey, FieldTable arguments) throws BrokerException, ValidationException { BindingSet bindingSet = bindingPatternToBindingsMap.computeIfAbsent(bindingKey, k -> new BindingSet()); Queue queue = queueHandler.getUnmodifiableQueue(); Binding binding = new Binding(queue, bindingKey, arguments); boolean success = bindingSet.add(binding); if (success) { queueHandler.addBinding(binding, bindingDeleteListener); if (queue.isDurable()) { bindingDao.persist(exchange.getName(), binding); } } LOGGER.debug("Binding added for queue {} with pattern {}", queueHandler, bindingKey); notifyOnBind(bindingKey); } BindingsRegistry(Exchange exchange, BindingDao bindingDao); void retrieveAllBindingsForExchange(QueueRegistry queueRegistry); Map<String, BindingSet> getAllBindings(); void addBindingsRegistryListeners(BindingsRegistryListener listener); }### Answer: @Test(dataProvider = "InvalidBindingData", expectedExceptions = ValidationException.class) public void testMultipleBindCallsWithDifferentSelectors(String queueName, String selectorOne, String selectorTwo) throws Exception { QueueHandler queueHandler = new QueueHandler(new MemQueueImpl(queueName, 2, false), null); registry.bind(queueHandler, queueName, getFieldTable(selectorOne)); registry.bind(queueHandler, queueName, getFieldTable(selectorTwo)); }
### Question: QueueBuffer { public int size() { return size.get(); } QueueBuffer(int inMemoryLimit, int indelibleMessageLimit, MessageReader messageReader); synchronized void add(Message message); synchronized void addAllBareMessages(Collection<Message> messages); synchronized void addBareMessage(Message message); synchronized boolean addIndelibleMessage(Message message); synchronized void remove(long messageId); synchronized void removeAll(Collection<DetachableMessage> messages); int size(); int getNumberOfInflightMessages(); int getNumberOfUndeliveredMessages(); synchronized Message getFirstDeliverable(); void markMessageFilled(Message message); void markMessageFillFailed(Message message); synchronized int clear(Consumer<Message> postDeleteAction); }### Answer: @Test public void testSize() { QueueBuffer queueBuffer = new QueueBuffer(10, 0, messageReader); for (int i = 0; i < 12; i++) { Message message = new Message(i + 1, mockMetadata); queueBuffer.add(message); } Assert.assertEquals(queueBuffer.size(), 12, "Message size should match the number of added items"); }
### Question: CarbonConfigAdapter implements ConfigProvider { @Override public <T> T getConfigurationObject(Class<T> aClass) throws ConfigurationException { return getConfig(aClass.getCanonicalName(), aClass); } CarbonConfigAdapter(BrokerConfigProvider configProvider); @Override T getConfigurationObject(Class<T> aClass); @Override Object getConfigurationObject(String s); @Override T getConfigurationObject(String s, Class<T> aClass); }### Answer: @Test public void testGetConfigurationObject() throws Exception { CarbonConfigAdapter carbonConfigAdapter = new CarbonConfigAdapter(configProvider); TestConfig configurationObject = (TestConfig) carbonConfigAdapter.getConfigurationObject(TEST_CONFIG_NAMESPACE); Assert.assertEquals(configurationObject.getTestField(), NAMESPACE_KEY); } @Test public void testGetConfigurationObject1() throws Exception { CarbonConfigAdapter carbonConfigAdapter = new CarbonConfigAdapter(configProvider); TestConfig configurationObject = carbonConfigAdapter.getConfigurationObject(TestConfig.class); Assert.assertEquals(configurationObject.getTestField(), CLASS_KEY); } @Test public void testGetConfigurationObject2() throws Exception { CarbonConfigAdapter carbonConfigAdapter = new CarbonConfigAdapter(configProvider); TestConfig configurationObject = carbonConfigAdapter.getConfigurationObject(TEST_CONFIG_NAMESPACE, TestConfig.class); Assert.assertEquals(configurationObject.getTestField(), NAMESPACE_KEY); } @Test(expectedExceptions = ConfigurationException.class) public void testGetInvalidConfigurationObject() throws Exception { CarbonConfigAdapter carbonConfigAdapter = new CarbonConfigAdapter(configProvider); TestConfig configurationObject = carbonConfigAdapter.getConfigurationObject("invalid.namespace", TestConfig.class); Assert.assertEquals(configurationObject.getTestField(), NAMESPACE_KEY); }
### Question: LongString implements EncodableData { @Override public long getSize() { return 4 + length; } @SuppressFBWarnings("EI_EXPOSE_REP2") LongString(long length, byte[] content); static LongString parseString(String data); @Override long getSize(); @Override void write(ByteBuf buf); static LongString parse(ByteBuf buf); static LongString parse(byte[] data); @Override boolean equals(Object obj); boolean isEmpty(); @Override int hashCode(); @Override String toString(); @SuppressFBWarnings("EI_EXPOSE_REP") byte[] getBytes(); }### Answer: @Test public void testGetSize() throws Exception { Assert.assertEquals(DEFAULT_TEST_OBJECT.getSize(), DEFAULT_DATA_STRING.length() + 4, "getSize should return " + "required byte array size"); }
### Question: LongString implements EncodableData { public static LongString parse(ByteBuf buf) throws Exception { int size = (int) buf.readUnsignedInt(); if (size < 0) { throw new Exception("Invalid string length"); } byte[] data = new byte[size]; buf.readBytes(data); return new LongString(size, data); } @SuppressFBWarnings("EI_EXPOSE_REP2") LongString(long length, byte[] content); static LongString parseString(String data); @Override long getSize(); @Override void write(ByteBuf buf); static LongString parse(ByteBuf buf); static LongString parse(byte[] data); @Override boolean equals(Object obj); boolean isEmpty(); @Override int hashCode(); @Override String toString(); @SuppressFBWarnings("EI_EXPOSE_REP") byte[] getBytes(); }### Answer: @Test public void testParse() throws Exception { ByteBuf buf = Unpooled.buffer(DEFAULT_DATA_STRING.length() + 4); DEFAULT_TEST_OBJECT.write(buf); LongString parsedObject = LongString.parse(buf); Assert.assertEquals(parsedObject, DEFAULT_TEST_OBJECT, "Encoding and decoding should match to same object"); } @Test(expectedExceptions = Exception.class) public void testInvalidBuffer() throws Exception { ByteBuf buf = Unpooled.buffer(DEFAULT_DATA_STRING.length() + 4); buf.writeLong(-2); LongString.parse(buf); }
### Question: LongString implements EncodableData { @Override public String toString() { return new String(content, StandardCharsets.UTF_8); } @SuppressFBWarnings("EI_EXPOSE_REP2") LongString(long length, byte[] content); static LongString parseString(String data); @Override long getSize(); @Override void write(ByteBuf buf); static LongString parse(ByteBuf buf); static LongString parse(byte[] data); @Override boolean equals(Object obj); boolean isEmpty(); @Override int hashCode(); @Override String toString(); @SuppressFBWarnings("EI_EXPOSE_REP") byte[] getBytes(); }### Answer: @Test public void testToString() throws Exception { Assert.assertEquals(DEFAULT_TEST_OBJECT.toString(), DEFAULT_DATA_STRING, "toString() should match the data " + "string used to create it"); }
### Question: QueueBuffer { public synchronized Message getFirstDeliverable() { submitMessageReads(); Node deliverableCandidate = firstDeliverableCandidate; if (deliverableCandidate != firstUndeliverable) { if (!deliverableCandidate.hasContent()) { return null; } firstDeliverableCandidate = deliverableCandidate.next; recordRemovingMessageForDelivery(); return deliverableCandidate.item; } else if (firstUndeliverable != null && firstUndeliverable.hasContent()) { Node newDeliverable = firstUndeliverable; firstDeliverableCandidate = firstUndeliverable.next; pushFirstUndeliverableCursor(); recordRemovingMessageForDelivery(); return newDeliverable.item; } else { return null; } } QueueBuffer(int inMemoryLimit, int indelibleMessageLimit, MessageReader messageReader); synchronized void add(Message message); synchronized void addAllBareMessages(Collection<Message> messages); synchronized void addBareMessage(Message message); synchronized boolean addIndelibleMessage(Message message); synchronized void remove(long messageId); synchronized void removeAll(Collection<DetachableMessage> messages); int size(); int getNumberOfInflightMessages(); int getNumberOfUndeliveredMessages(); synchronized Message getFirstDeliverable(); void markMessageFilled(Message message); void markMessageFillFailed(Message message); synchronized int clear(Consumer<Message> postDeleteAction); }### Answer: @Test public void testGetFirstDeliverable() { QueueBuffer queueBuffer = new QueueBuffer(10, 0, messageReader); for (int i = 0; i < 12; i++) { Message message = new Message(i + 1, mockMetadata); queueBuffer.add(message); } for (int i = 0; i < 12; i++) { Message message = queueBuffer.getFirstDeliverable(); Assert.assertNotNull(message.getMetadata(), "Messages returned from #getFirstDeliverable() should never " + "be empty"); queueBuffer.remove(message.getInternalId()); } Assert.assertEquals(queueBuffer.size(), 0, "Buffer size should be 0 after removing all messages"); }
### Question: LongString implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof LongString) && (Arrays.equals(content, ((LongString) obj).content)); } @SuppressFBWarnings("EI_EXPOSE_REP2") LongString(long length, byte[] content); static LongString parseString(String data); @Override long getSize(); @Override void write(ByteBuf buf); static LongString parse(ByteBuf buf); static LongString parse(byte[] data); @Override boolean equals(Object obj); boolean isEmpty(); @Override int hashCode(); @Override String toString(); @SuppressFBWarnings("EI_EXPOSE_REP") byte[] getBytes(); }### Answer: @Test public void testEquals() throws Exception { LongString other = LongString.parseString("different string"); LongString similar = LongString.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: LongString implements EncodableData { @Override public int hashCode() { return Arrays.hashCode(content); } @SuppressFBWarnings("EI_EXPOSE_REP2") LongString(long length, byte[] content); static LongString parseString(String data); @Override long getSize(); @Override void write(ByteBuf buf); static LongString parse(ByteBuf buf); static LongString parse(byte[] data); @Override boolean equals(Object obj); boolean isEmpty(); @Override int hashCode(); @Override String toString(); @SuppressFBWarnings("EI_EXPOSE_REP") byte[] getBytes(); }### Answer: @Test public void testHashCode() throws Exception { LongString similar = LongString.parseString(DEFAULT_DATA_STRING); Assert.assertEquals(similar.hashCode(), DEFAULT_TEST_OBJECT.hashCode(), "Hashcode should match for similar " + "data"); }
### Question: LongUint implements EncodableData { @Override public long getSize() { return 4L; } private LongUint(long value); @Override long getSize(); @Override void write(ByteBuf buf); long getInt(); @Override int hashCode(); @Override boolean equals(Object obj); static LongUint parse(ByteBuf buf); static LongUint parse(long value); @Override String toString(); }### Answer: @Test public void testGetSize() { Assert.assertEquals(TEST_OBJECT.getSize(), 4, "Size of long-uint should be 4"); }
### Question: LongUint implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof LongUint) && (value == ((LongUint) obj).value); } private LongUint(long value); @Override long getSize(); @Override void write(ByteBuf buf); long getInt(); @Override int hashCode(); @Override boolean equals(Object obj); static LongUint parse(ByteBuf buf); static LongUint parse(long value); @Override String toString(); }### Answer: @Test public void testEquals() { LongUint other = LongUint.parse(3); LongUint similar = LongUint.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: LongUint implements EncodableData { @Override public int hashCode() { return Objects.hash(value); } private LongUint(long value); @Override long getSize(); @Override void write(ByteBuf buf); long getInt(); @Override int hashCode(); @Override boolean equals(Object obj); static LongUint parse(ByteBuf buf); static LongUint parse(long value); @Override String toString(); }### Answer: @Test public void testHashCode() { LongUint similar = LongUint.parse(DATA_VALUE); Assert.assertEquals(similar.hashCode(), TEST_OBJECT.hashCode(), "Hashcode should match for similar data"); }
### Question: LongUint implements EncodableData { public static LongUint parse(ByteBuf buf) { return new LongUint(buf.readUnsignedInt()); } private LongUint(long value); @Override long getSize(); @Override void write(ByteBuf buf); long getInt(); @Override int hashCode(); @Override boolean equals(Object obj); static LongUint parse(ByteBuf buf); static LongUint parse(long value); @Override String toString(); }### Answer: @Test public void testParse() { ByteBuf buf = Unpooled.buffer(4); TEST_OBJECT.write(buf); LongUint parsedObject = LongUint.parse(buf); Assert.assertEquals(parsedObject, TEST_OBJECT, "Encoding and decoding should result in the same object"); }
### Question: ShortShortUint implements EncodableData { @Override public long getSize() { return 1L; } private ShortShortUint(short value); @Override long getSize(); @Override void write(ByteBuf buf); static ShortShortUint parse(ByteBuf buf); static ShortShortUint parse(short value); short getByte(); @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-uint should be 1"); }
### Question: ShortShortUint implements EncodableData { @Override public boolean equals(Object obj) { if (this == obj) { return true; } return (obj instanceof ShortShortUint) && (value == ((ShortShortUint) obj).value); } private ShortShortUint(short value); @Override long getSize(); @Override void write(ByteBuf buf); static ShortShortUint parse(ByteBuf buf); static ShortShortUint parse(short value); short getByte(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testEquals() { ShortShortUint other = ShortShortUint.parse((short) 3); ShortShortUint similar = ShortShortUint.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: ShortShortUint implements EncodableData { @Override public int hashCode() { return (int) value; } private ShortShortUint(short value); @Override long getSize(); @Override void write(ByteBuf buf); static ShortShortUint parse(ByteBuf buf); static ShortShortUint parse(short value); short getByte(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testHashCode() { ShortShortUint similar = ShortShortUint.parse(DATA_VALUE); Assert.assertEquals(similar.hashCode(), TEST_OBJECT.hashCode(), "Hashcode should match for similar data"); }
### Question: ExchangeRegistry { Exchange getExchange(String exchangeName) { return exchangeMap.get(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(dataProvider = "exchangeNames", description = "test frequently used exchanges types are defined") public void testGetExchanges(String exchangeName) { Exchange exchange = exchangeRegistry.getExchange(exchangeName); Assert.assertNotNull(exchange, "unable to find the exchange"); Assert.assertEquals(exchange.getName(), exchangeName, "invalid exchange returned"); }
### Question: ShortShortUint implements EncodableData { public static ShortShortUint parse(ByteBuf buf) { return new ShortShortUint(buf.readUnsignedByte()); } private ShortShortUint(short value); @Override long getSize(); @Override void write(ByteBuf buf); static ShortShortUint parse(ByteBuf buf); static ShortShortUint parse(short value); short getByte(); @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); ShortShortUint parsedObject = ShortShortUint.parse(buf); Assert.assertEquals(parsedObject, TEST_OBJECT, "Encoding and decoding should result in the same object"); }
### Question: ShortString implements EncodableData { public long getSize() { return length + 1; } @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 testGetSize() throws Exception { Assert.assertEquals(DEFAULT_TEST_OBJECT.getSize(), DEFAULT_DATA_STRING.length() + 1, "getSize should return " + "required byte array size"); }
### Question: ShortString implements EncodableData { public static ShortString parse(ByteBuf buf) { int size = buf.readUnsignedByte(); byte[] data = new byte[size]; buf.readBytes(data); return new ShortString(size, data); } @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 testParse() throws Exception { ByteBuf buf = Unpooled.buffer(DEFAULT_DATA_STRING.length() + 1); DEFAULT_TEST_OBJECT.write(buf); ShortString parsedObject = ShortString.parse(buf); Assert.assertEquals(parsedObject, DEFAULT_TEST_OBJECT, "Encoding and decoding should match to same object"); }
### Question: ShortString implements EncodableData { @Override public String toString() { return new String(content, StandardCharsets.UTF_8); } @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 testToString() throws Exception { Assert.assertEquals(DEFAULT_TEST_OBJECT.toString(), DEFAULT_DATA_STRING, "toString() should match the data " + "string used to create it"); }
### 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: 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: 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: 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 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 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 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: 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: 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 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: 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: 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 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: 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 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:")); }

Subsets and Splits

No community queries yet

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