PrintablePredicateFactory.java

package com.github.valid8j.pcond.core.printable;

import com.github.valid8j.pcond.core.Evaluable;
import com.github.valid8j.pcond.core.Evaluator;
import com.github.valid8j.pcond.core.identifieable.Identifiable;
import com.github.valid8j.pcond.experimentals.currying.context.CurriedContext;
import com.github.valid8j.pcond.internals.InternalUtils;
import com.github.valid8j.pcond.forms.Predicates;

import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

import static java.lang.String.format;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
import static java.util.Collections.singletonList;
import static java.util.Objects.requireNonNull;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

public enum PrintablePredicateFactory {
  NEGATION,
  CONJUNCTION,
  DISJUNCTION,
  LEAF,
  ;

  private static <T> PrintablePredicate<T> toPrintablePredicateIfNotPrintable(Predicate<T> predicate) {
    return (PrintablePredicate<T>) toLeafIfNotPrintable(predicate);
  }

  public static <T> Predicate<T> toLeafIfNotPrintable(Predicate<T> predicate) {
    if (!(predicate instanceof PrintablePredicate))
      return leaf(Identifiable.formatObjectName(predicate), predicate);
    return predicate;
  }

  public static <T> Predicate<T> leaf(String name, Predicate<T> predicate) {
    return leaf(() -> name, predicate);
  }

  public static <T> Predicate<T> leaf(Supplier<String> formatter, Predicate<T> predicate) {
    return leaf(formatter, predicate, PrintablePredicateFactory.class);
  }

  public static <T> Predicate<T> leaf(Supplier<String> formatter, Predicate<T> predicate, Object fallbackCreator) {
    return parameterizedLeaf(
        (args) -> formatter,
        (args) -> predicate,
        emptyList(),
        fallbackCreator);
  }

  public static <T> Predicate<T> parameterizedLeaf(
      Function<List<Object>, Supplier<String>> formatterFactory,
      Function<List<Object>, Predicate<T>> predicateFactory,
      List<Object> args,
      Object fallbackCreator
  ) {
    Supplier<String> formatter = formatterFactory.apply(args);
    Predicate<T> predicate = predicateFactory.apply(args);
    return Identifiable.creatorOf(predicate)
        .map(c -> new LeafPredicate<>(c, Identifiable.argsOf(predicate), formatter, predicate))
        .orElse(new LeafPredicate<>(fallbackCreator, args, formatter, predicate));
  }

  public static <P, O> TransformingPredicate.Factory<P, O> transform(Function<O, P> function) {
    return TransformingPredicate.Factory.create(function);
  }

  public static <T> Conjunction<T> and(List<Predicate<? super T>> predicates) {
    return new Conjunction<T>(predicates, true);
  }

  public static <T> Disjunction<T> or(List<Predicate<? super T>> predicates) {
    return new Disjunction<T>(predicates, true);
  }

  public static <T> Conjunction<T> allOf(List<Predicate<? super T>> predicates) {
    return new Conjunction<T>(predicates, false);
  }

  public static <T> Disjunction<T> anyOf(List<Predicate<? super T>> predicates) {
    return new Disjunction<T>(predicates, false);
  }

  public static <T> Predicate<T> not(Predicate<T> predicate) {
    return not_(predicate);
  }

  @SuppressWarnings("ClassEscapesDefinedScope")
  public static <T> Negation<T> not_(Predicate<T> predicate) {
    return new Negation<T>(toPrintablePredicateIfNotPrintable(predicate), singletonList(predicate));
  }

  public static <E> Predicate<Stream<E>> allMatch(Predicate<E> predicate) {
    return AllMatch.create(predicate);
  }

  public static <E> Predicate<Stream<E>> noneMatch(Predicate<E> predicate) {
    return NoneMatch.create(predicate);
  }

  public static <E> Predicate<Stream<E>> anyMatch(Predicate<E> predicate) {
    return AnyMatch.create(predicate);
  }

  public static <T> Predicate<CurriedContext> variableBundlePredicate(Predicate<T> predicate, int argIndex) {
    return CurriedContextPredicate.create(toPrintablePredicateIfNotPrintable(predicate), argIndex);
  }

  private static RuntimeException noPredicateGiven() {
    throw new IllegalArgumentException("No predicate was given");
  }

  /*
      Expected: "100 -> &&                                     ->   false"
       but: was "100 -> &&                                            ->   false"
   */
  public enum Leaf {
    ALWAYS_TRUE("alwaysTrue", v -> true),
    IS_TRUE("isTrue", (Boolean v) -> v),
    IS_FALSE("isFalse", (Boolean v) -> !v),
    IS_NULL("isNull", Objects::isNull),
    IS_NOT_NULL("isNotNull", Objects::nonNull),
    IS_EMPTY_STRING("isEmpty", v -> ((String) v).isEmpty()),
    IS_NULL_OR_EMPTY_STRING("isNullOrEmptyString", v -> v == null || ((String) v).isEmpty()),
    IS_EMPTY_ARRAY("isEmptyArray", objects -> ((Object[]) objects).length == 0),
    IS_EMPTY_COLLECTION("isEmpty", v -> ((Collection<?>) v).isEmpty()),
    ;
    final Predicate<?> instance;

    @SuppressWarnings("unchecked")
    Leaf(String s, Predicate<?> predicate) {
      this.instance = leaf(() -> s, (Predicate<? super Object>) predicate, this);
    }

    @SuppressWarnings("unchecked")
    public <T> Predicate<T> instance() {
      return (Predicate<T>) this.instance;
    }
  }

  public enum ParameterizedLeafFactory {
    IS_EQUAL_TO(
        (args) -> () -> format("isEqualTo[%s]", args.get(0)),
        (args) -> v -> Objects.equals(v, args.get(0))),
    @SuppressWarnings("unchecked") GREATER_THAN(
        (args) -> () -> format(">[%s]", args.get(0)),
        (args) -> v -> ((Comparable<? super Comparable<?>>) v).compareTo((Comparable<? super Comparable<?>>) args.get(0)) > 0),
    @SuppressWarnings("unchecked") GREATER_THAN_OR_EQUAL_TO(
        (args) -> () -> format(">=[%s]", args.get(0)),
        (args) -> v -> ((Comparable<? super Comparable<?>>) v).compareTo((Comparable<? super Comparable<?>>) args.get(0)) >= 0),
    @SuppressWarnings("unchecked") LESS_THAN_OR_EQUAL_TO(
        (args) -> () -> format("<=[%s]", args.get(0)),
        (args) -> v -> ((Comparable<? super Comparable<?>>) v).compareTo((Comparable<? super Comparable<?>>) args.get(0)) <= 0),
    @SuppressWarnings("unchecked") LESS_THAN(
        (args) -> () -> format("<[%s]", args.get(0)),
        (args) -> v -> ((Comparable<? super Comparable<?>>) v).compareTo((Comparable<? super Comparable<?>>) args.get(0)) < 0),
    @SuppressWarnings("unchecked") EQUAL_TO(
        (args) -> () -> format("=[%s]", args.get(0)),
        (args) -> v -> ((Comparable<? super Comparable<?>>) v).compareTo((Comparable<? super Comparable<?>>) args.get(0)) == 0),
    MATCHES_REGEX(
        (args) -> () -> String.format("matchesRegex[%s]", args.get(0)),
        (args) -> (s) -> ((String) s).matches((String) args.get(0))),
    CONTAINS_STRING(
        (args) -> () -> format("containsString[%s]", args.get(0)),
        (args) -> (s) -> ((String) s).contains((String) args.get(0))),
    STARTS_WITH(
        (args) -> () -> format("startsWith[%s]", args.get(0)),
        (args) -> (s) -> ((String) s).startsWith((String) args.get(0))),
    ENDS_WITH(
        (args) -> () -> format("endsWith[%s]", args.get(0)),
        (args) -> (s) -> ((String) s).endsWith((String) args.get(0))),
    EQUALS_IGNORE_CASE(
        (args) -> () -> format("equalsIgnoreCase[%s]", args.get(0)),
        (args) -> (s) -> {
          return ((String) s).equalsIgnoreCase((String) args.get(0));
        }),
    OBJECT_IS_SAME_AS(
        arg -> () -> format("==[%s]", arg.get(0)),
        args -> v -> v == args.get(0)),
    CONTAINS(
        (args) -> () -> format("contains[%s]", args.get(0)),
        (args) -> (c) -> ((Collection<?>) c).contains(args.get(0)));
    private final Function<List<Object>, Predicate<Object>> predicateFactory;
    private final Function<List<Object>, Supplier<String>>  formatterFactory;

    ParameterizedLeafFactory(Function<List<Object>, Supplier<String>> formatterFactory, Function<List<Object>, Predicate<Object>> predicateFactory) {
      this.predicateFactory = predicateFactory;
      this.formatterFactory = formatterFactory;
    }

    Function<List<Object>, Supplier<String>> formatterFactory() {
      return this.formatterFactory;
    }

    @SuppressWarnings({ "unchecked", "rawtypes" })
    <T> Function<List<Object>, Predicate<T>> functionFactory() {
      return (Function) this.predicateFactory;
    }

    public static <T> Predicate<T> create(ParameterizedLeafFactory parameterizedLeafFactory, List<Object> args) {
      return parameterizedLeaf(
          parameterizedLeafFactory.formatterFactory(), parameterizedLeafFactory.functionFactory(), args, parameterizedLeafFactory
      );
    }
  }

  private static class LeafPredicate<T> extends PrintablePredicate<T> implements Evaluable.LeafPred<T>, Evaluator.Explainable {
    protected LeafPredicate(Object creator, List<Object> args, Supplier<String> formatter, Predicate<? super T> predicate) {
      super(creator, args, formatter, predicate);
    }

    @Override
    public Predicate<? super T> predicate() {
      return predicate;
    }

    @Override
    public Object explainOutputExpectation() {
      return this.formatter.get();
    }

    @Override
    public Object explainActual(Object actualValue) {
      return actualValue;
    }

    @Override
    public String toString() {
      return InternalUtils.formatObject(InternalUtils.toNonStringObject(this.formatter.get()));
    }
  }

  static class Negation<T> extends PrintablePredicate<T> implements Evaluable.Negation<T> {
    final Evaluable<T> target;

    @SuppressWarnings("unchecked")
    protected Negation(Predicate<T> predicate, List<Object> args) {
      super(
          NEGATION,
          args,
          () -> format("!%s", predicate),
          (t) -> PrintablePredicate.unwrap((Predicate<Object>) predicate).negate().test(t));
      this.target = (Evaluable<T>) InternalUtils.toEvaluableIfNecessary(predicate);
      this.squashable = true;
    }

    @Override
    public Evaluable<T> target() {
      return target;
    }
  }

  public static class Conjunction<T> extends Junction<T> implements Evaluable.Conjunction<T> {
    protected Conjunction(List<Predicate<? super T>> predicates, boolean shortcut) {
      super(
          predicates,
          CONJUNCTION,
          "&&",
          Predicate::and,
          shortcut);
    }
  }

  public static class Disjunction<T> extends Junction<T> implements Evaluable.Disjunction<T> {
    protected Disjunction(List<Predicate<? super T>> predicates, boolean shortcut) {
      super(
          predicates,
          DISJUNCTION,
          "||",
          Predicate::or,
          shortcut);
    }
  }

  abstract static class Junction<T> extends PrintablePredicate<T> implements Evaluable.Composite<T> {
    final         List<Evaluable<T>> children;
    final private boolean            shortcut;

    @SuppressWarnings("unchecked")
    protected Junction(
        List<Predicate<? super T>> predicates,
        PrintablePredicateFactory creator,
        String junctionSymbol,
        BinaryOperator<Predicate<T>> junctionOp, boolean shortcut) {
      super(
          creator,
          new ArrayList<>(predicates),
          () -> formatJunction(predicates, junctionSymbol),
          junction(predicates, junctionOp));
      this.children = predicates.stream()
          .map(InternalUtils::toEvaluableIfNecessary)
          .map(each -> (Evaluable<T>) each)
          .collect(toList());
      this.shortcut = shortcut;
    }

    @Override
    public List<Evaluable<T>> children() {
      return this.children;
    }

    @Override
    public boolean shortcut() {
      return this.shortcut;
    }

    public List<Predicate<T>> childPredicates() {
      return childrenOfJunction(this);
    }

    static <T> String formatJunction(List<Predicate<? super T>> predicates, String junctionSymbol) {
      return predicates.stream()
          .map(PrintablePredicateFactory::toPrintablePredicateIfNotPrintable)
          .map(Object::toString)
          .collect(joining(junctionSymbol, "(", ")"));
    }

    @SuppressWarnings("unchecked")
    static <T> Predicate<T> junction(List<Predicate<? super T>> predicates_, BinaryOperator<Predicate<T>> junctionOp) {
      return predicates_
          .stream()
          .map(PrintablePredicate::unwrap)
          .map(p -> (Predicate<T>) p)
          .reduce(junctionOp)
          .orElseThrow(PrintablePredicateFactory::noPredicateGiven);
    }

    static <T> List<Predicate<T>> childrenOfJunction(Junction<T> junction) {
      return evaluablesToPredicates(junction.children);
    }

    @SuppressWarnings("unchecked")
    private static <T> List<Predicate<T>> evaluablesToPredicates(List<Evaluable<T>> evaluables) {
      return evaluables.stream()
          .peek(each -> {
            assert each instanceof Predicate;
          })
          .map(each -> (Predicate<T>) each)
          .collect(toList());
    }
  }

  /**
   * This is an interface that corresponds to a "matcher" in other assertion
   * libraries.
   */
  public static class TransformingPredicate<T, R> extends PrintablePredicate<T> implements Evaluable.Transformation<T, R> {
    private final Evaluable<? super T> mapper;
    private final Evaluable<? super R> checker;
    private final String               mapperName;
    private final String               checkerName;

    @SuppressWarnings("unchecked")
    public TransformingPredicate(String mapperName, String checkerName, Predicate<? super R> predicate, Function<? super T, ? extends R> function) {
      super(
          TransformingPredicate.class,
          asList(predicate, function),
          () -> mapperName == null ?
              format("%s %s", function, checkerName == null ? predicate : (checkerName + ":" + predicate.toString())) :
              format("%s(%s %s)", mapperName, function, checkerName == null ? predicate : checkerName + ":" + predicate.toString()),
          v -> predicate.test(function.apply(v)));
      this.mapper = (Evaluable<? super T>) InternalUtils.toEvaluableIfNecessary(function);
      this.mapperName = mapperName;
      this.checker = (Evaluable<? super R>) InternalUtils.toEvaluableIfNecessary(predicate);
      this.checkerName = checkerName;
      this.squashable = true;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Evaluable<T> mapper() {
      return (Evaluable<T>) this.mapper;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Evaluable<R> checker() {
      return (Evaluable<R>) this.checker;
    }

    @Override
    public Optional<String> mapperName() {
      return Optional.ofNullable(this.mapperName);
    }

    @Override
    public Optional<String> checkerName() {
      return Optional.ofNullable(this.checkerName);
    }

    /**
     * This is an interface that corresponds to a "matcher" in other assertion
     * libraries.
     *
     * @param <P> Intermediate parameter type tested by a predicated.
     * @param <O> Input parameter type.
     */
    public static abstract class Factory<P, O> {
      public abstract Predicate<O> check(String condName, Predicate<? super P> cond);

      @SuppressWarnings("unchecked")
      public <OO> Factory<P, OO> castTo(@SuppressWarnings("unused") Class<OO> ooClass) {
        return (Factory<P, OO>) this;
      }

      public abstract Predicate<O> check(Predicate<? super P> cond);

      @SafeVarargs
      public final Predicate<O> checkAllOf(Predicate<? super P>... conds) {
        return check(Predicates.allOf(conds));
      }
      @SafeVarargs
      public final Predicate<O> allOf(Predicate<? super P>... conds) {
        return checkAllOf(conds);
      }

      public static <P, O> Factory<P, O> create(Function<O, P> function) {
        return create(null, null, function);
      }

      public static <P, O> Factory<P, O> create(String mapperName, String checkerName, Function<O, P> function) {
        return new Factory<P, O>() {
          @Override
          public Predicate<O> check(String condName, Predicate<? super P> cond) {
            return new TransformingPredicate<>(mapperName, condName, cond, function);
          }

          @Override
          public Predicate<O> check(Predicate<? super P> cond) {
            return new TransformingPredicate<>(mapperName, checkerName, toPrintablePredicateIfNotPrintable(cond), function);
          }
        };
      }
    }
  }

  static class CurriedContextPredicate extends PrintablePredicate<CurriedContext> implements Evaluable.CurriedContextPred {
    private final Evaluable<?> enclosed;
    private final int          argIndex;

    private <T> CurriedContextPredicate(Object creator, List<Object> args, Predicate<T> predicate, int argIndex) {
      super(
          creator,
          args,
          () -> format("curry[%s,%s]", predicate, argIndex),
          context -> PrintablePredicate.unwrap(predicate).test(context.valueAt(argIndex)));
      this.enclosed = (Evaluable<?>) InternalUtils.toEvaluableIfNecessary(predicate);
      this.argIndex = argIndex;

    }

    @SuppressWarnings("unchecked")
    @Override
    public <TT> Evaluable<TT> enclosed() {
      return (Evaluable<TT>) this.enclosed;
    }

    @Override
    public int argIndex() {
      return argIndex;
    }

    public static <T> CurriedContextPredicate create(Predicate<T> predicate, int argIndex) {
      return new CurriedContextPredicate(CurriedContextPredicate.class, asList(predicate, argIndex), predicate, argIndex);
    }
  }

  static class AllMatch<E> extends StreamPredicate<E> {
    @SuppressWarnings("unchecked")
    private AllMatch(Predicate<? super E> predicate) {
      super(
          AllMatch.class,
          singletonList(predicate),
          () -> format("allMatch[%s]", predicate),
          (Stream<E> stream) -> stream.allMatch(predicate),
          InternalUtils.toEvaluableIfNecessary((Predicate<? super Stream<? extends E>>) predicate),
          true,
          false);
    }

    static <E> StreamPredicate<E> create(Predicate<? super E> predicate) {
      return new AllMatch<>(
          predicate
      );
    }
  }

  static class AnyMatch<E> extends StreamPredicate<E> {
    @SuppressWarnings("unchecked")
    private AnyMatch(Predicate<? super E> predicate) {
      super(
          AnyMatch.class,
          singletonList(predicate),
          () -> format("anyMatch[%s]", predicate),
          (Stream<E> stream) -> stream.anyMatch(PrintablePredicate.unwrap(predicate)),
          (Evaluable<Stream<E>>) InternalUtils.toEvaluableIfNecessary(predicate),
          false,
          true);
    }

    public static <E> StreamPredicate<E> create(Predicate<? super E> predicate) {
      return new AnyMatch<>(
          predicate
      );
    }
  }

  static class NoneMatch<E> extends StreamPredicate<E> {
    @SuppressWarnings("unchecked")
    private NoneMatch(Predicate<? super E> predicate) {
      super(
          NoneMatch.class,
          singletonList(predicate),
          () -> format("noneMatch[%s]", predicate),
          (Stream<E> stream) -> stream.noneMatch(predicate),
          (Evaluable<Stream<E>>) InternalUtils.toEvaluableIfNecessary((Predicate<? super Stream<E>>) predicate),
          true,
          true);
    }

    @Override
    public boolean requestExpectationFlip() {
      return true;
    }

    public static <E> StreamPredicate<E> create(Predicate<E> predicate) {
      return new NoneMatch<E>(
          predicate
      ) {
      };
    }
  }

  public abstract static class StreamPredicate<E> extends PrintablePredicate<Stream<E>> implements Evaluable.StreamPred<E> {
    private final Evaluable<Stream<E>> cut;
    private final boolean              defaultValue;
    private final boolean              cutOn;

    private StreamPredicate(Object creator, List<Object> args, Supplier<String> formatter, Predicate<Stream<E>> predicate, Evaluable<Stream<E>> cut, boolean defaultValue, boolean cutOn) {
      super(creator, args, formatter, predicate);
      this.cut = requireNonNull(cut);
      this.defaultValue = defaultValue;
      this.cutOn = cutOn;
    }

    @Override
    public boolean defaultValue() {
      return defaultValue;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Evaluable<E> cut() {
      return (Evaluable<E>) this.cut;
    }

    @Override
    public boolean valueToCut() {
      return cutOn;
    }
  }
}



















































































































Active mutators

CONDITIONALS_BOUNDARY
EMPTY_RETURNS
FALSE_RETURNS
INCREMENTS
INVERT_NEGS
MATH
NEGATE_CONDITIONALS
NULL_RETURNS
PRIMITIVE_RETURNS
TRUE_RETURNS
VOID_METHOD_CALLS

Tests examined

com.github.valid8j.ut.types.FloatTest.floatSatisfiesTest(com.github.valid8j.ut.types.FloatTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[104: REQUIRE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[7](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[12: DOLLAR: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[31](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[205: UNLESS_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[9](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[40: PRECONDITION: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[64: INVARIANT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[48: INVARIANTS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[217: UNLESS: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest.givenSomeFoundSomeNotFound$whenFindRegexes$thenFailed(com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[214: UNLESS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[155: HOLD_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[80: POSTCONDITION: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[66: POSTCONDITIONS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[202: UNLESS_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[224: EXPECT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[208: UNLESS_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello4(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$AnyMatchTest.whenMet$thenTrue(com.github.valid8j.ut.utilstest.PredicatesTest$AnyMatchTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[150: REQUIRE_STATE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_that(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest.exerciseTestCase[1: givenStreamPredicate_whenUnexpectedNullValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[188: ENSURE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[155: HOLD_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[71: POSTCONDITIONS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[18](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[4](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$IsInstanceOfTest.test(com.github.valid8j.ut.utilstest.PredicatesTest$IsInstanceOfTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[43](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[36](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[114: REQUIRE_ARGUMENTS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[176: ENSURE_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[2](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ValidatesTest.testX(com.github.valid8j.entrypoints.ValidatesTest) (5 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[5](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.givenStreamOfSingleString$hello$_whenRequireNonNullIsFound_thenPassing(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[179: ENSURE_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[1](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.reqireState_passing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[26](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[33](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.givenString$hello$_whenTransformToContextAndCheckContextValueIsNull_thenPreconditionViolationWithCorrectMessageThrown(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[143: REQUIRE_STATE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[124: REQUIRE_ARGUMENT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[40](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[221: EXPECT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[12: DOLLAR: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[68: Given:<"HELLO">:When:,<>)>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[33: PRECONDITION: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.TransformingPredicateTest.testEquals(com.github.valid8j.ut.internal.TransformingPredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[23: PRECONDITIONS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[18](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[55: INVARIANT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test5(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[27](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenNonNull$whenEnsureNonNull$thenPasses(com.github.valid8j.entrypoints.EnsuresTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[16: DOLLAR: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[123: REQUIRE_ARGUMENT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[17](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[185: ENSURE_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[67: POSTCONDITIONS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[42](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.valid8j.ut.utilstest.ReportDetailTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenValidValue$whenEnsure$thenPasses(com.github.valid8j.entrypoints.EnsuresTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[9](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[48: INVARIANTS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[18](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[105: REQUIRE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[154: HOLD_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[9](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[6: Given:<["A","B","C"]>:When::Then:identicalWith(value:[A, B, C])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[34](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[36](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[163: HOLD_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testIsEmptyOrNullString(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[82: POSTCONDITION: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[0](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[159: HOLD_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[10: ALL: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[6: ALL: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[67: Given:<"hello">:When:<<>.equals()->castTo[Boolean] THEN:isTrue>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.internal.PrintablesTest$PredicateTest.givenPredicateReturnedByNegate$whenTest$thenWorksRight(com.github.valid8j.ut.internal.PrintablesTest$PredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[146: REQUIRE_STATE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[160: HOLD_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed.testFailureFromAndThenStructureInTransformer(com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[228: EXPECT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[12](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[15](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[4: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.nullReturningFunctionAsPredicate(com.github.valid8j.ut.internal.CallTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[88: REQUIRE_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[76: Given:<"123">:When:identity->castTo[Short] THEN:=[123]>:Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.EnsuresTest.testEnsure(com.github.valid8j.entrypoints.EnsuresTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[40](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[5](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[51: INVARIANTS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireWithCustomStringTransformingPredicateAndSatisfyingValue(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[9](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[15](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[117: REQUIRE_ARGUMENTS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[15](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello5(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[199: UNLESS_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[171: HOLD: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.string_assertThatTest_failed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[43](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[91: REQUIRE_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.types.StreamTest.streamTransformerTestFailure(com.github.valid8j.ut.types.StreamTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[39](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_postconditions(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[1: Given::When::Then:identicalWith(value:true)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[77: POSTCONDITION: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[10: ALL: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[72: POSTCONDITIONS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[177: ENSURE_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[220: EXPECT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[14](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[25: Given:<"456">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[2](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[22](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[4](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[29](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test2(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[130: REQUIRE_ARGUMENT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[87: POSTCONDITION: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[21](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[53: INVARIANTS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[4: ALL: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[39](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[1](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[47: Given:<"A:B:C">:When::Then:identicalWith(value:A:B:C)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[103: REQUIRE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[39: PRECONDITION: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest.parameterizedPredicate_(com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest) (0 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello3(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[39](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[164: HOLD_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[11](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.types.FloatTest.toFloatTest(com.github.valid8j.ut.types.FloatTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testComparison(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[21: Given:<"123">:When::Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[14](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[35: PRECONDITION: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[6](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[102: REQUIRE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[170: HOLD: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[137: REQUIRE_STATES: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.PrintablePredicateTest$LeafPred.testHashCode(com.github.valid8j.ut.internal.PrintablePredicateTest$LeafPred) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[83: POSTCONDITION: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[21](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[1](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[27: PRECONDITIONS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[224: EXPECT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.examples.test.ExamplesTest.testMetarmorExampleFailing(com.github.valid8j.examples.test.ExamplesTest) (60 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[171: HOLD: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[22: PRECONDITIONS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello2(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[17](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest.exerciseTestCase[2: whenPredicatesAllReturningTrueUnderAllOf_thenPasses](com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[24](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[107: REQUIRE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[15](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[106: REQUIRE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[46: INVARIANTS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[31](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[187: ENSURE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[4](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$EqTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$EqTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireValue_passing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[99: REQUIRE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest.exerciseTestCase[1: whenOnePredicateThrowingExceptionUnderAllOf_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[27](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[157: HOLD_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.nestedLoop_fail(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[230: EXPECT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[30](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[15: DOLLAR: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[197: ENSURE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$NoneMatchTest.whenMet$thenTrue(com.github.valid8j.ut.utilstest.PredicatesTest$NoneMatchTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[17: Given:<[]>:When:] THEN:isEmpty>:Then:identicalWith(value:[])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[5](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[134: REQUIRE_STATES: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[37](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[100: REQUIRE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (6 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[23: Given:<"123">:When::Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[165: HOLD: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[113: REQUIRE_ARGUMENTS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (8 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[211: UNLESS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireWithTransformingPredicateAndSatisfyingValue(com.github.valid8j.entrypoints.RequiresTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[44: INVARIANTS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[43: Given:<"true">:When::Then:identicalWith(value:true)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[49: Given:<"A:B:C">:When::Then:identicalWith(value:A:B:C)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[6](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[113: REQUIRE_ARGUMENTS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[93: REQUIRE_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[34](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[34: Given:<"A">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[219: UNLESS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[34](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[31: PRECONDITIONS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[46: INVARIANTS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[22](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[85: POSTCONDITION: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[37: PRECONDITION: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[14: DOLLAR: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[170: HOLD: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[43](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[7](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[25](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[3](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[24: PRECONDITIONS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[135: REQUIRE_STATES: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[152: REQUIRE_STATE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[159: HOLD_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[41](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_b(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_equalTo(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[98: REQUIRE_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[153: REQUIRE_STATE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenIsTrueAndIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[1](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[145: REQUIRE_STATE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$ContainsStringTest.whenMet$thenTrue(com.github.valid8j.ut.utilstest.PredicatesTest$ContainsStringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[102: REQUIRE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[9: ALL: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[131: REQUIRE_ARGUMENT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[22](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[50: INVARIANTS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireWithSatisfyingValue(com.github.valid8j.entrypoints.RequiresTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[29](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[198: UNLESS_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[94: REQUIRE_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[11](com.github.valid8j.ut.equallness.EqualnessTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[36](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.typesupports.ListTest.testAllMatch(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[136: REQUIRE_STATES: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[160: HOLD_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[79: POSTCONDITION: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[120: REQUIRE_ARGUMENTS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssertAll_failed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[156: HOLD_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[1](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[147: REQUIRE_STATE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[29: Given:<"456">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[64: INVARIANT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[215: UNLESS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.types.FloatTest.floatTransformerTestFail(com.github.valid8j.ut.types.FloatTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[9](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[172: HOLD: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[128: REQUIRE_ARGUMENT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[5](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[11: Given:<[]>:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (8 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[43](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[33](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[18](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[25: PRECONDITIONS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[82: Given:<"123.5">:When:identity->castTo[Float] THEN:=[123.4]>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[125: REQUIRE_ARGUMENT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[190: ENSURE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[25](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[11: DOLLAR: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[218: UNLESS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[7](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.typesupports.StringTest.testEqualTo(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.entrypoints.AssertionsTest$Passing.testAssertPrecondition$thenPassing(com.github.valid8j.entrypoints.AssertionsTest$Passing) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[14: DOLLAR: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[40](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[102: REQUIRE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (6 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[134: REQUIRE_STATES: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[40](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[132: REQUIRE_STATES: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[141: REQUIRE_STATES: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.methodNotFound(com.github.valid8j.ut.internal.CallTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[15: Given:<[]>:When:] THEN:isEmpty>:Then:identicalWith(value:[])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[16: DOLLAR: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ValidatesTest.test(com.github.valid8j.entrypoints.ValidatesTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[6](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[12](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[149: REQUIRE_STATE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[58: Given:<"hello">:When:<==[hello]>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[40](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[40](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[8](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[6](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[56: Given:<"hello">:When:<==[hello]>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[3: ALL: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[87: POSTCONDITION: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$ContainsStringTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$ContainsStringTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[13](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat_usingFluentStyle(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_c(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[12](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[13: DOLLAR: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[183: ENSURE_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[188: ENSURE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[0](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[43](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[0: givenChainedTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[155: HOLD_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[137: REQUIRE_STATES: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[20: DOLLAR: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[36](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[41](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_precondition(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[31](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_isEmpty(com.github.valid8j.ut.styles.MoreFluentStringTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.given$hello$_$world$_whenRequireNestedStreamImpossibleConditions_thenPreconditionViolationExceptionWithCorrectMessage(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[88: REQUIRE_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[18](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[2](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[126: REQUIRE_ARGUMENT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[70: POSTCONDITIONS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[164: HOLD_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[186: ENSURE_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[175: HOLD: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[13](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.int_assertThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[73: POSTCONDITIONS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[7](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[22](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[205: UNLESS_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[35: PRECONDITION: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[5: ALL: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[3](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[47: INVARIANTS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[130: REQUIRE_ARGUMENT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[62: INVARIANT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_findRegexes(com.github.valid8j.ut.styles.MoreFluentStringTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$MatchesRegexTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$MatchesRegexTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[171: HOLD: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[76: POSTCONDITIONS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[15: DOLLAR: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[89: REQUIRE_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_endingWith(com.github.valid8j.ut.styles.MoreFluentStringTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[200: UNLESS_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[218: UNLESS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[33: Given:<"A">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[105: REQUIRE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[176: ENSURE_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[30](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[39](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[57: Given:<"hello">:When::Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[10](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[15](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[16: Given:<["X"]>:When:] THEN:isEmpty>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[141: REQUIRE_STATES: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[97: REQUIRE_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[139: REQUIRE_STATES: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureState_passing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[153: REQUIRE_STATE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$LtTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$LtTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[18: Given:<["X"]>:When:] THEN:isEmpty>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[69: POSTCONDITIONS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[2](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[78: POSTCONDITION: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[148: REQUIRE_STATE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[136: REQUIRE_STATES: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[36](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[6](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[79: POSTCONDITION: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[21](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.examples.test.JUnitBasedExamplesTest.testExampleUT(com.github.valid8j.examples.test.JUnitBasedExamplesTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[37](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[14](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[43](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[31](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[41: PRECONDITION: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[35](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[34](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[24](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[68: POSTCONDITIONS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[27](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[170: HOLD: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[190: ENSURE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[204: UNLESS_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.internal.PrintablePredicateTest$And (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[0](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[108: REQUIRE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[26](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest.exerciseTestCase[0: whenOnePredicateReturningFalseUnderAllOf_whenComparisonFailure](com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[24](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[173: HOLD: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[130: REQUIRE_ARGUMENT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[2: ALL: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[0](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[37](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[33: PRECONDITION: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[2: givenStreamPredicate$hello_b_e_2$_whenUnexpectedValue_thenComparisonFailure2](com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[63: INVARIANT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[107: REQUIRE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenTrue_whenIsTrue_thenPass(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (0 ms)
com.github.valid8j.entrypoints.AssertionsTest$Passing.testAssertThatValue$thenPass(com.github.valid8j.entrypoints.AssertionsTest$Passing) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_preconditions(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[11](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[81: POSTCONDITION: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[40](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_greaterThan(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.givenStreamOfSingleString$hello$_whenRequireNullIsFound_thenPreconditionViolationWithCorrectMessageIsThrown(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[34](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[157: HOLD_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[0](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[3: whenPredicatesFirstReturningFalseRestReturningTrueUnderAnyOf_thenPass](com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[7](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[7](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_greaterThanOrEqualTo(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[167: HOLD: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[187: ENSURE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[43: PRECONDITION: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[24](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[19](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[151: REQUIRE_STATE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[36](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validateNonNull_pass(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[43](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[73: POSTCONDITIONS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[208: UNLESS_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_equalsIgnoreCase(com.github.valid8j.ut.styles.MoreFluentStringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[61: INVARIANT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentListTest.test_stream(com.github.valid8j.ut.styles.MoreFluentListTest) (1 ms)
com.github.valid8j.ut.types.FloatTest.floatTransformerTest(com.github.valid8j.ut.types.FloatTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentListTest.test_isEmpty(com.github.valid8j.ut.styles.MoreFluentListTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[212: UNLESS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[57: INVARIANT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[17](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.NegatedPredicateTest.exerciseTestCase[1: givenNegatedSimplePredicateReturningTrue_whenUnexpectedValue_thenComparisonFailureThrown](com.github.valid8j.ut.propertybased.tests.NegatedPredicateTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.NegatedPredicateTest.exerciseTestCase[0: givenNegatedSimplePredicateReturningFalse_whenExpectedValue_thenValueReturned](com.github.valid8j.ut.propertybased.tests.NegatedPredicateTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_lessThan(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[177: ENSURE_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[33](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[26](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[225: EXPECT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[181: ENSURE_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[81: Given:<"123.4">:When:identity->castTo[Double] THEN:=[123.4]>:Then:identicalWith(value:123.4)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[39](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[40](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[32: Given:<"A">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[4](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.SimplePredicateTest.exerciseTestCase[0: givenSimplePredicate_whenExpectedValue_thenValueReturned](com.github.valid8j.ut.propertybased.tests.SimplePredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[212: UNLESS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (6 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[205: UNLESS_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[36](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[1: ALL: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[76: POSTCONDITIONS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[63: INVARIANT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[178: ENSURE_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[169: HOLD: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[17](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[39](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.SimplePredicateTest.exerciseTestCase[1: givenSimplePredicate_whenUnexpectedValue_thenComparisonFailureThrown](com.github.valid8j.ut.propertybased.tests.SimplePredicateTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[95: REQUIRE_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$AnyMatchTest.whenNot$thenFalse(com.github.valid8j.ut.utilstest.PredicatesTest$AnyMatchTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[135: REQUIRE_STATES: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[5: Given:<["A","B","C"]>:When::Then:identicalWith(value:[A, B, C])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[32: PRECONDITIONS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[13](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[17](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[73: POSTCONDITIONS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[181: ENSURE_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.RequiresTest.givenInvalidState$whenRequireState$thenIllegalStateExceptionThrown(com.github.valid8j.entrypoints.RequiresTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[25](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[16](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[211: UNLESS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[227: EXPECT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest.exerciseTestCase[2: givenStreamPredicate_whenUnexpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest) (2 ms)
com.github.valid8j.examples.test.ExamplesTest.testMetarmorExamplePassing(com.github.valid8j.examples.test.ExamplesTest) (7 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[16](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[83: POSTCONDITION: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_Short(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[81: POSTCONDITION: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[67: POSTCONDITIONS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[154: HOLD_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.givenIllegalArgument_whenRequireArgument_thenIllegalArgumentThrown(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[71: POSTCONDITIONS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_all(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenNonNullValue_whenEnsureNonNull_thenValueReturned(com.github.valid8j.entrypoints.EnsuresTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[40](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[27: PRECONDITIONS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test3(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.ut.typesupports.StringTest.testSameAs(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[100: REQUIRE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[119: REQUIRE_ARGUMENTS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[26](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[21](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[109: REQUIRE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[127: REQUIRE_ARGUMENT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[84: POSTCONDITION: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[0](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindStringTest.example(com.github.valid8j.ut.utilstest.PredicatesTest$FindStringTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[106: REQUIRE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[92: REQUIRE_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[158: HOLD_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[14](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.typesupports.ListTest.testAnyMatch(com.github.valid8j.ut.typesupports.ListTest) (1 ms)
com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest.toContextPredicateTest(com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[151: REQUIRE_STATE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[226: EXPECT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[142: REQUIRE_STATES: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[16](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[163: HOLD_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[110: REQUIRE_ARGUMENTS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[105: REQUIRE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[25](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[198: UNLESS_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[112: REQUIRE_ARGUMENTS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest.givenAllFound$whenFindString$thenPassed(com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[68: POSTCONDITIONS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[7](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[5](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[201: UNLESS_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_transforming_thenFail(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$LeTest.whenNotMet$thenFalse(com.github.valid8j.ut.utilstest.PredicatesTest$LeTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[152: REQUIRE_STATE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[65: Given:<"hello">:When:<<>.equals()>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[58: INVARIANT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[11: DOLLAR: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[49: INVARIANTS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[149: REQUIRE_STATE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[36](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[30](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[59: INVARIANT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[39](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[20](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[75: POSTCONDITIONS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[38: PRECONDITION: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[47: INVARIANTS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[178: ENSURE_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[37: Given::When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[10](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[116: REQUIRE_ARGUMENTS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[8](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[24](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$EqTest.whenMet$thenTrue(com.github.valid8j.ut.utilstest.PredicatesTest$EqTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[41](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[80: POSTCONDITION: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[50: INVARIANTS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[44: INVARIANTS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[13](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.typesupports.ListTest.testNoneMatch(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[204: UNLESS_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[35](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello3_a(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$AndTest (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[219: UNLESS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.internal.PrintablesFunctionTest$Simple.testHandleNull(com.github.valid8j.ut.internal.PrintablesFunctionTest$Simple) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[11](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[88: REQUIRE_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[29](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_postcondition(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.performCurriedPredicate(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[1](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[133: REQUIRE_STATES: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (6 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[223: EXPECT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[66: POSTCONDITIONS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[186: ENSURE_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[200: UNLESS_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[86: POSTCONDITION: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[43](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[7](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$IsInstanceOfTest.whenIsInstanceOfUsedInComposite_thenNoExplicitTypeParameterIsNeeded(com.github.valid8j.ut.utilstest.PredicatesTest$IsInstanceOfTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[40](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[21: DOLLAR: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[21](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[216: UNLESS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[126: REQUIRE_ARGUMENT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[225: EXPECT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_findSubstrings(com.github.valid8j.ut.styles.MoreFluentStringTest) (1 ms)
com.github.valid8j.ut.internal.PrintablePredicateTest$Negate (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[37](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[166: HOLD: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[3: ALL: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[30: Given:<"456">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[52: Given:<"A:B">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.examples.test.ExamplesTest.testIntroductionExample(com.github.valid8j.examples.test.ExamplesTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[174: HOLD: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[42](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[17](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[131: REQUIRE_ARGUMENT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[207: UNLESS_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[191: ENSURE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[24](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[11](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_Long(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[103: REQUIRE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[218: UNLESS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[27](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[226: EXPECT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_startingWith(com.github.valid8j.ut.styles.MoreFluentStringTest) (0 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test3(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$EqTest.whenHashCode$thenSameIsSameAndDifferentIsDifferent(com.github.valid8j.ut.utilstest.PredicatesTest$EqTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$MatchesRegexTest.whenMet$thenTrue(com.github.valid8j.ut.utilstest.PredicatesTest$MatchesRegexTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$NoneMatchTest.whenNot$thenFalse(com.github.valid8j.ut.utilstest.PredicatesTest$NoneMatchTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[213: UNLESS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[17](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[190: ENSURE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.FluentUtilsTest.expectationFlipping(com.github.valid8j.ut.utilstest.FluentUtilsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[207: UNLESS_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[33](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[59: INVARIANT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[32: PRECONDITIONS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.nestedLoop_success(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[3: givenStreamPredicate$hello_b_e_4$_whenUnexpectedValue_thenComparisonFailure2](com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[23](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest.givenAllFound$whenFindRegexes$thenPassed(com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$EqTest.whenNotMet$thenFalse(com.github.valid8j.ut.utilstest.PredicatesTest$EqTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[144: REQUIRE_STATE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[8](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[34: PRECONDITION: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[167: HOLD: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[111: REQUIRE_ARGUMENTS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[39](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[41](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testIsEmptyString(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[109: REQUIRE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[8](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[106: REQUIRE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.AssertionsTest$MessageTest.composeMessage$thenComposed(com.github.valid8j.entrypoints.AssertionsTest$MessageTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[3](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[39](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.methodIncompatible(com.github.valid8j.ut.internal.CallTest) (1 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenString_whenFails_then_2(com.github.valid8j.ut.utilstest.ReportDetailTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[18](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[17](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[10](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[63: Given:<"hello">:When:<<>.equals()->castTo[Boolean] THEN:isTrue>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[29](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest.exerciseTestCase[0: givenStreamPredicate_whenExpectedValue_thenValueReturned](com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[43](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[7: ALL: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[222: EXPECT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[41: PRECONDITION: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[5](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[189: ENSURE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[1: givenStreamPredicate$hello_b_e$_whenUnexpectedValue_thenComparisonFailure2](com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[165: HOLD: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$OrTest.performSingleOr$thenTrue(com.github.valid8j.ut.utilstest.PredicatesTest$OrTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[3](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[9: Given:<["X"]>:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[3](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequire$thenError(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[2](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[26: Given:<"456">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[22: PRECONDITIONS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.NegateTest.whenInvertedTransformingPredicateFails_thenPrintDesignedMessage$transformIsntLeafAndNotMerged(com.github.valid8j.ut.internal.NegateTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[20](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[31](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[35](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[18](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[22](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[75: POSTCONDITIONS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[41](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[142: REQUIRE_STATES: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.typesupports.StringTest.testStartsWith(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[69: Given:<"HELLO">:When:<<>.equals()>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[77: Given:<"124">:When:identity->castTo[Long] THEN:=[123]>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[75: Given:<"123">:When:identity->castTo[Integer] THEN:=[123]>:Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[38](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello6(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[41](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[56: INVARIANT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[21](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[192: ENSURE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.propertybased.tests.CurriedContextPredicateTest.exerciseTestCase[0: givenVariableBundlePredicate_whenExpectedValue_thenValueReturned](com.github.valid8j.ut.propertybased.tests.CurriedContextPredicateTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[91: REQUIRE_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[15](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[133: REQUIRE_STATES: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[12](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[86: POSTCONDITION: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[113: REQUIRE_ARGUMENTS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[25: PRECONDITIONS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[64: Given:<"hello">:When:,<>)>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[217: UNLESS: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[56: INVARIANT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[26: PRECONDITIONS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[30](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.givenValidState_whenRequireState_thenStateReturned(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[18: DOLLAR: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[19](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[33: PRECONDITION: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[37](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.typesupports.ListTest.testListContains(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[57: INVARIANT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[39](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[219: UNLESS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[28: Given:<"456">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[151: REQUIRE_STATE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[20](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[138: REQUIRE_STATES: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[117: REQUIRE_ARGUMENTS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[55: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_d_1(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[15](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[23](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[191: ENSURE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireWithCustomStringTransformingPredicate(com.github.valid8j.entrypoints.RequiresTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[31](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[40: PRECONDITION: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[108: REQUIRE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.TestAssertionsTest.testAllOf(com.github.valid8j.ut.utilstest.TestAssertionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[65: INVARIANT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.AssertionsTest$Passing.testAssertPostcondition$thenPassing(com.github.valid8j.entrypoints.AssertionsTest$Passing) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[21](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testIsInstanceOf(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test1(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (2 ms)
com.github.valid8j.ut.internal.NegateTest.whenInvertedTrasformingPredicateFails_thenPrintDesignedMessage$mergedWhenNotMismatch(com.github.valid8j.ut.internal.NegateTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[20](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[14](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenValidState$whenEnsureState$thenPasses(com.github.valid8j.entrypoints.EnsuresTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[36](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[15](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[2](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[40: PRECONDITION: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test7(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (0 ms)
com.github.valid8j.ut.styles.MoreFluentStreamTest.test_anyMatch(com.github.valid8j.ut.styles.MoreFluentStreamTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[85: Given:<"Bye">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[6](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[17](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.examples.test.ExamplesTest.testClassicExample(com.github.valid8j.examples.test.ExamplesTest) (34 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[17: DOLLAR: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[12: Given:<[]>:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (9 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[144: REQUIRE_STATE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[228: EXPECT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[35: PRECONDITION: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[12](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[89: REQUIRE_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[161: HOLD_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test5(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[49: INVARIANTS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[16](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[71: POSTCONDITIONS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[0: Given::When::Then:identicalWith(value:true)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (9 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[135: REQUIRE_STATES: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[133: REQUIRE_STATES: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[22](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[29: PRECONDITIONS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[19](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.givenStream_whenRequireConditionResultingInNPE_thenInternalExceptionWithCorrectMessageAndNpeAsNestedException(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_contains(com.github.valid8j.ut.styles.MoreFluentStringTest) (0 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test8(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[9](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.stream_assertThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindElementsTest.givenAllFound$whenFindElements$thenPassed(com.github.valid8j.ut.utilstest.PredicatesTest$FindElementsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[167: HOLD: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[42](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[122: REQUIRE_ARGUMENT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[49: INVARIANTS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[195: ENSURE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[46: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[94: REQUIRE_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[22: PRECONDITIONS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[229: EXPECT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[36: Given:<"A">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[8](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_Float(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[27](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[34](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[3](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[199: UNLESS_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.utilstest.FluentUtilsTest.test4(com.github.valid8j.ut.utilstest.FluentUtilsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[83: POSTCONDITION: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[107: REQUIRE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (9 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[65: INVARIANT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[38](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[24](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[37](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[21](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[2: givenTransformingPredicate_whenExpectedValue_thenValueReturned](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[168: HOLD: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.styles.MoreFluentStreamTest.test_allMatch(com.github.valid8j.ut.styles.MoreFluentStreamTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[32](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[48: INVARIANTS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureValuesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[196: ENSURE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[17](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[1](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$IsNotNullTest (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[80: Given:<"123.4">:When:identity->castTo[Float] THEN:=[123.4]>:Then:identicalWith(value:123.4)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[38](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[216: UNLESS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[10](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[28](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[195: ENSURE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.object_assertThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[121: REQUIRE_ARGUMENT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[26](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[2: ALL: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[35](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[48: Given:<"A:B:C">:When::Then:identicalWith(value:A:B:C)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[168: HOLD: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[90: REQUIRE_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[40: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$GtTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$GtTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[216: UNLESS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[12](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenIllegalValue_whenEnsure_thenPostconditionViolationThrown(com.github.valid8j.entrypoints.EnsuresTest) (3 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireArgumentsTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[146: REQUIRE_STATE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[42](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[5](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assertAll_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[24: PRECONDITIONS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[2](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test6(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[83: Given:<"123.5">:When:identity->castTo[Double] THEN:=[123.4]>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[11](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[23: PRECONDITIONS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest.exerciseTestCase[3: whenPredicatesFirstReturningFalseRestReturningTrueUnderAllOf_whenComparisonFailure](com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest) (2 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100_conj(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$IsNullTest (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[42](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureValue_passing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[213: UNLESS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[18](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[79: POSTCONDITION: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[8](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.givenValidArgument_whenRequireArgument_thenValueReturned(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.entrypoints.ValidatesTest.testValidateMethod$failing(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[124: REQUIRE_ARGUMENT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[143: REQUIRE_STATE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[161: HOLD_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100$whenShorterThan10(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[139: REQUIRE_STATES: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[28](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.NullValueHandlingTest.givenNull_whenStatementIsExamined_thenProcessedCorrectly3(com.github.valid8j.ut.NullValueHandlingTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[3: ALL: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[202: UNLESS_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[39: PRECONDITION: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$NoneMatchTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$NoneMatchTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[74: Given:<"123">:When:identity->castTo[Long] THEN:=[123]>:Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[20](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[185: ENSURE_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testWrapperIsTrue(com.github.valid8j.ut.typesupports.BooleanTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[23](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[187: ENSURE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.internal.TransformingPredicateTest.givenNonNullName$whenToString$thenLooksGood(com.github.valid8j.ut.internal.TransformingPredicateTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[26](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[90: REQUIRE_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testEqualsIgnoreCase(com.github.valid8j.ut.typesupports.StringTest) (1 ms)
com.github.valid8j.ut.types.StreamTest.streamTestFailure(com.github.valid8j.ut.types.StreamTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[181: ENSURE_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenString_whenFails_then(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[199: UNLESS_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[47: INVARIANTS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[2: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[169: HOLD: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[0](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[182: ENSURE_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$LtTest.whenMet$thenTrue(com.github.valid8j.ut.utilstest.PredicatesTest$LtTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[66: Given:<"hello">:When:,<>)->castTo[Boolean] THEN:isTrue>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[34: PRECONDITION: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.NullValueHandlingTest.givenNull_whenStatementIsExamined_thenProcessedCorrectly2(com.github.valid8j.ut.NullValueHandlingTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[23](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.typesupports.StringTest.testMatchesRegex(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[9](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[16](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[25](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[116: REQUIRE_ARGUMENTS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[196: ENSURE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.PrintablesTest$PredicateTest.givenPredicateReturnedByOr$whenTest$thenWorksRight(com.github.valid8j.ut.internal.PrintablesTest$PredicateTest) (0 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_b3(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[127: REQUIRE_ARGUMENT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[60: INVARIANT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[110: REQUIRE_ARGUMENTS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[2](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[38](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[223: EXPECT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.TransformingPredicateTest.givenNullForName$whenToString$thenLooksGood(com.github.valid8j.ut.internal.TransformingPredicateTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[38](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[150: REQUIRE_STATE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[26](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[43: PRECONDITION: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[89: REQUIRE_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.RequiresTest.givenValidValue_whenRequire_thenValueReturned(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[110: REQUIRE_ARGUMENTS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[111: REQUIRE_ARGUMENTS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[2](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[115: REQUIRE_ARGUMENTS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[30](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[142: REQUIRE_STATES: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[0](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ValidatesTest.testY(com.github.valid8j.entrypoints.ValidatesTest) (1 ms)
com.github.valid8j.entrypoints.EnsuresTest.testEnsureState(com.github.valid8j.entrypoints.EnsuresTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[13](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[7: ALL: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[148: REQUIRE_STATE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.nullCanMatch(com.github.valid8j.ut.internal.CallTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[34](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[119: REQUIRE_ARGUMENTS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[9: ALL: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[50: Given:<"A:B">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[27: PRECONDITIONS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[204: UNLESS_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[14: Given:<["X"]>:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[23](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[16](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[23](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[193: ENSURE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[22](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[37](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[1](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[14](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[30](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[134: REQUIRE_STATES: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[225: EXPECT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[210: UNLESS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[1](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[11](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[7](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[13: DOLLAR: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[32](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assumeThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[129: REQUIRE_ARGUMENT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.typesupports.StringTest.testEndsWith(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$NotTest.test(com.github.valid8j.ut.utilstest.PredicatesTest$NotTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[18: DOLLAR: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[166: HOLD: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.TransformingPredicateTest.testHashCode(com.github.valid8j.ut.internal.TransformingPredicateTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[24: Given:<"123">:When::Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[21: DOLLAR: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[35](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100$whenNull(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[101: REQUIRE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_Double(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$EqTest.whenEqualityIsChecked$thenSameIsSameAndDifferentIsDifferent(com.github.valid8j.ut.utilstest.PredicatesTest$EqTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[26](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[13](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[183: ENSURE_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[5](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[214: UNLESS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validate_pass(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[42](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[75: POSTCONDITIONS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[11](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.internal.PrintablesTest$PredicateTest.givenPredicateReturnedByAnd$whenToString$thenLooksGood(com.github.valid8j.ut.internal.PrintablesTest$PredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[123: REQUIRE_ARGUMENT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[11](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[108: REQUIRE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[7](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[37](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[13](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[227: EXPECT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[119: REQUIRE_ARGUMENTS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.internal.CallTest.methodAmbiguous_primitiveBoxed_negated(com.github.valid8j.ut.internal.CallTest) (1 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withoutEvaluator_conj_thenFail(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[42](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_b_e5(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (3 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[38: Given::When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$LeTest.whenMet$thenTrue(com.github.valid8j.ut.utilstest.PredicatesTest$LeTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[201: UNLESS_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[45: INVARIANTS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[19](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[10](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[4](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[19](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[4](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[39: PRECONDITION: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectedExceptionThrown_testPassing(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[19](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_matchesRegex(com.github.valid8j.ut.styles.MoreFluentStringTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[1: whenOnePredicateThrowingExceptionUnderAnyOf_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[209: UNLESS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_disj_thenPass(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[62: Given:<"hello">:When:,<>)->castTo[Boolean] THEN:isTrue>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[189: ENSURE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[16](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.utilstest.TestAssertionsTest.testAnyOf(com.github.valid8j.ut.utilstest.TestAssertionsTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[41](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[38](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[98: REQUIRE_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[1](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_lessThanOrEqualTo(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentListTest.test_elementAt(com.github.valid8j.ut.styles.MoreFluentListTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[180: ENSURE_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.types.StreamTest.streamTest(com.github.valid8j.ut.types.StreamTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[200: UNLESS_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.string_assertThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[8: Given:<["A","B"]>:When::Then:identicalWith(value:[A, B])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[94: REQUIRE_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[84: POSTCONDITION: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[53: INVARIANTS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[35](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[186: ENSURE_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[6](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[46: INVARIANTS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[4: givenTwoChainedTransformingPredicates_whenNonExpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (6 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[33](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[121: REQUIRE_ARGUMENT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[20](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[166: HOLD: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test6(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[13: DOLLAR: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[16](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[28](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[194: ENSURE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[72: Given::When::Then:identicalWith(value:null)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[6: ALL: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[62: INVARIANT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[99: REQUIRE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.boolean_assertThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[194: ENSURE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[42](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequire(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[29](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[11: DOLLAR: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[35](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[69: POSTCONDITIONS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[37: PRECONDITION: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[115: REQUIRE_ARGUMENTS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[31: PRECONDITIONS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[71: Given:<"HELLO">:When:<<>.equals()->castTo[Boolean] THEN:isTrue>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[8](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[11](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[61: INVARIANT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[28: PRECONDITIONS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[33](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[5: ALL: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_disj$or$_thenFail(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[14](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$AllMatchTest.whenMet$thenTrue(com.github.valid8j.ut.utilstest.PredicatesTest$AllMatchTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[10](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$MatchesRegexTest.whenNotMet$thenFalse(com.github.valid8j.ut.utilstest.PredicatesTest$MatchesRegexTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[58: INVARIANT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.AssertionsTest$Failing (39 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[80: POSTCONDITION: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[137: REQUIRE_STATES: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[20](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[19](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[23](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[201: UNLESS_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[128: REQUIRE_ARGUMENT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[25](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_isNullOrEmpty(com.github.valid8j.ut.styles.MoreFluentStringTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[32](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[33](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[21: DOLLAR: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[145: REQUIRE_STATE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[13: Given:<[]>:When::Then:identicalWith(value:[])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (10 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[30](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[51: Given:<"A:B">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[141: REQUIRE_STATES: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[15](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.RequiresTest.givenNonNullValue_whenRequireNonNull_thenValueReturned(com.github.valid8j.entrypoints.RequiresTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[30](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[8](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[115: REQUIRE_ARGUMENTS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[20: DOLLAR: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[116: REQUIRE_ARGUMENTS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[16](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[120: REQUIRE_ARGUMENTS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[103: REQUIRE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[92: REQUIRE_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[45: INVARIANTS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[29](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_Integer(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[20: Given:<"123">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[215: UNLESS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.exceptionThrowingMethod(com.github.valid8j.ut.internal.CallTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[203: UNLESS_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[38](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[1](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[10](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[194: ENSURE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.list_assertThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[38](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[144: REQUIRE_STATE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[77: POSTCONDITION: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[78: POSTCONDITION: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[6](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[56: INVARIANT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[174: HOLD: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[42: PRECONDITION: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[45: Given:<"XYZ">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[10: Given:<["X"]>:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (9 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[53: INVARIANTS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[197: ENSURE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[82: POSTCONDITION: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.typesupports.ListTest.testCollectionContains(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[59: INVARIANT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[132: REQUIRE_STATES: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[210: UNLESS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[129: REQUIRE_ARGUMENT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[17](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[180: ENSURE_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[230: EXPECT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[122: REQUIRE_ARGUMENT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[20](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[217: UNLESS: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[35](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[8](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[14](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$GeTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$GeTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenValidState_whenEnsureState_thenStateReturned(com.github.valid8j.entrypoints.EnsuresTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[14](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[54: INVARIANTS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[9](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.types.StreamTest.streamTransformerTest(com.github.valid8j.ut.types.StreamTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[85: POSTCONDITION: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[3](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[41: PRECONDITION: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[228: EXPECT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[128: REQUIRE_ARGUMENT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[23](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[223: EXPECT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[86: POSTCONDITION: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[50: INVARIANTS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[26](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[11](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[20](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[2](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$AllMatchTest.whenNot$thenFalse(com.github.valid8j.ut.utilstest.PredicatesTest$AllMatchTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[5](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[41](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$GtTest.whenNotMet$thenFalse(com.github.valid8j.ut.utilstest.PredicatesTest$GtTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[129: REQUIRE_ARGUMENT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[9](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[25](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[5](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[29](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[15](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[183: ENSURE_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[0: ALL: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[209: UNLESS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[73: Given:<"HELLO">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[229: EXPECT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[125: REQUIRE_ARGUMENT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[20: DOLLAR: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$ContainsStringTest.whenNotMet$thenFalse(com.github.valid8j.ut.utilstest.PredicatesTest$ContainsStringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[210: UNLESS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[207: UNLESS_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[58: INVARIANT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[95: REQUIRE_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[6: ALL: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testIsTrue(com.github.valid8j.ut.typesupports.BooleanTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[35](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[101: REQUIRE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[60: INVARIANT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[90: REQUIRE_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[156: HOLD_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[34](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[16](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest.parameterizedPredicateTest(com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[25](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[0](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[19](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$GeTest.whenNotMet$thenFalse(com.github.valid8j.ut.utilstest.PredicatesTest$GeTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[59: Given:<"hello">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.ut.internal.PrintablePredicateTest$Or (0 ms)
com.github.valid8j.entrypoints.AssertionsTest$MessageTest.givenLambda$whenPreconditionExercised_thenTrueReturned(com.github.valid8j.entrypoints.AssertionsTest$MessageTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[0: whenOnePredicateReturningFalseUnderAnyOf_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[21](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[32](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[27](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_disj$anyOf$_thenFail(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[124: REQUIRE_ARGUMENT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[32](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[10: ALL: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[230: EXPECT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[169: HOLD: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[51: INVARIANTS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[13](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[2](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[2: ALL: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[136: REQUIRE_STATES: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello3_b(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[54: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[10](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[42](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[42](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[38: PRECONDITION: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$GeTest.whenMet$thenTrue(com.github.valid8j.ut.utilstest.PredicatesTest$GeTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[32](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[36: PRECONDITION: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[154: HOLD_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[131: REQUIRE_ARGUMENT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[25: PRECONDITIONS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[0](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[193: ENSURE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[51: INVARIANTS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[18](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[168: HOLD: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[84: Given:<"Hello">:When::Then:identicalWith(value:Hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[24](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssumeAll_failed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[14](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[197: ENSURE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[211: UNLESS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.EnsuresTest.testEnsureNonNull(com.github.valid8j.entrypoints.EnsuresTest) (1 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withoutEvaluator_conj_thenPass(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[173: HOLD: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectingDifferentException_testFailing(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[28](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[43: PRECONDITION: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[38](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[42: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[28: PRECONDITIONS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.RequiresTest.givenValidState$whenRequireState$thenPass(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[18](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[25](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testContainsString(com.github.valid8j.ut.typesupports.StringTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[192: ENSURE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[0](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[4](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testIsFalse(com.github.valid8j.ut.typesupports.BooleanTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[7](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[36](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[33](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[3](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[175: HOLD: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[15: DOLLAR: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[173: HOLD: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[12](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.internal.NegateTest.whenInvertedTrasformingPredicateFails_thenPrintDesignedMessage$notMergedWhenMismatch(com.github.valid8j.ut.internal.NegateTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest.givenSomeFoundSomeNot$whenFindString$thenFailed(com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[3: givenTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[9: ALL: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[104: REQUIRE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[61: INVARIANT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_findRegexPatterns(com.github.valid8j.ut.styles.MoreFluentStringTest) (7 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[3](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[157: HOLD_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[12: DOLLAR: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[104: REQUIRE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[6](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[82: POSTCONDITION: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[172: HOLD: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (8 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[65: INVARIANT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[185: ENSURE_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[29: PRECONDITIONS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[101: REQUIRE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[35](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[61: Given:<"hello">:When:<<>.equals()>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[34: PRECONDITION: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[38: PRECONDITION: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[24: PRECONDITIONS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[27: Given:<"456">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[111: REQUIRE_ARGUMENTS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[221: EXPECT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[202: UNLESS_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[7: Given:<["A","B"]>:When::Then:identicalWith(value:[A, B])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[5](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[177: ENSURE_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[15](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[28](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[28](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[22](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[161: HOLD_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[203: UNLESS_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[53: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[224: EXPECT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[29: PRECONDITIONS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.PrintablesTest$PredicateTest.givenPredicateReturnedByNegate$whenToString$thenWorksRight(com.github.valid8j.ut.internal.PrintablesTest$PredicateTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[33](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[159: HOLD_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[23](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[15](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[31: Given:<"A">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.ut.internal.PrintablesTest$PredicateTest.givenPredicateReturnedByOr$whenToString$thenWorksRight(com.github.valid8j.ut.internal.PrintablesTest$PredicateTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[70: Given:<"HELLO">:When:,<>)->castTo[Boolean] THEN:isTrue>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenToBooleanIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[8](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[127: REQUIRE_ARGUMENT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[174: HOLD: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[19: Given:<"123">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectingExceptionButNotThrown_testFailing(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[37: PRECONDITION: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[13](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assertAllDifferentTypes_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[192: ENSURE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[180: ENSURE_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[12](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[229: EXPECT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[163: HOLD_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$LtTest.whenNotMet$thenFalse(com.github.valid8j.ut.utilstest.PredicatesTest$LtTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[97: REQUIRE_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[32](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[196: ENSURE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[188: ENSURE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidatesTest.test2(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_a(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[22](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[189: ENSURE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[32: PRECONDITIONS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[182: ENSURE_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireArgument_passing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindElementsTest.givenSomeToBeFoundSomeNotToBe$whenFindElements$thenFailed(com.github.valid8j.ut.utilstest.PredicatesTest$FindElementsTest) (1 ms)
com.github.valid8j.it.SmokeTest.givenBook_whenCheckTitleAndAbstract_thenTheyAreNotNullAndAppropriateLength_2(com.github.valid8j.it.SmokeTest) (12 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[95: REQUIRE_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[152: REQUIRE_STATE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[100: REQUIRE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[30](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[37](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[85: POSTCONDITION: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[91: REQUIRE_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[195: ENSURE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[165: HOLD: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[26: PRECONDITIONS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[175: HOLD: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[93: REQUIRE_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[126: REQUIRE_ARGUMENT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[32](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$GtTest.whenMet$thenTrue(com.github.valid8j.ut.utilstest.PredicatesTest$GtTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[13](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[3: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[6](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[149: REQUIRE_STATE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[26: PRECONDITIONS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[81: POSTCONDITION: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[0](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[14](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[4](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[7](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[24](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[26](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.internal.PrintablesTest$PredicateTest.givenPredicateReturnedByAnd$whenTest$thenWorksRight(com.github.valid8j.ut.internal.PrintablesTest$PredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[220: EXPECT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[9](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[19](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[28](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[213: UNLESS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[112: REQUIRE_ARGUMENTS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[16: DOLLAR: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[16](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.examples.test.ExamplesTest.testFluentExample(com.github.valid8j.examples.test.ExamplesTest) (4 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_nativePredicate(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[66: POSTCONDITIONS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[3](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[77: POSTCONDITION: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$LeTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$LeTest) (0 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validateState_pass(com.github.valid8j.entrypoints.ValidatesTest) (1 ms)
com.github.valid8j.ut.bugfixes.Issue42Test.givenPrivateClassOverridingPublicMethod$whenPublicMethodIsCalled$thenCallSucceeds(com.github.valid8j.ut.bugfixes.Issue42Test) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[31](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validateArgument_pass(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.ut.types.FloatTest.floatTestFail(com.github.valid8j.ut.types.FloatTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[214: UNLESS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[222: EXPECT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testWrapperIsFalse(com.github.valid8j.ut.typesupports.BooleanTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[78: Given:<"124">:When:identity->castTo[Integer] THEN:=[123]>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[92: REQUIRE_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireStatesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[8](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[160: HOLD_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[67: POSTCONDITIONS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[147: REQUIRE_STATE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[1: ALL: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[60: INVARIANT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[7: ALL: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[117: REQUIRE_ARGUMENTS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test7(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[148: REQUIRE_STATE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.utilstest.TestAssertionsTest.testAssumeThat(com.github.valid8j.ut.utilstest.TestAssertionsTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[9](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[19](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[87: POSTCONDITION: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[28: PRECONDITIONS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[120: REQUIRE_ARGUMENTS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.styles.MoreFluentListTest.test_size(com.github.valid8j.ut.styles.MoreFluentListTest) (1 ms)
com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest.helloError(com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[14](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[156: HOLD_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[114: REQUIRE_ARGUMENTS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[34](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[22: Given:<"123">:When::Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[158: HOLD_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[222: EXPECT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenTransformIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[68: POSTCONDITIONS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ValidatesTest.testValidateMethod$passing(com.github.valid8j.entrypoints.ValidatesTest) (1 ms)
com.github.valid8j.ut.bugfixes.Issue11Test.whenReproduceIssue(com.github.valid8j.ut.bugfixes.Issue11Test) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[172: HOLD: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed.testFailureFromComposeStructureInTransformer(com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[54: INVARIANTS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[27](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[99: REQUIRE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[10](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[27](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[2: whenPredicatesAllReturningTrueUnderAnyOf_thenPasses](com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest) (0 ms)
com.github.valid8j.ut.typesupports.ObjectTest.givenNull(com.github.valid8j.ut.typesupports.ObjectTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[6](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[28](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[54: INVARIANTS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[176: ENSURE_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[139: REQUIRE_STATES: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validate_fail(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[44: Given:<"false">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[122: REQUIRE_ARGUMENT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[45: INVARIANTS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[33](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[29](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[10](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[4](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[164: HOLD_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[4](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[41](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[3](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireNonNull(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[43](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[0: ALL: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.types.FloatTest.floatTest(com.github.valid8j.ut.types.FloatTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[32](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[41: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[138: REQUIRE_STATES: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[10](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[191: ENSURE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[4](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[145: REQUIRE_STATE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[27](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[179: ENSURE_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test8(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[32](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[70: POSTCONDITIONS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[62: INVARIANT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[10](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[138: REQUIRE_STATES: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test4(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[20](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireWithTransformingPredicate(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenCheckIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[215: UNLESS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[60: Given:<"hello">:When:,<>)>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[23](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[226: EXPECT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[158: HOLD_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssumeAll_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[1](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[31](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[42: PRECONDITION: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[6](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[12](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[12](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[114: REQUIRE_ARGUMENTS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[31](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[55: INVARIANT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.TransformingPredicateTest.testHashCodeSimply(com.github.valid8j.ut.internal.TransformingPredicateTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[17: DOLLAR: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.narrowerMethodIsChosen(com.github.valid8j.ut.internal.CallTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[69: POSTCONDITIONS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[25](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$AnyMatchTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$AnyMatchTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[41](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[12](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_b2(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[78: POSTCONDITION: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[31: PRECONDITIONS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[28](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[36: PRECONDITION: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.CallTest.cannotCallPrimitiveParameterMethodWithNull(com.github.valid8j.ut.internal.CallTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[97: REQUIRE_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessUsingCustomPredicateWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[153: REQUIRE_STATE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.CallTest.methodAmbiguous_primitiveBoxed(com.github.valid8j.ut.internal.CallTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[36: PRECONDITION: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[4](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[2](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[22](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireArgument(com.github.valid8j.entrypoints.RequiresTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[72: POSTCONDITIONS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[182: ENSURE_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[12](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[4: ALL: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireValuesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assumeThatTest_failed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.methodAmbiguous(com.github.valid8j.ut.internal.CallTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[209: UNLESS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[29](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[31](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessUsingCustomPredicateWithSlightlyDifferentString_thenExpectationSpecificFragmentsContainedOnlyByExplanationForExpectationAndActualValuesAreAlsoSo(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureStatesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalHashCode[38](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[9](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[23: PRECONDITIONS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[14: DOLLAR: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[39: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[5: ALL: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[203: UNLESS_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[17](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[1: ALL: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[76: POSTCONDITIONS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[123: REQUIRE_ARGUMENT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[112: REQUIRE_ARGUMENTS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat(com.github.valid8j.ut.utilstest.ReportDetailTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[98: REQUIRE_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[147: REQUIRE_STATE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[64: INVARIANT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithItself[24](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$ToEvaluableIfNecessaryTest.givenNonEvaluable$whenToEvaluableIfNecessary$thenConverted(com.github.valid8j.ut.internal.InternalUtilsTest$ToEvaluableIfNecessaryTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.sameObject[13](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[5](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[4: ALL: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test2(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.returnsSameHashCode[8](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.internal.PrintablePredicateTest$LeafPred.test(com.github.valid8j.ut.internal.PrintablePredicateTest$LeafPred) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[198: UNLESS_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[11](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[146: REQUIRE_STATE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test1(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[79: Given:<"124">:When:identity->castTo[Short] THEN:=[123]>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[227: EXPECT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[150: REQUIRE_STATE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$AllMatchTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$AllMatchTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[21](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[0: ALL: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (15 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[30](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[193: ENSURE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[125: REQUIRE_ARGUMENT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithAnother[27](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[178: ENSURE_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[0: givenStreamPredicate$RequireConditionResultingInNPE$_whenUnexpectedValue_thenComparisonFailure2](com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[212: UNLESS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[16](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[1: givenDoubleChainedTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (2 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$MessageTest.testFormat(com.github.valid8j.ut.utilstest.PredicatesTest$MessageTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenValidArgument_whenEnsure_thenValueReturned(com.github.valid8j.entrypoints.EnsuresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[55: INVARIANT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[18: DOLLAR: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[84: POSTCONDITION: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[35: Given:<"A">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[17: DOLLAR: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStreamTest.test_noneMatche(com.github.valid8j.ut.styles.MoreFluentStreamTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[44: INVARIANTS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[93: REQUIRE_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validateArgument_fail(com.github.valid8j.entrypoints.ValidatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[70: POSTCONDITIONS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[221: EXPECT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[28](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[179: ENSURE_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[72: POSTCONDITIONS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[208: UNLESS_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[132: REQUIRE_STATES: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.string_assertThat_useValue_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[121: REQUIRE_ARGUMENT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello4_a(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test4(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notEqualsWithForeignObject[34](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[42: PRECONDITION: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[57: INVARIANT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[63: INVARIANT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[109: REQUIRE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[143: REQUIRE_STATE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[220: EXPECT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[3](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[29](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.notSameObject[37](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[13](com.github.valid8j.ut.equallness.EqualnessTest) (3 ms)
com.github.valid8j.ut.typesupports.ListTest.testEmpty(com.github.valid8j.ut.typesupports.ListTest) (0 ms)

Report generated by PIT 1.7.3

1		package com.github.valid8j.pcond.core.printable;
2
3		import com.github.valid8j.pcond.core.Evaluable;
4		import com.github.valid8j.pcond.core.Evaluator;
5		import com.github.valid8j.pcond.core.identifieable.Identifiable;
6		import com.github.valid8j.pcond.experimentals.currying.context.CurriedContext;
7		import com.github.valid8j.pcond.internals.InternalUtils;
8		import com.github.valid8j.pcond.forms.Predicates;
9
10		import java.util.*;
11		import java.util.function.BinaryOperator;
12		import java.util.function.Function;
13		import java.util.function.Predicate;
14		import java.util.function.Supplier;
15		import java.util.stream.Stream;
16
17		import static java.lang.String.format;
18		import static java.util.Arrays.asList;
19		import static java.util.Collections.emptyList;
20		import static java.util.Collections.singletonList;
21		import static java.util.Objects.requireNonNull;
22		import static java.util.stream.Collectors.joining;
23		import static java.util.stream.Collectors.toList;
24
25		public enum PrintablePredicateFactory {
26		NEGATION,
27		CONJUNCTION,
28		DISJUNCTION,
29		LEAF,
30		;
31
32		private static <T> PrintablePredicate<T> toPrintablePredicateIfNotPrintable(Predicate<T> predicate) {
33	1 1. toPrintablePredicateIfNotPrintable : replaced return value with null for com/github/valid8j/pcond/core/printable/PrintablePredicateFactory::toPrintablePredicateIfNotPrintable → KILLED	return (PrintablePredicate<T>) toLeafIfNotPrintable(predicate);
34		}
35
36		public static <T> Predicate<T> toLeafIfNotPrintable(Predicate<T> predicate) {
37	1 1. toLeafIfNotPrintable : negated conditional → KILLED	if (!(predicate instanceof PrintablePredicate))
38	1 1. toLeafIfNotPrintable : replaced return value with null for com/github/valid8j/pcond/core/printable/PrintablePredicateFactory::toLeafIfNotPrintable → KILLED	return leaf(Identifiable.formatObjectName(predicate), predicate);
39	1 1. toLeafIfNotPrintable : replaced return value with null for com/github/valid8j/pcond/core/printable/PrintablePredicateFactory::toLeafIfNotPrintable → KILLED	return predicate;
40		}

PrintablePredicateFactory.java

Mutations

Active mutators

Tests examined