PrintablePredicateFactory.java

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

import com.github.dakusui.pcond.core.Evaluable;

import com.github.dakusui.pcond.core.Evaluator;

import com.github.dakusui.pcond.experimentals.currying.context.CurriedContext;

import com.github.dakusui.pcond.core.identifieable.Identifiable;

import com.github.dakusui.pcond.forms.Predicates;

import com.github.dakusui.pcond.internals.InternalUtils;

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 com.github.dakusui.pcond.core.identifieable.Identifiable.argsOf;

import static com.github.dakusui.pcond.core.identifieable.Identifiable.creatorOf;

import static com.github.dakusui.pcond.internals.InternalUtils.*;

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 creatorOf(predicate)

        .map(c -> new LeafPredicate<>(c, 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);

  }

  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 formatObject(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 = 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;

    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 = toEvaluableIfNecessary(function);

      this.mapperName = mapperName;

      this.checker = 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 = 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),

          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)),

          toEvaluableIfNecessary((Predicate<? super Stream<E>>) 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),

          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.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[61: Given:<"hello">:When:<<>.equals()>:Then:identicalWith(value:hello)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[3](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[1](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.ListTest.testAllMatch(com.github.dakusui.ut.valid8j.compatibility.ListTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[34](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$GtTest.whenMet$thenTrue(com.github.dakusui.ut.thincrest.ut.PredicatesTest$GtTest) (0 ms)
• com.github.dakusui.ut.valid8j.compatibility.ListTest.testCollectionContains(com.github.dakusui.ut.valid8j.compatibility.ListTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[22](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[0](com.github.dakusui.pcond.equallness.EqualnessTest) (5 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[16](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[35](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[10](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[15](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[28](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[41](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello_a(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[30](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[36](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[22](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[51: Given::When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[25: Given:<"456">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (6 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[9](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.propertybased.tests.StreamAllMatchPredicateTest.exerciseTestCase[0: givenStreamPredicate_whenExpectedValue_thenValueReturned](com.github.dakusui.pcond.propertybased.tests.StreamAllMatchPredicateTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[15](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[28](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[12](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[35](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_matchesRegex(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (0 ms)
• com.github.dakusui.pcond.propertybased.tests.CurriedContextPredicateTest.exerciseTestCase[0: givenVariableBundlePredicate_whenExpectedValue_thenValueReturned](com.github.dakusui.pcond.propertybased.tests.CurriedContextPredicateTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$EqTest.whenToString$thenLooksGood(com.github.dakusui.ut.thincrest.ut.PredicatesTest$EqTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[24](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.testY(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[28](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[0](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.CallTest.narrowerMethodIsChosen(com.github.dakusui.pcond.CallTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[19](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[7](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[11](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.TestAssertionsTest.testAssumeThat(com.github.dakusui.ut.thincrest.ut.TestAssertionsTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[0: Given::When::Then:identicalWith(value:true)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (8 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.string_assertThatTest_failed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[3](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[32](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[29](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[42](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[39](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenIsTrueAndIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[26](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[39](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[41](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_Integer(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[11](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[41](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testMatchesRegex(com.github.dakusui.ut.valid8j.compatibility.StringTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[31](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentListTest.test_elementAt(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentListTest) (1 ms)
• com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withEvaluator_nativePredicate(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssertAll_failed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (3 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$IsNullTest (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[17](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[8](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[8](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$LeTest.whenToString$thenLooksGood(com.github.dakusui.ut.thincrest.ut.PredicatesTest$LeTest) (0 ms)
• com.github.dakusui.pcond.ut.TransformingPredicateTest.testHashCodeSimply(com.github.dakusui.pcond.ut.TransformingPredicateTest) (1 ms)
• com.github.dakusui.pcond.propertybased.tests.AllOfPredicateTest.exerciseTestCase[0: whenOnePredicateReturningFalseUnderAllOf_whenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.AllOfPredicateTest) (9 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[68: Given::When::Then:identicalWith(value:null)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[21](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[8](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[43](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[25](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$AllMatchTest.whenMet$thenTrue(com.github.dakusui.ut.thincrest.ut.PredicatesTest$AllMatchTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[30](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[28](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[13](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[10](com.github.dakusui.pcond.equallness.EqualnessTest) (11 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[37](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[8](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[17](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[21](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$MatchesRegexTest.whenToString$thenLooksGood(com.github.dakusui.ut.thincrest.ut.PredicatesTest$MatchesRegexTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[26](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[2: Given::When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (6 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[21: Given:<"123">:When::Then:identicalWith(value:123)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[13](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$EqTest.whenMet$thenTrue(com.github.dakusui.ut.thincrest.ut.PredicatesTest$EqTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[43](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[30](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[17](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[27](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[9](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello4(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_Short(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[26](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[40](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[50: Given::When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (6 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[24](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[22: Given:<"123">:When::Then:identicalWith(value:123)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (6 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[4: Given::When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[36](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.givenString$hello$_whenTransformToContextAndCheckContextValueIsNull_thenPreconditionViolationWithCorrectMessageThrown(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[5](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[10](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[20](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[47: Given:<"A:B">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[16](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[3](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenString_whenFails_then(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.givenStreamOfSingleString$hello$_whenRequireNonNullIsFound_thenPassing(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_endingWith(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$AnyMatchTest.whenNot$thenFalse(com.github.dakusui.ut.thincrest.ut.PredicatesTest$AnyMatchTest) (0 ms)
• com.github.dakusui.pcond.CallTest.methodAmbiguous_primitiveBoxed_negated(com.github.dakusui.pcond.CallTest) (11 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[18](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[2](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[8](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[32](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[24](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$MessageTest.testFormat(com.github.dakusui.ut.thincrest.ut.PredicatesTest$MessageTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[33](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testEqualsIgnoreCase(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$GtTest.whenNotMet$thenFalse(com.github.dakusui.ut.thincrest.ut.PredicatesTest$GtTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[5: Given:<["A","B","C"]>:When::Then:identicalWith(value:[A, B, C])]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[13](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[12](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[34](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[12](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withEvaluator_disj_thenPass(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (0 ms)
• com.github.dakusui.pcond.ut.PrintablePredicateTest$LeafPred.testHashCode(com.github.dakusui.pcond.ut.PrintablePredicateTest$LeafPred) (0 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$NoneMatchTest.whenToString$thenLooksGood(com.github.dakusui.ut.thincrest.ut.PredicatesTest$NoneMatchTest) (0 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[9](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[19](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.BooleanTest.testWrapperIsTrue(com.github.dakusui.ut.valid8j.compatibility.BooleanTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentListTest.test_stream(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentListTest) (2 ms)
• com.github.dakusui.pcond.types.StreamTest.streamTestFailure(com.github.dakusui.pcond.types.StreamTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[16](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[10](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[32](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.EnsuresTest (5 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[23](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[36: Given::When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[64: Given:<"HELLO">:When:,<>)>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (6 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[12](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$IsInstanceOfTest.test(com.github.dakusui.ut.thincrest.ut.PredicatesTest$IsInstanceOfTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[18](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[13](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.PrintablesFunctionTest$Composed.testFailureFromComposeStructureInTransformer(com.github.dakusui.pcond.PrintablesFunctionTest$Composed) (5 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.testValidateMethod$passing(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[31: Given:<"A">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[19](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[23](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_greaterThanOrEqualTo(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$AnyMatchTest.whenToString$thenLooksGood(com.github.dakusui.ut.thincrest.ut.PredicatesTest$AnyMatchTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assumeThatTest_passed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[29](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.compatibility.ListTest.testListContains(com.github.dakusui.ut.valid8j.compatibility.ListTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[43](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[31](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assertAllDifferentTypes_passed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[29](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[0](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[37](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[8](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[4](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[26](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$AndTest (0 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[6](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[14](com.github.dakusui.pcond.equallness.EqualnessTest) (5 ms)
• com.github.dakusui.pcond.CallTest.methodNotFound(com.github.dakusui.pcond.CallTest) (3 ms)
• com.github.dakusui.pcond.types.FloatTest.floatTransformerTest(com.github.dakusui.pcond.types.FloatTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[26](com.github.dakusui.pcond.equallness.EqualnessTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[33](com.github.dakusui.pcond.equallness.EqualnessTest) (7 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testSameAs(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.FluentUtilsTest.test4(com.github.dakusui.ut.thincrest.ut.FluentUtilsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[37](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[3](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[4](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.propertybased.tests.NegatedPredicateTest.exerciseTestCase[0: givenNegatedSimplePredicateReturningFalse_whenExpectedValue_thenValueReturned](com.github.dakusui.pcond.propertybased.tests.NegatedPredicateTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[21](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[9: Given:<["X"]>:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (6 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[21](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[34](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.PrintablesFunctionTest$Simple.testHandleNull(com.github.dakusui.pcond.PrintablesFunctionTest$Simple) (2 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[0](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStreamTest.test_allMatch(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStreamTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[42](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.compatibility.ObjectTest.givenNull(com.github.dakusui.ut.valid8j.compatibility.ObjectTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureStatesTest_failing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[11](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.test(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[28: Given:<"456">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[7](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello_b_e5(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (4 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello3_b(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[1: Given::When::Then:identicalWith(value:true)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (7 ms)
• com.github.dakusui.pcond.propertybased.tests.StreamAllMatchPredicateTest.exerciseTestCase[1: givenStreamPredicate_whenUnexpectedNullValue_thenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.StreamAllMatchPredicateTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[3](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[5](com.github.dakusui.pcond.equallness.EqualnessTest) (7 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[66: Given:<"HELLO">:When:,<>)->castTo[Boolean] THEN:isTrue>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[23](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[43](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[38](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[80: Given:<"Hello">:When::Then:identicalWith(value:Hello)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello_b(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[26](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.CallTest.methodAmbiguous_primitiveBoxed(com.github.dakusui.pcond.CallTest) (61 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[81: Given:<"Bye">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[3](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[14](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100_conj(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[5](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[5](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[27: Given:<"456">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[5](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureValue_passing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[9](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[24](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[21](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[6](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[11](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssumeAll_failed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (3 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindElementsTest.givenAllFound$whenFindElements$thenPassed(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindElementsTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[75: Given:<"124">:When:identity->castTo[Short] THEN:=[123]>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[16](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$GeTest.whenNotMet$thenFalse(com.github.dakusui.ut.thincrest.ut.PredicatesTest$GeTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_postconditions(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[40](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[22](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_that(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello5(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[33](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[3](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[42](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[35](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[22](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.ut.PrintablesTest$PredicateTest.givenPredicateReturnedByOr$whenTest$thenWorksRight(com.github.dakusui.pcond.ut.PrintablesTest$PredicateTest) (0 ms)
• com.github.dakusui.ut.valid8j.compatibility.ListTest.testNoneMatch(com.github.dakusui.ut.valid8j.compatibility.ListTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[11](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_isEmpty(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[36](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[35](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.types.FloatTest.toFloatTest(com.github.dakusui.pcond.types.FloatTest) (3 ms)
• com.github.dakusui.pcond.CallTest.methodIncompatible(com.github.dakusui.pcond.CallTest) (2 ms)
• com.github.dakusui.pcond.NegateTest.whenInvertedTrasformingPredicateFails_thenPrintDesignedMessage$notMergedWhenMismatch(com.github.dakusui.pcond.NegateTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[3](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[28](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[3](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[15](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[7](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[3: givenTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest) (5 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[41](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[35](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_all(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[37](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[14](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[6](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenCheckIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[15](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[25](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.CallTest.exceptionThrowingMethod(com.github.dakusui.pcond.CallTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[37](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.test_validate_pass(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$OrTest.performSingleOr$thenTrue(com.github.dakusui.ut.thincrest.ut.PredicatesTest$OrTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[4](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[2](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[7: Given:<["A","B"]>:When::Then:identicalWith(value:[A, B])]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$GtTest.whenToString$thenLooksGood(com.github.dakusui.ut.thincrest.ut.PredicatesTest$GtTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[4](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[27](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[2](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[39](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[8](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[56: Given:<"hello">:When:,<>)>:Then:identicalWith(value:hello)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[14](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$IsNotNullTest (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[2](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[25](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireArgument_passing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[3](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[33: Given:<"A">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[10](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[37](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[18: Given:<["X"]>:When:] THEN:isEmpty>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (8 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[43](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[14](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[31](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[37](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[22](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[34](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[5](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[40: Given:<"false">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.int_assertThatTest_passed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_Long(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (1 ms)
• com.github.dakusui.pcond.ut.InternalUtilsTest$ToEvaluableIfNecessaryTest.givenNonEvaluable$whenToEvaluableIfNecessary$thenConverted(com.github.dakusui.pcond.ut.InternalUtilsTest$ToEvaluableIfNecessaryTest) (0 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello_b2(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.BooleanTest.testIsTrue(com.github.dakusui.ut.valid8j.compatibility.BooleanTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[18](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[3: givenStreamPredicate$hello_b_e_4$_whenUnexpectedValue_thenComparisonFailure2](com.github.dakusui.pcond.propertybased.tests.StreamNoneMatchPredicateTest) (7 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[34](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[20](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.bugfixes.Issue11Test.whenReproduceIssue(com.github.dakusui.pcond.bugfixes.Issue11Test) (7 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_findRegexPatterns(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessUsingCustomPredicateWithSlightlyDifferentString_thenExpectationSpecificFragmentsContainedOnlyByExplanationForExpectationAndActualValuesAreAlsoSo(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (3 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$EqTest.whenNotMet$thenFalse(com.github.dakusui.ut.thincrest.ut.PredicatesTest$EqTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[38](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.compatibility.BooleanTest.testIsFalse(com.github.dakusui.ut.valid8j.compatibility.BooleanTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[1](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[13](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[13](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireValue_passing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[36](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[23](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest.givenTrue_whenIsTrue_thenPass(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[20](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[10](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureState_passing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[79: Given:<"123.5">:When:identity->castTo[Double] THEN:=[123.4]>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[26](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[1](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[12](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[28](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[14](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_postcondition(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[34: Given::When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[39](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[9](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[15](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.RequiresTest (10 ms)
• com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withEvaluator_disj$or$_thenFail(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[24](com.github.dakusui.pcond.equallness.EqualnessTest) (4 ms)
• com.github.dakusui.ut.thincrest.ut.TestAssertionsTest.testAnyOf(com.github.dakusui.ut.thincrest.ut.TestAssertionsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[12](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[16](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[1](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[23](com.github.dakusui.pcond.equallness.EqualnessTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[23](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.NegateTest.whenInvertedTrasformingPredicateFails_thenPrintDesignedMessage$mergedWhenNotMismatch(com.github.dakusui.pcond.NegateTest) (5 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[38: Given::When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.ut.PrintablePredicateTest$And (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[7](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testIsEmptyOrNullString(com.github.dakusui.ut.valid8j.compatibility.StringTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[36](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[49: Given::When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (7 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[67: Given:<"HELLO">:When:<<>.equals()->castTo[Boolean] THEN:isTrue>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[0](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[3](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[30: Given:<"A">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[15](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$IsInstanceOfTest.whenIsInstanceOfUsedInComposite_thenNoExplicitTypeParameterIsNeeded(com.github.dakusui.ut.thincrest.ut.PredicatesTest$IsInstanceOfTest) (0 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testIsEmptyString(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[4](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[21](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[2](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.propertybased.tests.SimplePredicateTest.exerciseTestCase[0: givenSimplePredicate_whenExpectedValue_thenValueReturned](com.github.dakusui.pcond.propertybased.tests.SimplePredicateTest) (0 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testContainsString(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[19](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[33](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[39](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindElementsTest.givenSomeToBeFoundSomeNotToBe$whenFindElements$thenFailed(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindElementsTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[41](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.test_validate_fail(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (2 ms)
• com.github.dakusui.pcond.types.StreamTest.streamTransformerTest(com.github.dakusui.pcond.types.StreamTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[16](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[2](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[14](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.experimentals.TestAssertionsCurriedFunctionsTest.helloError(com.github.dakusui.pcond.experimentals.TestAssertionsCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[6](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.list_assertThatTest_passed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
• com.github.dakusui.pcond.propertybased.tests.AllOfPredicateTest.exerciseTestCase[2: whenPredicatesFirstReturningFalseRestReturningTrueUnderAllOf_whenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.AllOfPredicateTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[39](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_equalsIgnoreCase(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[27](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[1](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[8: Given:<["A","B"]>:When::Then:identicalWith(value:[A, B])]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (9 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[32](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[3: Given::When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[40](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[36](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[1: givenDoubleChainedTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest) (5 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.nestedLoop_success(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[2](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[0](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$ContainsStringTest.whenToString$thenLooksGood(com.github.dakusui.ut.thincrest.ut.PredicatesTest$ContainsStringTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStreamTest.test_anyMatch(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStreamTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[17: Given:<[]>:When:] THEN:isEmpty>:Then:identicalWith(value:[])]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (9 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testEqualTo(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 ms)
• com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[0: givenChainedTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[14](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[37](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[4](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[13](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[48: Given:<"A:B">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[26](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[77: Given:<"123.4">:When:identity->castTo[Double] THEN:=[123.4]>:Then:identicalWith(value:123.4)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[24](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[15](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[65: Given:<"HELLO">:When:<<>.equals()>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (6 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$ContainsStringTest.whenMet$thenTrue(com.github.dakusui.ut.thincrest.ut.PredicatesTest$ContainsStringTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[27](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[7](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[25](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[12](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[21](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_findRegexes(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[18](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[24](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[32](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.stream_assertThatTest_passed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.test_validateState_pass(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[40](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[40](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello_c(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello2(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.pcond.ut.fluent4.SmokeTest.givenBook_whenCheckTitleAndAbstract_thenTheyAreNotNullAndAppropriateLength_2(com.github.dakusui.pcond.ut.fluent4.SmokeTest) (27 ms)
• com.github.dakusui.pcond.ut.PrintablePredicateTest$Or (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[20](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[12](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$AllMatchTest.whenNot$thenFalse(com.github.dakusui.ut.thincrest.ut.PredicatesTest$AllMatchTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[38](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_lessThan(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[26](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.types.StreamTest.streamTransformerTestFailure(com.github.dakusui.pcond.types.StreamTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testStartsWith(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_equalTo(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[8](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[12](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenString_whenFails_then_2(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[25](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[12](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest.givenSomeFoundSomeNot$whenFindString$thenFailed(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[63: Given:<"hello">:When:<<>.equals()->castTo[Boolean] THEN:isTrue>:Then:identicalWith(value:hello)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[31](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.test_validateArgument_fail(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[11](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenTransformIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello6(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$AllMatchTest.whenToString$thenLooksGood(com.github.dakusui.ut.thincrest.ut.PredicatesTest$AllMatchTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[27](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[20](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[52: Given:<"hello">:When:<==[hello]>:Then:identicalWith(value:hello)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_startingWith(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[7](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_Float(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[15](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.string_assertThat_useValue_passed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[29: Given:<"A">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.test_validateArgument_pass(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (1 ms)
• com.github.dakusui.pcond.experimentals.TestAssertionsCurriedFunctionsTest.parameterizedPredicate_(com.github.dakusui.pcond.experimentals.TestAssertionsCurriedFunctionsTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.test_validateNonNull_pass(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[40](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[11](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[20](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireArgumentsTest_failing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[7](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.TestAssertionsTest.testAllOf(com.github.dakusui.ut.thincrest.ut.TestAssertionsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[37](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[0](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[1](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[23](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[0](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_contains(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[16](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[29](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[2](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.BooleanTest.testWrapperIsFalse(com.github.dakusui.ut.valid8j.compatibility.BooleanTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[43](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[45: Given:<"A:B:C">:When::Then:identicalWith(value:A:B:C)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[15](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[2](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.types.FloatTest.floatTest(com.github.dakusui.pcond.types.FloatTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[41](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[74: Given:<"124">:When:identity->castTo[Integer] THEN:=[123]>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[15](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[24: Given:<"456">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (7 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[31](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[12: Given:<[]>:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (10 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[39: Given:<"true">:When::Then:identicalWith(value:true)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.propertybased.tests.SimplePredicateTest.exerciseTestCase[1: givenSimplePredicate_whenUnexpectedValue_thenComparisonFailureThrown](com.github.dakusui.pcond.propertybased.tests.SimplePredicateTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[13](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[19](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[6](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[29](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withoutEvaluator_conj_thenFail(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[38](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$GeTest.whenToString$thenLooksGood(com.github.dakusui.ut.thincrest.ut.PredicatesTest$GeTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[16](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$LtTest.whenMet$thenTrue(com.github.dakusui.ut.thincrest.ut.PredicatesTest$LtTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[55: Given:<"hello">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[11](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_Double(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (1 ms)
• com.github.dakusui.pcond.bugfixes.Issue42Test.givenPrivateClassOverridingPublicMethod$whenPublicMethodIsCalled$thenCallSucceeds(com.github.dakusui.pcond.bugfixes.Issue42Test) (5 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[41](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssumeAll_passed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[25](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[22](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[2](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[1](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[19](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[28](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[32](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[34](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.AssertionsTest$MessageTest.composeMessage$thenComposed(com.github.dakusui.ut.valid8j.ut.AssertionsTest$MessageTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[7](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[29](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[1](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[38](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[0](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_findSubstrings(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[42](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[5](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[35: Given::When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.CallTest.nullCanMatch(com.github.dakusui.pcond.CallTest) (3 ms)
• com.github.dakusui.pcond.types.FloatTest.floatSatisfiesTest(com.github.dakusui.pcond.types.FloatTest) (1 ms)
• com.github.dakusui.pcond.ut.PrintablesTest$PredicateTest.givenPredicateReturnedByNegate$whenTest$thenWorksRight(com.github.dakusui.pcond.ut.PrintablesTest$PredicateTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[13](com.github.dakusui.pcond.equallness.EqualnessTest) (4 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireStatesTest_failing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[22](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[42](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[15: Given:<[]>:When:] THEN:isEmpty>:Then:identicalWith(value:[])]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (9 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[26: Given:<"456">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[16](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.ut.PrintablePredicateTest$Negate (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireValuesTest_failing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[40](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[30](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[28](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[9](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[42](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[27](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[24](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[40](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.testValidateMethod$failing(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[10](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[22](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[4](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$MatchesRegexTest.whenMet$thenTrue(com.github.dakusui.ut.thincrest.ut.PredicatesTest$MatchesRegexTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[41](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$EqTest.whenHashCode$thenSameIsSameAndDifferentIsDifferent(com.github.dakusui.ut.thincrest.ut.PredicatesTest$EqTest) (0 ms)
• com.github.dakusui.pcond.CallTest.methodAmbiguous(com.github.dakusui.pcond.CallTest) (9 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[42](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[72: Given:<"123">:When:identity->castTo[Short] THEN:=[123]>:Then:identicalWith(value:123)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[6](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[5](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[30](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[8](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.CallTest.nullReturningFunctionAsPredicate(com.github.dakusui.pcond.CallTest) (4 ms)
• com.github.dakusui.pcond.ut.TransformingPredicateTest.testEquals(com.github.dakusui.pcond.ut.TransformingPredicateTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[19: Given:<"123">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:identicalWith(value:123)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (9 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[32: Given:<"A">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.ut.PrintablesTest$PredicateTest.givenPredicateReturnedByAnd$whenTest$thenWorksRight(com.github.dakusui.pcond.ut.PrintablesTest$PredicateTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[5](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[9](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[20](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[34](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[36](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.boolean_assertThatTest_passed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.AssertionsTest$Passing.testAssertPrecondition$thenPassing(com.github.dakusui.ut.valid8j.ut.AssertionsTest$Passing) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[54: Given:<"hello">:When:<==[hello]>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[14](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[17](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[38](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[9](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[32](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[23](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[27](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[27](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[36](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.AssertionsTest$Passing.testAssertThatValue$thenPass(com.github.dakusui.ut.valid8j.ut.AssertionsTest$Passing) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureValuesTest_failing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[30](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[27](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[4](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[17](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.reqireState_passing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (3 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest.givenSomeFoundSomeNotFound$whenFindRegexes$thenFailed(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[37: Given::When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessUsingCustomPredicateWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[44: Given:<"A:B:C">:When::Then:identicalWith(value:A:B:C)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[35](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$NoneMatchTest.whenMet$thenTrue(com.github.dakusui.ut.thincrest.ut.PredicatesTest$NoneMatchTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[1](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[4](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[2: givenStreamPredicate$hello_b_e_2$_whenUnexpectedValue_thenComparisonFailure2](com.github.dakusui.pcond.propertybased.tests.StreamNoneMatchPredicateTest) (8 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[33](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[62: Given:<"hello">:When:,<>)->castTo[Boolean] THEN:isTrue>:Then:identicalWith(value:hello)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[38](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[29](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[31](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[17](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[11](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_isNullOrEmpty(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[25](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[10: Given:<["X"]>:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (7 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[14: Given:<["X"]>:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (9 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[41: Given:<"XYZ">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[43](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[18](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest.givenAllFound$whenFindString$thenPassed(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[13](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.given$hello$_$world$_whenRequireNestedStreamImpossibleConditions_thenPreconditionViolationExceptionWithCorrectMessage(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (16 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[14](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[25](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$LeTest.whenMet$thenTrue(com.github.dakusui.ut.thincrest.ut.PredicatesTest$LeTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[9](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.givenStream_whenRequireConditionResultingInNPE_thenInternalExceptionWithCorrectMessageAndNpeAsNestedException(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withEvaluator_disj$anyOf$_thenFail(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[38](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest.givenAllFound$whenFindRegexes$thenPassed(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest) (8 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[18](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$AnyMatchTest.whenMet$thenTrue(com.github.dakusui.ut.thincrest.ut.PredicatesTest$AnyMatchTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_greaterThan(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
• com.github.dakusui.pcond.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[0: givenStreamPredicate$RequireConditionResultingInNPE$_whenUnexpectedValue_thenComparisonFailure2](com.github.dakusui.pcond.propertybased.tests.StreamNoneMatchPredicateTest) (7 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.givenStreamOfSingleString$hello$_whenRequireNullIsFound_thenPreconditionViolationWithCorrectMessageIsThrown(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[17](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[13](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[20: Given:<"123">:When::Then:identicalWith(value:123)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.ut.thincrest.examples.JUnitBasedExamplesTest.testExampleUT(com.github.dakusui.ut.thincrest.examples.JUnitBasedExamplesTest) (20 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[9](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$LtTest.whenNotMet$thenFalse(com.github.dakusui.ut.thincrest.ut.PredicatesTest$LtTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[9](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.object_assertThatTest_passed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[31](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[35](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[9](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[0: whenOnePredicateReturningFalseUnderAnyOf_whenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.AnyOfPredicateTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[13: Given:<[]>:When::Then:identicalWith(value:[])]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (10 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectingExceptionButNotThrown_testFailing(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (12 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[36](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[19](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello_d_1(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[41](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$EqTest.whenEqualityIsChecked$thenSameIsSameAndDifferentIsDifferent(com.github.dakusui.ut.thincrest.ut.PredicatesTest$EqTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[20](com.github.dakusui.pcond.equallness.EqualnessTest) (8 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[0](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[26](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[36](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[57: Given:<"hello">:When:<<>.equals()>:Then:identicalWith(value:hello)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[34](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.ut.PrintablePredicateTest$LeafPred.test(com.github.dakusui.pcond.ut.PrintablePredicateTest$LeafPred) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello3(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[29](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[4](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[30](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[2](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[12](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.types.StreamTest.streamTest(com.github.dakusui.pcond.types.StreamTest) (5 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[6](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[42](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[39](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[31](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[23](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$LtTest.whenToString$thenLooksGood(com.github.dakusui.ut.thincrest.ut.PredicatesTest$LtTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[6: Given:<["A","B","C"]>:When::Then:identicalWith(value:[A, B, C])]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.AssertionsTest$Passing.testAssertPostcondition$thenPassing(com.github.dakusui.ut.valid8j.ut.AssertionsTest$Passing) (0 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringTest.example(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[31](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.propertybased.tests.StreamAllMatchPredicateTest.exerciseTestCase[2: givenStreamPredicate_whenUnexpectedValue_thenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.StreamAllMatchPredicateTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[24](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[18](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withoutEvaluator_conj_thenPass(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[4](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[19](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[12](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[69: Given:<"HELLO">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.experimentals.TestAssertionsCurriedFunctionsTest.toContextPredicateTest(com.github.dakusui.pcond.experimentals.TestAssertionsCurriedFunctionsTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[33](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[39](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[70: Given:<"123">:When:identity->castTo[Long] THEN:=[123]>:Then:identicalWith(value:123)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[20](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[24](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat_usingFluentStyle(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectingDifferentException_testFailing(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$GeTest.whenMet$thenTrue(com.github.dakusui.ut.thincrest.ut.PredicatesTest$GeTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[15](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[59: Given:<"hello">:When:<<>.equals()->castTo[Boolean] THEN:isTrue>:Then:identicalWith(value:hello)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[37](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.PrintablesTest$PredicateTest.givenPredicateReturnedByOr$whenToString$thenWorksRight(com.github.dakusui.pcond.ut.PrintablesTest$PredicateTest) (0 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[17](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.ut.PrintablesTest$PredicateTest.givenPredicateReturnedByNegate$whenToString$thenWorksRight(com.github.dakusui.pcond.ut.PrintablesTest$PredicateTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[6](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.string_assertThatTest_passed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[0](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[13](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[35](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[25](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[40](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[43: Given:<"A:B:C">:When::Then:identicalWith(value:A:B:C)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.ut.TransformingPredicateTest.givenNullForName$whenToString$thenLooksGood(com.github.dakusui.pcond.ut.TransformingPredicateTest) (0 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[11](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[35](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$LeTest.whenNotMet$thenFalse(com.github.dakusui.ut.thincrest.ut.PredicatesTest$LeTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assertAll_passed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$ContainsStringTest.whenNotMet$thenFalse(com.github.dakusui.ut.thincrest.ut.PredicatesTest$ContainsStringTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[73: Given:<"124">:When:identity->castTo[Long] THEN:=[123]>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectedExceptionThrown_testPassing(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
• com.github.dakusui.pcond.ut.TransformingPredicateTest.testHashCode(com.github.dakusui.pcond.ut.TransformingPredicateTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[60: Given:<"hello">:When:,<>)>:Then:identicalWith(value:hello)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[16](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[33](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[28](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[4](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[11: Given:<[]>:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (7 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[35](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[32](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.types.FloatTest.floatTestFail(com.github.dakusui.pcond.types.FloatTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.ListTest.testAnyMatch(com.github.dakusui.ut.valid8j.compatibility.ListTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[23](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[5](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[20](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[33](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[18](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$MatchesRegexTest.whenNotMet$thenFalse(com.github.dakusui.ut.thincrest.ut.PredicatesTest$MatchesRegexTest) (0 ms)
• com.github.dakusui.pcond.propertybased.tests.AllOfPredicateTest.exerciseTestCase[1: whenPredicatesAllReturningTrueUnderAllOf_thenPasses](com.github.dakusui.pcond.propertybased.tests.AllOfPredicateTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[39](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testIsInstanceOf(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[31](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[28](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testEndsWith(com.github.dakusui.ut.valid8j.compatibility.StringTest) (0 ms)
• com.github.dakusui.pcond.NegateTest.whenInvertedTransformingPredicateFails_thenPrintDesignedMessage$transformIsntLeafAndNotMerged(com.github.dakusui.pcond.NegateTest) (11 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[16](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[3](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[10](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[41](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assumeThatTest_failed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[8](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.FluentUtilsTest.expectationFlipping(com.github.dakusui.ut.thincrest.ut.FluentUtilsTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[43](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello_b3(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[10](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.types.FloatTest.floatTransformerTestFail(com.github.dakusui.pcond.types.FloatTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[38](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[7](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$NoneMatchTest.whenNot$thenFalse(com.github.dakusui.ut.thincrest.ut.PredicatesTest$NoneMatchTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[14](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[32](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[1](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[34](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[58: Given:<"hello">:When:,<>)->castTo[Boolean] THEN:isTrue>:Then:identicalWith(value:hello)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[17](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[38](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[1: givenStreamPredicate$hello_b_e$_whenUnexpectedValue_thenComparisonFailure2](com.github.dakusui.pcond.propertybased.tests.StreamNoneMatchPredicateTest) (18 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentListTest.test_isEmpty(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentListTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[16](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[30](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[43](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[71: Given:<"123">:When:identity->castTo[Integer] THEN:=[123]>:Then:identicalWith(value:123)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenToBooleanIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_lessThanOrEqualTo(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
• com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100$whenNull(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (4 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[32](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[42: Given::When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
• com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withEvaluator_transforming_thenFail(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[16: Given:<["X"]>:When:] THEN:isEmpty>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (8 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.nestedLoop_fail(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[11](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[19](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[18](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[6](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[21](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[0](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[76: Given:<"123.4">:When:identity->castTo[Float] THEN:=[123.4]>:Then:identicalWith(value:123.4)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (6 ms)
• com.github.dakusui.pcond.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[2: whenPredicatesFirstReturningFalseRestReturningTrueUnderAnyOf_thenPass](com.github.dakusui.pcond.propertybased.tests.AnyOfPredicateTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[25](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[7](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[5](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[14](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[40](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exerciseToString[10](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.PrintablesFunctionTest$Composed.testFailureFromAndThenStructureInTransformer(com.github.dakusui.pcond.PrintablesFunctionTest$Composed) (12 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello4_a(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[43](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[5](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.propertybased.tests.NegatedPredicateTest.exerciseTestCase[1: givenNegatedSimplePredicateReturningTrue_whenUnexpectedValue_thenComparisonFailureThrown](com.github.dakusui.pcond.propertybased.tests.NegatedPredicateTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[21](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[19](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_precondition(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStreamTest.test_noneMatche(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStreamTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[8](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[42](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[1: whenPredicatesAllReturningTrueUnderAnyOf_thenPasses](com.github.dakusui.pcond.propertybased.tests.AnyOfPredicateTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[39](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[33](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[21](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[7](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments_reversed[2](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[18](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[27](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithAnother[6](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notSameObject[8](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello3_a(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentListTest.test_size(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentListTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[33](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[46: Given:<"A:B">:When::Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[15](com.github.dakusui.pcond.equallness.EqualnessTest) (8 ms)
• com.github.dakusui.pcond.CallTest.cannotCallPrimitiveParameterMethodWithNull(com.github.dakusui.pcond.CallTest) (25 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithItself[6](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[17](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_preconditions(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[22](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[4: givenTwoChainedTransformingPredicates_whenNonExpectedValue_thenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest) (8 ms)
• com.github.dakusui.pcond.experimentals.TestAssertionsCurriedFunctionsTest.parameterizedPredicateTest(com.github.dakusui.pcond.experimentals.TestAssertionsCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[1](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[29](com.github.dakusui.pcond.equallness.EqualnessTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[17](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[10](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.TransformingPredicateTest.givenNonNullName$whenToString$thenLooksGood(com.github.dakusui.pcond.ut.TransformingPredicateTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[10](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.PrintablesTest$PredicateTest.givenPredicateReturnedByAnd$whenToString$thenLooksGood(com.github.dakusui.pcond.ut.PrintablesTest$PredicateTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[53: Given:<"hello">:When::Then:identicalWith(value:hello)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.sameObject[1](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.test2(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[78: Given:<"123.5">:When:identity->castTo[Float] THEN:=[123.4]>:Then:greaterThan(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThan(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[17](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[22](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalsWithOneCreatedFromSameFactoryAndArguments[7](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.testX(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (2 ms)
• com.github.dakusui.ut.valid8j.compatibility.ListTest.testEmpty(com.github.dakusui.ut.valid8j.compatibility.ListTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.notEqualsWithForeignObject[6](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.AssertionsTest$Failing (6 ms)
• com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[2: givenTransformingPredicate_whenExpectedValue_thenValueReturned](com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testComparison(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[23: Given:<"123">:When::Then:identicalWith(value:123)]>](com.github.dakusui.ut.valid8j.ut.styles.fluent.GeneralFluentTest) (7 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.returnsSameHashCode[34](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100$whenShorterThan10(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[42](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.equalHashCode[30](com.github.dakusui.pcond.equallness.EqualnessTest) (2 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[30](com.github.dakusui.pcond.equallness.EqualnessTest) (1 ms)
• com.github.dakusui.pcond.ut.ParameterizedPredicatesTest.exercisePredicate[11](com.github.dakusui.pcond.ut.ParameterizedPredicatesTest) (0 ms)
• com.github.dakusui.pcond.equallness.EqualnessTest.print[29](com.github.dakusui.pcond.equallness.EqualnessTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$NotTest.test(com.github.dakusui.ut.thincrest.ut.PredicatesTest$NotTest) (0 ms)