How to use

hasSize

method

in

org.assertj.core.api.AbstractStringAssert

@Property
void createdSequencesDoTheirWork(@ForAll("xOrY") @Size(min = 2) ActionSequence<String> sequence) {
  String result = sequence.run("");
  Assertions.assertThat(sequence.runActions().size()).isGreaterThanOrEqualTo(2);
  Assertions.assertThat(result).hasSize(sequence.runActions().size());
  Assertions.assertThat(result.contains("x") || result.contains("y")).isTrue();
}

@Test
void testLimitStringValueLength() throws IOException {
  StringBuilder longValue = new StringBuilder(DslJsonSerializer.MAX_VALUE_LENGTH + 1);
  for (int i = 0; i < DslJsonSerializer.MAX_VALUE_LENGTH + 1; i++) {
    longValue.append('0');
  }
  StringBuilder longStringValue = new StringBuilder(DslJsonSerializer.MAX_LONG_STRING_VALUE_LENGTH + 1);
  for (int i = 0; i < DslJsonSerializer.MAX_LONG_STRING_VALUE_LENGTH + 1; i++) {
    longStringValue.append('0');
  }
  serializer.jw.writeByte(JsonWriter.OBJECT_START);
  serializer.writeField("string", longValue.toString());
  serializer.writeField("stringBuilder", longValue);
  serializer.writeLongStringField("longString", longStringValue.toString());
  serializer.writeLastField("lastString", longValue.toString());
  serializer.jw.writeByte(JsonWriter.OBJECT_END);
  final JsonNode jsonNode = objectMapper.readTree(serializer.jw.toString());
  assertThat(jsonNode.get("stringBuilder").textValue()).hasSize(DslJsonSerializer.MAX_VALUE_LENGTH).endsWith("…");
  assertThat(jsonNode.get("string").textValue()).hasSize(DslJsonSerializer.MAX_VALUE_LENGTH).endsWith("…");
  assertThat(jsonNode.get("longString").textValue()).hasSize(DslJsonSerializer.MAX_LONG_STRING_VALUE_LENGTH).endsWith("…");
  assertThat(jsonNode.get("lastString").textValue()).hasSize(DslJsonSerializer.MAX_VALUE_LENGTH).endsWith("…");
}

@Example
void longString() {
  List<Shrinkable<Character>> elementShrinkables =
    IntStream.range(0, 1000) //
         .mapToObj(aChar -> new OneStepShrinkable(aChar, 0)) //
         .map(shrinkableInt -> shrinkableInt.map(anInt -> (char) (int) anInt)) //
         .collect(Collectors.toList());
  Shrinkable<String> shrinkable = new ShrinkableString(elementShrinkables, 5);
  ShrinkingSequence<String> sequence = shrinkable.shrink(String::isEmpty);
  while (sequence.next(count, reporter));
  assertThat(sequence.current().value()).hasSize(5);
  assertThat(counter.get()).isEqualTo(21);
}

@Test
void outgoingHeaderRootSpan() {
  final TraceContext traceContext = TraceContext.with64BitId(mock(ElasticApmTracer.class));
  traceContext.asRootSpan(ConstantSampler.of(true));
  assertThat(traceContext.isSampled()).isTrue();
  assertThat(traceContext.getOutgoingTraceParentHeader().toString()).hasSize(55);
  assertThat(traceContext.getOutgoingTraceParentHeader().toString()).startsWith("00-");
  assertThat(traceContext.getOutgoingTraceParentHeader().toString()).endsWith("-01");
}

@Property(tries = 20)
@Domain(NumberStringContext.class)
void onlyUseProvidersFromDeclaredDomain(@ForAll String aString) {
  assertThat(aString).hasSize(2);
  assertThat(aString).containsOnlyDigits();
}

@Property
void preconditionsAreConsidered(@ForAll("xOrZ") ActionSequence<String> actions) {
  String result = actions.run("");
  Assertions.assertThat(result).hasSize(actions.runActions().size());
  Assertions.assertThat(result).contains("x");
  Assertions.assertThat(result).doesNotContain("z");
}

@Property(tries = 20)
@Domain(NumberStringContext.class)
void applyConfiguratorsFromDeclaredDomain(@ForAll @DoubleString String aString) {
  assertThat(aString).hasSize(4);
  assertThat(aString).containsOnlyDigits();
}

@Property(tries = 50)
void shrinkingEmbeddedShrinkable(@ForAll long seed) {
  //noinspection unchecked
  Mockito.reset(valueReporter);
  counter.set(0);
  Shrinkable<Integer> integerShrinkable = new OneStepShrinkable(4);
  Function<Integer, Arbitrary<String>> flatMapper = anInt -> Arbitraries.strings().alpha().ofLength(anInt);
  Shrinkable<String> shrinkable = integerShrinkable.flatMap(flatMapper, 1000, seed);
  ShrinkingSequence<String> sequence = shrinkable.shrink(ignore -> false);
  assertThat(sequence.next(count, reporter)).isTrue();
  assertThat(sequence.current().value()).hasSize(3);
  verify(valueReporter).accept(ArgumentMatchers.argThat(aString -> aString.length() == 3));
  assertThat(sequence.next(count, reporter)).isTrue();
  assertThat(sequence.current().value()).hasSize(2);
  verify(valueReporter).accept(ArgumentMatchers.argThat(aString -> aString.length() == 2));
  assertThat(sequence.next(count, reporter)).isTrue();
  assertThat(sequence.current().value()).hasSize(1);
  verify(valueReporter).accept(ArgumentMatchers.argThat(aString -> aString.length() == 1));
  assertThat(sequence.next(count, reporter)).isTrue();
  assertThat(sequence.current().value()).hasSize(0);
  verify(valueReporter).accept(ArgumentMatchers.argThat(aString -> aString.length() == 0));
  assertThat(counter.get()).isEqualTo(4);
}

@Example
void flatMapIntegerToString() {
  Arbitrary<Integer> arbitrary = Arbitraries.samples(1, 2, 3, 4, 5);
  Arbitrary<String> mapped = arbitrary.flatMap(anInt -> Arbitraries.strings() //
      .withCharRange('a', 'e') //
      .ofMinLength(anInt).ofMaxLength(anInt));
  RandomGenerator<String> generator = mapped.generator(10);
  assertThat(generator.next(random).value()).hasSize(1);
  assertThat(generator.next(random).value()).hasSize(2);
  assertThat(generator.next(random).value()).hasSize(3);
  assertThat(generator.next(random).value()).hasSize(4);
  assertThat(generator.next(random).value()).hasSize(5);
  ArbitraryTestHelper.assertAtLeastOneGenerated(generator, s -> s.startsWith("a"));
  ArbitraryTestHelper.assertAtLeastOneGenerated(generator, s -> s.startsWith("b"));
  ArbitraryTestHelper.assertAtLeastOneGenerated(generator, s -> s.startsWith("c"));
  ArbitraryTestHelper.assertAtLeastOneGenerated(generator, s -> s.startsWith("d"));
  ArbitraryTestHelper.assertAtLeastOneGenerated(generator, s -> s.startsWith("e"));
}

@Property(tries = 20)
@Domain(DomainContext.Global.class)
@Domain(SmallNumbersContext.class)
void globalContextCanBeMixedIn(
  @ForAll @StringLength(5) @LowerChars String aString,
  @ForAll int smallNumber
) {
  assertThat(aString).hasSize(5);
  assertThat(aString.chars()).allSatisfy(Character::isLowerCase);
  assertThat(smallNumber).isBetween(1, 99);
}

@Property(tries = 20)
@Domain(NumberStringContext.class)
@Domain(SmallNumbersContext.class)
void severalDomainsAreConcatenated(
  @ForAll @DoubleString String aString,
  @ForAll int smallNumber,
  @ForAll @DoubleNumber int doubledNumber
) {
  assertThat(aString).hasSize(4);
  assertThat(aString).containsOnlyDigits();
  assertThat(smallNumber).isBetween(1, 99);
  assertThat(doubledNumber).isBetween(2, 198);
}

@Example
void alsoShrinkResultOfArbitraryEvaluation(@ForAll long seed) {
  Shrinkable<Integer> integerShrinkable = new OneStepShrinkable(4);
  Function<Integer, Arbitrary<String>> flatMapper = anInt -> Arbitraries.strings().withCharRange('a', 'z').ofLength(anInt);
  Shrinkable<String> shrinkable = integerShrinkable.flatMap(flatMapper, 1000, seed);
  assertThat(shrinkable.value()).hasSize(4);
  ShrinkingSequence<String> sequence = shrinkable.shrink(aString -> aString.length() < 3);
  while(sequence.next(count, reporter));
  assertThat(sequence.current().value()).isEqualTo("aaa");
}

@Example
void creation(@ForAll long seed) {
  Shrinkable<Integer> integerShrinkable = new OneStepShrinkable(3);
  Function<Integer, Arbitrary<String>> flatMapper = anInt -> Arbitraries.strings().alpha().ofLength(anInt);
  Shrinkable<String> shrinkable = integerShrinkable.flatMap(flatMapper, 1000, seed);
  assertThat(shrinkable.distance().dimensions()).startsWith(ShrinkingDistance.of(3), ShrinkingDistance.of(3));
  assertThat(shrinkable.value()).hasSize(3);
}