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: EasyRandom extends Random { public <T> Stream<T> objects(final Class<T> type, final int streamSize) { if (streamSize < 0) { throw new IllegalArgumentException("The stream size must be positive"); } return Stream.generate(() -> nextObject(type)).limit(streamSize); } EasyRandom(); EasyRandom(final EasyRandomParameters easyRandomParameters); T nextObject(final Class<T> type); Stream<T> objects(final Class<T> type, final int streamSize); }### Answer: @Test void generatedBeansNumberShouldBeEqualToSpecifiedNumber() { Stream<Person> persons = easyRandom.objects(Person.class, 2); assertThat(persons).hasSize(2).hasOnlyElementsOfType(Person.class); } @Test void whenSpecifiedNumberOfBeansToGenerateIsNegative_thenShouldThrowAnIllegalArgumentException() { assertThatThrownBy(() -> easyRandom.objects(Person.class, -2)).isInstanceOf(IllegalArgumentException.class); }
### Question: PriorityComparator implements Comparator<Object> { @Override public int compare(final Object o1, final Object o2) { int o1Priority = getPriority(o1); int o2Priority = getPriority(o2); return o2Priority - o1Priority; } @Override int compare(final Object o1, final Object o2); }### Answer: @Test void testCompare() { assertThat(priorityComparator.compare(foo, bar)).isGreaterThan(0); List<Object> objects = Arrays.asList(foo,bar); objects.sort(priorityComparator); assertThat(objects).containsExactly(bar, foo); }
### Question: DefaultExclusionPolicy implements ExclusionPolicy { public boolean shouldBeExcluded(final Field field, final RandomizerContext context) { if (isStatic(field)) { return true; } Set<Predicate<Field>> fieldExclusionPredicates = context.getParameters().getFieldExclusionPredicates(); for (Predicate<Field> fieldExclusionPredicate : fieldExclusionPredicates) { if (fieldExclusionPredicate.test(field)) { return true; } } return false; } boolean shouldBeExcluded(final Field field, final RandomizerContext context); boolean shouldBeExcluded(final Class<?> type, final RandomizerContext context); }### Answer: @Test void staticFieldsShouldBeExcluded() throws NoSuchFieldException { Field field = Human.class.getDeclaredField("SERIAL_VERSION_UID"); boolean actual = exclusionPolicy.shouldBeExcluded(field, randomizerContext); assertThat(actual).isTrue(); }
### Question: ObjenesisObjectFactory implements ObjectFactory { @Override public <T> T createInstance(Class<T> type, RandomizerContext context) { if (context.getParameters().isScanClasspathForConcreteTypes() && isAbstract(type)) { Class<?> randomConcreteSubType = randomElementOf(getPublicConcreteSubTypesOf((type))); if (randomConcreteSubType == null) { throw new InstantiationError("Unable to find a matching concrete subtype of type: " + type + " in the classpath"); } else { return (T) createNewInstance(randomConcreteSubType); } } else { try { return createNewInstance(type); } catch (Error e) { throw new ObjectCreationException("Unable to create an instance of type: " + type, e); } } } @Override T createInstance(Class<T> type, RandomizerContext context); }### Answer: @Test void concreteClassesShouldBeCreatedAsExpected() { String string = objenesisObjectFactory.createInstance(String.class, context); assertThat(string).isNotNull(); } @Test void whenNoConcreteTypeIsFound_thenShouldThrowAnInstantiationError() { Mockito.when(context.getParameters().isScanClasspathForConcreteTypes()).thenReturn(true); assertThatThrownBy(() -> objenesisObjectFactory.createInstance(AbstractFoo.class, context)).isInstanceOf(InstantiationError.class); }
### Question: EnumRandomizer extends AbstractRandomizer<E> { public static <E extends Enum<E>> EnumRandomizer<E> aNewEnumRandomizer(final Class<E> enumeration) { return new EnumRandomizer<>(enumeration); } EnumRandomizer(final Class<E> enumeration); EnumRandomizer(final Class<E> enumeration, final long seed); EnumRandomizer(final Class<E> enumeration, final E... excludedValues); static EnumRandomizer<E> aNewEnumRandomizer(final Class<E> enumeration); static EnumRandomizer<E> aNewEnumRandomizer(final Class<E> enumeration, final long seed); static EnumRandomizer<E> aNewEnumRandomizer(final Class<E> enumeration, final E... excludedValues); @Override E getRandomValue(); }### Answer: @Test void should_throw_an_exception_when_all_values_are_excluded() { assertThatThrownBy(() -> aNewEnumRandomizer(Gender.class, Gender.values())).isInstanceOf(IllegalArgumentException.class); }
### Question: OptionalRandomizer extends AbstractRandomizer<T> { @Override public T getRandomValue() { int randomPercent = random.nextInt(MAX_PERCENT); if (randomPercent <= optionalPercent) { return delegate.getRandomValue(); } return null; } OptionalRandomizer(final Randomizer<T> delegate, final int optionalPercent); static Randomizer<T> aNewOptionalRandomizer(final Randomizer<T> delegate, final int optionalPercent); @Override T getRandomValue(); }### Answer: @Test void whenOptionalPercentIsOneHundredThenShouldGenerateValue() { assertThat(optionalRandomizer.getRandomValue()) .isEqualTo(NAME); }
### Question: DoubleRangeRandomizer extends AbstractRangeRandomizer<Double> { @Override public Double getRandomValue() { return nextDouble(min, max); } DoubleRangeRandomizer(final Double min, final Double max); DoubleRangeRandomizer(final Double min, final Double max, final long seed); static DoubleRangeRandomizer aNewDoubleRangeRandomizer(final Double min, final Double max); static DoubleRangeRandomizer aNewDoubleRangeRandomizer(final Double min, final Double max, final long seed); @Override Double getRandomValue(); }### Answer: @Test void generatedValueShouldBeWithinSpecifiedRange() { Double randomValue = randomizer.getRandomValue(); assertThat(randomValue).isBetween(min, max); }
### Question: DoubleRangeRandomizer extends AbstractRangeRandomizer<Double> { public static DoubleRangeRandomizer aNewDoubleRangeRandomizer(final Double min, final Double max) { return new DoubleRangeRandomizer(min, max); } DoubleRangeRandomizer(final Double min, final Double max); DoubleRangeRandomizer(final Double min, final Double max, final long seed); static DoubleRangeRandomizer aNewDoubleRangeRandomizer(final Double min, final Double max); static DoubleRangeRandomizer aNewDoubleRangeRandomizer(final Double min, final Double max, final long seed); @Override Double getRandomValue(); }### Answer: @Test void whenSpecifiedMinValueIsAfterMaxValueThenThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewDoubleRangeRandomizer(max, min)).isInstanceOf(IllegalArgumentException.class); }
### Question: SqlDateRangeRandomizer extends AbstractRangeRandomizer<Date> { @Override public Date getRandomValue() { long minDateTime = min.getTime(); long maxDateTime = max.getTime(); long randomDateTime = (long) nextDouble(minDateTime, maxDateTime); return new Date(randomDateTime); } SqlDateRangeRandomizer(final Date min, final Date max); SqlDateRangeRandomizer(final Date min, final Date max, final long seed); static SqlDateRangeRandomizer aNewSqlDateRangeRandomizer(final Date min, final Date max); static SqlDateRangeRandomizer aNewSqlDateRangeRandomizer(final Date min, final Date max, final long seed); @Override Date getRandomValue(); }### Answer: @Test void generatedDateShouldNotBeNull() { assertThat(randomizer.getRandomValue()).isNotNull(); } @Test void generatedDateShouldBeWithinSpecifiedRange() { assertThat(randomizer.getRandomValue()).isBetween(minDate, maxDate); }
### Question: ByteRangeRandomizer extends AbstractRangeRandomizer<Byte> { @Override public Byte getRandomValue() { return (byte) nextDouble(min, max); } ByteRangeRandomizer(final Byte min, final Byte max); ByteRangeRandomizer(final Byte min, final Byte max, final long seed); static ByteRangeRandomizer aNewByteRangeRandomizer(final Byte min, final Byte max); static ByteRangeRandomizer aNewByteRangeRandomizer(final Byte min, final Byte max, final long seed); @Override Byte getRandomValue(); }### Answer: @Test void generatedValueShouldBeWithinSpecifiedRange() { Byte randomValue = randomizer.getRandomValue(); assertThat(randomValue).isBetween(min, max); }
### Question: ByteRangeRandomizer extends AbstractRangeRandomizer<Byte> { public static ByteRangeRandomizer aNewByteRangeRandomizer(final Byte min, final Byte max) { return new ByteRangeRandomizer(min, max); } ByteRangeRandomizer(final Byte min, final Byte max); ByteRangeRandomizer(final Byte min, final Byte max, final long seed); static ByteRangeRandomizer aNewByteRangeRandomizer(final Byte min, final Byte max); static ByteRangeRandomizer aNewByteRangeRandomizer(final Byte min, final Byte max, final long seed); @Override Byte getRandomValue(); }### Answer: @Test void whenSpecifiedMinValueIsAfterMaxValueThenThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewByteRangeRandomizer(max, min)).isInstanceOf(IllegalArgumentException.class); }
### Question: OffsetDateTimeRangeRandomizer extends AbstractRangeRandomizer<OffsetDateTime> { @Override public OffsetDateTime getRandomValue() { long minSeconds = min.toEpochSecond(); long maxSeconds = max.toEpochSecond(); long seconds = (long) nextDouble(minSeconds, maxSeconds); int minNanoSeconds = min.getNano(); int maxNanoSeconds = max.getNano(); long nanoSeconds = (long) nextDouble(minNanoSeconds, maxNanoSeconds); return OffsetDateTime.ofInstant(Instant.ofEpochSecond(seconds, nanoSeconds), EasyRandomParameters.DEFAULT_DATES_RANGE.getMin().getZone()); } OffsetDateTimeRangeRandomizer(final OffsetDateTime min, final OffsetDateTime max); OffsetDateTimeRangeRandomizer(final OffsetDateTime min, final OffsetDateTime max, final long seed); static OffsetDateTimeRangeRandomizer aNewOffsetDateTimeRangeRandomizer(final OffsetDateTime min, final OffsetDateTime max); static OffsetDateTimeRangeRandomizer aNewOffsetDateTimeRangeRandomizer(final OffsetDateTime min, final OffsetDateTime max, final long seed); @Override OffsetDateTime getRandomValue(); }### Answer: @Test void generatedOffsetDateTimeShouldNotBeNull() { assertThat(randomizer.getRandomValue()).isNotNull(); } @Test void generatedOffsetDateTimeShouldBeWithinSpecifiedRange() { assertThat(randomizer.getRandomValue()).isBetween(minOffsetDateTime, maxOffsetDateTime); }
### Question: OffsetDateTimeRangeRandomizer extends AbstractRangeRandomizer<OffsetDateTime> { public static OffsetDateTimeRangeRandomizer aNewOffsetDateTimeRangeRandomizer(final OffsetDateTime min, final OffsetDateTime max) { return new OffsetDateTimeRangeRandomizer(min, max); } OffsetDateTimeRangeRandomizer(final OffsetDateTime min, final OffsetDateTime max); OffsetDateTimeRangeRandomizer(final OffsetDateTime min, final OffsetDateTime max, final long seed); static OffsetDateTimeRangeRandomizer aNewOffsetDateTimeRangeRandomizer(final OffsetDateTime min, final OffsetDateTime max); static OffsetDateTimeRangeRandomizer aNewOffsetDateTimeRangeRandomizer(final OffsetDateTime min, final OffsetDateTime max, final long seed); @Override OffsetDateTime getRandomValue(); }### Answer: @Test void whenSpecifiedMinOffsetDateTimeIsAfterMaxOffsetDateTime_thenShouldThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewOffsetDateTimeRangeRandomizer(maxOffsetDateTime, minOffsetDateTime)).isInstanceOf(IllegalArgumentException.class); }
### Question: LocalDateRangeRandomizer extends AbstractRangeRandomizer<LocalDate> { @Override public LocalDate getRandomValue() { long minEpochDay = min.getLong(ChronoField.EPOCH_DAY); long maxEpochDay = max.getLong(ChronoField.EPOCH_DAY); long randomEpochDay = (long) nextDouble(minEpochDay, maxEpochDay); return LocalDate.ofEpochDay(randomEpochDay); } LocalDateRangeRandomizer(final LocalDate min, final LocalDate max); LocalDateRangeRandomizer(final LocalDate min, final LocalDate max, final long seed); static LocalDateRangeRandomizer aNewLocalDateRangeRandomizer(final LocalDate min, final LocalDate max); static LocalDateRangeRandomizer aNewLocalDateRangeRandomizer(final LocalDate min, final LocalDate max, final long seed); @Override LocalDate getRandomValue(); }### Answer: @Test void generatedLocalDateShouldNotBeNull() { assertThat(randomizer.getRandomValue()).isNotNull(); } @Test void generatedLocalDateShouldBeWithinSpecifiedRange() { assertThat(randomizer.getRandomValue()).isBetween(minDate, maxDate); }
### Question: LocalDateRangeRandomizer extends AbstractRangeRandomizer<LocalDate> { public static LocalDateRangeRandomizer aNewLocalDateRangeRandomizer(final LocalDate min, final LocalDate max) { return new LocalDateRangeRandomizer(min, max); } LocalDateRangeRandomizer(final LocalDate min, final LocalDate max); LocalDateRangeRandomizer(final LocalDate min, final LocalDate max, final long seed); static LocalDateRangeRandomizer aNewLocalDateRangeRandomizer(final LocalDate min, final LocalDate max); static LocalDateRangeRandomizer aNewLocalDateRangeRandomizer(final LocalDate min, final LocalDate max, final long seed); @Override LocalDate getRandomValue(); }### Answer: @Test void whenSpecifiedMinDateIsAfterMaxDate_thenShouldThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewLocalDateRangeRandomizer(maxDate, minDate)).isInstanceOf(IllegalArgumentException.class); }
### Question: InstantRangeRandomizer extends AbstractRangeRandomizer<Instant> { @Override public Instant getRandomValue() { long minEpochMillis = min.toEpochMilli(); long maxEpochMillis = max.toEpochMilli(); long randomEpochMillis = (long) nextDouble(minEpochMillis, maxEpochMillis); return Instant.ofEpochMilli(randomEpochMillis); } InstantRangeRandomizer(final Instant min, final Instant max); InstantRangeRandomizer(final Instant min, final Instant max, long seed); static InstantRangeRandomizer aNewInstantRangeRandomizer(final Instant min, final Instant max); static InstantRangeRandomizer aNewInstantRangeRandomizer(final Instant min, final Instant max, final long seed); @Override Instant getRandomValue(); }### Answer: @Test void generatedInstantShouldNotBeNull() { assertThat(randomizer.getRandomValue()).isNotNull(); } @Test void generatedInstantShouldBeWithinSpecifiedRange() { assertThat(randomizer.getRandomValue()).isBetween(minInstant, maxInstant); }
### Question: InstantRangeRandomizer extends AbstractRangeRandomizer<Instant> { public static InstantRangeRandomizer aNewInstantRangeRandomizer(final Instant min, final Instant max) { return new InstantRangeRandomizer(min, max); } InstantRangeRandomizer(final Instant min, final Instant max); InstantRangeRandomizer(final Instant min, final Instant max, long seed); static InstantRangeRandomizer aNewInstantRangeRandomizer(final Instant min, final Instant max); static InstantRangeRandomizer aNewInstantRangeRandomizer(final Instant min, final Instant max, final long seed); @Override Instant getRandomValue(); }### Answer: @Test void whenSpecifiedMinInstantIsAfterMaxInstant_thenShouldThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewInstantRangeRandomizer(maxInstant, minInstant)).isInstanceOf(IllegalArgumentException.class); }
### Question: BigIntegerRangeRandomizer implements Randomizer<BigInteger> { @Override public BigInteger getRandomValue() { return new BigInteger(String.valueOf(delegate.getRandomValue())); } BigIntegerRangeRandomizer(final Integer min, final Integer max); BigIntegerRangeRandomizer(final Integer min, final Integer max, final long seed); static BigIntegerRangeRandomizer aNewBigIntegerRangeRandomizer(final Integer min, final Integer max); static BigIntegerRangeRandomizer aNewBigIntegerRangeRandomizer(final Integer min, final Integer max, final long seed); @Override BigInteger getRandomValue(); }### Answer: @Test void generatedValueShouldBeWithinSpecifiedRange() { BigInteger randomValue = randomizer.getRandomValue(); assertThat(randomValue.intValue()).isBetween(min, max); }
### Question: BigIntegerRangeRandomizer implements Randomizer<BigInteger> { public static BigIntegerRangeRandomizer aNewBigIntegerRangeRandomizer(final Integer min, final Integer max) { return new BigIntegerRangeRandomizer(min, max); } BigIntegerRangeRandomizer(final Integer min, final Integer max); BigIntegerRangeRandomizer(final Integer min, final Integer max, final long seed); static BigIntegerRangeRandomizer aNewBigIntegerRangeRandomizer(final Integer min, final Integer max); static BigIntegerRangeRandomizer aNewBigIntegerRangeRandomizer(final Integer min, final Integer max, final long seed); @Override BigInteger getRandomValue(); }### Answer: @Test void whenSpecifiedMinValueIsAfterMaxValueThenThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewBigIntegerRangeRandomizer(max, min)).isInstanceOf(IllegalArgumentException.class); }
### Question: OffsetTimeRangeRandomizer extends AbstractRangeRandomizer<OffsetTime> { @Override public OffsetTime getRandomValue() { long minSecondOfDay = min.getLong(ChronoField.SECOND_OF_DAY); long maxSecondOfDay = max.getLong(ChronoField.SECOND_OF_DAY); long randomSecondOfDay = (long) nextDouble(minSecondOfDay, maxSecondOfDay); return OffsetTime.of(LocalTime.ofSecondOfDay(randomSecondOfDay), EasyRandomParameters.DEFAULT_DATES_RANGE.getMin().getOffset()); } OffsetTimeRangeRandomizer(final OffsetTime min, final OffsetTime max); OffsetTimeRangeRandomizer(final OffsetTime min, final OffsetTime max, final long seed); static OffsetTimeRangeRandomizer aNewOffsetTimeRangeRandomizer(final OffsetTime min, final OffsetTime max); static OffsetTimeRangeRandomizer aNewOffsetTimeRangeRandomizer(final OffsetTime min, final OffsetTime max, final long seed); @Override OffsetTime getRandomValue(); }### Answer: @Test void generatedOffsetTimeShouldNotBeNull() { assertThat(randomizer.getRandomValue()).isNotNull(); } @Test void generatedOffsetTimeShouldBeWithinSpecifiedRange() { assertThat(randomizer.getRandomValue()).isBetween(minTime, maxTime); }
### Question: OffsetTimeRangeRandomizer extends AbstractRangeRandomizer<OffsetTime> { public static OffsetTimeRangeRandomizer aNewOffsetTimeRangeRandomizer(final OffsetTime min, final OffsetTime max) { return new OffsetTimeRangeRandomizer(min, max); } OffsetTimeRangeRandomizer(final OffsetTime min, final OffsetTime max); OffsetTimeRangeRandomizer(final OffsetTime min, final OffsetTime max, final long seed); static OffsetTimeRangeRandomizer aNewOffsetTimeRangeRandomizer(final OffsetTime min, final OffsetTime max); static OffsetTimeRangeRandomizer aNewOffsetTimeRangeRandomizer(final OffsetTime min, final OffsetTime max, final long seed); @Override OffsetTime getRandomValue(); }### Answer: @Test void whenSpecifiedMinTimeIsAfterMaxDate_thenShouldThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewOffsetTimeRangeRandomizer(maxTime, minTime)).isInstanceOf(IllegalArgumentException.class); }
### Question: LocalTimeRangeRandomizer extends AbstractRangeRandomizer<LocalTime> { @Override public LocalTime getRandomValue() { long minSecondOfDay = min.getLong(ChronoField.SECOND_OF_DAY); long maxSecondOfDay = max.getLong(ChronoField.SECOND_OF_DAY); long randomSecondOfDay = (long) nextDouble(minSecondOfDay, maxSecondOfDay); return LocalTime.ofSecondOfDay(randomSecondOfDay); } LocalTimeRangeRandomizer(final LocalTime min, final LocalTime max); LocalTimeRangeRandomizer(final LocalTime min, final LocalTime max, final long seed); static LocalTimeRangeRandomizer aNewLocalTimeRangeRandomizer(final LocalTime min, final LocalTime max); static LocalTimeRangeRandomizer aNewLocalTimeRangeRandomizer(final LocalTime min, final LocalTime max, final long seed); @Override LocalTime getRandomValue(); }### Answer: @Test void generatedLocalTimeShouldNotBeNull() { assertThat(randomizer.getRandomValue()).isNotNull(); } @Test void generatedLocalTimeShouldBeWithinSpecifiedRange() { assertThat(randomizer.getRandomValue()).isBetween(minTime, maxTime); }
### Question: LocalTimeRangeRandomizer extends AbstractRangeRandomizer<LocalTime> { public static LocalTimeRangeRandomizer aNewLocalTimeRangeRandomizer(final LocalTime min, final LocalTime max) { return new LocalTimeRangeRandomizer(min, max); } LocalTimeRangeRandomizer(final LocalTime min, final LocalTime max); LocalTimeRangeRandomizer(final LocalTime min, final LocalTime max, final long seed); static LocalTimeRangeRandomizer aNewLocalTimeRangeRandomizer(final LocalTime min, final LocalTime max); static LocalTimeRangeRandomizer aNewLocalTimeRangeRandomizer(final LocalTime min, final LocalTime max, final long seed); @Override LocalTime getRandomValue(); }### Answer: @Test void whenSpecifiedMinTimeIsAfterMaxDate_thenShouldThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewLocalTimeRangeRandomizer(maxTime, minTime)).isInstanceOf(IllegalArgumentException.class); }
### Question: DateRangeRandomizer extends AbstractRangeRandomizer<Date> { @Override public Date getRandomValue() { long minDateTime = min.getTime(); long maxDateTime = max.getTime(); long randomDateTime = (long) nextDouble((double) minDateTime, (double) maxDateTime); return new Date(randomDateTime); } DateRangeRandomizer(final Date min, final Date max); DateRangeRandomizer(final Date min, final Date max, final long seed); static DateRangeRandomizer aNewDateRangeRandomizer(final Date min, final Date max); static DateRangeRandomizer aNewDateRangeRandomizer(final Date min, final Date max, final long seed); @Override Date getRandomValue(); }### Answer: @Test void generatedDateShouldNotBeNull() { assertThat(randomizer.getRandomValue()).isNotNull(); } @Test void generatedDateShouldBeWithinSpecifiedRange() { assertThat(randomizer.getRandomValue()).isBetween(minDate, maxDate); }
### Question: DateRangeRandomizer extends AbstractRangeRandomizer<Date> { public static DateRangeRandomizer aNewDateRangeRandomizer(final Date min, final Date max) { return new DateRangeRandomizer(min, max); } DateRangeRandomizer(final Date min, final Date max); DateRangeRandomizer(final Date min, final Date max, final long seed); static DateRangeRandomizer aNewDateRangeRandomizer(final Date min, final Date max); static DateRangeRandomizer aNewDateRangeRandomizer(final Date min, final Date max, final long seed); @Override Date getRandomValue(); }### Answer: @Test void whenSpecifiedMinDateIsAfterMaxDate_thenShouldThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewDateRangeRandomizer(maxDate, minDate)).isInstanceOf(IllegalArgumentException.class); }
### Question: YearMonthRangeRandomizer extends AbstractRangeRandomizer<YearMonth> { @Override public YearMonth getRandomValue() { long minYear = min.getLong(ChronoField.YEAR); long maxYear = max.getLong(ChronoField.YEAR); long randomYear = (long) nextDouble(minYear, maxYear); long minMonth = min.getLong(ChronoField.MONTH_OF_YEAR); long maxMonth = max.getLong(ChronoField.MONTH_OF_YEAR); long randomMonth = (long) nextDouble(minMonth, maxMonth); return YearMonth.of(Math.toIntExact(randomYear), Math.toIntExact(randomMonth)); } YearMonthRangeRandomizer(final YearMonth min, final YearMonth max); YearMonthRangeRandomizer(final YearMonth min, final YearMonth max, final long seed); static YearMonthRangeRandomizer aNewYearMonthRangeRandomizer(final YearMonth min, final YearMonth max); static YearMonthRangeRandomizer aNewYearMonthRangeRandomizer(final YearMonth min, final YearMonth max, final long seed); @Override YearMonth getRandomValue(); }### Answer: @Test void generatedYearMonthShouldNotBeNull() { assertThat(randomizer.getRandomValue()).isNotNull(); } @Test void generatedYearMonthShouldBeWithinSpecifiedRange() { assertThat(randomizer.getRandomValue()).isBetween(minYearMonth, maxYearMonth); }
### Question: YearMonthRangeRandomizer extends AbstractRangeRandomizer<YearMonth> { public static YearMonthRangeRandomizer aNewYearMonthRangeRandomizer(final YearMonth min, final YearMonth max) { return new YearMonthRangeRandomizer(min, max); } YearMonthRangeRandomizer(final YearMonth min, final YearMonth max); YearMonthRangeRandomizer(final YearMonth min, final YearMonth max, final long seed); static YearMonthRangeRandomizer aNewYearMonthRangeRandomizer(final YearMonth min, final YearMonth max); static YearMonthRangeRandomizer aNewYearMonthRangeRandomizer(final YearMonth min, final YearMonth max, final long seed); @Override YearMonth getRandomValue(); }### Answer: @Test void whenSpecifiedMinYearMonthIsAfterMaxYearMonth_thenShouldThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewYearMonthRangeRandomizer(maxYearMonth, minYearMonth)).isInstanceOf(IllegalArgumentException.class); }
### Question: YearRangeRandomizer extends AbstractRangeRandomizer<Year> { @Override public Year getRandomValue() { long minYear = min.getLong(ChronoField.YEAR); long maxYear = max.getLong(ChronoField.YEAR); long randomYear = (long) nextDouble(minYear, maxYear); return Year.of(Math.toIntExact(randomYear)); } YearRangeRandomizer(final Year min, final Year max); YearRangeRandomizer(final Year min, final Year max, final long seed); static YearRangeRandomizer aNewYearRangeRandomizer(final Year min, final Year max); static YearRangeRandomizer aNewYearRangeRandomizer(final Year min, final Year max, final long seed); @Override Year getRandomValue(); }### Answer: @Test void generatedYearShouldNotBeNull() { assertThat(randomizer.getRandomValue()).isNotNull(); } @Test void generatedYearShouldBeWithinSpecifiedRange() { assertThat(randomizer.getRandomValue()).isBetween(minYear, maxYear); }
### Question: YearRangeRandomizer extends AbstractRangeRandomizer<Year> { public static YearRangeRandomizer aNewYearRangeRandomizer(final Year min, final Year max) { return new YearRangeRandomizer(min, max); } YearRangeRandomizer(final Year min, final Year max); YearRangeRandomizer(final Year min, final Year max, final long seed); static YearRangeRandomizer aNewYearRangeRandomizer(final Year min, final Year max); static YearRangeRandomizer aNewYearRangeRandomizer(final Year min, final Year max, final long seed); @Override Year getRandomValue(); }### Answer: @Test void whenSpecifiedMinYearIsAfterMaxYear_thenShouldThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewYearRangeRandomizer(maxYear, minYear)).isInstanceOf(IllegalArgumentException.class); }
### Question: LongRangeRandomizer extends AbstractRangeRandomizer<Long> { @Override public Long getRandomValue() { return (long) nextDouble(min, max); } LongRangeRandomizer(final Long min, final Long max); LongRangeRandomizer(final Long min, final Long max, final long seed); static LongRangeRandomizer aNewLongRangeRandomizer(final Long min, final Long max); static LongRangeRandomizer aNewLongRangeRandomizer(final Long min, final Long max, final long seed); @Override Long getRandomValue(); }### Answer: @Test void generatedValueShouldBeWithinSpecifiedRange() { Long randomValue = randomizer.getRandomValue(); assertThat(randomValue).isBetween(min, max); }
### Question: LongRangeRandomizer extends AbstractRangeRandomizer<Long> { public static LongRangeRandomizer aNewLongRangeRandomizer(final Long min, final Long max) { return new LongRangeRandomizer(min, max); } LongRangeRandomizer(final Long min, final Long max); LongRangeRandomizer(final Long min, final Long max, final long seed); static LongRangeRandomizer aNewLongRangeRandomizer(final Long min, final Long max); static LongRangeRandomizer aNewLongRangeRandomizer(final Long min, final Long max, final long seed); @Override Long getRandomValue(); }### Answer: @Test void whenSpecifiedMinValueIsAfterMaxValueThenThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewLongRangeRandomizer(max, min)).isInstanceOf(IllegalArgumentException.class); }
### Question: LocalDateTimeRangeRandomizer extends AbstractRangeRandomizer<LocalDateTime> { @Override public LocalDateTime getRandomValue() { long minSeconds = min.toEpochSecond(ZoneOffset.UTC); long maxSeconds = max.toEpochSecond(ZoneOffset.UTC); long seconds = (long) nextDouble(minSeconds, maxSeconds); int minNanoSeconds = min.getNano(); int maxNanoSeconds = max.getNano(); long nanoSeconds = (long) nextDouble(minNanoSeconds, maxNanoSeconds); Instant instant = Instant.ofEpochSecond(seconds, nanoSeconds); return LocalDateTime.ofInstant(instant, ZoneOffset.UTC); } LocalDateTimeRangeRandomizer(final LocalDateTime min, final LocalDateTime max); LocalDateTimeRangeRandomizer(final LocalDateTime min, final LocalDateTime max, final long seed); static LocalDateTimeRangeRandomizer aNewLocalDateTimeRangeRandomizer(final LocalDateTime min, final LocalDateTime max); static LocalDateTimeRangeRandomizer aNewLocalDateTimeRangeRandomizer(final LocalDateTime min, final LocalDateTime max, final long seed); @Override LocalDateTime getRandomValue(); }### Answer: @Test void generatedLocalDateTimeShouldNotBeNull() { assertThat(randomizer.getRandomValue()).isNotNull(); } @Test void generatedLocalDateTimeShouldBeWithinSpecifiedRange() { assertThat(randomizer.getRandomValue()).isBetween(minDateTime, maxDateTime); }
### Question: LocalDateTimeRangeRandomizer extends AbstractRangeRandomizer<LocalDateTime> { public static LocalDateTimeRangeRandomizer aNewLocalDateTimeRangeRandomizer(final LocalDateTime min, final LocalDateTime max) { return new LocalDateTimeRangeRandomizer(min, max); } LocalDateTimeRangeRandomizer(final LocalDateTime min, final LocalDateTime max); LocalDateTimeRangeRandomizer(final LocalDateTime min, final LocalDateTime max, final long seed); static LocalDateTimeRangeRandomizer aNewLocalDateTimeRangeRandomizer(final LocalDateTime min, final LocalDateTime max); static LocalDateTimeRangeRandomizer aNewLocalDateTimeRangeRandomizer(final LocalDateTime min, final LocalDateTime max, final long seed); @Override LocalDateTime getRandomValue(); }### Answer: @Test void whenSpecifiedMinDateTimeIsAfterMaxDateTime_thenShouldThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewLocalDateTimeRangeRandomizer(maxDateTime, minDateTime)).isInstanceOf(IllegalArgumentException.class); }
### Question: IntegerRangeRandomizer extends AbstractRangeRandomizer<Integer> { @Override public Integer getRandomValue() { return (int) nextDouble(min, max); } IntegerRangeRandomizer(final Integer min, final Integer max); IntegerRangeRandomizer(final Integer min, final Integer max, final long seed); static IntegerRangeRandomizer aNewIntegerRangeRandomizer(final Integer min, final Integer max); static IntegerRangeRandomizer aNewIntegerRangeRandomizer(final Integer min, final Integer max, final long seed); @Override Integer getRandomValue(); }### Answer: @Test void generatedValueShouldBeWithinSpecifiedRange() { Integer randomValue = randomizer.getRandomValue(); assertThat(randomValue).isBetween(min, max); }
### Question: IntegerRangeRandomizer extends AbstractRangeRandomizer<Integer> { public static IntegerRangeRandomizer aNewIntegerRangeRandomizer(final Integer min, final Integer max) { return new IntegerRangeRandomizer(min, max); } IntegerRangeRandomizer(final Integer min, final Integer max); IntegerRangeRandomizer(final Integer min, final Integer max, final long seed); static IntegerRangeRandomizer aNewIntegerRangeRandomizer(final Integer min, final Integer max); static IntegerRangeRandomizer aNewIntegerRangeRandomizer(final Integer min, final Integer max, final long seed); @Override Integer getRandomValue(); }### Answer: @Test void whenSpecifiedMinValueIsAfterMaxValueThenThrowIllegalArgumentException() { assertThatThrownBy(() -> aNewIntegerRangeRandomizer(max, min)).isInstanceOf(IllegalArgumentException.class); }
### Question: RedisStore { public void delete(final String sentence) throws IOException { String word = WordUtils.getLastWord(sentence); if (word.isEmpty()) { return; } String rhyme = normalizeString(wordParser.phoneticRhymePart(word)); StressType type = wordParser.stressType(word); connect(); try { String sentenceKey = getUniqueIdKey(sentencens, normalizeString(sentence)); if (redis.exists(sentenceKey) == 0) { throw new IOException("The element to remove does not exist."); } String indexKey = getUniqueIdKey(indexns, buildUniqueToken(rhyme, type)); String sentenceId = redis.get(sentenceKey); sentenceId = sentencens.build(sentenceId).toString(); if (redis.exists(indexKey) == 1) { String indexId = redis.get(indexKey); indexId = indexns.build(indexId).toString(); if (redis.exists(indexId) == 1) { redis.srem(indexId, sentenceId); } if (redis.smembers(indexId).isEmpty()) { redis.del(indexId, indexKey); } } redis.del(sentenceId, sentenceKey); LOGGER.info("Deleted rhyme: {}", sentence); } finally { disconnect(); } } @Inject RedisStore(@Named("sentence") final Keymaker sentencens, @Named("index") final Keymaker indexns, final WordParser wordParser, final Jedis redis, final @Named(REDIS_PASSWORD) Optional<String> redisPassword, final Charset encoding); void add(final String sentence); void delete(final String sentence); Set<String> findAll(); String getRhyme(final String sentence); }### Answer: @Test(expectedExceptions = IOException.class) public void testDeleteUnexistingRhyme() throws IOException { store.delete("Unexisting"); } @Test public void testDeleteWithoutText() throws IOException { store.delete(null); store.delete(""); }
### Question: RedisStore { @VisibleForTesting String sum(final String value) { return Hashing.md5().hashString(value, encoding).toString(); } @Inject RedisStore(@Named("sentence") final Keymaker sentencens, @Named("index") final Keymaker indexns, final WordParser wordParser, final Jedis redis, final @Named(REDIS_PASSWORD) Optional<String> redisPassword, final Charset encoding); void add(final String sentence); void delete(final String sentence); Set<String> findAll(); String getRhyme(final String sentence); }### Answer: @Test public void testSum() { assertEquals(store.sum("foo"), "acbd18db4cc2f85cedef654fccc4a4d8"); assertEquals(store.sum("bar"), "37b51d194a7513e45b56f6524f2d51f2"); }
### Question: Keymaker { public Keymaker(final String namespace) { this.namespace = checkNotNull(namespace, "Namespace cannot be null"); } Keymaker(final String namespace); Keymaker build(final String... namespaces); @Override String toString(); }### Answer: @Test public void testKeymaker() { checkKeymaker(""); checkKeymaker(":"); checkKeymaker("test"); checkKeymaker(":test:"); checkKeymaker("test::"); checkKeymaker("::test"); checkKeymaker("test:test2"); }
### Question: ReplyCommand extends AbstracTwitterCommand { @Override public void execute() throws TwitterException { String rhyme = null; String targetUser = status.getUser().getScreenName(); try { rhyme = rhymeStore.getRhyme(status.getText()); if (rhyme == null) { if (wordParser.isWord(targetUser)) { LOGGER.info("Trying to rhyme with the screen name: {}", targetUser); rhyme = rhymeStore.getRhyme(targetUser); } } if (rhyme == null) { rhyme = wordParser.getDefaultRhyme(); LOGGER.info("No rhyme found. Using default rhyme: {}", rhyme); } } catch (IOException ex) { LOGGER.error( "An error occured while connecting to the rhyme store. Could not reply to {}", targetUser, ex); } try { String tweet = TwitterUtils.reply(targetUser, rhyme); LOGGER.info("Replying to {} with: {}", targetUser, tweet); StatusUpdate newStatus = new StatusUpdate(tweet); newStatus.setInReplyToStatusId(status.getId()); twitter.updateStatus(newStatus); } catch (TwitterException ex) { LOGGER.error("Could not send reply to tweet " + status.getId(), ex); } } ReplyCommand(final Twitter twitter, final WordParser wordParser, final RedisStore rhymeStore, final Status status); @Override void execute(); }### Answer: @Test public void testExecuteWithExistingRhyme() throws TwitterException { ReplyCommand replyCommand = createReplyCommand("Este test es casi perfecto"); replyCommand.execute(); assertTrue(twitter.getLastUpdatedStatus().contains("Rima por defecto")); } @Test public void testExecuteWithScreenNameRhyme() throws TwitterException { ReplyCommand replyCommand = createReplyCommand("Rima esto con el usuario"); replyCommand.execute(); assertTrue(twitter.getLastUpdatedStatus().contains("Esta rima es infame")); }
### Question: WordUtils { public static String capitalize(final String str) { if (str == null) { return null; } switch (str.length()) { case 0: return str; case 1: return str.toUpperCase(); default: return str.substring(0, 1).toUpperCase() + str.substring(1); } } static String getLastWord(final String sentence); static String capitalize(final String str); static boolean isNumber(String word); }### Answer: @Test public void testCapitalize() { assertEquals(capitalize(null), null); assertEquals(capitalize(""), ""); assertEquals(capitalize("hola"), "Hola"); assertEquals(capitalize("hOLA"), "HOLA"); }
### Question: WordUtils { public static String getLastWord(final String sentence) { String word = ""; if (sentence != null) { List<String> words = Arrays.asList(sentence.split(" ")); if (words.size() > 0) { word = words.get(words.size() - 1); } } return word; } static String getLastWord(final String sentence); static String capitalize(final String str); static boolean isNumber(String word); }### Answer: @Test public void testGetLastWord() { assertEquals(getLastWord(null), ""); assertEquals(getLastWord(""), ""); assertEquals(getLastWord("hola"), "hola"); assertEquals(getLastWord("hola adios"), "adios"); assertEquals(getLastWord("hola ."), "."); }
### Question: WordUtils { public static boolean isNumber(String word) { if (word == null) { return false; } String wordToParse = new String(word); if (wordToParse.startsWith("-")) { wordToParse = wordToParse.replaceFirst("-", ""); } if (wordToParse.length() == 0) { return false; } for (char c : wordToParse.toCharArray()) { if (!Character.isDigit(c)) { return false; } } return true; } static String getLastWord(final String sentence); static String capitalize(final String str); static boolean isNumber(String word); }### Answer: @Test public void testIsNumber() { assertFalse(isNumber(null)); assertFalse(isNumber("")); assertFalse(isNumber("a")); assertFalse(isNumber("-a")); assertFalse(isNumber("23a")); assertTrue(isNumber("-1")); assertTrue(isNumber("0")); assertTrue(isNumber("12345")); }
### Question: Configuration { static String getConfigValue(final String propertyName) { return getConfiguration().getProperty(propertyName); } private Configuration(); static final String CONFIG_FILE; static final String REDIS_HOST; static final String REDIS_PORT; static final String REDIS_PASSWORD; static final String FALLBACK_RHYMES; static final String DEFAULT_RHYMES; }### Answer: @Test public void testGetConfigValue() { assertNull(getConfigValue("unexisting")); assertEquals(getConfigValue(REDIS_HOST), "localhost"); }
### Question: Configuration { static String getRequiredConfigValue(final String propertyName) { String value = getConfiguration().getProperty(propertyName); if (value == null) { throw new ConfigurationException("Te requested property [" + propertyName + "] was not set."); } return value; } private Configuration(); static final String CONFIG_FILE; static final String REDIS_HOST; static final String REDIS_PORT; static final String REDIS_PASSWORD; static final String FALLBACK_RHYMES; static final String DEFAULT_RHYMES; }### Answer: @Test public void testGetRequiredConfigValue() { assertEquals(getRequiredConfigValue(REDIS_HOST), "localhost"); } @Test(expectedExceptions = ConfigurationException.class) public void testGetUnexistingRequiredConfigValue() { getRequiredConfigValue("unexisting"); }
### Question: RedisStore { public Set<String> findAll() throws IOException { Set<String> rhymes = new HashSet<String>(); connect(); try { String lastId = getLastId(sentencens); if (lastId != null) { Integer n = Integer.parseInt(getLastId(sentencens)); for (int i = 1; i <= n; i++) { String id = sentencens.build(String.valueOf(i)).toString(); if (redis.exists(id) == 1) { rhymes.add(URLDecoder.decode(redis.get(id), encoding.displayName())); } } } } finally { disconnect(); } return rhymes; } @Inject RedisStore(@Named("sentence") final Keymaker sentencens, @Named("index") final Keymaker indexns, final WordParser wordParser, final Jedis redis, final @Named(REDIS_PASSWORD) Optional<String> redisPassword, final Charset encoding); void add(final String sentence); void delete(final String sentence); Set<String> findAll(); String getRhyme(final String sentence); }### Answer: @Test public void testFindAll() throws IOException { assertEquals(store.findAll().size(), 2); }
### Question: RedisStore { public String getRhyme(final String sentence) throws IOException { String lastWord = WordUtils.getLastWord(sentence); String rhymepart = wordParser.phoneticRhymePart(lastWord); StressType type = wordParser.stressType(lastWord); LOGGER.debug("Finding rhymes for {}", sentence); Set<String> rhymes = Sets.newHashSet(); connect(); try { rhymes.addAll(search(rhymepart, type)); } finally { disconnect(); } if (rhymes.isEmpty()) { return null; } else { List<String> rhymeList = new ArrayList<String>(rhymes); Random random = new Random(System.currentTimeMillis()); int index = random.nextInt(rhymeList.size()); return rhymeList.get(index); } } @Inject RedisStore(@Named("sentence") final Keymaker sentencens, @Named("index") final Keymaker indexns, final WordParser wordParser, final Jedis redis, final @Named(REDIS_PASSWORD) Optional<String> redisPassword, final Charset encoding); void add(final String sentence); void delete(final String sentence); Set<String> findAll(); String getRhyme(final String sentence); }### Answer: @Test public void testGetRhyme() throws IOException { assertNull(store.getRhyme("no hay rima")); assertEquals(store.getRhyme("¿Hay algo que rime con tres?"), "Me escondo y no me ves"); assertEquals(store.getRhyme("Nada rima con dos"), "Ya son veintidós!!"); }
### Question: DimensionalIndex extends ISize { public int rollup(int xValue, int yValue, int zValue) { check(xValue,super.getX(),'x'); check(yValue,super.getY(),'y'); check(zValue,super.getZ(),'z'); return xValue + yValue * getX( ) + zValue * xy; } DimensionalIndex(int newX, int newY, int newZ); DimensionalIndex(String newX, String newY, String newZ); DimensionalIndex(ISize source); int rollup(int xValue, int yValue, int zValue); }### Answer: @Test public void validateIndexes( ) { boolean punched[] = new boolean[index.getXYZ()]; for (int x = 0; x < mX; x++) for (int y = 0; y < mY; y++) for (int z = 0; z < mZ; z++) { final int idx = index.rollup(x,y,z); assertFalse(punched[idx]); punched[idx] = true; } for (int p = 0; p < punched.length; ++p) { assertTrue(punched[p]); } } @Test(expected = RuntimeException.class) public void badX( ) { index.rollup(mX, 0,0); } @Test(expected = RuntimeException.class) public void badY( ) { index.rollup(0, mY,0); } @Test(expected = RuntimeException.class) public void badZ( ) { index.rollup(0,0,mZ); } @Test public void badZmsg( ) { try { index.rollup(0,0,mZ); Assert.fail("should have thrown an exception"); } catch (RuntimeException re) { } }
### Question: EventRateLimiter { public boolean isOkayToFireEventNow(){ long totalElapsedTimeNow = timeRightNow()-startTime; int currentTimeRegimeIndex = 0; for (int i=0; i<intervals.length; i++) { currentTimeRegimeIndex = i; if (totalElapsedTimeNow < intervals[i][TIME_INTERVAL_REGIME]){ break; } } if (timeSinceLastApprovedEvent() < intervals[currentTimeRegimeIndex][TIME_INTERVAL_PER_REGIME]){ return false; } else { timeOfLastEvent = timeRightNow(); return true; } } EventRateLimiter(long[][] specifiedIntervals); EventRateLimiter(); boolean isOkayToFireEventNow(); static void main(String[] args); }### Answer: @Test public void test() { try { EventRateLimiter eventRateLimiter = new EventRateLimiter(); long testStartTime = System.currentTimeMillis(); System.out.println("Starting at " + testStartTime); int approvedEventCount = 0; while (System.currentTimeMillis() < testStartTime + 60000) { if (eventRateLimiter.isOkayToFireEventNow()) { approvedEventCount++; System.out.println("Now it is "+ System.currentTimeMillis()); } } if ((approvedEventCount > 67) && (approvedEventCount < 73)) { System.out.println(String.valueOf(approvedEventCount)+ " events approved in one minute"); } else { System.out.println(String.valueOf(approvedEventCount)+" events approved in one minute is out of expected bounds"); fail(String.valueOf(approvedEventCount)+" events approved in one minute is out of expected bounds"); } } catch (Exception e) { fail("Exception occured: "+e.getMessage()); } }
### Question: User implements java.io.Serializable, Matchable, Immutable { public boolean isPublisher() { return Arrays.asList(publishers).contains(userName); } User(String userid, KeyValue key); static String createGuestErrorMessage(String theOffendingOp); static boolean isGuest(String checkThisName); boolean compareEqual(Matchable obj); boolean equals(Object obj); KeyValue getID(); String getName(); int hashCode(); boolean isPublisher(); boolean isTestAccount(); static boolean isTestAccount(String accountName); String toString(); static final String[] publishers; static final User tempUser; static final String VCELL_GUEST; }### Answer: @Test public void publisherTest( ) { User u = new User("schaff", testKey( )); Assert.assertTrue(u.isPublisher()); u = new User("fido", testKey( )); Assert.assertFalse(u.isPublisher()); }
### Question: User implements java.io.Serializable, Matchable, Immutable { public boolean isTestAccount() { return isTestAccount(getName( )); } User(String userid, KeyValue key); static String createGuestErrorMessage(String theOffendingOp); static boolean isGuest(String checkThisName); boolean compareEqual(Matchable obj); boolean equals(Object obj); KeyValue getID(); String getName(); int hashCode(); boolean isPublisher(); boolean isTestAccount(); static boolean isTestAccount(String accountName); String toString(); static final String[] publishers; static final User tempUser; static final String VCELL_GUEST; }### Answer: @Test public void testAcctTest( ) { User u = new User("vcelltestaccount", testKey( )); Assert.assertTrue(u.isTestAccount()); u = new User("fido", testKey( )); Assert.assertFalse(u.isTestAccount()); }
### Question: VCCollections { public static <T> boolean equal(Collection<T> a, Collection<T> b, Comparator<T> cmp) { return equal(a,b,cmp,null); } static boolean equal(Collection<T> a, Collection<T> b, Comparator<T> cmp); static boolean equal(Collection<T> a, Collection<T> b, Comparator<T> cmp , Collection<Delta<T> > diffs); }### Answer: @Test public <T> void ctest( ) { ArrayList<Delta<Integer>> dt = new ArrayList<VCCollections.Delta<Integer>>( ); b.addAll(a); assertTrue(VCCollections.equal(a, b, cmp, null)); assertTrue(VCCollections.equal(a, b, cmp, dt)); for (int i = 0; i < 10 ;i++) { Collections.shuffle(b); assertTrue(VCCollections.equal(a, b, cmp, null)); assertTrue(VCCollections.equal(a, b, cmp, dt)); } b.add(7); assertFalse(VCCollections.equal(a, b, cmp, null)); assertFalse(VCCollections.equal(a, b, cmp, dt)); a.add(8); assertFalse(VCCollections.equal(a, b, cmp, null)); assertFalse(VCCollections.equal(a, b, cmp, dt)); }
### Question: CircularList extends AbstractCollection<E> { @Override public boolean add(E e) { storage.add(e); while (storage.size() > capacity()) { storage.pop(); } return true; } CircularList(int capacity); int capacity(); @Override boolean add(E e); @Override Iterator<E> iterator(); @Override int size(); }### Answer: @Test public void tryIt( ) { insert(7,10); validate(7,8,9,10); list.clear(); insert(1,23); validate(19,20,21,22,23); list.add(7); validate(20,21,22,23,7); }
### Question: CachedDataBaseReferenceReader { public static CachedDataBaseReferenceReader getCachedReader( ) { CachedDataBaseReferenceReader r = dbReader.get(); if (r != null) { return r; } synchronized(dbReader) { r = dbReader.get(); if (r != null) { return r; } r = new CachedDataBaseReferenceReader(); dbReader = new SoftReference<CachedDataBaseReferenceReader>(r); } return r; } private CachedDataBaseReferenceReader( ); static CachedDataBaseReferenceReader getCachedReader( ); String getMoleculeDataBaseReference(String molId); String getChEBIName(String chebiId); String getGOTerm(String goId); String getMoleculeDataBaseReference(String db, String id); }### Answer: @Ignore @Test public void fetchAndConsume( ) { ReferenceQueue<CachedDataBaseReferenceReader> rq = new ReferenceQueue<CachedDataBaseReferenceReader>(); WeakReference<CachedDataBaseReferenceReader> weakR = new WeakReference<CachedDataBaseReferenceReader>( CachedDataBaseReferenceReader.getCachedReader(),rq); boolean outOfMem = false; ArrayList<int[]> pig = new ArrayList<int[]>( ); for (int size = 10;!outOfMem;size*=10) { try { assertFalse(weakR.isEnqueued()); pig.add(new int[size]); CachedDataBaseReferenceReader w = weakR.get( ); assertTrue(w == CachedDataBaseReferenceReader.getCachedReader()); } catch(OutOfMemoryError error) { assertTrue(weakR.isEnqueued()); assertTrue(weakR.get( ) == null); outOfMem = true; } } pig.clear(); CachedDataBaseReferenceReader dbReader = CachedDataBaseReferenceReader.getCachedReader(); assertTrue(dbReader != null); }
### Question: UnitSymbol implements Serializable { public String getUnitSymbolAsInfix() { return rootNode.toInfix(); } UnitSymbol(String unitStr); String getUnitSymbolAsInfix(); String getUnitSymbolAsInfixWithoutFloatScale(); double getNumericScale(); String getUnitSymbol(); String getUnitSymbolUnicode(); String getUnitSymbolHtml(); }### Answer: @Test public void example( ) { Assert.assertEquals("uM*s^-1", new UnitSymbol("uM.s-1").getUnitSymbolAsInfix()); }
### Question: VCellThreadChecker { public static void checkCpuIntensiveInvocation() { if (guiThreadChecker == null){ System.out.println("!!!!!!!!!!!!!! --VCellThreadChecker.setGUIThreadChecker() not set"); Thread.dumpStack(); }else if (guiThreadChecker.isEventDispatchThread() && cpuSuppressed.get() == 0) { System.out.println("!!!!!!!!!!!!!! --calling cpu intensive method from swing thread-----"); Thread.dumpStack(); } } static void setGUIThreadChecker(GUIThreadChecker argGuiThreadChecker); static void checkRemoteInvocation(); static void checkSwingInvocation(); static void checkCpuIntensiveInvocation(); }### Answer: @Test public void notSwingCheck( ) { VCellThreadChecker.checkCpuIntensiveInvocation(); checkQuiet( ); } @Test public void swingCheckSupp( ) throws InvocationTargetException, InterruptedException { SwingUtilities.invokeAndWait(new Runnable() { @Override public void run() { try (VCellThreadChecker.SuppressIntensive si = new VCellThreadChecker.SuppressIntensive()) { subCall( ); VCellThreadChecker.checkCpuIntensiveInvocation(); } } }); checkQuiet( ); } @Test(expected=IllegalStateException.class) public void swingCheckNotSupp( ) throws InvocationTargetException, InterruptedException { SwingUtilities.invokeAndWait(new Runnable() { @Override public void run() { try (VCellThreadChecker.SuppressIntensive si = new VCellThreadChecker.SuppressIntensive()) { } VCellThreadChecker.checkCpuIntensiveInvocation(); } }); checkQuiet( ); }
### Question: VCellThreadChecker { public static void checkSwingInvocation() { if (guiThreadChecker == null){ System.out.println("!!!!!!!!!!!!!! --VCellThreadChecker.setGUIThreadChecker() not set"); Thread.dumpStack(); }else if (!guiThreadChecker.isEventDispatchThread()) { System.out.println("!!!!!!!!!!!!!! --calling swing from non-swing thread-----"); Thread.dumpStack(); } } static void setGUIThreadChecker(GUIThreadChecker argGuiThreadChecker); static void checkRemoteInvocation(); static void checkSwingInvocation(); static void checkCpuIntensiveInvocation(); }### Answer: @Test public void swingCheck( ) throws InvocationTargetException, InterruptedException { SwingUtilities.invokeAndWait(new Runnable() { @Override public void run() { VCellThreadChecker.checkSwingInvocation(); } }); checkQuiet( ); }
### Question: GenericUtils { @SuppressWarnings("unchecked") public static <T> java.util.List<T> convert(java.util.List<?> list, Class<T> clzz) { for (Object o : list) { if (!clzz.isAssignableFrom(o.getClass()) ) { throw new RuntimeException("invalid list conversion, " + clzz.getName() + " list contains " + o.getClass()); } } return (List<T>) list; } @SuppressWarnings("unchecked") static java.util.List<T> convert(java.util.List<?> list, Class<T> clzz); }### Answer: @Test public void goodConvert( ) { ArrayList<Object> al = new ArrayList<Object>( ); for (int i = 0; i < 5; i++) { al.add(Integer.valueOf(i)); } List<Integer> asIntArray = GenericUtils.convert(al, Integer.class); for (int i = 0; i < 5; i++) { assertTrue(asIntArray.get(i) == i); } } @Test(expected = RuntimeException.class) public void badConvert( ) { ArrayList<Object> al = new ArrayList<Object>( ); for (int i = 0; i < 5; i++) { al.add(Integer.valueOf(i)); } List<String> asIntArray = GenericUtils.convert(al, String.class); System.out.println(asIntArray); }
### Question: StreamingResultSet implements Iterator<Map<String, Node>>, Closeable { public StreamingResultSet(BufferedReader in) throws IOException { this.in = in; tsvParser = new TsvParser(in); if ((currentTuple = tsvParser.getTuple()) == null) { hasNext = false; } } StreamingResultSet(BufferedReader in); StreamingResultSet(HttpURLConnection conn); @Override Map<String, Node> next(); String[] getResultVars(); @Override void close(); @Override boolean hasNext(); }### Answer: @Test public void testStreamingResultSet() throws IOException { BufferedReader bufferedReader = new BufferedReader(new StringReader("?s\t?p\t?o\n" + "<http: + "<http: + "<http: List<Map<String, Node>> result = new ArrayList<>(); try (StreamingResultSet resultSet = new StreamingResultSet(bufferedReader)) { assertArrayEquals(new String[] {"s", "p", "o"}, resultSet.getResultVars()); int rowsRead = 0; assertEquals(rowsRead, resultSet.getRowNumber()); while (resultSet.hasNext()) { Map<String, Node> rs = resultSet.next(); System.out.println(rs); result.add(rs); rowsRead++; assertEquals(rowsRead, resultSet.getRowNumber()); } } assertEquals(3, result.size()); }
### Question: TsvParser { private static Optional<Node> parseNode(String nodeString) { try { return Optional.of(NodeFactoryExtra.parseNode(nodeString)); } catch (RiotException e) { log.error("Parsing of value '{}' failed: {}", nodeString, e.getMessage()); return Optional.empty(); } } TsvParser(BufferedReader in); Map<String, Node> getTuple(); }### Answer: @Test public void testResourceEnding() throws IOException { Map<String, Node> result = parseSingleTuple("?s\n" + "<http: assertEquals(NodeFactoryExtra.parseNode("<http: } @Test public void testEmptyVariablesInResult() throws IOException { Map<String, Node> result = parseSingleTuple("?s\t?p\t?o\n" + "<http: assertEquals(NodeFactoryExtra.parseNode("<http: assertFalse(result.containsKey("p")); assertEquals(NodeFactoryExtra.parseNode("\"o2\""), result.get("o")); } @Test public void testMultipleEmptyVariablesInResult() throws IOException { Map<String, Node> result; result = parseSingleTuple("?s\t?p\t?o\n" + "\t\t\"o2\"\n"); assertFalse(result.containsKey("s")); assertFalse(result.containsKey("p")); assertEquals(NodeFactoryExtra.parseNode("\"o2\""), result.get("o")); result = parseSingleTuple("?s\t?p\t?o\n" + "<http: assertEquals(NodeFactoryExtra.parseNode("<http: assertFalse(result.containsKey("p")); assertFalse(result.containsKey("o")); result = parseSingleTuple("?s\t?p\t?o\n" + "\t\t\t\n"); assertEquals(0, result.size()); } @Test public void testNodeParser() { Node parseNode = NodeFactoryExtra.parseNode("\"Hallo \\\"Echo\\\"!\"@de"); assertEquals("de", parseNode.getLiteralLanguage()); assertEquals("Hallo \"Echo\"!", parseNode.getLiteralValue()); }
### Question: FeaturePluginToMavenDependencyConverter { static Set<Dependency> convert(Set<IFeaturePlugin> featurePlugins) { return featurePlugins.stream().map(FeaturePluginToMavenDependencyConverter::convert).collect(Collectors.toSet()); } }### Answer: @Test public void testConversionForFXDependency() { IFeaturePlugin featurePlugin = Mockito.mock(IFeaturePlugin.class); Mockito.when(featurePlugin.getId()).thenReturn(FEATURE_PLUGIN_ID_FX); Mockito.when(featurePlugin.getVersion()).thenReturn(FEATURE_PLUGIN_VERSION_FX); Set<Dependency> dependencies = FeaturePluginToMavenDependencyConverter.convert(new HashSet<>(Arrays.asList(featurePlugin))); assertThat(dependencies.size(), equalTo(1)); if (dependencies.size() == 1) { Dependency dependency = dependencies.iterator().next(); assertThat(dependency.getGroupId(), equalTo("at.bestsolution.efxclipse.rt")); assertThat(dependency.getArtifactId(), equalTo(FEATURE_PLUGIN_ID_FX)); assertThat(dependency.getVersion(), equalTo("3.0.0")); } } @Test public void testConversionForNonFXDependency() { IFeaturePlugin featurePlugin = Mockito.mock(IFeaturePlugin.class); Mockito.when(featurePlugin.getId()).thenReturn(FEATURE_PLUGIN_ID_NON_FX); Mockito.when(featurePlugin.getVersion()).thenReturn(FEATURE_PLUGIN_VERSION_NON_FX); Set<Dependency> dependencies = FeaturePluginToMavenDependencyConverter.convert(new HashSet<>(Arrays.asList(featurePlugin))); assertThat(dependencies.size(), equalTo(1)); if (dependencies.size() == 1) { Dependency dependency = dependencies.iterator().next(); assertThat(dependency.getGroupId(), equalTo("at.bestsolution.efxclipse.eclipse")); assertThat(dependency.getArtifactId(), equalTo(FEATURE_PLUGIN_ID_NON_FX)); assertThat(dependency.getVersion(), equalTo("0.10.0")); } }
### Question: JarAccessor { static InputStream readEntry(String jarUrl, String entryName) { try { URL url = new URL(convertToJarUrl(jarUrl)); JarURLConnection jarConnection = (JarURLConnection) url.openConnection(); JarFile jarFile = jarConnection.getJarFile(); return jarFile.getInputStream(jarFile.getEntry(entryName)); } catch (IOException e) { LoggingSupport.logErrorMessage(e.getMessage(), e); } return null; } }### Answer: @Test public void testRead() { try { InputStream inputStream = JarAccessor.readEntry(JarAccessorTest.class.getResource(FEATURE_TEST_JAR).toURI().toString(), FEATURE_TEST_XML); assertNotNull(inputStream); } catch (URISyntaxException e) { e.printStackTrace(); fail(); } }
### Question: AdditionalDependencyProvider { static Set<Dependency> readAdditionalDependencies(InputStream additionalDependenciesFile) { Set<Dependency> additionalDependencies = new HashSet<>(); try (Scanner sc = new Scanner(additionalDependenciesFile)) { while (sc.hasNextLine()) { handleDependency(additionalDependencies, sc.nextLine(), additionalDependenciesFile.toString()); } } return additionalDependencies; } }### Answer: @Test public void testDependencyAdder() { InputStream resource = FeaturePluginFilter.class.getResourceAsStream(ADDITIONAL_DEPENDENCIES_FILE); Set<Dependency> dependencies = AdditionalDependencyProvider.readAdditionalDependencies(resource); assertThat(dependencies.size(), equalTo(1)); if (dependencies.size() == 1) { Dependency dependency = dependencies.iterator().next(); assertThat(dependency.getGroupId(), equalTo(GROUP_ID)); assertThat(dependency.getArtifactId(), equalTo(ARTIFACT_ID)); assertThat(dependency.getVersion(), equalTo(VERSION)); } }
### Question: FeaturePluginExtractor { static Set<IFeaturePlugin> extractFeaturePlugins(InputStream featureInputStream) { WorkspaceFeatureModel fmodel = new WorkspaceFeatureModel(new FileWrapper(featureInputStream)); fmodel.load(); Map<String, IFeaturePlugin> map = new HashMap<>(); Arrays.stream(fmodel.getFeature().getPlugins()).forEach(p -> map.put(p.getId(), p)); return new HashSet<>(map.values()); } }### Answer: @Test public void testExtractFeaturePlugins() { Set<IFeaturePlugin> featurePlugins = FeaturePluginExtractor .extractFeaturePlugins(getClass().getResourceAsStream(FEATURE_TEST_XML)); assertThat(featurePlugins.size(), equalTo(1)); if (featurePlugins.size() == 1) { IFeaturePlugin featurePlugin = featurePlugins.iterator().next(); assertThat(featurePlugin.getId(), equalTo(FEATURE_ID)); assertThat(featurePlugin.getVersion(), equalTo(FEATURE_VERSION)); } }
### Question: UpdateSiteAccessor { static String extractRelativeTargetPlatformFeatureJarUrl(InputStream siteInputStream, String urlPrefix) { WorkspaceSiteModel model = new WorkspaceSiteModel(new FileWrapper(siteInputStream)); model.load(); for (ISiteFeature f : model.getSite().getFeatures()) { if (f.getURL().startsWith(urlPrefix)) { return f.getURL(); } } return null; } }### Answer: @Test public void testExctractRelativeUrl() { String jarPath = UpdateSiteAccessor.extractRelativeTargetPlatformFeatureJarUrl(getClass().getResourceAsStream(SITE_TEST_XML), JAR_PREFIX); assertThat(jarPath, equalTo(JAR_PATH)); }
### Question: UpdateSiteAccessor { static String readRelativeTargetPlatformFeatureJarUrl(String siteUrl, String targetJarUrlPrefix, Proxy proxy) { try { URL url = new URL(siteUrl); if (proxy != null) { LoggingSupport.logInfoMessage("Using proxy (" + proxy.address() + ") for getting the targetplatform feature at URL " + siteUrl); } URLConnection connection = proxy != null ? url.openConnection(proxy) : url.openConnection(); InputStream siteInputStream = connection.getInputStream(); return extractRelativeTargetPlatformFeatureJarUrl(siteInputStream, targetJarUrlPrefix); } catch (IOException e) { LoggingSupport.logErrorMessage(e.getMessage(), e); return null; } } }### Answer: @Test public void testReadRelativeUrl() { try { URL resource = getClass().getResource(SITE_TEST_XML); String jarPath = UpdateSiteAccessor.readRelativeTargetPlatformFeatureJarUrl(resource.toURI().toString(), JAR_PREFIX, null); assertThat(jarPath, equalTo(JAR_PATH)); } catch (URISyntaxException e) { fail(e.getMessage()); } }
### Question: PomWriter { static void writePom(File file, String groupId, String artifactId, String version, Set<Dependency> dependencies) { Model model = new Model(); model.setModelVersion(MAVEN_MODEL_VERSION); model.setArtifactId(artifactId); model.setGroupId(groupId); model.setVersion(version); model.setPackaging(PACKAGING_TYPE); model.setDependencies(new ArrayList<>(dependencies)); DefaultModelWriter writer = new DefaultModelWriter(); try { writer.write(file, (Map<String, Object>) null, model); } catch (IOException e) { LoggingSupport.logErrorMessage(e.getMessage(), e); } } }### Answer: @Test public void testPomGeneration() throws IOException { File pomFile = createDestinationFile(); Set<Dependency> dependencies = generateDependencies(); PomWriter.writePom(pomFile, GROUP_ID, ARTIFACT_ID, VERSION, dependencies); Scanner scanner = new Scanner(pomFile); StringWriter writer = new StringWriter(); String generatedFileContent = scanner.useDelimiter(DELIMITER).next(); IOUtils.copy(getClass().getResourceAsStream(POM_CMP_XML), writer); String expectedFileContent = writer.toString(); scanner.close(); assertThat(generatedFileContent.replaceAll("\\s+", ""), equalTo(expectedFileContent.replaceAll("\\s+", ""))); pomFile.delete(); }
### Question: RxActivityResults { public <T> ObservableTransformer<T, ActivityResult> composer(final Intent intent) { return new ObservableTransformer<T, ActivityResult>() { @Override public ObservableSource<ActivityResult> apply(@NonNull Observable<T> upstream) { return request(upstream, intent); } }; } RxActivityResults(@NonNull Activity activity); ObservableTransformer<T, ActivityResult> composer(final Intent intent); ObservableTransformer<T, Boolean> ensureOkResult(final Intent intent); Observable<ActivityResult> start(Intent intent); void setLogging(boolean logging); }### Answer: @Test public void composer() throws Exception { Intent someIntent = new Intent(); ActivityResult testResult = new ActivityResult(Activity.RESULT_OK, Activity.RESULT_OK, someIntent); TestObserver<ActivityResult> composerTest = trigger().compose(rxActivityResults.composer(someIntent)).test(); rxActivityResults.onActivityResult(testResult.getResultCode(), someIntent); composerTest.assertNoErrors() .assertSubscribed() .assertComplete() .assertValueCount(1) .assertValue(testResult); } @Test(expected = IllegalArgumentException.class) public void requestNullIntent() throws Exception { TestObserver<ActivityResult> composerTest = trigger().compose(rxActivityResults.composer(null)).test(); composerTest.assertError(IllegalArgumentException.class) .assertSubscribed() .assertComplete() .assertValueCount(0); }
### Question: RxActivityResults { public <T> ObservableTransformer<T, Boolean> ensureOkResult(final Intent intent) { return new ObservableTransformer<T, Boolean>() { @Override public ObservableSource<Boolean> apply(@NonNull Observable<T> upstream) { return request(upstream, intent).map(new Function<ActivityResult, Boolean>() { @Override public Boolean apply(@NonNull ActivityResult activityResult) throws Exception { return activityResult.isOk(); } }); } }; } RxActivityResults(@NonNull Activity activity); ObservableTransformer<T, ActivityResult> composer(final Intent intent); ObservableTransformer<T, Boolean> ensureOkResult(final Intent intent); Observable<ActivityResult> start(Intent intent); void setLogging(boolean logging); }### Answer: @Test public void ensureOkResult() throws Exception { Intent someIntent = new Intent(); ActivityResult testResult = new ActivityResult(Activity.RESULT_OK, Activity.RESULT_OK, someIntent); TestObserver<Boolean> composerTest = trigger().compose(rxActivityResults.ensureOkResult(someIntent)).test(); rxActivityResults.onActivityResult(testResult.getResultCode(), someIntent); composerTest.assertNoErrors() .assertSubscribed() .assertComplete() .assertValueCount(1) .assertValue(testResult.isOk()); }
### Question: RxActivityResults { public Observable<ActivityResult> start(Intent intent) { return Observable.just(TRIGGER).compose(this.composer(intent)); } RxActivityResults(@NonNull Activity activity); ObservableTransformer<T, ActivityResult> composer(final Intent intent); ObservableTransformer<T, Boolean> ensureOkResult(final Intent intent); Observable<ActivityResult> start(Intent intent); void setLogging(boolean logging); }### Answer: @Test public void start() throws Exception { Intent someIntent = new Intent(); ActivityResult testResult = new ActivityResult(Activity.RESULT_OK, Activity.RESULT_OK, someIntent); TestObserver<ActivityResult> composerTest = rxActivityResults.start(someIntent).test(); rxActivityResults.onActivityResult(testResult.getResultCode(), someIntent); verify(rxActivityResults.mRxActivityResultsFragment) .onActivityResult(any(Integer.class), eq(testResult.getResultCode()), any(Intent.class)); composerTest.assertNoErrors() .assertSubscribed() .assertComplete() .assertValueCount(1) .assertValue(testResult); }
### Question: ActivityResult { @Override public boolean equals(Object obj) { if (obj instanceof ActivityResult) { if (this == obj) { return true; } ActivityResult activityResult = (ActivityResult) obj; return activityResult.data == data && activityResult.resultCode == resultCode; } else { return false; } } ActivityResult(int okResultCode, int resultCode, Intent data); Intent getData(); int getResultCode(); boolean isOk(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void equalsTrue() throws Exception { ActivityResult testResult = new ActivityResult(Activity.RESULT_OK, resultCode, intent); assertTrue(activityResult.equals(testResult)); assertTrue(activityResult.equals(activityResult)); } @Test public void equalsFalse() throws Exception { ActivityResult testResult = new ActivityResult(Activity.RESULT_OK, resultCode - 1, intent); assertFalse(activityResult.equals(testResult)); assertFalse(activityResult.equals(intent)); }
### Question: ActivityResult { public boolean isOk() { return resultCode == okResultCode; } ActivityResult(int okResultCode, int resultCode, Intent data); Intent getData(); int getResultCode(); boolean isOk(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void isOkTest() throws Exception { ActivityResult faultyResult = new ActivityResult(Activity.RESULT_OK, resultCode - 1, intent); assertFalse(faultyResult.isOk()); ActivityResult okResult = new ActivityResult(Activity.RESULT_OK, Activity.RESULT_OK, intent); assertTrue(okResult.isOk()); }
### Question: ActivityResult { @Override public String toString() { return "ActivityResult { ResultCode = " + resultCode + ", Data = " + data + " }"; } ActivityResult(int okResultCode, int resultCode, Intent data); Intent getData(); int getResultCode(); boolean isOk(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void toStringTest() throws Exception { String testResult = "ActivityResult { ResultCode" + " = " + resultCode + ", Data = " + intent + " }"; assertEquals(activityResult.toString(), testResult); }
### Question: ActivityResult { public Intent getData() { return data; } ActivityResult(int okResultCode, int resultCode, Intent data); Intent getData(); int getResultCode(); boolean isOk(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void getData() { assertEquals(activityResult.getData(), intent); }
### Question: ActivityResult { public int getResultCode() { return resultCode; } ActivityResult(int okResultCode, int resultCode, Intent data); Intent getData(); int getResultCode(); boolean isOk(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void getResultCode() { assertEquals(activityResult.getResultCode(), resultCode); }
### Question: DefaultAlertsPoliciesApi extends ApiBase implements AlertsPoliciesApi { @Override public Optional<AlertsPolicy> getByName(String alertsPolicyName) { Invocation.Builder builder = client .target(POLICIES_URL) .queryParam("filter[name]", alertsPolicyName) .request(APPLICATION_JSON_TYPE); return getPageable(builder, AlertsPolicyList.class) .filter(alertsPolicy -> alertsPolicy.getName().equals(alertsPolicyName)) .getSingle(); } DefaultAlertsPoliciesApi(NewRelicClient client); @Override Optional<AlertsPolicy> getByName(String alertsPolicyName); @Override AlertsPolicy create(AlertsPolicy policy); @Override AlertsPolicy delete(int policyId); @Override AlertsPolicyChannels updateChannels(AlertsPolicyChannels channels); }### Answer: @Test public void getByName_shouldReturnPolicy_whenClientReturnsNotUniqueResult() throws Exception { when(responseMock.readEntity(AlertsPolicyList.class)).thenReturn(new AlertsPolicyList(asList( AlertsPolicy.builder().name("policy").build(), AlertsPolicy.builder().name("policy1").build() ))); Optional<AlertsPolicy> policyOptional = testee.getByName("policy"); assertThat(policyOptional).isNotEmpty(); } @Test public void getByName_shouldNotReturnPolicy_whenClientReturnsNotMatchingResult() throws Exception { when(responseMock.readEntity(AlertsPolicyList.class)).thenReturn(new AlertsPolicyList(Collections.singletonList( AlertsPolicy.builder().name("policy1").build() ))); Optional<AlertsPolicy> policyOptional = testee.getByName("policy"); assertThat(policyOptional).isEmpty(); } @Test public void getByName_shouldNotReturnPolicy_whenClientReturnsEmptyList() throws Exception { when(responseMock.readEntity(AlertsPolicyList.class)).thenReturn(new AlertsPolicyList(Collections.emptyList())); Optional<AlertsPolicy> policyOptional = testee.getByName("policy"); assertThat(policyOptional).isEmpty(); }
### Question: DefaultApplicationsApi extends ApiBase implements ApplicationsApi { @Override public Optional<Application> getByName(String applicationName) { Invocation.Builder builder = client .target(APPLICATIONS_URL) .queryParam("filter[name]", applicationName) .request(APPLICATION_JSON_TYPE); return getPageable(builder, ApplicationList.class) .filter(application -> application.getName().equals(applicationName)) .getSingle(); } DefaultApplicationsApi(NewRelicClient client); @Override Optional<Application> getByName(String applicationName); @Override Application update(int applicationId, Application application); }### Answer: @Test public void getByName_shouldNotReturnApplication_whenClientReturnsNotMatchingResult() throws Exception { when(responseMock.readEntity(ApplicationList.class)).thenReturn(new ApplicationList(Collections.singletonList( Application.builder().name("app1").build() ))); Optional<Application> applicationOptional = testee.getByName("app"); assertThat(applicationOptional).isEmpty(); } @Test public void getByName_shouldNotReturnApplication_whenClientReturnsEmptyList() throws Exception { when(responseMock.readEntity(ApplicationList.class)).thenReturn(new ApplicationList(Collections.emptyList())); Optional<Application> applicationOptional = testee.getByName("app"); assertThat(applicationOptional).isEmpty(); } @Test public void getByName_shouldReturnApplication_whenClientReturnsNotUniqueResult() throws Exception { when(responseMock.readEntity(ApplicationList.class)).thenReturn(new ApplicationList(asList( Application.builder().name("app").build(), Application.builder().name("app1").build() ))); Optional<Application> applicationOptional = testee.getByName("app"); assertThat(applicationOptional).isNotEmpty(); }
### Question: Configurator { public void sync() { for (ApplicationConfiguration applicationConfiguration : applicationConfigurations) { applicationConfigurator.sync(applicationConfiguration); } for (PolicyConfiguration configuration : policyConfigurations) { policyConfigurator.sync(configuration); conditionConfigurator.sync(configuration); externalServiceConditionConfigurator.sync(configuration); nrqlConditionConfigurator.sync(configuration); syntheticsConditionConfigurator.sync(configuration); channelConfigurator.sync(configuration); } } Configurator(@NonNull String apiKey); Configurator(ApplicationConfigurator applicationConfigurator, PolicyConfigurator policyConfigurator, ConditionConfigurator conditionConfigurator, ExternalServiceConditionConfigurator externalServiceConditionConfigurator, NrqlConditionConfigurator nrqlConditionConfigurator, SyntheticsConditionConfigurator syntheticsConditionConfigurator, ChannelConfigurator channelConfigurator); void sync(); void setApplicationConfigurations(@NonNull Collection<ApplicationConfiguration> applicationConfigurations); void setPolicyConfigurations(@NonNull Collection<PolicyConfiguration> policyConfigurations); }### Answer: @Test public void shouldNotSynchronizeAnything_whenNoConfigurationsSet() { testee.sync(); InOrder order = inOrder(applicationConfiguratorMock, policyConfiguratorMock, conditionConfiguratorMock, externalServiceConditionConfiguratorMock, nrqlConditionConfiguratorMock, syntheticsConditionConfiguratorMock, channelConfiguratorMock); order.verifyNoMoreInteractions(); }
### Question: ApplicationConfigurator { void sync(@NonNull ApplicationConfiguration config) { LOG.info("Synchronizing application {}...", config.getApplicationName()); Application application = api.getApplicationsApi().getByName(config.getApplicationName()).orElseThrow( () -> new NewRelicSyncException(format("Application %s does not exist", config.getApplicationName()))); ApplicationSettings settings = ApplicationSettings.builder() .appApdexThreshold(config.getAppApdexThreshold()) .endUserApdexThreshold(config.getEndUserApdexThreshold()) .enableRealUserMonitoring(config.isEnableRealUserMonitoring()) .build(); Application applicationUpdate = Application.builder() .name(config.getApplicationName()) .settings(settings) .build(); api.getApplicationsApi().update(application.getId(), applicationUpdate); LOG.info("Application {} synchronized", config.getApplicationName()); } ApplicationConfigurator(@NonNull NewRelicApi api); }### Answer: @Test public void shouldThrowException_whenApplicationDoesNotExist() { when(applicationsApiMock.getByName(APPLICATION_NAME)).thenReturn(Optional.empty()); expectedException.expect(NewRelicSyncException.class); expectedException.expectMessage(format("Application %s does not exist", APPLICATION_NAME)); testee.sync(CONFIGURATION); } @Test public void shouldUpdateApplication() { when(applicationsApiMock.getByName(APPLICATION_NAME)).thenReturn(Optional.of(APPLICATION)); ApplicationSettings expectedSettings = ApplicationSettings.builder() .appApdexThreshold(APP_APDEX_THRESHOLD) .endUserApdexThreshold(USER_APDEX_THRESHOLD) .enableRealUserMonitoring(ENABLE_REAL_USER_MONITORING) .build(); Application expectedApplicationUpdate = Application.builder() .name(APPLICATION_NAME) .settings(expectedSettings) .build(); testee.sync(CONFIGURATION); verify(applicationsApiMock).update(APPLICATION.getId(), expectedApplicationUpdate); }
### Question: DefaultDashboardsApi extends ApiBase implements DashboardsApi { @Override public List<Dashboard> getByTitle(String dashboardTitle) { String dashboardTitleEncoded = UriComponent.encode(dashboardTitle, QUERY_PARAM_SPACE_ENCODED); Invocation.Builder builder = client .target(DASHBOARDS_URL) .queryParam("filter[title]", dashboardTitleEncoded) .request(APPLICATION_JSON_TYPE); return getPageable(builder, DashboardList.class) .getList(); } DefaultDashboardsApi(NewRelicClient client); @Override Dashboard getById(int dashboardId); @Override List<Dashboard> getByTitle(String dashboardTitle); @Override Dashboard create(Dashboard dashboard); @Override Dashboard update(Dashboard dashboard); @Override Dashboard delete(int dashboardId); }### Answer: @Test public void getByTitle_shouldReturnDashboards_whenClientReturnsNotUniqueResult() { when(responseMock.readEntity(DashboardList.class)).thenReturn(new DashboardList(asList( Dashboard.builder().title(DASHBOARD_FILTER_VALUE).build(), Dashboard.builder().title("dashboard1").build() ))); List<Dashboard> dashboard = testee.getByTitle(DASHBOARD_FILTER_VALUE); assertThat(dashboard).isNotEmpty(); assertThat(dashboard).hasSize(2); } @Test public void getByTitle_shouldReturnDashboard_whenClientReturnsResultContainingQueriedTitle() { when(responseMock.readEntity(DashboardList.class)).thenReturn(new DashboardList(Collections.singletonList( Dashboard.builder().title("dashboard1").build() ))); List<Dashboard> dashboard = testee.getByTitle(DASHBOARD_FILTER_VALUE); assertThat(dashboard).isNotEmpty(); } @Test public void getByTitle_shouldNotReturnDashboard_whenClientReturnsEmptyList() { when(responseMock.readEntity(DashboardList.class)).thenReturn(new DashboardList(Collections.emptyList())); List<Dashboard> dashboard = testee.getByTitle(DASHBOARD_FILTER_VALUE); assertThat(dashboard).isEmpty(); }
### Question: DefaultServersApi extends ApiBase implements ServersApi { @Override public Optional<Server> getByName(String serverName) { String serverNameEncoded = UriComponent.encode(serverName, QUERY_PARAM_SPACE_ENCODED); Invocation.Builder builder = client .target(SERVERS_URL) .queryParam("filter[name]", serverNameEncoded) .request(APPLICATION_JSON_TYPE); return getPageable(builder, ServerList.class) .filter(application -> application.getName().equals(serverName)) .getSingle(); } DefaultServersApi(NewRelicClient client); @Override Optional<Server> getByName(String serverName); @Override Server getById(int serverId); }### Answer: @Test public void getByName_shouldReturnServer_whenClientReturnsNotUniqueResult() throws Exception { when(responseMock.readEntity(ServerList.class)).thenReturn(new ServerList(asList( Server.builder().name("server").build(), Server.builder().name("server1").build() ))); Optional<Server> serverOptional = testee.getByName("server"); assertThat(serverOptional).isNotEmpty(); } @Test public void getByName_shouldNotReturnServer_whenClientReturnsNotMatchingResult() throws Exception { when(responseMock.readEntity(ServerList.class)).thenReturn(new ServerList(Collections.singletonList( Server.builder().name("server1").build() ))); Optional<Server> serverOptional = testee.getByName("server"); assertThat(serverOptional).isEmpty(); } @Test public void getByName_shouldNotReturnServer_whenClientReturnsEmptyList() throws Exception { when(responseMock.readEntity(ServerList.class)).thenReturn(new ServerList(Collections.emptyList())); Optional<Server> serverOptional = testee.getByName("server"); assertThat(serverOptional).isEmpty(); }
### Question: EmbeddedJMSBrokerHolder implements AutoCloseable, ConnectionFactoryAccessor, ActiveMQConnectionFactoryAccessor, BrokerURIAccessor { public static EmbeddedJMSBrokerHolder create(final String name, boolean marshal, boolean persistent) { final File tempDir = Files.createTempDir(); LOGGER.debug("Created temporary directory: \"{}\"", tempDir.getAbsolutePath()); return new EmbeddedJMSBrokerHolder(createAndConfigureBrokerService(new BrokerSettings(name, marshal, persistent, tempDir)), tempDir); } EmbeddedJMSBrokerHolder(final BrokerService brokerService, final File tempDir); BrokerService getBrokerService(); @Override ConnectionFactory getConnectionFactory(); @Override ActiveMQConnectionFactory getActiveMQConnectionFactory(); @Override URI getBrokerUri(); static EmbeddedJMSBrokerHolder create(final String name, boolean marshal, boolean persistent); void start(); @Override void close(); }### Answer: @DisplayName("Create EmbeddedJMSBrokerHolder instance") @Test void create() throws Exception { try (final EmbeddedJMSBrokerHolder embeddedJmsBrokerHolder = EmbeddedJMSBrokerHolder .create("name", false, false)) { assertNotNull(embeddedJmsBrokerHolder.getBrokerService()); assertFalse(embeddedJmsBrokerHolder.getBrokerService().isStarted()); } } @DisplayName("Creating a broker using an illegal URI as name should fail") @Test void createFails() { assertThrows(IllegalStateException.class, () -> EmbeddedJMSBrokerHolder .create("\\\\\\", false, false)); }
### Question: EmbeddedJmsRuleImpl implements EmbeddedJmsRule { @Override public ConnectionFactory connectionFactory() { return activeMqConnectionFactory(); } EmbeddedJmsRuleImpl(final String predefinedName, final boolean marshal, final boolean persistent); @Override ConnectionFactory connectionFactory(); @Override ActiveMQConnectionFactory activeMqConnectionFactory(); @Override URI brokerUri(); @Override Statement apply(final Statement base, final Description description); }### Answer: @Test(expected = IllegalStateException.class) public void connectionFactory() throws Exception { final EmbeddedJmsRuleImpl rule = new EmbeddedJmsRuleImpl("predefined", true, false); rule.connectionFactory(); }
### Question: EmbeddedJmsRuleImpl implements EmbeddedJmsRule { @Override public ActiveMQConnectionFactory activeMqConnectionFactory() { if (jmsBrokerHolder == null) { throw new IllegalStateException("Can not create ConnectionFactory before the broker has started"); } else { return jmsBrokerHolder.getActiveMQConnectionFactory(); } } EmbeddedJmsRuleImpl(final String predefinedName, final boolean marshal, final boolean persistent); @Override ConnectionFactory connectionFactory(); @Override ActiveMQConnectionFactory activeMqConnectionFactory(); @Override URI brokerUri(); @Override Statement apply(final Statement base, final Description description); }### Answer: @Test(expected = IllegalStateException.class) public void activeMqConnectionFactory() throws Exception { final EmbeddedJmsRuleImpl rule = new EmbeddedJmsRuleImpl("predefined", true, false); rule.activeMqConnectionFactory(); }
### Question: EmbeddedJmsRuleImpl implements EmbeddedJmsRule { @Override public URI brokerUri() { if (jmsBrokerHolder == null) { throw new IllegalStateException("Can not create broker URI before the broker has started"); } else { return jmsBrokerHolder.getBrokerUri(); } } EmbeddedJmsRuleImpl(final String predefinedName, final boolean marshal, final boolean persistent); @Override ConnectionFactory connectionFactory(); @Override ActiveMQConnectionFactory activeMqConnectionFactory(); @Override URI brokerUri(); @Override Statement apply(final Statement base, final Description description); }### Answer: @Test(expected = IllegalStateException.class) public void brokerUri() throws Exception { final EmbeddedJmsRuleImpl rule = new EmbeddedJmsRuleImpl("predefined", true, false); rule.brokerUri(); }
### Question: BrokerConfiguration { @Override public int hashCode() { return Objects.hash(name, marshal, persistenceEnabled); } BrokerConfiguration(final String name, final Boolean marshal, final Boolean persistenceEnabled); String getName(); Boolean getMarshal(); Boolean getPersistenceEnabled(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); static final BrokerConfiguration DEFAULT; }### Answer: @Test void testHashCode() { assertEquals(BrokerConfigurationBuilder.instance().build().hashCode(), BrokerConfigurationBuilder.instance().build().hashCode()); }
### Question: BrokerConfiguration { @Override public String toString() { final StringBuilder sb = new StringBuilder("BrokerConfiguration{"); sb.append("name='").append(name).append('\''); sb.append(", marshal=").append(marshal); sb.append(", persistenceEnabled=").append(persistenceEnabled); sb.append('}'); return sb.toString(); } BrokerConfiguration(final String name, final Boolean marshal, final Boolean persistenceEnabled); String getName(); Boolean getMarshal(); Boolean getPersistenceEnabled(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); static final BrokerConfiguration DEFAULT; }### Answer: @Test void testToString() { assertEquals(BrokerConfigurationBuilder.instance().build().toString(), BrokerConfigurationBuilder.instance().build().toString()); }
### Question: ZeebeExpressionResolver implements BeanFactoryAware { @SuppressWarnings("unchecked") public <T> T resolve(final String value) { final String resolvedValue = resolve.apply(value); if (!(resolvedValue.startsWith("#{") && value.endsWith("}"))) { return (T) resolvedValue; } return (T) this.resolver.evaluate(resolvedValue, this.expressionContext); } @Override void setBeanFactory(final BeanFactory beanFactory); @SuppressWarnings("unchecked") T resolve(final String value); }### Answer: @Test public void resolveNetworkClientPort() throws Exception { final String port = resolver.resolve("${zeebe.network.client.port}"); assertThat(port).isEqualTo("123"); } @Test public void useValueIfNoExpression() throws Exception { final String normalString = resolver.resolve("normalString"); assertThat(normalString).isEqualTo("normalString"); }
### Question: AbstractBFInclusionOracle extends AbstractBFOracle<A, I, D> implements InclusionOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { return super.findCounterExample(hypothesis, inputs); } AbstractBFInclusionOracle(MembershipOracle<I, D> membershipOracle, double multiplier); @Override boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, D output); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testFindCounterExample() { final DefaultQuery<Character, D> cex = bfio.findCounterExample(automaton, ALPHABET); Assert.assertEquals(cex, query); }
### Question: CExFirstOracle implements BlackBoxOracle<A, I, D> { @Override public List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles() { return propertyOracles; } CExFirstOracle(); CExFirstOracle(PropertyOracle<I, A, ?, D> propertyOracle); CExFirstOracle(Collection<? extends PropertyOracle<I, ? super A, ?, D>> propertyOracles); @Override List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles(); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testGetPropertyOracles() { Assert.assertEquals(oracle.getPropertyOracles().size(), 2); }
### Question: CExFirstOracle implements BlackBoxOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { for (PropertyOracle<I, ? super A, ?, D> propertyOracle : propertyOracles) { final DefaultQuery<I, D> result = propertyOracle.findCounterExample(hypothesis, inputs); if (result != null) { assert isCounterExample(hypothesis, result.getInput(), result.getOutput()); return result; } } return null; } CExFirstOracle(); CExFirstOracle(PropertyOracle<I, A, ?, D> propertyOracle); CExFirstOracle(Collection<? extends PropertyOracle<I, ? super A, ?, D>> propertyOracles); @Override List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles(); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testFindCounterExample() { final DefaultQuery<Boolean, Boolean> ce = oracle.findCounterExample(automaton, inputs); Assert.assertEquals(ce, query); Mockito.verify(po1).disprove(automaton, inputs); Mockito.verify(po2, Mockito.never()).disprove(automaton, inputs); Mockito.verify(po2, Mockito.never()).findCounterExample(automaton, inputs); }
### Question: RandomWalkEQOracle implements MealyEquivalenceOracle<I, O> { @Override public @Nullable DefaultQuery<I, Word<O>> findCounterExample(MealyMachine<?, I, ?, O> hypothesis, Collection<? extends I> inputs) { return doFindCounterExample(hypothesis, inputs); } RandomWalkEQOracle(SUL<I, O> sul, double restartProbability, long maxSteps, boolean resetStepCount, Random random); RandomWalkEQOracle(SUL<I, O> sul, double restartProbability, long maxSteps, Random random); @Override @Nullable DefaultQuery<I, Word<O>> findCounterExample(MealyMachine<?, I, ?, O> hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testOracle() { final DummySUL dummySUL = new DummySUL(); final MealyEquivalenceOracle<Character, Character> mOracle = new RandomWalkEQOracle<>(dummySUL, 0.01, MAX_LENGTH, new Random(42)); final DefaultQuery<Character, Word<Character>> ce = mOracle.findCounterExample(new DummyMealy(ALPHABET), ALPHABET); Assert.assertNull(ce); Assert.assertTrue(dummySUL.isCalledPost()); }
### Question: SimulatorOracle implements SingleQueryOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { MQUtil.answerQueries(this, queries); } SimulatorOracle(SuffixOutput<I, D> automaton); @Override D answerQuery(Word<I> prefix, Word<I> suffix); @Override void processQueries(Collection<? extends Query<I, D>> queries); }### Answer: @Test public void testDFASimulatorOracle() { DFA<?, Symbol> dfa = ExamplePaulAndMary.constructMachine(); SimulatorOracle<Symbol, Boolean> oracle = new SimulatorOracle<>(dfa); List<DefaultQuery<Symbol, Boolean>> queries = new ArrayList<>(); DefaultQuery<Symbol, Boolean> q1 = new DefaultQuery<>(Word.fromSymbols(ExamplePaulAndMary.IN_PAUL, ExamplePaulAndMary.IN_LOVES, ExamplePaulAndMary.IN_MARY)); DefaultQuery<Symbol, Boolean> q2 = new DefaultQuery<>(Word.fromSymbols(ExamplePaulAndMary.IN_MARY, ExamplePaulAndMary.IN_LOVES, ExamplePaulAndMary.IN_PAUL)); queries.add(q1); queries.add(q2); Assert.assertEquals(queries.get(0).getInput().size(), 3); Assert.assertEquals(queries.get(1).getInput().size(), 3); oracle.processQueries(queries); Assert.assertEquals(queries.get(0).getOutput(), Boolean.TRUE); Assert.assertEquals(queries.get(1).getOutput(), Boolean.FALSE); }
### Question: StaticParallelOmegaOracle extends AbstractStaticBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } StaticParallelOmegaOracle(Collection<? extends OmegaMembershipOracle<S, I, D>> oracles, @NonNegative int minBatchSize, PoolPolicy policy); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }### Answer: @Test public void testSingleMethods() { final ParallelOmegaOracle<?, Integer, TestOutput> oracle = getBuilder().create(); Assert.assertThrows(OmegaException.class, oracle::getMembershipOracle); Assert.assertThrows(OmegaException.class, () -> oracle.isSameState(null, null, null, null)); }
### Question: DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } DynamicParallelOmegaOracle(Supplier<? extends OmegaMembershipOracle<S, I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }### Answer: @Test public void testSingleMethods() { final ParallelOmegaOracle<?, Void, Void> oracle = getBuilder().create(); Assert.assertThrows(OmegaException.class, oracle::getMembershipOracle); Assert.assertThrows(OmegaException.class, () -> oracle.isSameState(null, null, null, null)); }
### Question: HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }### Answer: @Test(dependsOnMethods = "testInitialState") public void testFirstQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2); oracle.processQueries(queries); verifyCounts(2, 0, 0, 0); } @Test(dependsOnMethods = "testFirstQueryBatch") public void testEmptyQueryBatch() { Collection<Query<Integer, Word<Character>>> noQueries = Collections.emptySet(); oracle.processQueries(noQueries); verifyCounts(2, 0, 0, 0); } @Test(dependsOnMethods = "testEmptyQueryBatch") public void testSecondQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2, 5, TestQueries.INPUTS); oracle.processQueries(queries); verifyCounts(4, 10, 2.5, 0); }
### Question: HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }### Answer: @Test(dependsOnMethods = "testSecondQueryBatch") public void testSummary() throws IOException { final String details = oracle.getStatisticalData().getDetails(); final String summary = oracle.getStatisticalData().getSummary(); try (InputStream detailStream = HistogramOracleTest.class.getResourceAsStream("/histogram_details.txt"); InputStream summaryStream = HistogramOracleTest.class.getResourceAsStream("/histogram_summary.txt")) { final String expectedDetail = CharStreams.toString(IOUtil.asBufferedUTF8Reader(detailStream)); final String expectedSummary = CharStreams.toString(IOUtil.asBufferedUTF8Reader(summaryStream)); Assert.assertEquals(details, expectedDetail); Assert.assertEquals(summary, expectedSummary); } } @Test public void testGetName() { Assert.assertEquals(oracle.getStatisticalData().getName(), COUNTER_NAME); }
### Question: SuffixASCIIWriter extends AbstractObservationTableWriter<I, D> { @Override public void write(ObservationTable<? extends I, ? extends D> table, Appendable out) throws IOException { List<? extends Word<? extends I>> suffixes = table.getSuffixes(); StringBuilder sb = new StringBuilder(); boolean first = true; for (Word<? extends I> word : suffixes) { if (first) { first = false; } else { sb.append(WORD_DELIMITER); } String stringRepresentation = wordToString(word); if (stringRepresentation.contains(WORD_DELIMITER)) { throw new IllegalArgumentException( "Delimiter '" + WORD_DELIMITER + "' must not be used in symbol names. " + "Symbol containing the delimiter was '" + stringRepresentation + '\''); } else { sb.append(stringRepresentation); } } out.append(sb.toString()); } SuffixASCIIWriter(); @Override void write(ObservationTable<? extends I, ? extends D> table, Appendable out); }### Answer: @Test public void testWrite() { SuffixASCIIWriter<String, String> writer = new SuffixASCIIWriter<>(); ObservationTable<String, String> ot = ObservationTableSource.otWithFourSuffixes(); Assert.assertEquals(OTUtils.toString(ot, writer), ";A;B;A,B"); }
### Question: CounterOracle implements StatisticOracle<I, D> { public long getCount() { return counter.getCount(); } CounterOracle(MembershipOracle<I, D> nextOracle, String name); @Override void processQueries(Collection<? extends Query<I, D>> queries); @Override Counter getStatisticalData(); Counter getCounter(); long getCount(); @Override void setNext(MembershipOracle<I, D> next); }### Answer: @Test public void testInitialState() { Assert.assertEquals(oracle.getCount(), 0L); }
### Question: CounterOracle implements StatisticOracle<I, D> { public Counter getCounter() { return this.counter; } CounterOracle(MembershipOracle<I, D> nextOracle, String name); @Override void processQueries(Collection<? extends Query<I, D>> queries); @Override Counter getStatisticalData(); Counter getCounter(); long getCount(); @Override void setNext(MembershipOracle<I, D> next); }### Answer: @Test public void testGetName() { Assert.assertEquals(oracle.getCounter().getName(), COUNTER_NAME); }
### Question: JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } JointCounterOracle(MembershipOracle<I, D> delegate); @Override void processQueries(Collection<? extends Query<I, D>> queries); long getQueryCount(); long getSymbolCount(); }### Answer: @Test(dependsOnMethods = "testInitialState") public void testFirstQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2); oracle.processQueries(queries); verifyCounts(2, 0); } @Test(dependsOnMethods = "testFirstQueryBatch") public void testEmptyQueryBatch() { Collection<Query<Integer, Word<Character>>> noQueries = Collections.emptySet(); oracle.processQueries(noQueries); verifyCounts(2, 0); } @Test(dependsOnMethods = "testEmptyQueryBatch") public void testSecondQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2, 5, TestQueries.INPUTS); oracle.processQueries(queries); verifyCounts(4, 10); }

Subsets and Splits