EvaluationEntry.java

package com.github.dakusui.pcond.core;

import com.github.dakusui.pcond.core.ValueHolder.State;
import com.github.dakusui.pcond.validator.Validator;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicReference;

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.Evaluator.Explainable.*;
import static com.github.dakusui.pcond.core.Evaluator.Impl.EVALUATION_SKIPPED;
import static com.github.dakusui.pcond.core.Evaluator.Snapshottable.toSnapshotIfPossible;
import static com.github.dakusui.pcond.core.ValueHolder.CreatorFormType.FUNC_TAIL;
import static com.github.dakusui.pcond.core.ValueHolder.State.VALUE_RETURNED;
import static java.lang.String.format;
import static java.util.Arrays.asList;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

/**
 *
 * // @formatter:off
 * A class to hold an entry of execution history of the {@link Evaluator}.
 * When an evaluator enters into one {@link Evaluable} (actually a predicate or a function),
 * an {@code OnGoing} entry is created and held by the evaluator as a current
 * one.
 * Since one evaluate can have its children and only one child can be evaluated at once,
 * on-going entries are held as a list (stack).
 *
 * When the evaluator leaves the evaluable, the entry is "finalized".
 * From the data held by an entry, "expectation" and "actual behavior" reports are generated.
 *
 * .Evaluation Summary Format
 * ----
 * +----------------------------------------------------------------------------- Failure Detail Index
 * |  +-------------------------------------------------------------------------- Input
 * |  |                                            +----------------------------- Form (Function/Predicate)
 * |  |                                            |                           +- Output
 * |  |                                            |                           |
 * V  V                                            V                           V
 *     Book:[title:<De Bello G...i appellantur.>]->check:allOf               ->false
 *                                                    transform:title       ->"De Bello Gallico"
 *                       "De Bello Gallico"     ->    check:allOf           ->false
 *                                                        isNotNull         ->true
 * [0]                                                    transform:parseInt->NumberFormatException:"For input s...ico""
 *                          null                ->        check:allOf       ->false
 *                                                            >=[10]        ->true
 *                                                            <[40]         ->true
 *    Book:[title:<De Bello G...i appellantur.>]->    transform:title       ->"Gallia est omnis divis...li appellantur."
 *    "Gallia est omnis divis...li appellantur."->    check:allOf           ->false
 *                                                        isNotNull         ->true
 *                                                        transform:length  ->145
 *    145                                       ->        check:allOf       ->false
 * [1]                                                         >=[200]       ->true
 * <[400]        ->true
 * ----
 *
 * Failure Detail Index::
 * In the full format of a failure report, detailed descriptions of mismatching forms are provided if the form is {@link Evaluator.Explainable}.
 * This index points an item in the detail part of the full report.
 * Input::
 * Values given to forms are printed here.
 * If the previous line uses the same value, the value will not be printed.
 * Form (Function/Predicate)::
 * This part displays names of forms (predicates and functions).
 * If a form is marked trivial, the framework may merge the form with the next line.
 * Output::
 * For predicates, expected boolean value is printed.
 * For functions, if a function does not throw an exception during its evaluation, the result will be printed here both for expectation and actual behavior summary.
 * If it throws an exception, the exception will be printed here in actual behavior summary.
 *
 * // @formatter:on
 */
public abstract class EvaluationEntry {
  private final Type   type;
  /**
   * A name of a form (evaluable; function, predicate)
   */
  private final String formName;
  int level;
  
  Object inputExpectation;
  Object detailInputExpectation;
  
  Object inputActualValue;
  Object detailInputActualValue;
  
  Object outputExpectation;
  Object detailOutputExpectation;
  
  
  /**
   * A flag to let the framework know this entry should be printed in a less outstanding form.
   */
  final boolean squashable;
  
  EvaluationEntry(String formName, Type type, int level, Object inputExpectation_, Object detailInputExpectation_, Object outputExpectation, Object detailOutputExpectation, Object inputActualValue, Object detailInputActualValue, boolean squashable) {
    this.type = type;
    this.level = level;
    this.formName = formName;
    this.inputExpectation = inputExpectation_;
    this.detailInputExpectation = detailInputExpectation_;
    this.outputExpectation = outputExpectation;
    this.detailOutputExpectation = detailOutputExpectation;
    this.inputActualValue = inputActualValue;
    this.detailInputActualValue = detailInputActualValue;
    this.squashable = squashable;
  }
  
  public String formName() {
    return formName;
  }
  
  public Type type() {
    return this.type;
  }
  
  @SuppressWarnings("BooleanMethodIsAlwaysInverted")
  public boolean isSquashable(EvaluationEntry nextEntry) {
    return this.squashable;
  }
  
  public abstract boolean requiresExplanation();
  
  public int level() {
    return level;
  }
  
  public Object inputExpectation() {
    return this.inputExpectation;
  }
  
  public Object detailInputExpectation() {
    return this.detailInputExpectation;
  }
  
  public Object outputExpectation() {
    return this.outputExpectation;
  }
  
  public Object detailOutputExpectation() {
    return this.detailOutputExpectation;
  }
  
  public Object inputActualValue() {
    return this.inputActualValue;
  }
  
  public abstract Object outputActualValue();
  
  public abstract Object detailOutputActualValue();
  
  public abstract boolean ignored();
  
  @Override
  public String toString() {
    return String.format("%s(%s)", formName(), inputActualValue());
  }
  
  static String composeDetailOutputActualValueFromInputAndThrowable(Object input, Throwable throwable) {
    StringBuilder b = new StringBuilder();
    b.append("Input: '").append(input).append("'").append(format("%n"));
    b.append("Input Type: ").append(input == null ? "(null)" : input.getClass().getName()).append(format("%n"));
    b.append("Thrown Exception: '").append(throwable.getClass().getName()).append("'").append(format("%n"));
    b.append("Exception Message: ").append(sanitizeExceptionMessage(throwable)).append(format("%n"));
    
    for (StackTraceElement each : foldInternalPackageElements(throwable)) {
      b.append("\t");
      b.append(each);
      b.append(format("%n"));
    }
    return b.toString();
  }
  
  private static String sanitizeExceptionMessage(Throwable throwable) {
    if (throwable.getMessage() == null)
      return null;
    return Arrays.stream(throwable.getMessage().split("\n"))
        .map(s -> "> " + s)
        .collect(joining(String.format("%n")));
  }
  
  static <T, E extends Evaluable<T>> Object computeInputActualValue(EvaluableIo<T, E, ?> evaluableIo) {
    return evaluableIo.input().value();
  }
  
  static <T, E extends Evaluable<T>> Object computeOutputExpectation(EvaluableIo<T, E, ?> evaluableIo, boolean expectationFlipped) {
    final State state = evaluableIo.output().state();
    if (state == VALUE_RETURNED) {
      if (evaluableIo.evaluableType() == FUNCTION || evaluableIo.evaluableType() == TRANSFORM)
        return toSnapshotIfPossible(evaluableIo.output().returnedValue());
      return !expectationFlipped;
    } else if (state == State.EXCEPTION_THROWN || state == State.EVALUATION_SKIPPED)
      return EVALUATION_SKIPPED;
    else
      throw new AssertionError("output state=<" + state + ">");
  }
  
  static <T, E extends Evaluable<T>> Object computeOutputActualValue(EvaluableIo<T, E, ?> evaluableIo) {
    if (evaluableIo.output().state() == State.VALUE_RETURNED)
      return toSnapshotIfPossible(evaluableIo.output().returnedValue());
    if (evaluableIo.output().state() == State.EXCEPTION_THROWN)
      return evaluableIo.output().thrownException();
    else
      return EVALUATION_SKIPPED;
  }
  
  static <T, E extends Evaluable<T>> boolean isExplanationRequired(EvaluableIo<T, E, ?> evaluableIo, boolean expectationFlipped) {
    return asList(FUNCTION, LEAF).contains(evaluableIo.evaluableType()) && (
        evaluableIo.output().state() == State.EXCEPTION_THROWN || (
            evaluableIo.evaluable() instanceof Evaluable.LeafPred && returnedValueOrVoidIfSkipped(expectationFlipped, evaluableIo)));
  }
  
  private static List<StackTraceElement> foldInternalPackageElements(Throwable throwable) {
    AtomicReference<StackTraceElement> firstInternalStackElement = new AtomicReference<>();
    String lastPackageNameElementPattern = "\\.[a-zA-Z0-9_.]+$";
    String internalPackageName = Validator.class.getPackage().getName()
        .replaceFirst(lastPackageNameElementPattern, "")
        .replaceFirst(lastPackageNameElementPattern, "");
    return Arrays.stream(throwable.getStackTrace())
        .filter(e -> {
          if (e.getClassName().startsWith(internalPackageName)) {
            if (firstInternalStackElement.get() == null) {
              firstInternalStackElement.set(e);
              return true;
            }
            return false;
          }
          firstInternalStackElement.set(null);
          return true;
        })
        .map(e -> {
          if (e.getClassName().startsWith(internalPackageName)) {
            return new StackTraceElement("...internal.package.InternalClass", "internalMethod", "InternalClass.java", 0);
          }
          return e;
        })
        .collect(toList());
  }
  
  private static boolean returnedValueOrVoidIfSkipped(boolean expectationFlipped, EvaluableIo<?, ?, ?> io) {
    if (io.output().state() == State.EVALUATION_SKIPPED)
      return false;
    return expectationFlipped ^ !(Boolean) io.output().returnedValue();
  }
  
  public enum Type {
    TRANSFORM_AND_CHECK {
      @Override
      String formName(Evaluable<?> evaluable) {
        return "transformAndCheck";
      }
    },
    TRANSFORM {
      @Override
      String formName(Evaluable<?> evaluable) {
        return "transform";
      }
      
      @Override
      boolean isSquashableWith(EvaluationEntry.Impl nextEntry) {
        if (Objects.equals(FUNCTION, nextEntry.evaluableIo().evaluableType()))
          return !((Evaluable.Func<?>) nextEntry.evaluableIo().evaluable()).tail().isPresent();
        return false;
      }
    },
    CHECK {
      @Override
      String formName(Evaluable<?> evaluable) {
        return resolveEvaluationEntryType(evaluable).formName(evaluable);
      }
      
      @Override
      boolean isSquashableWith(EvaluationEntry.Impl nextEntry) {
        return asList(LEAF, NOT, AND, OR, TRANSFORM).contains(nextEntry.evaluableIo().evaluableType());
      }
    },
    AND {
      @Override
      String formName(Evaluable<?> evaluable) {
        return ((Evaluable.Conjunction<?>) evaluable).shortcut() ? "and" : "allOf";
      }
    },
    OR {
      @Override
      String formName(Evaluable<?> evaluable) {
        return ((Evaluable.Disjunction<?>) evaluable).shortcut() ? "or" : "anyOf";
      }
    },
    NOT {
      @Override
      String formName(Evaluable<?> evaluable) {
        return "not";
      }
      
      @Override
      boolean isSquashableWith(EvaluationEntry.Impl nextEntry) {
        return Objects.equals(LEAF, nextEntry.evaluableIo().evaluableType());
      }
    },
    LEAF {
      @Override
      String formName(Evaluable<?> evaluable) {
        return evaluable.toString();
      }
    },
    FUNCTION {
      @Override
      String formName(Evaluable<?> evaluable) {
        if (DebuggingUtils.showEvaluableDetail()) {
          if (!((Evaluable.Func<?>) evaluable).tail().isPresent())
            return ((Evaluable.Func<?>) evaluable).head().toString();
          return ((Evaluable.Func<?>) evaluable).head().toString() + "(" + ((Evaluable.Func<?>) evaluable).tail().get() + ")";
        }
        return ((Evaluable.Func<?>) evaluable).head().toString();
      }
    };
    
    abstract String formName(Evaluable<?> evaluable);
    
    boolean isSquashableWith(EvaluationEntry.Impl nextEntry) {
      return false;
    }
  }
  
  static class Finalized extends EvaluationEntry {
    final         Object  outputActualValue;
    final         Object  detailOutputActualValue;
    private final boolean requiresExplanation;
    private final boolean ignored;
    
    Finalized(
        String formName,
        Type type,
        int level,
        Object inputExpectation_, Object detailInputExpectation_,
        Object outputExpectation, Object detailOutputExpectation,
        Object inputActualValue, Object detailInputActualValue,
        Object outputActualValue, Object detailOutputActualValue,
        boolean squashable, boolean requiresExplanation, boolean ignored) {
      super(
          formName, type, level,
          inputExpectation_, detailInputExpectation_,
          outputExpectation, detailOutputExpectation,
          inputActualValue, detailInputActualValue, squashable);
      this.outputActualValue = outputActualValue;
      this.detailOutputActualValue = detailOutputActualValue;
      this.requiresExplanation = requiresExplanation;
      this.ignored = ignored;
    }
    
    @Override
    public Object outputActualValue() {
      return outputActualValue;
    }
    
    @Override
    public Object detailOutputActualValue() {
      return this.detailOutputActualValue;
    }
    
    @Override
    public boolean ignored() {
      return this.ignored;
    }
    
    @Override
    public boolean requiresExplanation() {
      return this.requiresExplanation;
    }
  }
  
  public static EvaluationEntry create(
      String formName, Type type,
      int level,
      Object inputExpectation_, Object detailInputExpectation_,
      Object outputExpectation, Object detailOutputExpectation,
      Object inputActualValue, Object detailInputActualValue,
      Object outputActualValue, Object detailOutputActualValue,
      boolean trivial, boolean requiresExplanation, boolean ignored) {
    return new Finalized(
        formName, type,
        level,
        inputExpectation_, detailInputExpectation_,
        outputExpectation, detailOutputExpectation,
        inputActualValue, detailInputActualValue,
        outputActualValue, detailOutputActualValue,
        trivial, requiresExplanation, ignored
    );
  }
  
  public static class Impl extends EvaluationEntry {
    
    private final EvaluableIo<?, ?, ?> evaluableIo;
    private final boolean              expectationFlipped;
    private       boolean              ignored;
    
    private boolean finalized = false;
    private Object  outputActualValue;
    private Object  detailOutputActualValue;
    
    <T, E extends Evaluable<T>> Impl(
        EvaluationContext<T> evaluationContext,
        EvaluableIo<T, E, ?> evaluableIo) {
      super(
          EvaluationContext.formNameOf(evaluableIo),
          evaluableIo.evaluableType(),
          evaluationContext.visitorLineage.size(),
          computeInputExpectation(evaluableIo),                   // inputExpectation        == inputActualValue
          explainInputExpectation(evaluableIo),                   // detailInputExpectation  == detailInputActualValue
          null, // not necessary                                  // outputExpectation
          explainOutputExpectation(evaluableIo.evaluable(), evaluableIo),      // detailOutputExpectation
          computeInputActualValue(evaluableIo),                   // inputActualValue
          explainInputActualValue(evaluableIo.evaluable(), computeInputActualValue(evaluableIo)), // detailInputActualValue
          evaluableIo.evaluable().isSquashable());
      this.evaluableIo = evaluableIo;
      this.expectationFlipped = evaluationContext.isExpectationFlipped();
      this.ignored = false;
    }
    
    private static <E extends Evaluable<T>, T> Object explainInputExpectation(EvaluableIo<T, E, ?> evaluableIo) {
      return explainInputActualValue(evaluableIo, computeInputExpectation(evaluableIo));
    }
    
    private static <E extends Evaluable<T>, T> Object computeInputExpectation(EvaluableIo<T, E, ?> evaluableIo) {
      return computeInputActualValue(evaluableIo);
    }
    
    @Override
    public boolean requiresExplanation() {
      return isExplanationRequired(evaluableIo(), this.expectationFlipped);
    }
    
    @SuppressWarnings("unchecked")
    public <I, O> EvaluableIo<I, Evaluable<I>, O> evaluableIo() {
      return (EvaluableIo<I, Evaluable<I>, O>) this.evaluableIo;
    }
    
    public Object outputExpectation() {
      assert finalized;
      return outputExpectation;
    }
    
    @Override
    public Object outputActualValue() {
      assert finalized;
      return outputActualValue;
    }
    
    @Override
    public Object detailOutputActualValue() {
      assert finalized;
      return detailOutputActualValue;
    }
    
    public boolean ignored() {
      assert finalized;
      return this.ignored;
    }
    
    public boolean isSquashable(EvaluationEntry nextEntry) {
      if (nextEntry instanceof EvaluationEntry.Impl)
        return this.type().isSquashableWith((Impl) nextEntry);
      return false;
    }
    
    public String formName() {
      if (DebuggingUtils.showEvaluableDetail())
        return evaluableIo.formName() + "(" +
            evaluableIo.evaluableType() + ":" +
            evaluableIo.input().creatorFormType() + ":" +
            evaluableIo.output().creatorFormType() +
            (finalized && this.ignored() ? ":ignored" : "") + ")";
      return this.evaluableIo.formName();
    }
    
    public void finalizeValues() {
      this.outputExpectation = computeOutputExpectation(evaluableIo(), expectationFlipped);
      this.outputActualValue = computeOutputActualValue(evaluableIo());
      this.detailOutputActualValue = explainActual(evaluableIo());
      this.ignored =
          (this.evaluableIo.evaluableType() == TRANSFORM_AND_CHECK && this.evaluableIo.formName().equals("transformAndCheck")) ||
              (this.evaluableIo.evaluableType() == FUNCTION && this.evaluableIo.output().creatorFormType() == FUNC_TAIL);
      this.finalized = true;
    }
    
    @Override
    public String toString() {
      return String.format("%s(%s)=%s (expected:=%s):%s", formName(), inputActualValue(), finalized ? outputActualValue() : "(n/a)", finalized ? outputExpectation() : "(n/a)", this.level());
    }
  }
}

























































































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.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_lessThan(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (1 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.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.types.StreamTest.streamTest(com.github.dakusui.pcond.types.StreamTest) (5 ms)
com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.hello_a(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (2 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.ut.valuechecker.DefaultValidatorTest.withoutEvaluator_conj_thenPass(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (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.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.styles.MoreFluentComparableNumberCheckerTest.test_Float(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (0 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.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.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.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat_usingFluentStyle(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (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.fluent.FluentBooleanTest.givenFalse_whenIsTrueAndIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (2 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.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.pcond.ut.valuechecker.DefaultValidatorTest.withEvaluator_nativePredicate(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 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.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssertAll_failed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (3 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.SimplePredicateTest.exerciseTestCase[1: givenSimplePredicate_whenUnexpectedValue_thenComparisonFailureThrown](com.github.dakusui.pcond.propertybased.tests.SimplePredicateTest) (3 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.ut.valuechecker.DefaultValidatorTest.withoutEvaluator_conj_thenFail(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 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.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.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.thincrest.ut.FluentUtilsTest.expectationFlipping(com.github.dakusui.ut.thincrest.ut.FluentUtilsTest) (1 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.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.experimentals.DbCCurriedFunctionsTest.hello_b3(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (0 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.pcond.types.FloatTest.floatTransformerTestFail(com.github.dakusui.pcond.types.FloatTest) (1 ms)
com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessUsingCustomPredicateWithSlightlyDifferentString_thenExpectationSpecificFragmentsContainedOnlyByExplanationForExpectationAndActualValuesAreAlsoSo(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (3 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.valid8j.ut.styles.fluent.FluentBooleanTest.givenTrue_whenIsTrue_thenPass(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (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.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.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.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.ut.thincrest.ut.PredicatesTest$IsInstanceOfTest.test(com.github.dakusui.ut.thincrest.ut.PredicatesTest$IsInstanceOfTest) (1 ms)
com.github.dakusui.pcond.PrintablesFunctionTest$Composed.testFailureFromAndThenStructureInTransformer(com.github.dakusui.pcond.PrintablesFunctionTest$Composed) (12 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.MoreFluentComparableNumberCheckerTest.test_greaterThanOrEqualTo(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (0 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.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.pcond.propertybased.tests.NegatedPredicateTest.exerciseTestCase[0: givenNegatedSimplePredicateReturningFalse_whenExpectedValue_thenValueReturned](com.github.dakusui.pcond.propertybased.tests.NegatedPredicateTest) (0 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.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.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest.test_greaterThan(com.github.dakusui.ut.thincrest.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.nestedLoop_success(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (1 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.ValidatesTest.testX(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (2 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.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.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)

Report generated by PIT 1.7.3

1		package com.github.dakusui.pcond.core;
2
3		import com.github.dakusui.pcond.core.ValueHolder.State;
4		import com.github.dakusui.pcond.validator.Validator;
5
6		import java.util.Arrays;
7		import java.util.List;
8		import java.util.Objects;
9		import java.util.concurrent.atomic.AtomicReference;
10
11		import static com.github.dakusui.pcond.core.EvaluationContext.resolveEvaluationEntryType;
12		import static com.github.dakusui.pcond.core.EvaluationEntry.Type.*;
13		import static com.github.dakusui.pcond.core.Evaluator.Explainable.*;
14		import static com.github.dakusui.pcond.core.Evaluator.Impl.EVALUATION_SKIPPED;
15		import static com.github.dakusui.pcond.core.Evaluator.Snapshottable.toSnapshotIfPossible;
16		import static com.github.dakusui.pcond.core.ValueHolder.CreatorFormType.FUNC_TAIL;
17		import static com.github.dakusui.pcond.core.ValueHolder.State.VALUE_RETURNED;
18		import static java.lang.String.format;
19		import static java.util.Arrays.asList;
20		import static java.util.stream.Collectors.joining;
21		import static java.util.stream.Collectors.toList;
22
23		/**
24		*
25		* // @formatter:off
26		* A class to hold an entry of execution history of the {@link Evaluator}.
27		* When an evaluator enters into one {@link Evaluable} (actually a predicate or a function),
28		* an {@code OnGoing} entry is created and held by the evaluator as a current
29		* one.
30		* Since one evaluate can have its children and only one child can be evaluated at once,
31		* on-going entries are held as a list (stack).
32		*
33		* When the evaluator leaves the evaluable, the entry is "finalized".
34		* From the data held by an entry, "expectation" and "actual behavior" reports are generated.
35		*
36		* .Evaluation Summary Format
37		* ----
38		* +----------------------------------------------------------------------------- Failure Detail Index
39		* \| +-------------------------------------------------------------------------- Input
40		* \| \| +----------------------------- Form (Function/Predicate)

EvaluationEntry.java

Mutations

Active mutators

Tests examined