Evaluator.java

package com.github.dakusui.pcond.core;

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

import java.util.function.Function;

import java.util.function.Predicate;

import java.util.stream.Stream;

import static com.github.dakusui.pcond.core.EvaluationContext.formNameOf;

import static com.github.dakusui.pcond.core.EvaluationContext.resolveEvaluationEntryType;

import static com.github.dakusui.pcond.core.EvaluationEntry.Type.*;

import static com.github.dakusui.pcond.core.EvaluationEntry.composeDetailOutputActualValueFromInputAndThrowable;

import static com.github.dakusui.pcond.core.ValueHolder.CreatorFormType.FUNC_HEAD;

import static com.github.dakusui.pcond.core.ValueHolder.CreatorFormType.FUNC_TAIL;

import static com.github.dakusui.pcond.core.ValueHolder.State.*;

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

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

import static java.util.Objects.requireNonNull;

/**

 * A visitor interface that defines a mechanism to "evaluate" printable predicates.

 */

public interface Evaluator {

  /**

   * Evaluates `value` with `conjunction` predicate ("and").

   *

   * @param <T>               The type of the `value`.

   * @param evaluableIo       An object to hold an evaluable and its input and output.

   * @param evaluationContext An evaluation context.

   * @see com.github.dakusui.pcond.core.Evaluable.Conjunction

   */

  <T> void evaluateConjunction(EvaluableIo<T, Evaluable.Conjunction<T>, Boolean> evaluableIo, EvaluationContext<T> evaluationContext);

  /**

   * Evaluates `value` with a `disjunction` predicate ("or").

   *

   * @param <T>               The type of the `value`.

   * @param evaluableIo       An object to hold an evaluable and its input and output.

   * @param evaluationContext An evaluation context.

   * @see com.github.dakusui.pcond.core.Evaluable.Disjunction

   */

  <T> void evaluateDisjunction(EvaluableIo<T, Evaluable.Disjunction<T>, Boolean> evaluableIo, EvaluationContext<T> evaluationContext);

  /**

   * Evaluates `value` with a `negation` predicate ("not").

   *

   * @param <T>               The type of the `value`.

   * @param evaluableIo       An object to hold an evaluable and its input and output.

   * @param evaluationContext An evaluation context.

   * @see com.github.dakusui.pcond.core.Evaluable.Negation

   */

  <T> void evaluateNegation(EvaluableIo<T, Evaluable.Negation<T>, Boolean> evaluableIo, EvaluationContext<T> evaluationContext);

  /**

   * Evaluates `value` with a leaf predicate.

   *

   * @param <T>               The type of the `value`.

   * @param evaluableIo       An object to hold an evaluable and its input and output.

   * @param evaluationContext An evaluation context.

   * @see com.github.dakusui.pcond.core.Evaluable.LeafPred

   */

  <T> void evaluateLeaf(EvaluableIo<T, Evaluable.LeafPred<T>, Boolean> evaluableIo, EvaluationContext<T> evaluationContext);

  /**

   * Evaluates `value` with a "function" predicate.

   *

   * @param evaluableIo       An object to hold an evaluable and its input and output.

   * @param evaluationContext An evaluation context.

   * @see com.github.dakusui.pcond.core.Evaluable.Func

   */

  <T, R> void evaluateFunction(EvaluableIo<T, Evaluable.Func<T>, R> evaluableIo, EvaluationContext<T> evaluationContext);

  /**

   * Evaluates `value` with a context predicate.

   *

   * @param evaluableIo       An object to hold an evaluable and its input and output.

   * @param evaluationContext An evaluation context.

   * @see Evaluable.CurriedContextPred

   */

  void evaluateCurriedContextPredicate(EvaluableIo<CurriedContext, Evaluable.CurriedContextPred, Boolean> evaluableIo, EvaluationContext<CurriedContext> evaluationContext);

  /**

   * Evaluates `value` with a "transformation" predicate.

   *

   * @param evaluableIo       An object to hold an evaluable and its input and output.

   * @param evaluationContext An evaluation context.

   * @see com.github.dakusui.pcond.core.Evaluable.Transformation

   */

  <T, R> void evaluateTransformation(EvaluableIo<T, Evaluable.Transformation<T, R>, Boolean> evaluableIo, EvaluationContext<T> evaluationContext);

  /**

   * Evaluates `value` with a predicate for a stream.

   *

   * @param evaluableIo       An object to hold an evaluable and its input and output.

   * @param evaluationContext An evaluation context.

   * @see com.github.dakusui.pcond.core.Evaluable.StreamPred

   */

  <E> void evaluateStreamPredicate(EvaluableIo<Stream<E>, Evaluable.StreamPred<E>, Boolean> evaluableIo, EvaluationContext<Stream<E>> evaluationContext);

  /**

   * Returns a new instance of this interface.

   *

   * @return a new instance of this interface.

   */

  static Evaluator create() {

    return new Impl();

  }

  class Impl implements Evaluator {

    public static final Object EVALUATION_SKIPPED = new Object() {

      @Override

      public String toString() {

        return "(not evaluated)";

      }

    };

    private static final Object NULL_VALUE = new Object() {

      public String toString() {

        return "null";

      }

    };

    public Impl() {

    }

    @Override

    public <T> void evaluateConjunction(EvaluableIo<T, Evaluable.Conjunction<T>, Boolean> evaluableIo, EvaluationContext<T> evaluationContext) {

      evaluationContext.evaluate(

          evaluableIo,

          (Evaluable.Conjunction<T> evaluable, ValueHolder<T> input) -> {

            ValueHolder<Boolean> ret = ValueHolder.create();

            boolean result = true;

            ValueHolder<Boolean> retSkipped = null;

            for (Evaluable<T> each : evaluable.children()) {

              EvaluableIo<T, Evaluable<T>, Boolean> child = createChildEvaluableIoOf(each, input);

              each.accept(child, evaluationContext, this);

              ValueHolder<Boolean> outputFromEach = child.output();

              if (outputFromEach.isValueReturned()) {

                result &= outputFromEach.returnedValue();

                ret = ValueHolder.forValue(result);

              } else if (child.output().isExceptionThrown()) {

                ret = ValueHolder.<Boolean>create().evaluationSkipped();

                retSkipped = retSkipped != null ? retSkipped : ret;

              } else if (child.output().isEvaluationSkipped()) {

                ret = ValueHolder.<Boolean>create().evaluationSkipped();

                retSkipped = retSkipped != null ? retSkipped : ret;

              } else

                assert false;

              if (evaluable.shortcut() && (ret.isEvaluationSkipped() || !result))

                break;

            }

            return retSkipped != null ? retSkipped : ret;

          });

    }

    @Override

    public <T> void evaluateDisjunction(EvaluableIo<T, Evaluable.Disjunction<T>, Boolean> evaluableIo, EvaluationContext<T> evaluationContext) {

      evaluationContext.evaluate(

          evaluableIo,

          (Evaluable.Disjunction<T> evaluable, ValueHolder<T> input) -> {

            ValueHolder<Boolean> ret = ValueHolder.create();

            boolean result = false;

            ValueHolder<Boolean> retSkipped = null;

            for (Evaluable<T> each : evaluable.children()) {

              EvaluableIo<T, Evaluable<T>, Boolean> child = createChildEvaluableIoOf(each, input);

              each.accept(child, evaluationContext, this);

              ValueHolder<Boolean> outputFromEach = child.output();

              if (outputFromEach.isValueReturned()) {

                result |= outputFromEach.returnedValue();

                ret = ValueHolder.forValue(result);

              } else if (outputFromEach.isExceptionThrown()) {

                ret = ValueHolder.<Boolean>create().evaluationSkipped();

                retSkipped = retSkipped != null ? retSkipped : ret;

              } else if (outputFromEach.isEvaluationSkipped()) {

                ret = ValueHolder.<Boolean>create().evaluationSkipped();

                retSkipped = retSkipped != null ? retSkipped : ret;

              } else

                assert false;

              if (evaluable.shortcut() && (ret.isEvaluationSkipped() || result))

                break;

            }

            return retSkipped != null ? retSkipped : ret;

          });

    }

    @Override

    public <T> void evaluateNegation(EvaluableIo<T, Evaluable.Negation<T>, Boolean> evaluableIo, EvaluationContext<T> evaluationContext) {

      evaluationContext.evaluate(

          evaluableIo,

          (Evaluable.Negation<T> evaluable, ValueHolder<T> input) -> {

            evaluationContext.flipExpectation();

            try {

              EvaluableIo<T, Evaluable<T>, Boolean> childIo = createChildEvaluableIoOf(evaluable.target(), input);

              evaluable.target().accept(childIo, evaluationContext, this);

              return childIo.output().isValueReturned() ?

                  ValueHolder.forValue(evaluationContext.isExpectationFlipped() ^ childIo.output().returnedValue()) :

                  childIo.output();

            } finally {

              evaluationContext.flipExpectation();

            }

          }

      );

    }

    @Override

    public <T> void evaluateLeaf(EvaluableIo<T, Evaluable.LeafPred<T>, Boolean> evaluableIo, EvaluationContext<T> evaluationContext) {

      evaluationContext.evaluate(

          LEAF,

          evaluableIo,

          (evaluable, input) -> {

            ValueHolder<Boolean> ret = ValueHolder.create();

            if (input.isValueReturned()) {

              T value = input.returnedValue();

              Predicate<? super T> predicate = requireNonNull(evaluable.predicate());

              try {

                return ret.valueReturned(predicate.test(value));

              } catch (Throwable t) {

                return ret.exceptionThrown(t);

              }

            } else

              return ret.evaluationSkipped();

          });

    }

    @SuppressWarnings("unchecked")

    @Override

    public <T, R> void evaluateFunction(EvaluableIo<T, Evaluable.Func<T>, R> evaluableIo, EvaluationContext<T> evaluationContext) {

      evaluationContext.evaluate( //#2

          FUNCTION,

          evaluableIo,

          (Evaluable.Func<T> evaluable, ValueHolder<T> input) -> {

            ValueHolder<R> ret;

            {

              EvaluableIo<T, Evaluable<T>, Object> ioForHead = createChildEvaluableIoOf(evaluable, input);

              EvaluationContext<T> childContext = new EvaluationContext<>(evaluationContext);

              childContext.evaluate(FUNCTION, ioForHead, io -> {

                ValueHolder<Object> tmp = ValueHolder.create();

                if (io.input().isValueReturned())

                  tmp = applyFunction(tmp, io.input().returnedValue(), ((Evaluable.Func<T>) io.evaluable()).head());

                else

                  tmp = tmp.evaluationSkipped();

                return tmp.creatorFormType(FUNC_HEAD);

              });

              evaluationContext.importEntries(childContext, 1);

              ret = (ValueHolder<R>) ioForHead.output().creatorFormType(FUNC_TAIL);

            }

            ValueHolder<Object> finalRet = (ValueHolder<Object>) ret;

            return evaluable.tail().map((Evaluable<Object> e) -> {

                  EvaluableIo<Object, Evaluable<Object>, R> ioForTail = createChildEvaluableIoOf(e, finalRet);

                  DebuggingUtils.printIo("FUNC_TAIL:BEFORE", ioForTail);

                  e.accept(ioForTail, (EvaluationContext<Object>) evaluationContext, this);

                  DebuggingUtils.printIo("FUNC_TAIL:AFTER", ioForTail);

                  return ioForTail.output().creatorFormType(FUNC_TAIL);

                })

                .orElse(ret);

          });

    }

    @SuppressWarnings("unchecked")

    private static <T, R> ValueHolder<R> applyFunction(ValueHolder<R> ret, T in, Function<? super T, Object> function) {

      try {

        R returnedValue;

        returnedValue = (R) function.apply(in);

        return ret.valueReturned(returnedValue);

      } catch (Throwable t) {

        return ret.exceptionThrown(t);

      }

    }

    @SuppressWarnings({ "unchecked", "rawtypes" })

    @Override

    public <T, R> void evaluateTransformation(EvaluableIo<T, Evaluable.Transformation<T, R>, Boolean> evaluableIo, EvaluationContext<T> evaluationContext) {

      if (isDummyFunction((Function<?, ?>) evaluableIo.evaluable().mapper())) {

        evaluableIo.evaluable().checker().accept((EvaluableIo<R, Evaluable<R>, Boolean>) (Evaluable) evaluableIo, (EvaluationContext<R>) evaluationContext, this);

        return;

      }

      EvaluationContext<T> childContext = new EvaluationContext<>(evaluationContext);

      childContext.evaluate(

          evaluableIo,

          (Evaluable.Transformation<T, R> evaluable, ValueHolder<T> input) -> {

            DebuggingUtils.printInput("TRANSFORMATION:BEFORE", evaluable, input);

            EvaluableIo<T, Evaluable<T>, R> mapperIo = evaluateMapper(evaluable.mapperName().orElse("transform"), evaluable.mapper(), input, childContext);

            EvaluableIo<R, Evaluable<R>, Boolean> checkerIo = evaluateChecker(evaluable.checkerName().orElse("check"), evaluable.checker(), mapperIo.output(), childContext);

            DebuggingUtils.printInputAndOutput(evaluable, input, checkerIo.output());

            return checkerIo.output();

          }

      );

      evaluationContext.importEntries(childContext, 1);

    }

    private <T, R> EvaluableIo<T, Evaluable<T>, R> evaluateMapper(String mapperName, Evaluable<T> mapper, ValueHolder<T> input, EvaluationContext<T> evaluationContext) {

      EvaluableIo<T, Evaluable<T>, R> ioForMapper = createChildEvaluableIoOf(mapper, input.creatorFormType(ValueHolder.CreatorFormType.TRANSFORM));

      {

        EvaluationContext<T> childContext = new EvaluationContext<>(evaluationContext);

        // #1

        childContext.evaluate(TRANSFORM, mapperName, ioForMapper, io -> {

          DebuggingUtils.printIo("TRANSFORM:BEFORE", io);

          io.evaluable().accept(io, childContext, this);

          DebuggingUtils.printIo("TRANSFORM:AFTER", io);

          return io.output();

        });

        evaluationContext.importEntries(childContext, 0);

      }

      return ioForMapper;

    }

    private <T, R> EvaluableIo<R, Evaluable<R>, Boolean> evaluateChecker(String checkerName, Evaluable<R> checker, ValueHolder<R> input, EvaluationContext<T> evaluationContext) {

      EvaluableIo<R, Evaluable<R>, Boolean> ioForChecker = createChildEvaluableIoOf(checker, input);

      {

        EvaluationContext<R> childContext = new EvaluationContext<>(evaluationContext);

        childContext.evaluate(CHECK, checkerName, ioForChecker, io -> {

          DebuggingUtils.printIo("CHECK:BEFORE", io);

          io.evaluable().accept(io, childContext, this);

          DebuggingUtils.printIo("CHECK:AFTER", io);

          return io.output();

        });

        evaluationContext.importEntries(childContext, 0);

      }

      return ioForChecker;

    }

    //             ValueToCut  ValueOnCut ValueForNone(=default)

    // NoneMatch         true       false                   true

    // AnyMatch          true        true                  false

    // AllMatch         false       false                   true

    @Override

    public <E> void evaluateStreamPredicate(EvaluableIo<Stream<E>, Evaluable.StreamPred<E>, Boolean> evaluableIo, EvaluationContext<Stream<E>> evaluationContext) {

      evaluationContext.evaluate(

          evaluableIo,

          (Evaluable.StreamPred<E> evaluable, ValueHolder<Stream<E>> input) -> input.returnedValue()

              .map((E e) -> {

                if (evaluable.requestExpectationFlip())

                  evaluationContext.flipExpectation();

                try {

                  EvaluationContext<E> childContext = new EvaluationContext<>(evaluationContext);

                  EvaluableIo<E, Evaluable<E>, Boolean> ioForCutPredicate = createChildEvaluableIoOf(evaluable.cut(), ValueHolder.forValue(e));

                  evaluable.cut().accept(ioForCutPredicate, childContext, this);

                  evaluationContext.importEntries(childContext);

                  return ioForCutPredicate.output();

                } finally {

                  if (evaluable.requestExpectationFlip())

                    evaluationContext.flipExpectation();

                }

              })

              .filter(eachResult -> {

                if (!eachResult.isValueReturned())

                  return true;

                return eachResult.returnedValue() == evaluable.valueToCut();

              })

              .map(eachResult -> eachResult.valueReturned(!evaluable.defaultValue())) // compute Value on cut

              .findFirst()

              .orElseGet(() -> ValueHolder.forValue(evaluable.defaultValue())));      // compute Value for none

    }

    @Override

    public void evaluateCurriedContextPredicate(EvaluableIo<CurriedContext, Evaluable.CurriedContextPred, Boolean> evaluableIo, EvaluationContext<CurriedContext> evaluationContext) {

      evaluationContext.evaluate(evaluableIo, (Evaluable.CurriedContextPred evaluable, ValueHolder<CurriedContext> input) -> {

        EvaluableIo<Object, Evaluable<Object>, Boolean> io = createChildEvaluableIoOf(evaluable.enclosed(), ValueHolder.forValue(input.returnedValue().valueAt(evaluable.argIndex())));

        EvaluationContext<Object> childContext = new EvaluationContext<>(evaluationContext);

        evaluable.enclosed().accept(io, childContext, this);

        evaluationContext.importEntries(childContext);

        return io.output();

      });

    }

    private static <T, E extends Evaluable<T>, O> EvaluableIo<T, Evaluable<T>, O> createChildEvaluableIoOf(E evaluable, ValueHolder<T> input) {

      return createChildEvaluableIoOf(resolveEvaluationEntryType(evaluable).formName(evaluable), evaluable, input);

    }

    private static <T, E extends Evaluable<T>, O> EvaluableIo<T, Evaluable<T>, O> createChildEvaluableIoOf(String formName, E evaluable, ValueHolder<T> input) {

      EvaluationEntry.Type evaluableType = resolveEvaluationEntryType(evaluable);

      return createChildEvaluableIoOf(evaluableType, formName, evaluable, input);

    }

    private static <T, E extends Evaluable<T>, O> EvaluableIo<T, Evaluable<T>, O> createChildEvaluableIoOf(EvaluationEntry.Type evaluableType, String formName, E evaluable, ValueHolder<T> input) {

      return new EvaluableIo<>(input, evaluableType, formName, evaluable);

    }

  }

  /**

   * If an input or an output value object of a form implements this interface,

   * The value returned by `snapshot` method is stored in a {@link EvaluationEntry}

   * record, instead of the value itself.

   *

   * An implementation of this interface should override `toString()` method to return a string form of the original state of this object.

   */

  interface Snapshottable {

    Object NULL = new Object() {

      @Override

      public String toString() {

        return "null";

      }

    };

    Object snapshot();

    static Object toSnapshotIfPossible(Object value) {

      if (value instanceof Snapshottable)

        return ((Snapshottable) value).snapshot();

      if (value == null)

        return NULL;

      else

        return value;

    }

  }

  /**

   * An interface to define methods that make a predicate "explainable" to humans.

   */

  interface Explainable {

    Object explainOutputExpectation();

    Object explainActual(Object actualValue);

    static Object explainOutputExpectation(Object evaluable, EvaluableIo<?, ?, ?> evaluableIo) {

      if (evaluable instanceof Explainable)

        return explainValue(((Explainable) evaluable).explainOutputExpectation());

      if (evaluable instanceof Evaluable)

        return formNameOf(evaluableIo);

      return null;

    }

    static Object explainInputActualValue(Object evaluable, Object actualValue) {

      if (evaluable instanceof Explainable)

        return explainValue(((Explainable) evaluable).explainActual(actualValue));

      return null;

    }

    static <T, E extends Evaluable<T>> Object explainActual(EvaluableIo<T, E, ?> evaluableIo) {

      if (evaluableIo.output().state() == VALUE_RETURNED) {

        T ret = evaluableIo.input().returnedValue();

        return ret != null ? ret : Impl.NULL_VALUE;

      } else if (evaluableIo.output().state() == EXCEPTION_THROWN)

        return composeDetailOutputActualValueFromInputAndThrowable(evaluableIo.input().value(), evaluableIo.output().thrownException());

      else if (evaluableIo.output().state() == EVALUATION_SKIPPED) {

        return EVALUATION_SKIPPED;

      } else

        throw new AssertionError("evaluableIo:" + evaluableIo);

    }

  }

}

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.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectingExceptionButNotThrown_testFailing(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (12 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.experimentals.DbCCurriedFunctionsTest.hello_b(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.CallTest.methodAmbiguous_primitiveBoxed(com.github.dakusui.pcond.CallTest) (61 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.pcond.experimentals.DbCCurriedFunctionsTest.hello_d_1(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (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.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100_conj(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello_c(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.ListTest.testAllMatch(com.github.dakusui.ut.valid8j.compatibility.ListTest) (2 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello2(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.ListTest.testCollectionContains(com.github.dakusui.ut.valid8j.compatibility.ListTest) (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.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureValue_passing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (1 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.pcond.experimentals.DbCCurriedFunctionsTest.hello3(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 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.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_lessThan(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (1 ms)
• com.github.dakusui.pcond.types.StreamTest.streamTransformerTestFailure(com.github.dakusui.pcond.types.StreamTest) (1 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.experimentals.DbCCurriedFunctionsTest.hello_a(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.types.StreamTest.streamTest(com.github.dakusui.pcond.types.StreamTest) (5 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.ut.thincrest.ut.ReportDetailTest.givenString_whenFails_then_2(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (2 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.propertybased.tests.StreamAllMatchPredicateTest.exerciseTestCase[0: givenStreamPredicate_whenExpectedValue_thenValueReturned](com.github.dakusui.pcond.propertybased.tests.StreamAllMatchPredicateTest) (1 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.pcond.experimentals.DbCCurriedFunctionsTest.hello5(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.test_validateArgument_fail(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (1 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.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenTransformIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (2 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.StreamAllMatchPredicateTest.exerciseTestCase[2: givenStreamPredicate_whenUnexpectedValue_thenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.StreamAllMatchPredicateTest) (3 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello6(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 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.valid8j.compatibility.ListTest.testNoneMatch(com.github.dakusui.ut.valid8j.compatibility.ListTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.testY(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (3 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_isEmpty(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (0 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.types.FloatTest.toFloatTest(com.github.dakusui.pcond.types.FloatTest) (3 ms)
• com.github.dakusui.pcond.NegateTest.whenInvertedTrasformingPredicateFails_thenPrintDesignedMessage$notMergedWhenMismatch(com.github.dakusui.pcond.NegateTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.TestAssertionsTest.testAssumeThat(com.github.dakusui.ut.thincrest.ut.TestAssertionsTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_Float(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (0 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.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.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.valid8j.ut.ValidatesTest.test_validateArgument_pass(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (1 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.test_validateNonNull_pass(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (1 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.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[3: givenTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest) (5 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.ut.thincrest.ut.TestAssertionsTest.testAllOf(com.github.dakusui.ut.thincrest.ut.TestAssertionsTest) (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.ut.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenCheckIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (4 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_Integer(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_contains(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (1 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.ut.valid8j.compatibility.StringTest.testMatchesRegex(com.github.dakusui.ut.valid8j.compatibility.StringTest) (0 ms)
• com.github.dakusui.ut.valid8j.compatibility.BooleanTest.testWrapperIsFalse(com.github.dakusui.ut.valid8j.compatibility.BooleanTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentListTest.test_elementAt(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentListTest) (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.valid8j.ut.ValidatesTest.test_validate_pass(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (0 ms)
• com.github.dakusui.pcond.types.FloatTest.floatTest(com.github.dakusui.pcond.types.FloatTest) (1 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.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectedExceptionThrown_testPassing(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (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.pcond.propertybased.tests.SimplePredicateTest.exerciseTestCase[1: givenSimplePredicate_whenUnexpectedValue_thenComparisonFailureThrown](com.github.dakusui.pcond.propertybased.tests.SimplePredicateTest) (3 ms)
• com.github.dakusui.pcond.types.FloatTest.floatTestFail(com.github.dakusui.pcond.types.FloatTest) (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.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireArgument_passing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (0 ms)
• com.github.dakusui.pcond.bugfixes.Issue42Test.givenPrivateClassOverridingPublicMethod$whenPublicMethodIsCalled$thenCallSucceeds(com.github.dakusui.pcond.bugfixes.Issue42Test) (5 ms)
• com.github.dakusui.ut.valid8j.compatibility.ListTest.testAnyMatch(com.github.dakusui.ut.valid8j.compatibility.ListTest) (1 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.experimentals.DbCCurriedFunctionsTest.hello(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.propertybased.tests.AllOfPredicateTest.exerciseTestCase[1: whenPredicatesAllReturningTrueUnderAllOf_thenPasses](com.github.dakusui.pcond.propertybased.tests.AllOfPredicateTest) (0 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testIsInstanceOf(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 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.pcond.NegateTest.whenInvertedTransformingPredicateFails_thenPrintDesignedMessage$transformIsntLeafAndNotMerged(com.github.dakusui.pcond.NegateTest) (11 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testEndsWith(com.github.dakusui.ut.valid8j.compatibility.StringTest) (0 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.experimentals.DbCCurriedFunctionsTest.hello4(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (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.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_Short(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (1 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.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (2 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.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.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireStatesTest_failing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (3 ms)
• com.github.dakusui.ut.thincrest.ut.FluentUtilsTest.expectationFlipping(com.github.dakusui.ut.thincrest.ut.FluentUtilsTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello_b3(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (0 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.ut.thincrest.ut.styles.MoreFluentStringTest.test_findRegexPatterns(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (0 ms)
• com.github.dakusui.pcond.bugfixes.Issue11Test.whenReproduceIssue(com.github.dakusui.pcond.bugfixes.Issue11Test) (7 ms)
• com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessUsingCustomPredicateWithSlightlyDifferentString_thenExpectationSpecificFragmentsContainedOnlyByExplanationForExpectationAndActualValuesAreAlsoSo(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (3 ms)
• com.github.dakusui.pcond.types.FloatTest.floatTransformerTestFail(com.github.dakusui.pcond.types.FloatTest) (1 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.experimentals.DbCCurriedFunctionsTest.givenString$hello$_whenTransformToContextAndCheckContextValueIsNull_thenPreconditionViolationWithCorrectMessageThrown(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (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.valid8j.compatibility.BooleanTest.testIsFalse(com.github.dakusui.ut.valid8j.compatibility.BooleanTest) (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.pcond.CallTest.methodAmbiguous_primitiveBoxed_negated(com.github.dakusui.pcond.CallTest) (11 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.testValidateMethod$failing(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (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.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireValue_passing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$MessageTest.testFormat(com.github.dakusui.ut.thincrest.ut.PredicatesTest$MessageTest) (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.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureState_passing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (2 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testEqualsIgnoreCase(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 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.FluentBooleanTest.givenFalse_whenToBooleanIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (1 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.CallTest.nullReturningFunctionAsPredicate(com.github.dakusui.pcond.CallTest) (4 ms)
• com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100$whenNull(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (4 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_transforming_thenFail(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 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.experimentals.DbCCurriedFunctionsTest.nestedLoop_fail(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.TestAssertionsTest.testAnyOf(com.github.dakusui.ut.thincrest.ut.TestAssertionsTest) (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.NegateTest.whenInvertedTrasformingPredicateFails_thenPrintDesignedMessage$mergedWhenNotMismatch(com.github.dakusui.pcond.NegateTest) (5 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.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[2: whenPredicatesFirstReturningFalseRestReturningTrueUnderAnyOf_thenPass](com.github.dakusui.pcond.propertybased.tests.AnyOfPredicateTest) (1 ms)
• com.github.dakusui.pcond.types.StreamTest.streamTestFailure(com.github.dakusui.pcond.types.StreamTest) (3 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testIsEmptyOrNullString(com.github.dakusui.ut.valid8j.compatibility.StringTest) (0 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.EnsuresTest (5 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.experimentals.DbCCurriedFunctionsTest.hello4_a(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 ms)
• com.github.dakusui.pcond.PrintablesFunctionTest$Composed.testFailureFromAndThenStructureInTransformer(com.github.dakusui.pcond.PrintablesFunctionTest$Composed) (12 ms)
• com.github.dakusui.ut.thincrest.ut.PredicatesTest$IsInstanceOfTest.test(com.github.dakusui.ut.thincrest.ut.PredicatesTest$IsInstanceOfTest) (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.AssertionsTest$Passing.testAssertThatValue$thenPass(com.github.dakusui.ut.valid8j.ut.AssertionsTest$Passing) (1 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.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureValuesTest_failing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (4 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.ut.valid8j.compatibility.StringTest.testContainsString(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 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.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.reqireState_passing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (3 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStreamTest.test_noneMatche(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStreamTest) (0 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$FindStringsTest.givenSomeFoundSomeNotFound$whenFindRegexes$thenFailed(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest) (3 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.ut.thincrest.ut.PredicatesTest$FindElementsTest.givenSomeToBeFoundSomeNotToBe$whenFindElements$thenFailed(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindElementsTest) (3 ms)
• com.github.dakusui.pcond.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[1: whenPredicatesAllReturningTrueUnderAnyOf_thenPasses](com.github.dakusui.pcond.propertybased.tests.AnyOfPredicateTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessUsingCustomPredicateWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (1 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest.test_isEqualTo(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.test_validate_fail(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (2 ms)
• com.github.dakusui.ut.valid8j.compatibility.ListTest.testListContains(com.github.dakusui.ut.valid8j.compatibility.ListTest) (1 ms)
• com.github.dakusui.pcond.types.StreamTest.streamTransformerTest(com.github.dakusui.pcond.types.StreamTest) (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.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assertAllDifferentTypes_passed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (2 ms)
• com.github.dakusui.pcond.experimentals.TestAssertionsCurriedFunctionsTest.helloError(com.github.dakusui.pcond.experimentals.TestAssertionsCurriedFunctionsTest) (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.ut.thincrest.ut.FluentUtilsTest.example2(com.github.dakusui.ut.thincrest.ut.FluentUtilsTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (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.ut.thincrest.ut.styles.MoreFluentStringTest.test_isNullOrEmpty(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStringTest) (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.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_preconditions(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (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.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.ut.thincrest.ut.PredicatesTest$FindStringsTest.givenAllFound$whenFindString$thenPassed(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest) (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.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[4: givenTwoChainedTransformingPredicates_whenNonExpectedValue_thenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest) (8 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.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.ut.thincrest.ut.PredicatesTest$FindStringsTest.givenAllFound$whenFindRegexes$thenPassed(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest) (8 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.ut.valid8j.ut.ValidatesTest.test2(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (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.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_greaterThan(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
• com.github.dakusui.ut.valid8j.ut.ValidatesTest.testX(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (2 ms)
• com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStreamTest.test_anyMatch(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentStreamTest) (1 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.ut.valid8j.compatibility.ListTest.testEmpty(com.github.dakusui.ut.valid8j.compatibility.ListTest) (1 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testEqualTo(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 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.pcond.PrintablesFunctionTest$Simple.testHandleNull(com.github.dakusui.pcond.PrintablesFunctionTest$Simple) (2 ms)
• com.github.dakusui.ut.thincrest.examples.JUnitBasedExamplesTest.testExampleUT(com.github.dakusui.ut.thincrest.examples.JUnitBasedExamplesTest) (20 ms)
• com.github.dakusui.ut.valid8j.compatibility.StringTest.testComparison(com.github.dakusui.ut.valid8j.compatibility.StringTest) (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.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureStatesTest_failing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (4 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.ut.valid8j.ut.ValidatesTest.test(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (3 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.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100$whenShorterThan10(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello3_b(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 ms)
• com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello_b_e5(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (4 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.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[0: whenOnePredicateReturningFalseUnderAnyOf_whenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.AnyOfPredicateTest) (3 ms)