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: QpidCollector extends Collector { static String toSnakeCase(final String simpleName) { final StringBuilder sb = new StringBuilder(); final char[] chars = simpleName.toCharArray(); for (int i = 0; i < chars.length; i++) { final char ch = chars[i]; if (Character.isUpperCase(ch)) { if (i > 0) { sb.append('_'); } sb.append(Character.toLowerCase(ch)); } else { sb.append(ch); } } return sb.toString(); } QpidCollector(final ConfiguredObject<?> root, final Predicate<ConfiguredObjectStatistic<?,?>> includeStatisticFilter, final Predicate<String> includeMetricFilter); @Override List<MetricFamilySamples> collect(); }### Answer: @Test public void testToSnakeCase() { assertThat(QpidCollector.toSnakeCase("carEngineOilChanges"), is(equalTo("car_engine_oil_changes"))); }
### Question: ArrayUtils { public static <T> T[] clone(T[] array) { return array != null ? array.clone() : null; } private ArrayUtils(); static T[] clone(T[] array); static boolean isEmpty(Object[] array); }### Answer: @Test public void testClone_NullInput() { assertNull(ArrayUtils.clone(null)); } @Test public void testClone_EmptyInput() { String[] data = new String[0]; String[] result = ArrayUtils.clone(data); assertArrayEquals(data, result); assertNotSame(data, result); } @Test public void testClone() { String[] data = new String[]{"A", null, "B", "CC"}; String[] result = ArrayUtils.clone(data); assertArrayEquals(data, result); assertNotSame(data, result); }
### Question: UnsettledDelivery { public Binary getDeliveryTag() { return _deliveryTag; } UnsettledDelivery(final Binary deliveryTag, final LinkEndpoint<?, ?> linkEndpoint); Binary getDeliveryTag(); LinkEndpoint<?, ?> getLinkEndpoint(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void testGetDeliveryTag() { assertThat(_unsettledDelivery.getDeliveryTag(), is(equalTo(_deliveryTag))); }
### Question: ArrayUtils { public static boolean isEmpty(Object[] array) { return array == null \|\| array.length == 0; } private ArrayUtils(); static T[] clone(T[] array); static boolean isEmpty(Object[] array); }### Answer: @Test public void testIsEmpty_NullInput() { assertTrue(ArrayUtils.isEmpty(null)); } @Test public void testIsEmpty_EmptyInput() { assertTrue(ArrayUtils.isEmpty(new String[0])); } @Test public void testIsEmpty() { assertFalse(ArrayUtils.isEmpty(new String[]{"A"})); assertFalse(ArrayUtils.isEmpty(new String[]{"A", "B"})); assertFalse(ArrayUtils.isEmpty(new String[]{null})); }
### Question: UnsettledDelivery { public LinkEndpoint<?, ?> getLinkEndpoint() { return _linkEndpoint; } UnsettledDelivery(final Binary deliveryTag, final LinkEndpoint<?, ?> linkEndpoint); Binary getDeliveryTag(); LinkEndpoint<?, ?> getLinkEndpoint(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void testGetLinkEndpoint() { assertThat(_unsettledDelivery.getLinkEndpoint(), is(equalTo(_linkEndpoint))); }
### Question: GelfMessageStaticFields implements Validator<Map<String, Object>> { public static Validator<Map<String, Object>> validator() { return VALIDATOR; } private GelfMessageStaticFields(); static Validator<Map<String, Object>> validator(); static void validateStaticFields(Map<String, Object> value, ConfiguredObject<?> object, String attribute); @Override void validate(Map<String, Object> map, final ConfiguredObject<?> object, final String attribute); }### Answer: @Test public void testValidator() { assertNotNull("Factory method has to produce a instance", GelfMessageStaticFields.validator()); }
### Question: Port implements Validator<Integer>, Predicate<Integer> { public static Validator<Integer> validator() { return VALIDATOR; } private Port(); static Validator<Integer> validator(); static void validatePort(Integer value, ConfiguredObject<?> object, String attribute); @Override boolean test(Integer value); @Override void validate(Integer value, ConfiguredObject<?> object, String attribute); }### Answer: @Test public void testValidator() { assertNotNull("Factory method has to produce a instance", Port.validator()); }
### Question: Port implements Validator<Integer>, Predicate<Integer> { public static void validatePort(Integer value, ConfiguredObject<?> object, String attribute) { validator().validate(value, object, attribute); } private Port(); static Validator<Integer> validator(); static void validatePort(Integer value, ConfiguredObject<?> object, String attribute); @Override boolean test(Integer value); @Override void validate(Integer value, ConfiguredObject<?> object, String attribute); }### Answer: @Test public void testValidate_NullAsInput() { TestConfiguredObject object = new TestConfiguredObject(); try { Port.validatePort(null, object, "attr"); fail("An exception is expected"); } catch (IllegalConfigurationException e) { assertEquals("Attribute 'attr' instance of org.apache.qpid.server.logging.logback.validator.TestConfiguredObject named 'TestConfiguredObject' cannot have value 'null' as it has to be in range [1, 65535]", e.getMessage()); } catch (RuntimeException e) { fail("A generic exception is not expected"); } } @Test public void testValidate_ValidInput() { TestConfiguredObject object = new TestConfiguredObject(); try { Port.validatePort(14420, object, "attr"); } catch (RuntimeException e) { fail("Any exception is not expected"); } } @Test public void testValidate_InvalidInput() { TestConfiguredObject object = new TestConfiguredObject(); try { Port.validatePort(170641, object, "attr"); fail("An exception is expected"); } catch (IllegalConfigurationException e) { assertEquals("Attribute 'attr' instance of org.apache.qpid.server.logging.logback.validator.TestConfiguredObject named 'TestConfiguredObject' cannot have value '170641' as it has to be in range [1, 65535]", e.getMessage()); } catch (RuntimeException e) { fail("A generic exception is not expected"); } }
### Question: UnsettledDelivery { @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null \|\| getClass() != o.getClass()) { return false; } final UnsettledDelivery that = (UnsettledDelivery) o; return Objects.equals(_deliveryTag, that._deliveryTag) && Objects.equals(_linkEndpoint, that._linkEndpoint); } UnsettledDelivery(final Binary deliveryTag, final LinkEndpoint<?, ?> linkEndpoint); Binary getDeliveryTag(); LinkEndpoint<?, ?> getLinkEndpoint(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void testEqualsToNewUnsettledDeliveryWithTheSameFields() { assertThat(_unsettledDelivery.equals(new UnsettledDelivery(_deliveryTag, _linkEndpoint)), is(equalTo(true))); } @Test public void testEqualsToNewUnsettledDeliveryWithEqualsFields() { assertThat(_unsettledDelivery.equals(new UnsettledDelivery(new Binary(DATA), _linkEndpoint)), is(equalTo(true))); } @Test public void testNotEqualsWhenDeliveryTagIsDifferent() { assertThat(_unsettledDelivery.equals(new UnsettledDelivery(new Binary(new byte[]{(byte) 32, (byte) 33}), _linkEndpoint)), is(equalTo(false))); } @Test public void testNotEqualsWhenLinkEndpointIsDifferent() { final LinkEndpoint<?, ?> linkEndpoint = mock(LinkEndpoint.class); assertThat(_unsettledDelivery.equals(new UnsettledDelivery(new Binary(new byte[]{(byte) 32, (byte) 33}), linkEndpoint)), is(equalTo(false))); }
### Question: AtLeastZero extends AtLeast { public static Validator<Integer> validator() { return VALIDATOR; } private AtLeastZero(); static Validator<Integer> validator(); static void validateValue(Integer value, ConfiguredObject<?> object, String attribute); }### Answer: @Test public void validator() { assertNotNull("Factory method has to produce a instance", AtLeastZero.validator()); }
### Question: AtLeastZero extends AtLeast { public static void validateValue(Integer value, ConfiguredObject<?> object, String attribute) { validator().validate(value, object, attribute); } private AtLeastZero(); static Validator<Integer> validator(); static void validateValue(Integer value, ConfiguredObject<?> object, String attribute); }### Answer: @Test public void testValidate_NullAsInput() { TestConfiguredObject object = new TestConfiguredObject(); try { AtLeastZero.validateValue(null, object, "attr"); fail("An exception is expected"); } catch (IllegalConfigurationException e) { assertEquals("Attribute 'attr' instance of org.apache.qpid.server.logging.logback.validator.TestConfiguredObject named 'TestConfiguredObject' cannot have value 'null' as it has to be at least 0", e.getMessage()); } catch (RuntimeException e) { fail("A generic exception is not expected"); } } @Test public void testValidate_ValidInput() { TestConfiguredObject object = new TestConfiguredObject(); try { AtLeastZero.validateValue(2, object, "attr"); } catch (RuntimeException e) { fail("Any exception is not expected"); } } @Test public void testValidate_InvalidInput() { TestConfiguredObject object = new TestConfiguredObject(); try { AtLeastZero.validateValue(-1, object, "attr"); fail("An exception is expected"); } catch (IllegalConfigurationException e) { assertEquals("Attribute 'attr' instance of org.apache.qpid.server.logging.logback.validator.TestConfiguredObject named 'TestConfiguredObject' cannot have value '-1' as it has to be at least 0", e.getMessage()); } catch (RuntimeException e) { fail("A generic exception is not expected"); } }
### Question: AtLeast implements Validator<Integer>, Predicate<Integer> { @Override public void validate(Integer value, ConfiguredObject<?> object, String attribute) { if (!test(value)) { throw new IllegalConfigurationException(errorMessage(value, object, attribute)); } } AtLeast(int min); @Override boolean test(Integer value); @Override void validate(Integer value, ConfiguredObject<?> object, String attribute); }### Answer: @Test public void testValidate_NullAsInput() { TestConfiguredObject object = new TestConfiguredObject(); Validator<Integer> validator = new AtLeast(42); try { validator.validate(null, object, "attr"); fail("An exception is expected"); } catch (IllegalConfigurationException e) { assertEquals("Attribute 'attr' instance of org.apache.qpid.server.logging.logback.validator.TestConfiguredObject named 'TestConfiguredObject' cannot have value 'null' as it has to be at least 42", e.getMessage()); } catch (RuntimeException e) { fail("A generic exception is not expected"); } } @Test public void testValidate_ValidInput() { TestConfiguredObject object = new TestConfiguredObject(); Validator<Integer> validator = new AtLeast(42); try { validator.validate(42, object, "attr"); } catch (RuntimeException e) { fail("Any exception is not expected"); } } @Test public void testValidate_InvalidInput() { TestConfiguredObject object = new TestConfiguredObject(); Validator<Integer> validator = new AtLeast(42); try { validator.validate(41, object, "attr"); fail("An exception is expected"); } catch (IllegalConfigurationException e) { assertEquals("Attribute 'attr' instance of org.apache.qpid.server.logging.logback.validator.TestConfiguredObject named 'TestConfiguredObject' cannot have value '41' as it has to be at least 42", e.getMessage()); } catch (RuntimeException e) { fail("A generic exception is not expected"); } }
### Question: AtLeastOne extends AtLeast { public static Validator<Integer> validator() { return VALIDATOR; } private AtLeastOne(); static Validator<Integer> validator(); static void validateValue(Integer value, ConfiguredObject<?> object, String attribute); }### Answer: @Test public void validator() { assertNotNull("Factory method has to produce a instance", AtLeastOne.validator()); }
### Question: AtLeastOne extends AtLeast { public static void validateValue(Integer value, ConfiguredObject<?> object, String attribute) { validator().validate(value, object, attribute); } private AtLeastOne(); static Validator<Integer> validator(); static void validateValue(Integer value, ConfiguredObject<?> object, String attribute); }### Answer: @Test public void testValidate_NullAsInput() { TestConfiguredObject object = new TestConfiguredObject(); try { AtLeastOne.validateValue(null, object, "attr"); fail("An exception is expected"); } catch (IllegalConfigurationException e) { assertEquals("Attribute 'attr' instance of org.apache.qpid.server.logging.logback.validator.TestConfiguredObject named 'TestConfiguredObject' cannot have value 'null' as it has to be at least 1", e.getMessage()); } catch (RuntimeException e) { fail("A generic exception is not expected"); } } @Test public void testValidate_ValidInput() { TestConfiguredObject object = new TestConfiguredObject(); try { AtLeastOne.validateValue(2, object, "attr"); } catch (RuntimeException e) { fail("Any exception is not expected"); } } @Test public void testValidate_InvalidInput() { TestConfiguredObject object = new TestConfiguredObject(); try { AtLeastOne.validateValue(0, object, "attr"); fail("An exception is expected"); } catch (IllegalConfigurationException e) { assertEquals("Attribute 'attr' instance of org.apache.qpid.server.logging.logback.validator.TestConfiguredObject named 'TestConfiguredObject' cannot have value '0' as it has to be at least 1", e.getMessage()); } catch (RuntimeException e) { fail("A generic exception is not expected"); } }
### Question: GraylogAppender extends AsyncAppender { static GraylogAppender newInstance(Context context, GelfAppenderConfiguration config) { final GraylogAppender appender = new GraylogAppender(config); appender.setContext(context); appender.setQueueSize(config.getMessageBufferCapacity()); appender.setNeverBlock(true); appender.setMaxFlushTime(config.getMessagesFlushTimeOut()); appender.setIncludeCallerData(config.isCallerDataIncluded()); return appender; } private GraylogAppender(GelfAppenderConfiguration configuration); @Override void start(); @Override void setName(final String name); @Override void setContext(final Context context); @Override void doAppend(ILoggingEvent eventObject); }### Answer: @Test public void testNewInstance() { TestGelfAppenderConfiguration logger = new TestGelfAppenderConfiguration(); Context context = new LoggerContext(); GraylogAppender appender = GraylogAppender.newInstance(context, logger); assertNotNull(appender); }
### Question: GraylogAppender extends AsyncAppender { @Override public void setName(final String name) { super.setName(name); iteratorForAppenders().forEachRemaining(item -> item.setName(name)); } private GraylogAppender(GelfAppenderConfiguration configuration); @Override void start(); @Override void setName(final String name); @Override void setContext(final Context context); @Override void doAppend(ILoggingEvent eventObject); }### Answer: @Test public void testSetName() { TestGelfAppenderConfiguration configuration = new TestGelfAppenderConfiguration(); Context context = new LoggerContext(); GraylogAppender appender = configuration.newAppender(context); appender.setName("GelfAppender"); appender.start(); appender.setName("NewGelfAppender"); Iterator<Appender<ILoggingEvent>> iterator = appender.iteratorForAppenders(); while (iterator.hasNext()) { Appender<ILoggingEvent> app = iterator.next(); assertNotNull(app); assertEquals("NewGelfAppender", app.getName()); } }
### Question: GraylogAppender extends AsyncAppender { @Override public void setContext(final Context context) { super.setContext(context); iteratorForAppenders().forEachRemaining(item -> item.setContext(context)); } private GraylogAppender(GelfAppenderConfiguration configuration); @Override void start(); @Override void setName(final String name); @Override void setContext(final Context context); @Override void doAppend(ILoggingEvent eventObject); }### Answer: @Test public void testSetContext() { TestGelfAppenderConfiguration logger = new TestGelfAppenderConfiguration(); Context context = new LoggerContext(); GraylogAppender appender = logger.newAppender(context); appender.setName("GelfAppender"); appender.start(); appender.setContext(context); Iterator<Appender<ILoggingEvent>> iterator = appender.iteratorForAppenders(); while (iterator.hasNext()) { Appender<ILoggingEvent> app = iterator.next(); assertNotNull(app); assertEquals(context, app.getContext()); } }
### Question: UnsettledDelivery { @Override public int hashCode() { return Objects.hash(_deliveryTag, _linkEndpoint); } UnsettledDelivery(final Binary deliveryTag, final LinkEndpoint<?, ?> linkEndpoint); Binary getDeliveryTag(); LinkEndpoint<?, ?> getLinkEndpoint(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer: @Test public void testHashCode() { int expected = Objects.hash(_deliveryTag, _linkEndpoint); assertThat(_unsettledDelivery.hashCode(), is(equalTo(expected))); }
### Question: DeliveryRegistryImpl implements DeliveryRegistry { @Override public void addDelivery(final UnsignedInteger deliveryId, final UnsettledDelivery unsettledDelivery) { _deliveries.put(deliveryId, unsettledDelivery); _deliveryIds.put(unsettledDelivery, deliveryId); } @Override void addDelivery(final UnsignedInteger deliveryId, final UnsettledDelivery unsettledDelivery); @Override void removeDelivery(final UnsignedInteger deliveryId); @Override UnsettledDelivery getDelivery(final UnsignedInteger deliveryId); @Override void removeDeliveriesForLinkEndpoint(final LinkEndpoint<?, ?> linkEndpoint); @Override UnsignedInteger getDeliveryId(final Binary deliveryTag, final LinkEndpoint<?, ?> linkEndpoint); @Override int size(); }### Answer: @Test public void addDelivery() { assertThat(_registry.size(), is(equalTo(0))); _registry.addDelivery(DELIVERY_ID, _unsettledDelivery); assertThat(_registry.size(), is(equalTo(1))); }
### Question: GraylogAppender extends AsyncAppender { @Override public void doAppend(ILoggingEvent eventObject) { super.doAppend(LoggingEvent.wrap(eventObject)); } private GraylogAppender(GelfAppenderConfiguration configuration); @Override void start(); @Override void setName(final String name); @Override void setContext(final Context context); @Override void doAppend(ILoggingEvent eventObject); }### Answer: @Test public void testDoAppend() { Context context = new LoggerContext(); TestGelfAppenderConfiguration configuration = new TestGelfAppenderConfiguration(); GraylogAppender appender = configuration.newAppender(context); try { appender.doAppend(new TestLoggingEvent()); } catch (RuntimeException e) { fail("Any exception is not expected"); } }
### Question: LoggingEvent implements ILoggingEvent { public static ILoggingEvent wrap(ILoggingEvent event) { return event != null ? new LoggingEvent(event) : null; } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testWrap_NullAsInput() { assertNull(LoggingEvent.wrap(null)); } @Test public void testWrap() { assertNotNull(LoggingEvent.wrap(new TestLoggingEvent())); }
### Question: LoggingEvent implements ILoggingEvent { @Override public String getThreadName() { return _event.getThreadName(); } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testGetThreadName() { TestLoggingEvent event = new TestLoggingEvent(); ILoggingEvent wrapper = LoggingEvent.wrap(event); assertNotNull(wrapper); assertEquals(event.getThreadName(), wrapper.getThreadName()); }
### Question: LoggingEvent implements ILoggingEvent { @Override public Level getLevel() { return _event.getLevel(); } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testGetLevel() { TestLoggingEvent event = new TestLoggingEvent(); ILoggingEvent wrapper = LoggingEvent.wrap(event); assertNotNull(wrapper); assertEquals(event.getLevel(), wrapper.getLevel()); }
### Question: LoggingEvent implements ILoggingEvent { @Override public String getMessage() { return _event.getMessage(); } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testGetMessage() { TestLoggingEvent event = new TestLoggingEvent(); ILoggingEvent wrapper = LoggingEvent.wrap(event); assertNotNull(wrapper); assertEquals(event.getMessage(), wrapper.getMessage()); }
### Question: DeliveryRegistryImpl implements DeliveryRegistry { @Override public void removeDelivery(final UnsignedInteger deliveryId) { UnsettledDelivery unsettledDelivery = _deliveries.remove(deliveryId); if (unsettledDelivery != null) { _deliveryIds.remove(unsettledDelivery); } } @Override void addDelivery(final UnsignedInteger deliveryId, final UnsettledDelivery unsettledDelivery); @Override void removeDelivery(final UnsignedInteger deliveryId); @Override UnsettledDelivery getDelivery(final UnsignedInteger deliveryId); @Override void removeDeliveriesForLinkEndpoint(final LinkEndpoint<?, ?> linkEndpoint); @Override UnsignedInteger getDeliveryId(final Binary deliveryTag, final LinkEndpoint<?, ?> linkEndpoint); @Override int size(); }### Answer: @Test public void removeDelivery() { _registry.addDelivery(DELIVERY_ID, _unsettledDelivery); assertThat(_registry.size(), is(equalTo(1))); _registry.removeDelivery(DELIVERY_ID); assertThat(_registry.size(), is(equalTo(0))); assertThat(_registry.getDelivery(UnsignedInteger.ZERO), is(nullValue())); }
### Question: LoggingEvent implements ILoggingEvent { @Override public Object[] getArgumentArray() { return _event.getArgumentArray(); } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testGetArgumentArray() { TestLoggingEvent event = new TestLoggingEvent(); ILoggingEvent wrapper = LoggingEvent.wrap(event); assertNotNull(wrapper); assertTrue(Arrays.deepEquals(event.getArgumentArray(), wrapper.getArgumentArray())); }
### Question: LoggingEvent implements ILoggingEvent { @Override public String getFormattedMessage() { return _event.getFormattedMessage(); } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testGetFormattedMessage() { TestLoggingEvent event = new TestLoggingEvent(); ILoggingEvent wrapper = LoggingEvent.wrap(event); assertNotNull(wrapper); assertEquals(event.getFormattedMessage(), wrapper.getFormattedMessage()); }
### Question: LoggingEvent implements ILoggingEvent { @Override public String getLoggerName() { return _event.getLoggerName(); } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testGetLoggerName() { TestLoggingEvent event = new TestLoggingEvent(); ILoggingEvent wrapper = LoggingEvent.wrap(event); assertNotNull(wrapper); assertEquals(event.getLoggerName(), wrapper.getLoggerName()); }
### Question: LoggingEvent implements ILoggingEvent { @Override public LoggerContextVO getLoggerContextVO() { return _event.getLoggerContextVO(); } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testGetLoggerContextVO() { TestLoggingEvent event = new TestLoggingEvent(); ILoggingEvent wrapper = LoggingEvent.wrap(event); assertNotNull(wrapper); assertEquals(event.getLoggerContextVO(), wrapper.getLoggerContextVO()); }
### Question: LoggingEvent implements ILoggingEvent { @Override public IThrowableProxy getThrowableProxy() { return _event.getThrowableProxy(); } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testGetThrowableProxy() { TestLoggingEvent event = new TestLoggingEvent(); ILoggingEvent wrapper = LoggingEvent.wrap(event); assertNotNull(wrapper); assertEquals(event.getThrowableProxy(), wrapper.getThrowableProxy()); }
### Question: LoggingEvent implements ILoggingEvent { @Override public Marker getMarker() { return _event.getMarker(); } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testGetMarker() { TestLoggingEvent event = new TestLoggingEvent(); ILoggingEvent wrapper = LoggingEvent.wrap(event); assertNotNull(wrapper); assertEquals(event.getMarker(), wrapper.getMarker()); }
### Question: LoggingEvent implements ILoggingEvent { @Deprecated @Override public Map<String, String> getMdc() { return _event.getMdc(); } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testGetMdc() { TestLoggingEvent event = new TestLoggingEvent(); ILoggingEvent wrapper = LoggingEvent.wrap(event); assertNotNull(wrapper); Map<String, String> originalMap = event.getMdc(); Map<String, String> map = wrapper.getMdc(); assertEquals(originalMap.keySet(), map.keySet()); for (Map.Entry<String, String> entry : originalMap.entrySet()) { assertEquals(entry.getValue(), map.get(entry.getKey())); } }
### Question: LoggingEvent implements ILoggingEvent { @Override public long getTimeStamp() { return _event.getTimeStamp(); } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testGetTimeStamp() { TestLoggingEvent event = new TestLoggingEvent(); ILoggingEvent wrapper = LoggingEvent.wrap(event); assertNotNull(wrapper); assertEquals(event.getTimeStamp(), wrapper.getTimeStamp()); }
### Question: LoggingEvent implements ILoggingEvent { @Override public void prepareForDeferredProcessing() { _event.prepareForDeferredProcessing(); } private LoggingEvent(ILoggingEvent event); static ILoggingEvent wrap(ILoggingEvent event); @Override String getThreadName(); @Override Level getLevel(); @Override String getMessage(); @Override Object[] getArgumentArray(); @Override String getFormattedMessage(); @Override String getLoggerName(); @Override LoggerContextVO getLoggerContextVO(); @Override IThrowableProxy getThrowableProxy(); @Override StackTraceElement[] getCallerData(); @Override boolean hasCallerData(); @Override Marker getMarker(); @Override Map<String, String> getMDCPropertyMap(); @Deprecated @Override Map<String, String> getMdc(); @Override long getTimeStamp(); @Override void prepareForDeferredProcessing(); }### Answer: @Test public void testPrepareForDeferredProcessing() { TestLoggingEvent event = new TestLoggingEvent(); ILoggingEvent wrapper = LoggingEvent.wrap(event); assertNotNull(wrapper); assertFalse(event.isPreparedForDeferredProcessing()); wrapper.prepareForDeferredProcessing(); assertTrue(event.isPreparedForDeferredProcessing()); }
### Question: BBDecoder extends AbstractDecoder { public void init(ByteBuffer in) { this.in = in; this.in.order(ByteOrder.BIG_ENDIAN); } void init(ByteBuffer in); void releaseBuffer(); @Override boolean hasRemaining(); @Override short readUint8(); @Override int readUint16(); @Override long readUint32(); @Override long readUint64(); @Override byte[] readBin128(); @Override byte[] readBytes(int howManyBytes); @Override double readDouble(); @Override float readFloat(); @Override short readInt16(); @Override int readInt32(); @Override byte readInt8(); @Override byte[] readRemainingBytes(); @Override long readInt64(); }### Answer: @Test public void str8Caching() { String testString = "Test"; BBEncoder encoder = new BBEncoder(64); encoder.writeStr8(testString); encoder.writeStr8(testString); ByteBuffer buffer = encoder.buffer(); BBDecoder decoder = new BBDecoder(); decoder.init(buffer); Cache<Binary, String> original = BBDecoder.getStringCache(); Cache<Binary, String> cache = CacheBuilder.newBuilder().maximumSize(2).build(); try { BBDecoder.setStringCache(cache); String decodedString1 = decoder.readStr8(); String decodedString2 = decoder.readStr8(); assertThat(testString, is(equalTo(decodedString1))); assertThat(testString, is(equalTo(decodedString2))); assertSame(decodedString1, decodedString2); } finally { cache.cleanUp(); BBDecoder.setStringCache(original); } }
### Question: DeliveryRegistryImpl implements DeliveryRegistry { @Override public UnsettledDelivery getDelivery(final UnsignedInteger deliveryId) { return _deliveries.get(deliveryId); } @Override void addDelivery(final UnsignedInteger deliveryId, final UnsettledDelivery unsettledDelivery); @Override void removeDelivery(final UnsignedInteger deliveryId); @Override UnsettledDelivery getDelivery(final UnsignedInteger deliveryId); @Override void removeDeliveriesForLinkEndpoint(final LinkEndpoint<?, ?> linkEndpoint); @Override UnsignedInteger getDeliveryId(final Binary deliveryTag, final LinkEndpoint<?, ?> linkEndpoint); @Override int size(); }### Answer: @Test public void getDelivery() { _registry.addDelivery(DELIVERY_ID, _unsettledDelivery); assertThat(_registry.size(), is(equalTo(1))); final UnsettledDelivery expected = new UnsettledDelivery(_unsettledDelivery.getDeliveryTag(), _unsettledDelivery.getLinkEndpoint()); assertThat(_registry.getDelivery(UnsignedInteger.ZERO), is(equalTo(expected))); }
### Question: BBEncoder extends AbstractEncoder { private void grow(int size) { ByteBuffer old = out; int capacity = old.capacity(); out = ByteBuffer.allocate(Math.max(capacity + size, 2*capacity)); out.order(ByteOrder.BIG_ENDIAN); old.flip(); out.put(old); } BBEncoder(int capacity); @Override void init(); ByteBuffer segment(); ByteBuffer buffer(); @Override int position(); ByteBuffer underlyingBuffer(); @Override void writeUint8(short b); @Override void writeUint16(int s); @Override void writeUint32(long i); @Override void writeUint64(long l); @Override int beginSize8(); @Override void endSize8(int pos); @Override int beginSize16(); @Override void endSize16(int pos); @Override int beginSize32(); @Override void endSize32(int pos); @Override void writeDouble(double aDouble); @Override void writeInt16(short aShort); @Override void writeInt32(int anInt); @Override void writeInt64(long aLong); @Override void writeInt8(byte aByte); @Override void writeBin128(byte[] byteArray); void writeBin128(UUID id); @Override void writeFloat(float aFloat); }### Answer: @Test public void testGrow() { BBEncoder enc = new BBEncoder(4); enc.writeInt32(0xDEADBEEF); ByteBuffer buf = enc.buffer(); assertEquals((long) 0xDEADBEEF, (long) buf.getInt(0)); enc.writeInt32(0xBEEFDEAD); buf = enc.buffer(); assertEquals((long) 0xDEADBEEF, (long) buf.getInt(0)); assertEquals((long) 0xBEEFDEAD, (long) buf.getInt(4)); }
### Question: MessageTransferMessageMutator implements ServerMessageMutator<MessageTransferMessage> { @Override public void setPriority(final byte priority) { if (_deliveryProperties == null) { _deliveryProperties = new DeliveryProperties(); } _deliveryProperties.setPriority(MessageDeliveryPriority.get(priority)); } MessageTransferMessageMutator(final MessageTransferMessage message, final MessageStore messageStore); @Override void setPriority(final byte priority); @Override byte getPriority(); @Override MessageTransferMessage create(); }### Answer: @Test public void setPriority() { _messageMutator.setPriority((byte) (TEST_PRIORITY + 1)); assertThat(_messageMutator.getPriority(), is(equalTo((byte) (TEST_PRIORITY + 1)))); }
### Question: MessageTransferMessageMutator implements ServerMessageMutator<MessageTransferMessage> { @Override public byte getPriority() { MessageDeliveryPriority priority = _deliveryProperties == null \|\| !_deliveryProperties.hasPriority() ? MessageDeliveryPriority.MEDIUM : _deliveryProperties.getPriority(); return (byte) priority.getValue(); } MessageTransferMessageMutator(final MessageTransferMessage message, final MessageStore messageStore); @Override void setPriority(final byte priority); @Override byte getPriority(); @Override MessageTransferMessage create(); }### Answer: @Test public void getPriority() { assertThat((int) _messageMutator.getPriority(), is(equalTo((int) TEST_PRIORITY))); }
### Question: MessageTransferMessageMutator implements ServerMessageMutator<MessageTransferMessage> { @Override public MessageTransferMessage create() { final Header header = new Header(_deliveryProperties, _messageProperties); final MessageMetaData_0_10 messageMetaData = new MessageMetaData_0_10(header, (int) _message.getSize(), _message.getArrivalTime()); final QpidByteBuffer content = _message.getContent(); final MessageHandle<MessageMetaData_0_10> addedMessage = _messageStore.addMessage(messageMetaData); if (content != null) { addedMessage.addContent(content); } return new MessageTransferMessage(addedMessage.allContentAdded(), _message.getConnectionReference()); } MessageTransferMessageMutator(final MessageTransferMessage message, final MessageStore messageStore); @Override void setPriority(final byte priority); @Override byte getPriority(); @Override MessageTransferMessage create(); }### Answer: @Test public void create() { _messageMutator.setPriority((byte) (TEST_PRIORITY + 1)); MessageTransferMessage newMessage = _messageMutator.create(); assertThat(newMessage.getMessageHeader().getPriority(), is(equalTo((byte) (TEST_PRIORITY + 1)))); assertThat(newMessage.getMessageHeader().getMimeType(), is(equalTo(TEST_CONTENT_TYPE))); assertThat(newMessage.getMessageHeader().getHeader(TEST_HEADER_NAME), is(equalTo(TEST_HEADER_VALUE))); QpidByteBuffer content = newMessage.getContent(); final byte[] bytes = new byte[content.remaining()]; content.copyTo(bytes); assertThat(new String(bytes, UTF_8), is(equalTo(TEST_CONTENT))); }
### Question: DerbyMessageStore extends AbstractDerbyMessageStore { @Override public void onDelete(ConfiguredObject parent) { if (isMessageStoreOpen()) { throw new IllegalStateException("Cannot delete the store as store is still open"); } FileBasedSettings fileBasedSettings = (FileBasedSettings)parent; String storePath = fileBasedSettings.getStorePath(); if (storePath != null) { LOGGER.debug("Deleting store : {}", storePath); File configFile = new File(storePath); if (!FileUtils.delete(configFile, true)) { LOGGER.info("Failed to delete the store at location : {}", storePath); } } } @Override Connection getConnection(); @Override void onDelete(ConfiguredObject parent); @Override String getStoreLocation(); @Override File getStoreLocationAsFile(); }### Answer: @Test public void testOnDelete() throws Exception { File location = new File(_storeLocation); assertTrue("Store does not exist at " + _storeLocation, location.exists()); getStore().closeMessageStore(); assertTrue("Store does not exist at " + _storeLocation, location.exists()); DerbyVirtualHost mockVH = mock(DerbyVirtualHost.class); when(mockVH.getStorePath()).thenReturn(_storeLocation); getStore().onDelete(mockVH); assertFalse("Store exists at " + _storeLocation, location.exists()); }
### Question: BoneCPConnectionProviderFactory implements JDBCConnectionProviderFactory { @Override public Set<String> getProviderAttributeNames() { return _supportedAttributes; } BoneCPConnectionProviderFactory(); @Override String getType(); @Override ConnectionProvider getConnectionProvider(String connectionUrl, String username, String password, Map<String, String> providerAttributes); @Override Set<String> getProviderAttributeNames(); }### Answer: @Test public void testGetProviderAttributeNames() { BoneCPConnectionProviderFactory factory = new BoneCPConnectionProviderFactory(); Set<String> supported = factory.getProviderAttributeNames(); assertFalse("Supported settings cannot be empty", supported.isEmpty()); assertTrue("partitionCount is not found", supported.contains(PARTITION_COUNT)); assertTrue("maxConnectionsPerPartition is not found", supported.contains(MAX_CONNECTIONS_PER_PARTITION)); assertTrue("minConnectionsPerPartition is not found",supported.contains(MIN_CONNECTIONS_PER_PARTITION)); }
### Question: DeliveryRegistryImpl implements DeliveryRegistry { @Override public void removeDeliveriesForLinkEndpoint(final LinkEndpoint<?, ?> linkEndpoint) { Iterator<UnsettledDelivery> iterator = _deliveries.values().iterator(); while (iterator.hasNext()) { UnsettledDelivery unsettledDelivery = iterator.next(); if (unsettledDelivery.getLinkEndpoint() == linkEndpoint) { iterator.remove(); _deliveryIds.remove(unsettledDelivery); } } } @Override void addDelivery(final UnsignedInteger deliveryId, final UnsettledDelivery unsettledDelivery); @Override void removeDelivery(final UnsignedInteger deliveryId); @Override UnsettledDelivery getDelivery(final UnsignedInteger deliveryId); @Override void removeDeliveriesForLinkEndpoint(final LinkEndpoint<?, ?> linkEndpoint); @Override UnsignedInteger getDeliveryId(final Binary deliveryTag, final LinkEndpoint<?, ?> linkEndpoint); @Override int size(); }### Answer: @Test public void removeDeliveriesForLinkEndpoint() { _registry.addDelivery(DELIVERY_ID, _unsettledDelivery); _registry.addDelivery(DELIVERY_ID_2, new UnsettledDelivery(DELIVERY_TAG_2, _unsettledDelivery.getLinkEndpoint())); _registry.addDelivery(UnsignedInteger.valueOf(2), new UnsettledDelivery(DELIVERY_TAG, mock(LinkEndpoint.class))); assertThat(_registry.size(), is(equalTo(3))); _registry.removeDeliveriesForLinkEndpoint(_unsettledDelivery.getLinkEndpoint()); assertThat(_registry.size(), is(equalTo(1))); }
### Question: ConnectionPrincipalLimitRule extends ConnectionPrincipalStatisticsRule { protected boolean matches(final AMQPConnection<?> connection) { return connection.getAuthenticatedPrincipalConnectionCount() <= getLimit(); } ConnectionPrincipalLimitRule(final int limit); @Override String toString(); }### Answer: @Test public void limitBreached() { when(_connection.getAuthenticatedPrincipalConnectionCount()).thenReturn(2); final ConnectionPrincipalLimitRule rule = new ConnectionPrincipalLimitRule(1); assertThat(rule.matches(_subject), is(false)); } @Test public void frequencyEqualsLimit() { when(_connection.getAuthenticatedPrincipalConnectionCount()).thenReturn(2); final ConnectionPrincipalLimitRule rule = new ConnectionPrincipalLimitRule(2); assertThat(rule.matches(_subject), is(true)); } @Test public void frequencyBelowLimit() { when(_connection.getAuthenticatedPrincipalConnectionCount()).thenReturn(1); final ConnectionPrincipalLimitRule rule = new ConnectionPrincipalLimitRule(2); assertThat(rule.matches(_subject), is(true)); }
### Question: ConnectionPrincipalFrequencyLimitRule extends ConnectionPrincipalStatisticsRule { @Override boolean matches(final AMQPConnection<?> connection) { return connection.getAuthenticatedPrincipalConnectionFrequency() <= getLimit(); } ConnectionPrincipalFrequencyLimitRule(final int limit); @Override String toString(); }### Answer: @Test public void limitBreached() { when(_connection.getAuthenticatedPrincipalConnectionFrequency()).thenReturn(2); final ConnectionPrincipalFrequencyLimitRule rule = new ConnectionPrincipalFrequencyLimitRule(1); assertThat(rule.matches(_subject), is(false)); } @Test public void frequencyEqualsLimit() { when(_connection.getAuthenticatedPrincipalConnectionFrequency()).thenReturn(2); final ConnectionPrincipalFrequencyLimitRule rule = new ConnectionPrincipalFrequencyLimitRule(2); assertThat(rule.matches(_subject), is(true)); } @Test public void frequencyBelowLimit() { when(_connection.getAuthenticatedPrincipalConnectionFrequency()).thenReturn(1); final ConnectionPrincipalFrequencyLimitRule rule = new ConnectionPrincipalFrequencyLimitRule(2); assertThat(rule.matches(_subject), is(true)); }
### Question: DeliveryRegistryImpl implements DeliveryRegistry { @Override public UnsignedInteger getDeliveryId(final Binary deliveryTag, final LinkEndpoint<?, ?> linkEndpoint) { return _deliveryIds.get(new UnsettledDelivery(deliveryTag, linkEndpoint)); } @Override void addDelivery(final UnsignedInteger deliveryId, final UnsettledDelivery unsettledDelivery); @Override void removeDelivery(final UnsignedInteger deliveryId); @Override UnsettledDelivery getDelivery(final UnsignedInteger deliveryId); @Override void removeDeliveriesForLinkEndpoint(final LinkEndpoint<?, ?> linkEndpoint); @Override UnsignedInteger getDeliveryId(final Binary deliveryTag, final LinkEndpoint<?, ?> linkEndpoint); @Override int size(); }### Answer: @Test public void getDeliveryId() { _registry.addDelivery(DELIVERY_ID, _unsettledDelivery); _registry.addDelivery(DELIVERY_ID_2, new UnsettledDelivery(DELIVERY_TAG, mock(LinkEndpoint.class))); final UnsignedInteger deliveryId = _registry.getDeliveryId(DELIVERY_TAG, _unsettledDelivery.getLinkEndpoint()); assertThat(deliveryId, is(equalTo(DELIVERY_ID))); }
### Question: DeliveryRegistryImpl implements DeliveryRegistry { @Override public int size() { return _deliveries.size(); } @Override void addDelivery(final UnsignedInteger deliveryId, final UnsettledDelivery unsettledDelivery); @Override void removeDelivery(final UnsignedInteger deliveryId); @Override UnsettledDelivery getDelivery(final UnsignedInteger deliveryId); @Override void removeDeliveriesForLinkEndpoint(final LinkEndpoint<?, ?> linkEndpoint); @Override UnsignedInteger getDeliveryId(final Binary deliveryTag, final LinkEndpoint<?, ?> linkEndpoint); @Override int size(); }### Answer: @Test public void size() { assertThat(_registry.size(), is(equalTo(0))); _registry.addDelivery(DELIVERY_ID, _unsettledDelivery); assertThat(_registry.size(), is(equalTo(1))); _registry.removeDelivery(DELIVERY_ID); assertThat(_registry.size(), is(equalTo(0))); }
### Question: AclAction { public Map<ObjectProperties.Property, String> getAttributes() { return _predicates.getParsedProperties(); } AclAction(LegacyOperation operation, ObjectType object, AclRulePredicates predicates); AclAction(LegacyOperation operation); AclAction(LegacyOperation operation, ObjectType object, ObjectProperties properties); DynamicRule getDynamicRule(); Action getAction(); boolean isAllowed(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); Map<ObjectProperties.Property, String> getAttributes(); }### Answer: @Test public void testGetAttributes() { final ObjectType objectType = ObjectType.VIRTUALHOST; final LegacyOperation operation = LegacyOperation.ACCESS; final AclRulePredicates predicates = new AclRulePredicates(); predicates.parse(ObjectProperties.Property.FROM_HOSTNAME.name(), TEST_HOSTNAME); predicates.parse(ObjectProperties.Property.ATTRIBUTES.name(), TEST_ATTRIBUTES); predicates.parse(ObjectProperties.Property.NAME.name(), getTestName()); final AclAction aclAction = new AclAction(operation, objectType, predicates); final Map<ObjectProperties.Property, String> attributes = aclAction.getAttributes(); assertThat(attributes, allOf(aMapWithSize(3), hasEntry(ObjectProperties.Property.FROM_HOSTNAME, TEST_HOSTNAME), hasEntry(ObjectProperties.Property.ATTRIBUTES, TEST_ATTRIBUTES), hasEntry(ObjectProperties.Property.NAME, getTestName()))); }
### Question: Message_1_0_Mutator implements ServerMessageMutator<Message_1_0> { @Override public void setPriority(final byte priority) { if (_header == null) { _header = new Header(); } _header.setPriority(UnsignedByte.valueOf(priority)); } Message_1_0_Mutator(final Message_1_0 message, final MessageStore messageStore); @Override void setPriority(final byte priority); @Override byte getPriority(); @Override Message_1_0 create(); }### Answer: @Test public void setPriority() { _messageMutator.setPriority((byte) (TEST_PRIORITY + 1)); assertThat(_messageMutator.getPriority(), is(equalTo((byte) (TEST_PRIORITY + 1)))); }
### Question: Action { private boolean propertiesMatch(Action a) { boolean propertiesMatch = false; if (_properties != null) { propertiesMatch = _properties.propertiesMatch(a.getProperties()); } else if (a.getProperties() == null) { propertiesMatch = true; } return propertiesMatch; } Action(LegacyOperation operation); Action(LegacyOperation operation, ObjectType object, String name); Action(LegacyOperation operation, ObjectType object); Action(LegacyOperation operation, ObjectType object, ObjectProperties properties); LegacyOperation getOperation(); ObjectType getObjectType(); ObjectProperties getProperties(); boolean matches(Action a); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testMatchesReturnsTrueForMatchingActions() { when(_properties1.propertiesMatch(_properties2)).thenReturn(true); assertMatches( new Action(LegacyOperation.CONSUME, ObjectType.QUEUE, _properties1), new Action(LegacyOperation.CONSUME, ObjectType.QUEUE, _properties2)); }
### Question: Message_1_0_Mutator implements ServerMessageMutator<Message_1_0> { @Override public byte getPriority() { if (_header == null \|\| _header.getPriority() == null) { return 4; } else { return _header.getPriority().byteValue(); } } Message_1_0_Mutator(final Message_1_0 message, final MessageStore messageStore); @Override void setPriority(final byte priority); @Override byte getPriority(); @Override Message_1_0 create(); }### Answer: @Test public void getPriority() { assertThat((int) _messageMutator.getPriority(), is(equalTo((int) TEST_PRIORITY))); }
### Question: JDBCSettingsDrivenConnectionSource extends ConnectionSourceBase { @Override public void start() { _connectionProvider.getAndUpdate(provider -> provider == null ? create() : provider); discoverConnectionProperties(); if (!supportsGetGeneratedKeys() && getSQLDialectCode() == SQLDialectCode.UNKNOWN_DIALECT) { addWarn("Connection does not support GetGeneratedKey method and could not discover the dialect."); } super.start(); } JDBCSettingsDrivenConnectionSource(final ConfiguredObject<?> object, final JDBCSettings jdbcSettings); @Override Connection getConnection(); @Override void start(); @Override void stop(); @Override String toString(); }### Answer: @Test public void testStart() throws SQLException { try { _connectionSource.getConnection(); fail("connection should fail for non started ConnectionSource"); } catch (IllegalConfigurationException e) { } _connectionSource.start(); final Connection connection = _connectionSource.getConnection(); connection.close(); }
### Question: JDBCSettingsDrivenConnectionSource extends ConnectionSourceBase { @Override public void stop() { super.stop(); final ConnectionProvider connectionProvider = _connectionProvider.getAndSet(null); if (connectionProvider != null) { try { connectionProvider.close(); } catch (SQLException e) { LOGGER.warn("Unable to close connection provider", e); } } } JDBCSettingsDrivenConnectionSource(final ConfiguredObject<?> object, final JDBCSettings jdbcSettings); @Override Connection getConnection(); @Override void start(); @Override void stop(); @Override String toString(); }### Answer: @Test public void testStop() throws SQLException { _connectionSource.start(); _connectionSource.stop(); try { _connectionSource.getConnection(); fail("connection should fail for stopped ConnectionSource"); } catch (IllegalConfigurationException e) { } }
### Question: JDBCSettingsDrivenConnectionSource extends ConnectionSourceBase { @Override public Connection getConnection() throws SQLException { final ConnectionProvider connectionProvider = _connectionProvider.get(); if (connectionProvider == null) { throw new IllegalConfigurationException("Connection provider does not exist"); } return connectionProvider.getConnection(); } JDBCSettingsDrivenConnectionSource(final ConfiguredObject<?> object, final JDBCSettings jdbcSettings); @Override Connection getConnection(); @Override void start(); @Override void stop(); @Override String toString(); }### Answer: @Test public void testGetConnection() throws SQLException { _connectionSource.start(); final Connection connection = _connectionSource.getConnection(); connection.close(); }
### Question: JDBCVirtualHostLoggerImpl extends AbstractVirtualHostLogger<JDBCVirtualHostLoggerImpl> implements JDBCVirtualHostLogger<JDBCVirtualHostLoggerImpl> { @Override public String getTableNamePrefix() { return _tableNamePrefix; } @ManagedObjectFactoryConstructor protected JDBCVirtualHostLoggerImpl(final Map<String, Object> attributes, VirtualHost<?> virtualHost); @Override String getConnectionUrl(); @Override String getConnectionPoolType(); @Override String getUsername(); @Override String getPassword(); @Override String getTableNamePrefix(); }### Answer: @Test public void changeTablePrefix() { _logger.create(); final Map<String, Object> attributes = Collections.singletonMap(JDBCSettings.TABLE_NAME_PREFIX, TABLE_PREFIX); _logger.setAttributes(attributes); assertEquals(TABLE_PREFIX, _logger.getTableNamePrefix()); }
### Question: JDBCBrokerLoggerImpl extends AbstractBrokerLogger<JDBCBrokerLoggerImpl> implements JDBCBrokerLogger<JDBCBrokerLoggerImpl> { @Override public String getTableNamePrefix() { return _tableNamePrefix; } @ManagedObjectFactoryConstructor protected JDBCBrokerLoggerImpl(final Map<String, Object> attributes, Broker<?> broker); @Override String getConnectionUrl(); @Override String getConnectionPoolType(); @Override String getUsername(); @Override String getPassword(); @Override String getTableNamePrefix(); }### Answer: @Test public void changeTablePrefix() { _logger.create(); final Map<String, Object> attributes = Collections.singletonMap(JDBCSettings.TABLE_NAME_PREFIX, TABLE_PREFIX); _logger.setAttributes(attributes); assertEquals(TABLE_PREFIX, _logger.getTableNamePrefix()); }
### Question: JDBCSettingsDBNameResolver implements DBNameResolver { @Override public <N extends Enum<?>> String getTableName(final N tableName) { final String settingsTableNamePrefix = _settings.getTableNamePrefix(); final String prefix = settingsTableNamePrefix == null ? "" : settingsTableNamePrefix; final String name = prefix + tableName.toString(); return name.toLowerCase(); } JDBCSettingsDBNameResolver(final JDBCSettings settings); @Override String getTableName(final N tableName); @Override String getColumnName(final N columnName); }### Answer: @Test public void getTableName() { assertEquals((TABLE_PREFIX + TableName.LOGGING_EVENT.name()).toLowerCase(), _dbNameResolver.getTableName(TableName.LOGGING_EVENT)); }
### Question: JDBCSettingsDBNameResolver implements DBNameResolver { @Override public <N extends Enum<?>> String getColumnName(final N columnName) { return columnName.toString().toLowerCase(); } JDBCSettingsDBNameResolver(final JDBCSettings settings); @Override String getTableName(final N tableName); @Override String getColumnName(final N columnName); }### Answer: @Test public void getColumnName() { assertEquals(ColumnName.LOGGER_NAME.name().toLowerCase(), _dbNameResolver.getColumnName(ColumnName.LOGGER_NAME)); }
### Question: JDBCLoggerHelper { Appender<ILoggingEvent> createAppenderInstance(final Context context, final ConfiguredObject<?> logger, final JDBCSettings settings) { try { final JDBCSettingsDBNameResolver dbNameResolver = new JDBCSettingsDBNameResolver(settings); final ConnectionSource connectionSource = createConnectionSource(context, logger, settings); final DBAppender appender = new DBAppender(); appender.setDbNameResolver(dbNameResolver); appender.setConnectionSource(connectionSource); appender.setContext(context); appender.start(); return appender; } catch (Exception e) { LOGGER.error("Failed to create appender", e); throw new IllegalConfigurationException("Cannot create appender"); } } }### Answer: @Test public void createAppenderInstance() { final LoggerContext context = ROOT_LOGGER.getLoggerContext(); final Appender<ILoggingEvent> appender = _jdbcLoggerHelper.createAppenderInstance(context, _broker, _jdbcSettings); assertTrue(appender instanceof DBAppender); assertTrue(appender.isStarted()); assertEquals(context, appender.getContext()); assertTrue(((DBAppender) appender).getConnectionSource() instanceof JDBCSettingsDrivenConnectionSource); }
### Question: JDBCLoggerHelper { void restartAppenderIfExists(final Appender appender) { if (appender != null) { appender.stop(); appender.start(); } } }### Answer: @Test public void restartAppenderIfExists() { final Appender appender = mock(Appender.class); _jdbcLoggerHelper.restartAppenderIfExists(appender); verify(appender).stop(); verify(appender).start(); verifyNoMoreInteractions(appender); }
### Question: JDBCLoggerHelper { void restartConnectionSourceIfExists(final Appender appender) { if (appender instanceof DBAppender) { final ConnectionSource connectionSource = ((DBAppender) appender).getConnectionSource(); if (connectionSource != null) { connectionSource.stop(); connectionSource.start(); } } } }### Answer: @Test public void restartConnectionSourceIfExists() { final ConnectionSource connectionSource = mock(ConnectionSource.class); final DBAppender appender = mock(DBAppender.class); when(appender.getConnectionSource()).thenReturn(connectionSource); _jdbcLoggerHelper.restartConnectionSourceIfExists(appender); verify(connectionSource).stop(); verify(connectionSource).start(); verifyNoMoreInteractions(connectionSource); }
### Question: JDBCLoggerHelper { void validateConnectionSourceSettings(final ConfiguredObject<?> logger, final JDBCSettings settings) { try { final ConnectionSource connectionSource = createConnectionSource(logger, settings); connectionSource.getConnection().close(); } catch (Exception e) { throw new IllegalConfigurationException( "Cannot create connection source from given URL, credentials and connection pool type"); } } }### Answer: @Test public void validateConnectionSourceSettings() { _jdbcLoggerHelper.validateConnectionSourceSettings(_broker, _jdbcSettings); } @Test public void validateConnectionSourceSettingsForInvalidURL() { when(_jdbcSettings.getConnectionUrl()).thenReturn(INVALID_JDBC_URL); try { _jdbcLoggerHelper.validateConnectionSourceSettings(_broker, _jdbcSettings); fail("Exception is expected"); } catch (IllegalConfigurationException e) { } }
### Question: StoreConfigurationChangeListener implements ConfigurationChangeListener { @Override public void stateChanged(ConfiguredObject object, State oldState, State newState) { if (newState == State.DELETED) { if(object.isDurable()) { _store.remove(object.asObjectRecord()); } object.removeChangeListener(this); } } StoreConfigurationChangeListener(DurableConfigurationStore store); @Override void stateChanged(ConfiguredObject object, State oldState, State newState); @Override void childAdded(ConfiguredObject<?> object, ConfiguredObject<?> child); @Override void bulkChangeStart(final ConfiguredObject<?> object); @Override void bulkChangeEnd(final ConfiguredObject<?> object); @Override void childRemoved(ConfiguredObject object, ConfiguredObject child); @Override void attributeSet(ConfiguredObject object, String attributeName, Object oldAttributeValue, Object newAttributeValue); @Override String toString(); }### Answer: @Test public void testStateChanged() { notifyBrokerStarted(); UUID id = UUID.randomUUID(); ConfiguredObject object = mock(VirtualHost.class); when(object.isDurable()).thenReturn(true); when(object.getId()).thenReturn(id); ConfiguredObjectRecord record = mock(ConfiguredObjectRecord.class); when(object.asObjectRecord()).thenReturn(record); _listener.stateChanged(object, State.ACTIVE, State.DELETED); verify(_store).remove(record); }
### Question: StoreConfigurationChangeListener implements ConfigurationChangeListener { @Override public void attributeSet(ConfiguredObject object, String attributeName, Object oldAttributeValue, Object newAttributeValue) { if (object.isDurable() && !_bulkChanges) { _store.update(false, object.asObjectRecord()); } } StoreConfigurationChangeListener(DurableConfigurationStore store); @Override void stateChanged(ConfiguredObject object, State oldState, State newState); @Override void childAdded(ConfiguredObject<?> object, ConfiguredObject<?> child); @Override void bulkChangeStart(final ConfiguredObject<?> object); @Override void bulkChangeEnd(final ConfiguredObject<?> object); @Override void childRemoved(ConfiguredObject object, ConfiguredObject child); @Override void attributeSet(ConfiguredObject object, String attributeName, Object oldAttributeValue, Object newAttributeValue); @Override String toString(); }### Answer: @Test public void testAttributeSet() { notifyBrokerStarted(); Broker broker = mock(Broker.class); when(broker.getCategoryClass()).thenReturn(Broker.class); when(broker.isDurable()).thenReturn(true); final ConfiguredObjectRecord record = mock(ConfiguredObjectRecord.class); when(broker.asObjectRecord()).thenReturn(record); _listener.attributeSet(broker, Broker.DESCRIPTION, null, "test description"); verify(_store).update(eq(false), eq(record)); }
### Question: LocalTransaction implements ServerTransaction { @Override public void addPostTransactionAction(Action postTransactionAction) { sync(); _postTransactionActions.add(postTransactionAction); } LocalTransaction(MessageStore transactionLog); LocalTransaction(MessageStore transactionLog, TransactionObserver transactionObserver); LocalTransaction(MessageStore transactionLog, ActivityTimeAccessor activityTime, TransactionObserver transactionObserver, boolean resetable); @Override long getTransactionStartTime(); @Override long getTransactionUpdateTime(); @Override void addPostTransactionAction(Action postTransactionAction); @Override void dequeue(MessageEnqueueRecord record, Action postTransactionAction); @Override void dequeue(Collection<MessageInstance> queueEntries, Action postTransactionAction); @Override void enqueue(TransactionLogResource queue, EnqueueableMessage message, EnqueueAction postTransactionAction); @Override void enqueue(Collection<? extends BaseQueue> queues, EnqueueableMessage message, EnqueueAction postTransactionAction); @Override void commit(); @Override void commit(Runnable immediateAction); void commitAsync(final Runnable deferred); @Override void rollback(); void sync(); @Override boolean isTransactional(); boolean setRollbackOnly(); boolean isRollbackOnly(); boolean hasOutstandingWork(); boolean isDischarged(); void addTransactionListener(LocalTransactionListener listener); void removeTransactionListener(LocalTransactionListener listener); }### Answer: @Test public void testAddingPostCommitActionNotFiredImmediately() throws Exception { _transaction.addPostTransactionAction(_action1); assertNotFired(_action1); }
### Question: LocalTransaction implements ServerTransaction { @Override public void commit() { commit(null); } LocalTransaction(MessageStore transactionLog); LocalTransaction(MessageStore transactionLog, TransactionObserver transactionObserver); LocalTransaction(MessageStore transactionLog, ActivityTimeAccessor activityTime, TransactionObserver transactionObserver, boolean resetable); @Override long getTransactionStartTime(); @Override long getTransactionUpdateTime(); @Override void addPostTransactionAction(Action postTransactionAction); @Override void dequeue(MessageEnqueueRecord record, Action postTransactionAction); @Override void dequeue(Collection<MessageInstance> queueEntries, Action postTransactionAction); @Override void enqueue(TransactionLogResource queue, EnqueueableMessage message, EnqueueAction postTransactionAction); @Override void enqueue(Collection<? extends BaseQueue> queues, EnqueueableMessage message, EnqueueAction postTransactionAction); @Override void commit(); @Override void commit(Runnable immediateAction); void commitAsync(final Runnable deferred); @Override void rollback(); void sync(); @Override boolean isTransactional(); boolean setRollbackOnly(); boolean isRollbackOnly(); boolean hasOutstandingWork(); boolean isDischarged(); void addTransactionListener(LocalTransactionListener listener); void removeTransactionListener(LocalTransactionListener listener); }### Answer: @Test public void testCommitNoWork() throws Exception { _transaction.commit(); assertEquals("Unexpected number of store dequeues", (long) 0, (long) _storeTransaction.getNumberOfDequeuedMessages()); assertEquals("Unexpected number of store enqueues", (long) 0, (long) _storeTransaction.getNumberOfEnqueuedMessages()); assertEquals("Unexpected transaction state", TransactionState.NOT_STARTED, _storeTransaction.getState()); }
### Question: AutoCommitTransaction implements ServerTransaction { @Override public void addPostTransactionAction(final Action immediateAction) { immediateAction.postCommit(); } AutoCommitTransaction(MessageStore transactionLog); @Override long getTransactionStartTime(); @Override long getTransactionUpdateTime(); @Override void addPostTransactionAction(final Action immediateAction); @Override void dequeue(MessageEnqueueRecord record, Action postTransactionAction); @Override void dequeue(Collection<MessageInstance> queueEntries, Action postTransactionAction); @Override void enqueue(TransactionLogResource queue, EnqueueableMessage message, EnqueueAction postTransactionAction); @Override void enqueue(Collection<? extends BaseQueue> queues, EnqueueableMessage message, EnqueueAction postTransactionAction); @Override void commit(final Runnable immediatePostTransactionAction); @Override void commit(); @Override void rollback(); @Override boolean isTransactional(); }### Answer: @Test public void testPostCommitActionFiredImmediately() throws Exception { _transaction.addPostTransactionAction(_action); assertTrue("Post commit action must be fired", _action.isPostCommitActionFired()); assertFalse("Rollback action must be fired", _action.isRollbackActionFired()); }
### Question: FlowToDiskTransactionObserver implements TransactionObserver { @Override public void onDischarge(final ServerTransaction transaction) { TransactionDetails transactionDetails = _uncommittedMessages.remove(transaction); if (transactionDetails != null) { _uncommittedMessageSize.addAndGet(-transactionDetails.getUncommittedMessageSize()); } if (_maxUncommittedInMemorySize > _uncommittedMessageSize.get()) { _reported = false; } } FlowToDiskTransactionObserver(final long maxUncommittedInMemorySize, final LogSubject logSubject, final EventLogger eventLogger); @Override void onMessageEnqueue(final ServerTransaction transaction, final EnqueueableMessage<? extends StorableMessageMetaData> message); @Override void onDischarge(final ServerTransaction transaction); @Override void reset(); }### Answer: @Test public void testOnDischarge() throws Exception { EnqueueableMessage<?> message1 = createMessage(MAX_UNCOMMITTED_IN_MEMORY_SIZE - 1); EnqueueableMessage<?> message2 = createMessage(1); EnqueueableMessage<?> message3 = createMessage(1); _flowToDiskMessageObserver.onMessageEnqueue(_transaction, message1); final ServerTransaction transaction2 = mock(ServerTransaction.class); _flowToDiskMessageObserver.onMessageEnqueue(transaction2, message2); _flowToDiskMessageObserver.onDischarge(_transaction); _flowToDiskMessageObserver.onMessageEnqueue(transaction2, message3); StoredMessage handle1 = message1.getStoredMessage(); StoredMessage handle2 = message2.getStoredMessage(); StoredMessage handle3 = message2.getStoredMessage(); verify(handle1, never()).flowToDisk(); verify(handle2, never()).flowToDisk(); verify(handle3, never()).flowToDisk(); verify(_eventLogger, never()).message(same(_logSubject), any(LogMessage.class)); }
### Question: SystemLauncher { public void startup(final Map<String,Object> systemConfigAttributes) throws Exception { final SystemOutMessageLogger systemOutMessageLogger = new SystemOutMessageLogger(); _eventLogger = new EventLogger(systemOutMessageLogger); Subject.doAs(_brokerTaskSubject, new PrivilegedExceptionAction<Object>() { @Override public Object run() throws Exception { _listener.beforeStartup(); try { startupImpl(systemConfigAttributes); } catch (RuntimeException e) { systemOutMessageLogger.message(new SystemStartupMessage(e)); LOGGER.error("Exception during startup", e); _listener.errorOnStartup(e); closeSystemConfigAndCleanUp(); } finally { _listener.afterStartup(); } return null; } }); } SystemLauncher(SystemLauncherListener listener); SystemLauncher(SystemLauncherListener... listeners); SystemLauncher(); static void populateSystemPropertiesFromDefaults(final String initialProperties); Principal getSystemPrincipal(); void shutdown(); void shutdown(int exitStatusCode); void startup(final Map<String,Object> systemConfigAttributes); }### Answer: @Test public void testInitialSystemPropertiesAreSetOnBrokerStartup() throws Exception { Map<String,Object> attributes = new HashMap<>(); attributes.put(SystemConfig.INITIAL_SYSTEM_PROPERTIES_LOCATION, _initialSystemProperties.getAbsolutePath()); attributes.put(SystemConfig.INITIAL_CONFIGURATION_LOCATION, _initialConfiguration.getAbsolutePath()); attributes.put(SystemConfig.TYPE, JsonSystemConfigImpl.SYSTEM_CONFIG_TYPE); attributes.put(SystemConfig.STARTUP_LOGGED_TO_SYSTEM_OUT, Boolean.TRUE); _systemLauncher = new SystemLauncher(); _systemLauncher.startup(attributes); assertEquals("Unexpected JVM system property", INITIAL_SYSTEM_PROPERTY_VALUE, System.getProperty(INITIAL_SYSTEM_PROPERTY)); assertEquals("Unexpected QPID_WORK system property", _brokerWork.getAbsolutePath(), System.getProperty("QPID_WORK")); }
### Question: GZIPUtils { public static byte[] uncompressBufferToArray(ByteBuffer contentBuffer) { if(contentBuffer != null) { try (ByteBufferInputStream input = new ByteBufferInputStream(contentBuffer)) { return uncompressStreamToArray(input); } } else { return null; } } static byte[] compressBufferToArray(ByteBuffer input); static byte[] uncompressBufferToArray(ByteBuffer contentBuffer); static byte[] uncompressStreamToArray(InputStream stream); static final String GZIP_CONTENT_ENCODING; }### Answer: @Test public void testUncompressNonZipReturnsNull() throws Exception { byte[] data = new byte[1024]; Arrays.fill(data, (byte)'a'); assertNull("Non zipped data should not uncompress", GZIPUtils.uncompressBufferToArray(ByteBuffer.wrap(data))); } @Test public void testUncompressNullBufferReturnsNull() throws Exception { assertNull("Null buffer should return null", GZIPUtils.uncompressBufferToArray(null)); }
### Question: GZIPUtils { public static byte[] uncompressStreamToArray(InputStream stream) { if(stream != null) { try (GZIPInputStream gzipInputStream = new GZIPInputStream(stream)) { ByteArrayOutputStream inflatedContent = new ByteArrayOutputStream(); int read; byte[] buf = new byte[4096]; while ((read = gzipInputStream.read(buf)) != -1) { inflatedContent.write(buf, 0, read); } return inflatedContent.toByteArray(); } catch (IOException e) { LOGGER.warn("Unexpected IOException when attempting to uncompress with gzip", e); } } return null; } static byte[] compressBufferToArray(ByteBuffer input); static byte[] uncompressBufferToArray(ByteBuffer contentBuffer); static byte[] uncompressStreamToArray(InputStream stream); static final String GZIP_CONTENT_ENCODING; }### Answer: @Test public void testUncompressStreamWithErrorReturnsNull() throws Exception { InputStream is = new InputStream() { @Override public int read() throws IOException { throw new IOException(); } }; assertNull("Stream error should return null", GZIPUtils.uncompressStreamToArray(is)); } @Test public void testUncompressNullStreamReturnsNull() throws Exception { assertNull("Null Stream should return null", GZIPUtils.uncompressStreamToArray(null)); }
### Question: GZIPUtils { public static byte[] compressBufferToArray(ByteBuffer input) { if(input != null) { try (ByteArrayOutputStream compressedBuffer = new ByteArrayOutputStream()) { try (GZIPOutputStream gzipOutputStream = new GZIPOutputStream(compressedBuffer)) { if (input.hasArray()) { gzipOutputStream.write(input.array(), input.arrayOffset() + input.position(), input.remaining()); } else { byte[] data = new byte[input.remaining()]; input.duplicate().get(data); gzipOutputStream.write(data); } } return compressedBuffer.toByteArray(); } catch (IOException e) { LOGGER.warn("Unexpected IOException when attempting to compress with gzip", e); } } return null; } static byte[] compressBufferToArray(ByteBuffer input); static byte[] uncompressBufferToArray(ByteBuffer contentBuffer); static byte[] uncompressStreamToArray(InputStream stream); static final String GZIP_CONTENT_ENCODING; }### Answer: @Test public void testCompressNullArrayReturnsNull() { assertNull(GZIPUtils.compressBufferToArray(null)); }
### Question: FileHelper { public Path createNewFile(File newFile, String posixFileAttributes) throws IOException { return createNewFile(newFile.toPath(), posixFileAttributes); } void writeFileSafely(Path targetFile, BaseAction<File, IOException> operation); void writeFileSafely(Path targetFile, Path backupFile, Path tmpFile, BaseAction<File, IOException> write); Path createNewFile(File newFile, String posixFileAttributes); Path createNewFile(Path newFile, String posixFileAttributes); Path createNewFile(Path newFile, Set<PosixFilePermission> permissions); boolean isPosixFileSystem(Path path); Path atomicFileMoveOrReplace(Path sourceFile, Path targetFile); boolean isWritableDirectory(String path); }### Answer: @Test public void testCreateNewFile() throws Exception { assertFalse("File should not exist", _testFile.exists()); Path path = _fileHelper.createNewFile(_testFile, TEST_FILE_PERMISSIONS); assertTrue("File was not created", path.toFile().exists()); if (Files.getFileAttributeView(path, PosixFileAttributeView.class) != null) { assertPermissions(path); } } @Test public void testCreateNewFileUsingRelativePath() throws Exception { _testFile = new File("./tmp-" + System.currentTimeMillis()); assertFalse("File should not exist", _testFile.exists()); Path path = _fileHelper.createNewFile(_testFile, TEST_FILE_PERMISSIONS); assertTrue("File was not created", path.toFile().exists()); if (Files.getFileAttributeView(path, PosixFileAttributeView.class) != null) { assertPermissions(path); } }
### Question: FileHelper { public void writeFileSafely(Path targetFile, BaseAction<File, IOException> operation) throws IOException { String name = targetFile.toFile().getName(); writeFileSafely(targetFile, targetFile.resolveSibling(name + ".bak"), targetFile.resolveSibling(name + ".tmp"), operation); } void writeFileSafely(Path targetFile, BaseAction<File, IOException> operation); void writeFileSafely(Path targetFile, Path backupFile, Path tmpFile, BaseAction<File, IOException> write); Path createNewFile(File newFile, String posixFileAttributes); Path createNewFile(Path newFile, String posixFileAttributes); Path createNewFile(Path newFile, Set<PosixFilePermission> permissions); boolean isPosixFileSystem(Path path); Path atomicFileMoveOrReplace(Path sourceFile, Path targetFile); boolean isWritableDirectory(String path); }### Answer: @Test public void testWriteFileSafely() throws Exception { Path path = _fileHelper.createNewFile(_testFile, TEST_FILE_PERMISSIONS); _fileHelper.writeFileSafely(path, new BaseAction<File, IOException>() { @Override public void performAction(File file) throws IOException { Files.write(file.toPath(), "test".getBytes("UTF8")); assertEquals("Unexpected name", _testFile.getAbsolutePath() + ".tmp", file.getPath()); } }); assertTrue("File was not created", path.toFile().exists()); if (Files.getFileAttributeView(path, PosixFileAttributeView.class) != null) { assertPermissions(path); } String content = new String(Files.readAllBytes(path), "UTF-8"); assertEquals("Unexpected file content", "test", content); }
### Question: FileHelper { public Path atomicFileMoveOrReplace(Path sourceFile, Path targetFile) throws IOException { try { return Files.move(sourceFile, targetFile, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING); } catch(AtomicMoveNotSupportedException e) { if (sourceFile.toFile().renameTo(targetFile.toFile())) { return targetFile; } else { throw new RuntimeException("Atomic move is unsupported and rename from : '" + sourceFile + "' to: '" + targetFile + "' failed."); } } } void writeFileSafely(Path targetFile, BaseAction<File, IOException> operation); void writeFileSafely(Path targetFile, Path backupFile, Path tmpFile, BaseAction<File, IOException> write); Path createNewFile(File newFile, String posixFileAttributes); Path createNewFile(Path newFile, String posixFileAttributes); Path createNewFile(Path newFile, Set<PosixFilePermission> permissions); boolean isPosixFileSystem(Path path); Path atomicFileMoveOrReplace(Path sourceFile, Path targetFile); boolean isWritableDirectory(String path); }### Answer: @Test public void testAtomicFileMoveOrReplace() throws Exception { Path path = _fileHelper.createNewFile(_testFile, TEST_FILE_PERMISSIONS); Files.write(path, "test".getBytes("UTF8")); _testFile = _fileHelper.atomicFileMoveOrReplace(path, path.resolveSibling(_testFile.getName() + ".target")).toFile(); assertFalse("File was not moved", path.toFile().exists()); assertTrue("Target file does not exist", _testFile.exists()); if (Files.getFileAttributeView(_testFile.toPath(), PosixFileAttributeView.class) != null) { assertPermissions(_testFile.toPath()); } }
### Question: FileHelper { public boolean isWritableDirectory(String path) { File storePath = new File(path).getAbsoluteFile(); if (storePath.exists()) { if (!storePath.isDirectory()) { return false; } } else { do { storePath = storePath.getParentFile(); if (storePath == null) { return false; } } while (!storePath.exists()); } return storePath.canWrite(); } void writeFileSafely(Path targetFile, BaseAction<File, IOException> operation); void writeFileSafely(Path targetFile, Path backupFile, Path tmpFile, BaseAction<File, IOException> write); Path createNewFile(File newFile, String posixFileAttributes); Path createNewFile(Path newFile, String posixFileAttributes); Path createNewFile(Path newFile, Set<PosixFilePermission> permissions); boolean isPosixFileSystem(Path path); Path atomicFileMoveOrReplace(Path sourceFile, Path targetFile); boolean isWritableDirectory(String path); }### Answer: @Test public void testIsWritableDirectoryForNonWritablePath() throws Exception { File workDir = TestFileUtils.createTestDirectory("test", true); try { if (Files.getFileAttributeView(workDir.toPath(), PosixFileAttributeView.class) != null) { File file = new File(workDir, getTestName()); file.mkdirs(); if (file.setWritable(false, false)) { assertFalse("Should return false for non writable folder", _fileHelper.isWritableDirectory(new File(file, "test").getAbsolutePath())); } } } finally { FileUtils.delete(workDir, true); } }
### Question: CommandLineParser { public String getOptionsInForce() { if (parsedProperties == null) { return ""; } StringBuilder result = new StringBuilder("Options in force:\n"); for (Map.Entry<Object, Object> property : parsedProperties.entrySet()) { result.append(property.getKey()) .append(" = ") .append(property.getValue()) .append('\n'); } return result.toString(); } CommandLineParser(String[][] config); String getErrors(); String getOptionsInForce(); String getUsage(); void setErrorsOnUnknowns(boolean errors); Properties parseCommandLine(String[] args); void addCommandLineToProperties(Properties properties); void reset(); static Properties processCommandLine(String[] args, CommandLineParser commandLine, Properties properties); }### Answer: @Test public void testGetOptionsInForceReturnsEmptyStringBeforeParsing() throws Exception { CommandLineParser parser = new CommandLineParser( new String[][] { { "t1", "Test Flag 1." }, { "t2", "Test Option 2.", "test" }, { "t3", "Test Option 3.", "test", "true" }, { "t4", "Test Option 4.", "test", null, "^test$" } }); assertTrue("The options in force method did not return an empty string.", "".equals(parser.getOptionsInForce())); }
### Question: CommandLineParser { public String getUsage() { String result = "Options:\n"; for (CommandLineOption optionInfo : optionMap.values()) { result += "-" + optionInfo.option + " " + ((optionInfo.argument != null) ? (optionInfo.argument + " ") : "") + optionInfo.comment + "\n"; } return result; } CommandLineParser(String[][] config); String getErrors(); String getOptionsInForce(); String getUsage(); void setErrorsOnUnknowns(boolean errors); Properties parseCommandLine(String[] args); void addCommandLineToProperties(Properties properties); void reset(); static Properties processCommandLine(String[] args, CommandLineParser commandLine, Properties properties); }### Answer: @Test public void testGetUsageReturnsString() throws Exception { CommandLineParser parser = new CommandLineParser( new String[][] { { "t1", "Test Flag 1." }, { "t2", "Test Option 2.", "test" }, { "t3", "Test Option 3.", "test", "true" }, { "t4", "Test Option 4.", "test", null, "^test$" } }); final boolean condition = !((parser.getUsage() == null) \|\| "".equals(parser.getUsage())); assertTrue("The usage method did not return a non empty string.", condition); }
### Question: StringUtil { public String randomAlphaNumericString(int maxLength) { char[] result = new char[maxLength]; for (int i = 0; i < maxLength; i++) { result[i] = (char) CHARACTERS[_random.nextInt(CHARACTERS.length)]; } return new String(result); } static String elideDataUrl(final String path); static String toHex(byte[] bin); String randomAlphaNumericString(int maxLength); String createUniqueJavaName(String managerName); }### Answer: @Test public void testRandomAlphaNumericStringInt() { String password = _util.randomAlphaNumericString(10); assertEquals("Unexpected password string length", (long) 10, (long) password.length()); assertCharacters(password); }
### Question: StringUtil { public String createUniqueJavaName(String managerName) { StringBuilder builder = new StringBuilder(); boolean initialChar = true; for (int i = 0; i < managerName.length(); i++) { char c = managerName.charAt(i); if ((initialChar && Character.isJavaIdentifierStart(c)) \|\| (!initialChar && Character.isJavaIdentifierPart(c))) { builder.append(c); initialChar = false; } } if (builder.length() > 0) { builder.append("_"); } try { byte[] digest = MessageDigest.getInstance("MD5").digest(managerName.getBytes(StandardCharsets.UTF_8)); builder.append(toHex(digest).toLowerCase()); } catch (NoSuchAlgorithmException e) { throw new ServerScopedRuntimeException(e); } return builder.toString(); } static String elideDataUrl(final String path); static String toHex(byte[] bin); String randomAlphaNumericString(int maxLength); String createUniqueJavaName(String managerName); }### Answer: @Test public void testCreateUniqueJavaName() { assertEquals("MyName_973de1b4e26b629d4817c8255090e58e", _util.createUniqueJavaName("MyName")); assertEquals("ContaisIllegalJavaCharacters_a68b2484f2eb790558d6527e56c595fa", _util.createUniqueJavaName("Contais+Illegal-Java*Characters")); assertEquals("StartsWithIllegalInitial_93031eec569608c60c6a98ac9e84a0a7", _util.createUniqueJavaName("9StartsWithIllegalInitial")); assertEquals("97b247ba19ff869340d3797cc73ca065", _util.createUniqueJavaName("1++++----")); assertEquals("d41d8cd98f00b204e9800998ecf8427e", _util.createUniqueJavaName("")); }
### Question: FileUtils { public static boolean deleteFile(String filePath) { return delete(new File(filePath), false); } private FileUtils(); static byte[] readFileAsBytes(String filename); static String readFileAsString(String filename); static String readFileAsString(File file); @SuppressWarnings("resource") static InputStream openFileOrDefaultResource(String filename, String defaultResource, ClassLoader cl); static void copy(File src, File dst); static void copyCheckedEx(File src, File dst); static void copy(InputStream in, File dst); static boolean deleteFile(String filePath); static boolean deleteDirectory(String directoryPath); static boolean delete(File file, boolean recursive); static void copyRecursive(File source, File dst); static List<String> searchFile(File file, String search); }### Answer: @Test public void testDeleteFile() { File test = new File("FileUtilsTest-testDelete"); String path = test.getAbsolutePath(); File[] filesBefore = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles(); int fileCountBefore = filesBefore.length; try { test.createNewFile(); test.deleteOnExit(); } catch (IOException e) { fail(e.getMessage()); } assertTrue("File does not exists", test.exists()); assertTrue("File is not a file", test.isFile()); int fileCountCreated = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles().length; assertEquals("File creation was no registered", (long) (fileCountBefore + 1), (long) fileCountCreated); assertTrue("Unable to cleanup", FileUtils.deleteFile("FileUtilsTest-testDelete")); final boolean condition = !test.exists(); assertTrue("File exists after delete", condition); File[] filesAfter = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles(); int fileCountAfter = filesAfter.length; assertEquals("File creation was no registered", (long) fileCountBefore, (long) fileCountAfter); checkFileLists(filesBefore, filesAfter); }
### Question: FileUtils { public static boolean deleteDirectory(String directoryPath) { File directory = new File(directoryPath); if (directory.isDirectory()) { if (directory.listFiles().length == 0) { return delete(directory, true); } } return false; } private FileUtils(); static byte[] readFileAsBytes(String filename); static String readFileAsString(String filename); static String readFileAsString(File file); @SuppressWarnings("resource") static InputStream openFileOrDefaultResource(String filename, String defaultResource, ClassLoader cl); static void copy(File src, File dst); static void copyCheckedEx(File src, File dst); static void copy(InputStream in, File dst); static boolean deleteFile(String filePath); static boolean deleteDirectory(String directoryPath); static boolean delete(File file, boolean recursive); static void copyRecursive(File source, File dst); static List<String> searchFile(File file, String search); }### Answer: @Test public void testEmptyDirectoryDelete() { String directoryName = "FileUtilsTest-testRecursiveDelete"; File test = new File(directoryName); String path = test.getAbsolutePath(); File[] filesBefore = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles(); int fileCountBefore = filesBefore.length; final boolean condition1 = !test.exists(); assertTrue("Directory exists", condition1); test.mkdir(); test.deleteOnExit(); assertTrue("Non Empty Directory was successfully deleted.", FileUtils.deleteDirectory(directoryName)); final boolean condition = !test.exists(); assertTrue("Directory was deleted.", condition); File[] filesAfter = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles(); int fileCountAfter = filesAfter.length; assertEquals("File creation was no registered", (long) fileCountBefore, (long) fileCountAfter); checkFileLists(filesBefore, filesAfter); }
### Question: CachingUUIDFactory { public UUID createUuidFromBits(final long mostSigBits, final long leastSigBits) { UUID candidate = new UUID(mostSigBits, leastSigBits); return cacheIfNecessary(candidate); } UUID createUuidFromString(final String name); UUID createUuidFromBits(final long mostSigBits, final long leastSigBits); }### Answer: @Test public void testUuidFromBits() { UUID first = _factory.createUuidFromBits(0L,0L); UUID second = _factory.createUuidFromBits(0L,0L); assertSame("UUIDFactory should return the same object", first, second); }
### Question: ByteBufferInputStream extends InputStream { @Override public int read() throws IOException { if (_buffer.hasRemaining()) { return _buffer.get() & 0xFF; } return -1; } ByteBufferInputStream(ByteBuffer buffer); @Override int read(); @Override int read(byte[] b, int off, int len); @Override void mark(int readlimit); @Override void reset(); @Override boolean markSupported(); @Override long skip(long n); @Override int available(); @Override void close(); }### Answer: @Test public void testRead() throws IOException { for (int i = 0; i < _data.length; i++) { assertEquals("Unexpected byte at position " + i, (long) _data[i], (long) _inputStream.read()); } assertEquals("EOF not reached", (long) -1, (long) _inputStream.read()); } @Test public void testReadByteArray() throws IOException { byte[] readBytes = new byte[_data.length]; int length = _inputStream.read(readBytes, 0, 2); byte[] expected = new byte[_data.length]; System.arraycopy(_data, 0, expected, 0, 2); assertTrue("Unexpected data", Arrays.equals(expected, readBytes)); assertEquals("Unexpected length", (long) 2, (long) length); length = _inputStream.read(readBytes, 2, 3); assertTrue("Unexpected data", Arrays.equals(_data, readBytes)); assertEquals("Unexpected length", (long) 3, (long) length); length = _inputStream.read(readBytes); assertEquals("EOF not reached", (long) -1, (long) length); }
### Question: RollingPolicyDecorator implements RollingPolicy { @Override public String getActiveFileName() { return _decorated.getActiveFileName(); } RollingPolicyDecorator(RollingPolicyBase decorated, RolloverListener listener, ScheduledExecutorService executorService); @Override void rollover(); @Override String getActiveFileName(); @Override CompressionMode getCompressionMode(); @Override void setParent(FileAppender appender); @Override void start(); @Override void stop(); @Override boolean isStarted(); RollingPolicyBase getDecorated(); static final int DEFAULT_RESCAN_DELAY; static final String ROLLOVER_RESCAN_DELAY_MS_PROPERTY_NAME; static final int DEFAULT_RESCAN_LIMIT; static final String ROLLOVER_RESCAN_LIMIT_PROPERTY_NAME; }### Answer: @Test public void testGetActiveFileName() { _policy.getActiveFileName(); verify(_delegate).getActiveFileName(); }
### Question: ByteBufferInputStream extends InputStream { @Override public long skip(long n) throws IOException { _buffer.position(_buffer.position()+(int)n); return n; } ByteBufferInputStream(ByteBuffer buffer); @Override int read(); @Override int read(byte[] b, int off, int len); @Override void mark(int readlimit); @Override void reset(); @Override boolean markSupported(); @Override long skip(long n); @Override int available(); @Override void close(); }### Answer: @Test public void testSkip() throws IOException { _inputStream.skip(3); byte[] readBytes = new byte[_data.length - 3]; int length = _inputStream.read(readBytes); byte[] expected = new byte[_data.length - 3]; System.arraycopy(_data, 3, expected, 0, _data.length - 3); assertTrue("Unexpected data", Arrays.equals(expected, readBytes)); assertEquals("Unexpected length", (long) (_data.length - 3), (long) length); }
### Question: ByteBufferInputStream extends InputStream { @Override public int available() throws IOException { return _buffer.remaining(); } ByteBufferInputStream(ByteBuffer buffer); @Override int read(); @Override int read(byte[] b, int off, int len); @Override void mark(int readlimit); @Override void reset(); @Override boolean markSupported(); @Override long skip(long n); @Override int available(); @Override void close(); }### Answer: @Test public void testAvailable() throws IOException { int available = _inputStream.available(); assertEquals("Unexpected number of available bytes", (long) _data.length, (long) available); byte[] readBytes = new byte[_data.length]; _inputStream.read(readBytes); available = _inputStream.available(); assertEquals("Unexpected number of available bytes", (long) 0, (long) available); }
### Question: ByteBufferInputStream extends InputStream { @Override public boolean markSupported() { return true; } ByteBufferInputStream(ByteBuffer buffer); @Override int read(); @Override int read(byte[] b, int off, int len); @Override void mark(int readlimit); @Override void reset(); @Override boolean markSupported(); @Override long skip(long n); @Override int available(); @Override void close(); }### Answer: @Test public void testMarkSupported() throws IOException { assertTrue("Unexpected mark supported", _inputStream.markSupported()); }
### Question: AMQPProtocolVersionWrapper { public Protocol getProtocol() { return Protocol.valueOf(this.toString()); } AMQPProtocolVersionWrapper(Protocol amqpProtocol); int getMajor(); int getMinor(); int getPatch(); Protocol getProtocol(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testAMQPProtocolVersionWrapperGetProtocol() throws Exception { for (final Protocol protocol : Protocol.values()) { if (protocol.isAMQP()) { assertEquals(protocol, new AMQPProtocolVersionWrapper(protocol).getProtocol()); } } }
### Question: StandardQueueEntryList extends OrderedQueueEntryList { @Override public QueueEntry getLeastSignificantOldestEntry() { return getOldestEntry(); } StandardQueueEntryList(final StandardQueue<?> queue, QueueStatistics queueStatistics); @Override QueueEntry getLeastSignificantOldestEntry(); }### Answer: @Test public void testGetLesserOldestEntry() { StandardQueueEntryList queueEntryList = new StandardQueueEntryList(_testQueue, _testQueue.getQueueStatistics()); QueueEntry entry1 = queueEntryList.add(createServerMessage(1), null); assertEquals("Unexpected last message", entry1, queueEntryList.getLeastSignificantOldestEntry()); queueEntryList.add(createServerMessage(2), null); assertEquals("Unexpected last message", entry1, queueEntryList.getLeastSignificantOldestEntry()); queueEntryList.add(createServerMessage(3), null); assertEquals("Unexpected last message", entry1, queueEntryList.getLeastSignificantOldestEntry()); }
### Question: SortedQueueEntryList extends AbstractQueueEntryList { @Override public QueueEntryIterator iterator() { return new QueueEntryIteratorImpl(_head); } SortedQueueEntryList(final SortedQueueImpl queue, final QueueStatistics queueStatistics); @Override SortedQueueImpl getQueue(); @Override SortedQueueEntry add(final ServerMessage message, final MessageEnqueueRecord enqueueRecord); @Override SortedQueueEntry next(final QueueEntry entry); @Override QueueEntryIterator iterator(); @Override SortedQueueEntry getHead(); @Override SortedQueueEntry getTail(); @Override QueueEntry getOldestEntry(); @Override void entryDeleted(final QueueEntry e); @Override int getPriorities(); @Override QueueEntry getLeastSignificantOldestEntry(); }### Answer: @Override @Test public void testIterator() throws Exception { super.testIterator(); final QueueEntryIterator iter = getTestList().iterator(); int count = 0; while(iter.advance()) { final Object expected = keysSorted[count++]; assertEquals("Sorted queue entry value does not match sorted key array", expected, getSortedKeyValue(iter)); } }
### Question: SortedQueueEntryList extends AbstractQueueEntryList { @Override public QueueEntry getLeastSignificantOldestEntry() { return getOldestEntry(); } SortedQueueEntryList(final SortedQueueImpl queue, final QueueStatistics queueStatistics); @Override SortedQueueImpl getQueue(); @Override SortedQueueEntry add(final ServerMessage message, final MessageEnqueueRecord enqueueRecord); @Override SortedQueueEntry next(final QueueEntry entry); @Override QueueEntryIterator iterator(); @Override SortedQueueEntry getHead(); @Override SortedQueueEntry getTail(); @Override QueueEntry getOldestEntry(); @Override void entryDeleted(final QueueEntry e); @Override int getPriorities(); @Override QueueEntry getLeastSignificantOldestEntry(); }### Answer: @Test public void testGetLeastSignificantOldestEntry() { SortedQueueEntryList list = new SortedQueueEntryList(_testQueue, _testQueue.getQueueStatistics()); SortedQueueEntry entry1 = list.add(generateTestMessage(1, "B"), null); assertEquals("Unexpected last entry", entry1, list.getLeastSignificantOldestEntry()); list.add(generateTestMessage(2, "C"), null); assertEquals("Unexpected last entry", entry1, list.getLeastSignificantOldestEntry()); list.add(generateTestMessage(3, null), null); assertEquals("Unexpected last entry", entry1, list.getLeastSignificantOldestEntry()); list.add(generateTestMessage(4, "A"), null); assertEquals("Unexpected last entry", entry1, list.getLeastSignificantOldestEntry()); }
### Question: RollingPolicyDecorator implements RollingPolicy { @Override public CompressionMode getCompressionMode() { return _decorated.getCompressionMode(); } RollingPolicyDecorator(RollingPolicyBase decorated, RolloverListener listener, ScheduledExecutorService executorService); @Override void rollover(); @Override String getActiveFileName(); @Override CompressionMode getCompressionMode(); @Override void setParent(FileAppender appender); @Override void start(); @Override void stop(); @Override boolean isStarted(); RollingPolicyBase getDecorated(); static final int DEFAULT_RESCAN_DELAY; static final String ROLLOVER_RESCAN_DELAY_MS_PROPERTY_NAME; static final int DEFAULT_RESCAN_LIMIT; static final String ROLLOVER_RESCAN_LIMIT_PROPERTY_NAME; }### Answer: @Test public void testGetCompressionMode() { _policy.getCompressionMode(); verify(_delegate).getCompressionMode(); }
### Question: ProducerFlowControlOverflowPolicyHandler implements OverflowPolicyHandler { @Override public void checkOverflow(final QueueEntry newlyEnqueued) { _handler.checkOverflow(newlyEnqueued); } ProducerFlowControlOverflowPolicyHandler(Queue<?> queue, EventLogger eventLogger); @Override void checkOverflow(final QueueEntry newlyEnqueued); }### Answer: @Test public void testCheckOverflowBlocksSessionWhenOverfullBytes() throws Exception { AMQPSession<?, ?> session = mock(AMQPSession.class); when(_queue.getQueueDepthBytes()).thenReturn(11L); when(_queue.getMaximumQueueDepthBytes()).thenReturn(10L); checkOverflow(session); verify(session, times(1)).block(_queue); LogMessage logMessage = QueueMessages.OVERFULL(11, 10, 0, -1); verify(_eventLogger).message(same(_subject), argThat(new LogMessageMatcher(logMessage))); verifyNoMoreInteractions(_eventLogger); verifyNoMoreInteractions(session); } @Test public void testCheckOverflowBlocksSessionWhenOverfullMessages() throws Exception { AMQPSession<?, ?> session = mock(AMQPSession.class); when(_queue.getMaximumQueueDepthMessages()).thenReturn(10L); when(_queue.getQueueDepthMessages()).thenReturn(11); checkOverflow(session); verify(session, times(1)).block(_queue); LogMessage logMessage = QueueMessages.OVERFULL(0, -1, 11, 10); verify(_eventLogger).message(same(_subject), argThat(new LogMessageMatcher(logMessage))); verifyNoMoreInteractions(_eventLogger); verifyNoMoreInteractions(session); }
### Question: ProducerFlowControlOverflowPolicyHandler implements OverflowPolicyHandler { boolean isQueueFlowStopped() { return _handler.isQueueFlowStopped(); } ProducerFlowControlOverflowPolicyHandler(Queue<?> queue, EventLogger eventLogger); @Override void checkOverflow(final QueueEntry newlyEnqueued); }### Answer: @Test public void testIsQueueFlowStopped() throws Exception { assertFalse("Flow should not be stopped", _producerFlowControlOverflowPolicyHandler.isQueueFlowStopped()); when(_queue.getQueueDepthBytes()).thenReturn(11L); when(_queue.getMaximumQueueDepthBytes()).thenReturn(10L); checkOverflow(mock(AMQPSession.class)); assertTrue("Flow should be stopped", _producerFlowControlOverflowPolicyHandler.isQueueFlowStopped()); }
### Question: RejectPolicyHandler { void checkReject(final ServerMessage<?> newMessage) throws MessageUnacceptableException { _handler.checkReject(newMessage); } RejectPolicyHandler(final Queue<?> queue); }### Answer: @Test public void testOverfullBytes() throws Exception { ServerMessage incomingMessage = createIncomingMessage(6); when(_queue.getQueueDepthBytes()).thenReturn(5L); when(_queue.getMaximumQueueDepthBytes()).thenReturn(10L); when(_queue.getQueueDepthMessages()).thenReturn(1); try { _rejectOverflowPolicyHandler.checkReject(incomingMessage); fail("Exception expected"); } catch (MessageUnacceptableException e) { } } @Test public void testOverfullMessages() throws Exception { ServerMessage incomingMessage = createIncomingMessage(5); when(_queue.getMaximumQueueDepthMessages()).thenReturn(7L); when(_queue.getQueueDepthMessages()).thenReturn(7); when(_queue.getQueueDepthBytes()).thenReturn(10L); try { _rejectOverflowPolicyHandler.checkReject(incomingMessage); fail("Exception expected"); } catch (MessageUnacceptableException e) { } }
### Question: SortedQueueEntry extends QueueEntryImpl { @Override public int compareTo(final QueueEntry other) { SortedQueueEntry o = (SortedQueueEntry)other; final String otherKey = o._key; final int compare = _key == null ? (otherKey == null ? 0 : -1) : otherKey == null ? 1 : _key.compareTo(otherKey); return compare == 0 ? super.compareTo(o) : compare; } SortedQueueEntry(final SortedQueueEntryList queueEntryList); SortedQueueEntry(final SortedQueueEntryList queueEntryList, final ServerMessage message, final long entryId, final MessageEnqueueRecord messageEnqueueRecord); @Override int compareTo(final QueueEntry other); Colour getColour(); String getKey(); SortedQueueEntry getLeft(); @Override SortedQueueEntry getNextNode(); @Override SortedQueueEntry getNextValidEntry(); SortedQueueEntry getParent(); SortedQueueEntry getPrev(); SortedQueueEntry getRight(); void setColour(final Colour colour); void setKey(final String key); void setLeft(final SortedQueueEntry left); void setNext(final SortedQueueEntry next); void setParent(final SortedQueueEntry parent); void setPrev(final SortedQueueEntry prev); void setRight(final SortedQueueEntry right); @Override String toString(); }### Answer: @Override @Test public void testCompareTo() { assertTrue(_queueEntry.compareTo(_queueEntry2) > 0); assertTrue(_queueEntry.compareTo(_queueEntry3) > 0); assertTrue(_queueEntry2.compareTo(_queueEntry3) < 0); assertTrue(_queueEntry2.compareTo(_queueEntry) < 0); assertTrue(_queueEntry3.compareTo(_queueEntry2) > 0); assertTrue(_queueEntry3.compareTo(_queueEntry) < 0); assertTrue(_queueEntry.compareTo(_queueEntry) == 0); assertTrue(_queueEntry2.compareTo(_queueEntry2) == 0); assertTrue(_queueEntry3.compareTo(_queueEntry3) == 0); }
### Question: RollingPolicyDecorator implements RollingPolicy { @Override public void setParent(FileAppender appender) { _decorated.setParent(appender); } RollingPolicyDecorator(RollingPolicyBase decorated, RolloverListener listener, ScheduledExecutorService executorService); @Override void rollover(); @Override String getActiveFileName(); @Override CompressionMode getCompressionMode(); @Override void setParent(FileAppender appender); @Override void start(); @Override void stop(); @Override boolean isStarted(); RollingPolicyBase getDecorated(); static final int DEFAULT_RESCAN_DELAY; static final String ROLLOVER_RESCAN_DELAY_MS_PROPERTY_NAME; static final int DEFAULT_RESCAN_LIMIT; static final String ROLLOVER_RESCAN_LIMIT_PROPERTY_NAME; }### Answer: @Test public void testSetParent() { FileAppender appender = mock(FileAppender.class); _policy.setParent(appender); verify(_delegate).setParent(appender); }
### Question: SortedQueueEntry extends QueueEntryImpl { @Override public SortedQueueEntry getNextValidEntry() { return getNextNode(); } SortedQueueEntry(final SortedQueueEntryList queueEntryList); SortedQueueEntry(final SortedQueueEntryList queueEntryList, final ServerMessage message, final long entryId, final MessageEnqueueRecord messageEnqueueRecord); @Override int compareTo(final QueueEntry other); Colour getColour(); String getKey(); SortedQueueEntry getLeft(); @Override SortedQueueEntry getNextNode(); @Override SortedQueueEntry getNextValidEntry(); SortedQueueEntry getParent(); SortedQueueEntry getPrev(); SortedQueueEntry getRight(); void setColour(final Colour colour); void setKey(final String key); void setLeft(final SortedQueueEntry left); void setNext(final SortedQueueEntry next); void setParent(final SortedQueueEntry parent); void setPrev(final SortedQueueEntry prev); void setRight(final SortedQueueEntry right); @Override String toString(); }### Answer: @Override @Test public void testTraverseWithNoDeletedEntries() { QueueEntry current = _queueEntry2; current = current.getNextValidEntry(); assertSame("Unexpected current entry", _queueEntry3, current); current = current.getNextValidEntry(); assertSame("Unexpected current entry", _queueEntry, current); current = current.getNextValidEntry(); assertNull(current); } @Override @Test public void testTraverseWithDeletedEntries() { _queueEntry3.acquire(); _queueEntry3.delete(); assertTrue(_queueEntry3.isDeleted()); QueueEntry current = _queueEntry2; current = current.getNextValidEntry(); assertSame("Unexpected current entry", _queueEntry, current); current = current.getNextValidEntry(); assertNull(current); }
### Question: InternalMessageMutator implements ServerMessageMutator<InternalMessage> { @Override public void setPriority(final byte priority) { _priority = priority; } InternalMessageMutator(final InternalMessage message, final MessageStore messageStore); @Override void setPriority(final byte priority); @Override byte getPriority(); @Override InternalMessage create(); }### Answer: @Test public void setPriority() { _messageMutator.setPriority((byte) (TEST_PRIORITY + 1)); assertThat(_messageMutator.getPriority(), is(equalTo((byte) (TEST_PRIORITY + 1)))); }

Subsets and Splits

No community queries yet

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