ReportComposer.java

package com.github.dakusui.pcond.validator;

import com.github.dakusui.pcond.core.DebuggingUtils;
import com.github.dakusui.pcond.core.EvaluationEntry;
import com.github.dakusui.pcond.fluent.ValueHolder;
import com.github.dakusui.pcond.internals.InternalUtils;

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;
import java.util.function.Supplier;

import static com.github.dakusui.pcond.internals.InternalUtils.*;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.String.format;
import static java.util.Collections.emptyList;
import static java.util.Collections.unmodifiableList;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

public interface ReportComposer {
  default Explanation explanationFromMessage(String msg) {
    return Explanation.fromMessage(msg);
  }
  
  default Explanation composeExplanation(String message, List<EvaluationEntry> evaluationEntries) {
    return Utils.composeExplanation(this, message, evaluationEntries);
  }
  
  default FormattedEntry createFormattedEntryForExpectation(EvaluationEntry evaluationEntry) {
    return Utils.createFormattedEntryForExpectation(this, evaluationEntry);
  }
  
  default FormattedEntry createFormattedEntryForActualValue(EvaluationEntry evaluationEntry) {
    return Utils.createFormattedEntryForActualValue(this, evaluationEntry);
  }
  
  default boolean requiresExplanation(EvaluationEntry evaluationEntry) {
    return evaluationEntry.requiresExplanation();
  }
  
  /**
   * A default implementation of `ReportComposer`.
   */
  class Default implements ReportComposer {
  }
  
  interface Report {
    String summary();
    
    List<String> details();
    
    static Report create(String summary, List<String> details) {
      List<String> detailsCopy = unmodifiableList(new ArrayList<>(details));
      return new Report() {
        @Override
        public String summary() {
          return summary;
        }
        
        @Override
        public List<String> details() {
          return detailsCopy;
        }
      };
    }
  }
  
  class FormattedEntry {
    private final String  input;
    private final String  formName;
    private final String  indent;
    private final String  output;
    private final boolean requiresExplanation;
    
    public FormattedEntry(String input, String formName, String indent, String output, boolean requiresExplanation) {
      this.input = input;
      this.formName = formName;
      this.indent = indent;
      this.output = output;
      this.requiresExplanation = requiresExplanation;
    }
    
    Optional<String> input() {
      return Optional.ofNullable(this.input);
    }
    
    String indent() {
      return this.indent;
    }
    
    String formName() {
      return this.formName;
    }
    
    Optional<String> output() {
      return Optional.ofNullable(this.output);
    }
    
    public boolean requiresExplanation() {
      return this.requiresExplanation;
    }
  }
  
  enum Utils {
    ;
    
    /**
     * Note that an exception thrown during an evaluation is normally caught by the framework.
     *
     * @param message           A message to be prepended to a summary.
     * @param evaluationHistory An "evaluation history" object represented as a list of evaluation entries.
     * @return An explanation object.
     */
    public static Explanation composeExplanation(ReportComposer reportComposer, String message, List<EvaluationEntry> evaluationHistory) {
      List<Object> detailsForExpectation = new LinkedList<>();
      List<ReportComposer.FormattedEntry> summaryDataForExpectations = squashTrivialEntries(reportComposer, evaluationHistory)
          .stream()
          .peek((EvaluationEntry each) -> addToDetailsListIfExplanationIsRequired(reportComposer, detailsForExpectation, each, each::detailOutputExpectation))
          .map(reportComposer::createFormattedEntryForExpectation)
          .collect(toList());
      String textSummaryForExpectations = composeSummaryForExpectations(minimizeIndentation(summaryDataForExpectations));
      List<Object> detailsForActual = new LinkedList<>();
      List<ReportComposer.FormattedEntry> summaryForActual = squashTrivialEntries(reportComposer, evaluationHistory)
          .stream()
          .peek((EvaluationEntry each) -> addToDetailsListIfExplanationIsRequired(reportComposer, detailsForActual, each, each::detailOutputActualValue))
          .map(reportComposer::createFormattedEntryForActualValue)
          .collect(toList());
      String textSummaryForActualResult = composeSummaryForActualResults(minimizeIndentation(summaryForActual));
      return new Explanation(message,
          composeReport(textSummaryForExpectations, detailsForExpectation),
          composeReport(textSummaryForActualResult, detailsForActual));
    }
    
    public static ReportComposer.FormattedEntry createFormattedEntryForExpectation(ReportComposer reportComposer, EvaluationEntry entry) {
      return new ReportComposer.FormattedEntry(
          formatObject(entry.inputExpectation()),
          entry.formName(),
          indent(entry.level()),
          formatObject(entry.outputExpectation()),
          reportComposer.requiresExplanation(entry));
    }
    
    public static ReportComposer.FormattedEntry createFormattedEntryForActualValue(ReportComposer reportComposer, EvaluationEntry entry) {
      return new ReportComposer.FormattedEntry(
          formatObject(entry.inputActualValue()),
          entry.formName(),
          indent(entry.level()),
          formatObject(entry.outputActualValue()),
          reportComposer.requiresExplanation(entry));
    }
    
    private static List<FormattedEntry> minimizeIndentation(List<FormattedEntry> summaryForActual) {
      String minIndent = summaryForActual.stream()
          .map(e -> e.indent)
          .min(Comparator.comparingInt(String::length))
          .orElse("");
      return summaryForActual.stream()
          .map(e -> new ReportComposer.FormattedEntry(e.input, e.formName(), e.indent().replaceFirst(minIndent, ""), e.output, e.requiresExplanation()))
          .collect(toList());
    }
    
    private static List<EvaluationEntry> squashTrivialEntries(ReportComposer reportComposer, List<EvaluationEntry> evaluationHistory) {
      if (evaluationHistory.size() > 1) {
        List<EvaluationEntry> ret = new LinkedList<>();
        List<EvaluationEntry> entriesToSquash = new LinkedList<>();
        AtomicReference<EvaluationEntry> cur = new AtomicReference<>();
        evaluationHistory.stream()
            .filter(each -> !each.ignored() || DebuggingUtils.reportIgnoredEntries())
            .filter(each -> {
              if (cur.get() != null)
                return true;
              else {
                cur.set(each);
                return false;
              }
            })
            .forEach(each -> {
              if (entriesToSquash.isEmpty()) {
                if (cur.get().isSquashable(each) && !suppressSquashing()) {
                  entriesToSquash.add(cur.get());
                } else {
                  ret.add(cur.get());
                }
              } else {
                entriesToSquash.add(cur.get());
                ret.add(squashEntries(reportComposer, entriesToSquash));
                entriesToSquash.clear();
              }
              cur.set(each);
            });
        finishLeftOverEntries(reportComposer, ret, entriesToSquash, cur);
        return ret.stream()
            .filter(e -> !(e.inputActualValue() instanceof ValueHolder))
            .collect(toList());
      } else {
        return new ArrayList<>(evaluationHistory);
      }
    }
    
    private static void finishLeftOverEntries(ReportComposer reportComposer, List<EvaluationEntry> out, List<EvaluationEntry> leftOverEntriesToSquash, AtomicReference<EvaluationEntry> leftOver) {
      if (!leftOverEntriesToSquash.isEmpty() && leftOverEntriesToSquash.get(leftOverEntriesToSquash.size() - 1).isSquashable(leftOver.get()) && !suppressSquashing()) {
        leftOverEntriesToSquash.add(leftOver.get());
        out.add(squashEntries(reportComposer, leftOverEntriesToSquash));
      } else {
        if (!leftOverEntriesToSquash.isEmpty())
          out.add(squashEntries(reportComposer, leftOverEntriesToSquash));
        out.add(leftOver.get());
      }
    }
    
    private static EvaluationEntry squashEntries(ReportComposer reportComposer, List<EvaluationEntry> squashedItems) {
      EvaluationEntry first = squashedItems.get(0);
      return EvaluationEntry.create(
          squashedItems.stream()
              .map(e -> (EvaluationEntry.Impl) e)
              .map(EvaluationEntry::formName)
              .collect(joining(":")),
          first.type(),
          first.level(),
          first.inputExpectation(), first.detailInputExpectation(),
          first.outputExpectation(), computeDetailOutputExpectationFromSquashedItems(squashedItems),
          first.inputActualValue(), null,
          first.outputActualValue(), squashedItems.get(squashedItems.size() - 1).detailOutputActualValue(),
          false,
          squashedItems.stream().anyMatch(reportComposer::requiresExplanation), false);
    }
    
    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
    private static boolean suppressSquashing() {
      return DebuggingUtils.suppressSquashing();
    }
    
    private static String computeDetailOutputExpectationFromSquashedItems(List<EvaluationEntry> squashedItems) {
      return squashedItems.stream()
          .filter(e -> e.type() != EvaluationEntry.Type.TRANSFORM && e.type() != EvaluationEntry.Type.CHECK)
          .map(EvaluationEntry::detailOutputExpectation)
          .map(Objects::toString)
          .collect(joining(":"));
    }
    
    private static void addToDetailsListIfExplanationIsRequired(ReportComposer reportComposer, List<Object> detailsForExpectation, EvaluationEntry evaluationEntry, Supplier<Object> detailOutput) {
      if (reportComposer.requiresExplanation(evaluationEntry))
        detailsForExpectation.add(detailOutput.get());
    }
    
    static Report composeReport(String summary, List<Object> details) {
      List<String> stringFormDetails = details != null ?
          details.stream()
              .filter(Objects::nonNull)
              .map(Objects::toString)
              .collect(toList()) :
          emptyList();
      return ReportComposer.Report.create(summary, stringFormDetails);
    }
    
    private static String composeSummaryForActualResults(List<ReportComposer.FormattedEntry> formattedEntries) {
      return composeSummary(formattedEntries);
    }
    
    private static String composeSummaryForExpectations(List<ReportComposer.FormattedEntry> formattedEntries) {
      return composeSummaryForActualResults(formattedEntries);
    }
    
    private static String composeSummary(List<ReportComposer.FormattedEntry> formattedEntries) {
      AtomicInteger mismatchExplanationCount = new AtomicInteger(0);
      boolean mismatchExplanationFound = formattedEntries
          .stream()
          .anyMatch(ReportComposer.FormattedEntry::requiresExplanation);
      return evaluatorEntriesToString(
          hideInputValuesWhenRepeated(formattedEntries),
          columnLengths -> formattedEntryToString(
              columnLengths[0],
              columnLengths[1],
              columnLengths[2],
              mismatchExplanationCount,
              mismatchExplanationFound));
    }
    
    private static Function<ReportComposer.FormattedEntry, String> formattedEntryToString(
        int inputColumnWidth,
        int formNameColumnLength,
        int outputColumnLength,
        AtomicInteger i,
        boolean mismatchExplanationFound) {
      return (ReportComposer.FormattedEntry formattedEntry) ->
          (mismatchExplanationFound ?
              format("%-4s", formattedEntry.requiresExplanation ?
                  "[" + i.getAndIncrement() + "]" : "") :
              "") +
              format("%-" + max(2, inputColumnWidth) + "s" +
                      "%-" + (formNameColumnLength + 2) + "s" +
                      "%-" + max(2, outputColumnLength) + "s",
                  formattedEntry.input().orElse(""),
                  formattedEntry.input()
                      .map(v -> "->")
                      .orElse("  ") + formatObject(InternalUtils.toNonStringObject(formattedEntry.indent() + formattedEntry.formName()), formNameColumnLength - 2),
                  formattedEntry
                      .output()
                      .map(v -> "->" + v).orElse(""));
    }
    
    private static String evaluatorEntriesToString(List<ReportComposer.FormattedEntry> formattedEntries, Function<int[], Function<ReportComposer.FormattedEntry, String>> formatterFactory) {
      int maxInputLength = 0, maxIndentAndFormNameLength = 0, maxOutputLength = 0;
      for (ReportComposer.FormattedEntry eachEntry : formattedEntries) {
        int inputLength = eachEntry.input().map(String::length).orElse(0);
        if (inputLength > maxInputLength)
          maxInputLength = inputLength;
        int inputAndFormNameLength = eachEntry.indent().length() + eachEntry.formName().length();
        if (inputAndFormNameLength > maxIndentAndFormNameLength)
          maxIndentAndFormNameLength = inputAndFormNameLength;
        int outputLength = eachEntry.output().map(String::length).orElse(0);
        if (outputLength > maxOutputLength)
          maxOutputLength = outputLength;
      }
      int formNameColumnLength = (formNameColumnLength = max(
          DebuggingUtils.showEvaluableDetail() ? 80 : 12,
          min(summarizedStringLength(), maxIndentAndFormNameLength))) + formNameColumnLength % 2;
      Function<ReportComposer.FormattedEntry, String> formatter = formatterFactory.apply(
          new int[] { maxInputLength, formNameColumnLength, maxOutputLength });
      return formattedEntries
          .stream()
          .map(formatter)
          .map(s -> ("+" + s).trim().substring(1))
          .collect(joining(format("%n")));
    }
    
    private static List<ReportComposer.FormattedEntry> hideInputValuesWhenRepeated(List<ReportComposer.FormattedEntry> formattedEntries) {
      AtomicReference<Object> previousInput = new AtomicReference<>();
      return formattedEntries.stream()
          .map(each -> {
            if (!Objects.equals(previousInput.get(), each.input())) {
              previousInput.set(each.input());
              return each;
            } else {
              return new ReportComposer.FormattedEntry("", each.formName(), each.indent(), each.output().orElse(null), each.requiresExplanation());
            }
          })
          .collect(toList());
    }
    
    
  }
}









































































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.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.ut.InternalUtilsTest$FormatObjectTest.testCreateInstanceFromClassName$thenNotFound(com.github.dakusui.pcond.ut.InternalUtilsTest$FormatObjectTest) (0 ms)
com.github.dakusui.pcond.ut.valuechecker.Opentest4jTest.test_testSkippedException$String(com.github.dakusui.pcond.ut.valuechecker.Opentest4jTest) (1 ms)
com.github.dakusui.pcond.CallTest.methodAmbiguous_primitiveBoxed(com.github.dakusui.pcond.CallTest) (61 ms)
com.github.dakusui.pcond.bugfixes.Issue11Test.whenReproduceIssue(com.github.dakusui.pcond.bugfixes.Issue11Test) (7 ms)
com.github.dakusui.pcond.ut.InternalUtilsTest$CreateInstanceFromClassNameTest.testConstructorPrivate(com.github.dakusui.pcond.ut.InternalUtilsTest$CreateInstanceFromClassNameTest) (1 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.pcond.ut.valuechecker.Opentest4jTest.test_testFailedException(com.github.dakusui.pcond.ut.valuechecker.Opentest4jTest) (2 ms)
com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100_conj(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.dakusui.pcond.ut.CurryingTest.givenExceptionThrowingFunction$whenApplythenThrown(com.github.dakusui.pcond.ut.CurryingTest) (1 ms)
com.github.dakusui.ut.valid8j.compatibility.ListTest.testAllMatch(com.github.dakusui.ut.valid8j.compatibility.ListTest) (2 ms)
com.github.dakusui.ut.valid8j.compatibility.ListTest.testCollectionContains(com.github.dakusui.ut.valid8j.compatibility.ListTest) (1 ms)
com.github.dakusui.pcond.ut.InternalUtilsTest$CreateInstanceFromClassNameTest.testUndefinedConstructor(com.github.dakusui.pcond.ut.InternalUtilsTest$CreateInstanceFromClassNameTest) (1 ms)
com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenString_whenFails_then(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (1 ms)
com.github.dakusui.ut.valid8j.compatibility.BooleanTest.testIsFalse(com.github.dakusui.ut.valid8j.compatibility.BooleanTest) (1 ms)
com.github.dakusui.pcond.ut.fluent4.SmokeTest.givenBook_whenCheckTitleAndAbstract_thenTheyAreNotNullAndAppropriateLength_2(com.github.dakusui.pcond.ut.fluent4.SmokeTest) (27 ms)
com.github.dakusui.pcond.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.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssumeAll_failed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (3 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.PredicatesTest$MessageTest.testFormat(com.github.dakusui.ut.thincrest.ut.PredicatesTest$MessageTest) (2 ms)
com.github.dakusui.pcond.types.StreamTest.streamTransformerTestFailure(com.github.dakusui.pcond.types.StreamTest) (1 ms)
com.github.dakusui.pcond.ut.InternalUtilsTest$WrapIfNecessaryTest.testWrapIfNecessary(com.github.dakusui.pcond.ut.InternalUtilsTest$WrapIfNecessaryTest) (0 ms)
com.github.dakusui.ut.valid8j.compatibility.StringTest.testStartsWith(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 ms)
com.github.dakusui.ut.valid8j.compatibility.StringTest.testEqualsIgnoreCase(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 ms)
com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenString_whenFails_then_2(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (2 ms)
com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest.givenSomeFoundSomeNot$whenFindString$thenFailed(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindStringsTest) (2 ms)
com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenToBooleanIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (1 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.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.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenTransformIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (2 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.propertybased.tests.StreamAllMatchPredicateTest.exerciseTestCase[2: givenStreamPredicate_whenUnexpectedValue_thenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.StreamAllMatchPredicateTest) (3 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.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.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.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.pcond.types.FloatTest.toFloatTest(com.github.dakusui.pcond.types.FloatTest) (3 ms)
com.github.dakusui.pcond.ut.InternalUtilsTest$CreateInstanceFromClassNameTest.testConstructorThrowingException(com.github.dakusui.pcond.ut.InternalUtilsTest$CreateInstanceFromClassNameTest) (1 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.FluentStyleTestAssertionTest$ForTestAssertionsTest.string_assertThatTest_failed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.dakusui.ut.valid8j.ut.EnsuresTest (5 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.compatibility.StringTest.testIsEmptyString(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 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.styles.FluentStyleDbCTest$ForEnsuresTest.ensureValuesTest_failing(com.github.dakusui.ut.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (4 ms)
com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenIsTrueAndIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
com.github.dakusui.pcond.propertybased.tests.NegatedPredicateTest.exerciseTestCase[1: givenNegatedSimplePredicateReturningTrue_whenUnexpectedValue_thenComparisonFailureThrown](com.github.dakusui.pcond.propertybased.tests.NegatedPredicateTest) (3 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.compatibility.StringTest.testContainsString(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 ms)
com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenCheckIsTrue_thenComparisonFailure(com.github.dakusui.ut.valid8j.ut.styles.fluent.FluentBooleanTest) (4 ms)
com.github.dakusui.pcond.ut.InternalUtilsTest$GetMethodTest.testGetMethod(com.github.dakusui.pcond.ut.InternalUtilsTest$GetMethodTest) (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.PredicatesTest$FindElementsTest.givenSomeToBeFoundSomeNotToBe$whenFindElements$thenFailed(com.github.dakusui.ut.thincrest.ut.PredicatesTest$FindElementsTest) (3 ms)
com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessUsingCustomPredicateWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (1 ms)
com.github.dakusui.ut.valid8j.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.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.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssertAll_failed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (3 ms)
com.github.dakusui.pcond.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[2: givenStreamPredicate$hello_b_e_2$_whenUnexpectedValue_thenComparisonFailure2](com.github.dakusui.pcond.propertybased.tests.StreamNoneMatchPredicateTest) (8 ms)
com.github.dakusui.pcond.experimentals.TestAssertionsCurriedFunctionsTest.helloError(com.github.dakusui.pcond.experimentals.TestAssertionsCurriedFunctionsTest) (2 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.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.propertybased.tests.AllOfPredicateTest.exerciseTestCase[2: whenPredicatesFirstReturningFalseRestReturningTrueUnderAllOf_whenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.AllOfPredicateTest) (3 ms)
com.github.dakusui.pcond.ut.CurryingTest.undefinedMethod(com.github.dakusui.pcond.ut.CurryingTest) (1 ms)
com.github.dakusui.pcond.CallTest.methodNotFound(com.github.dakusui.pcond.CallTest) (3 ms)
com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest.given$hello$_$world$_whenRequireNestedStreamImpossibleConditions_thenPreconditionViolationExceptionWithCorrectMessage(com.github.dakusui.pcond.experimentals.DbCCurriedFunctionsTest) (16 ms)
com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withoutEvaluator_conj_thenFail(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[4: givenTwoChainedTransformingPredicates_whenNonExpectedValue_thenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.TransformAndCheckPredicateTest) (8 ms)
com.github.dakusui.pcond.ut.InternalUtilsTest$FormatObjectTest.testCreateInstanceFromClassName$thenConstructorFails(com.github.dakusui.pcond.ut.InternalUtilsTest$FormatObjectTest) (1 ms)
com.github.dakusui.ut.valid8j.compatibility.StringTest.testSameAs(com.github.dakusui.ut.valid8j.compatibility.StringTest) (1 ms)
com.github.dakusui.pcond.types.FloatTest.floatTestFail(com.github.dakusui.pcond.types.FloatTest) (1 ms)
com.github.dakusui.ut.thincrest.ut.FluentUtilsTest.test4(com.github.dakusui.ut.thincrest.ut.FluentUtilsTest) (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.valid8j.compatibility.ListTest.testAnyMatch(com.github.dakusui.ut.valid8j.compatibility.ListTest) (1 ms)
com.github.dakusui.pcond.ut.InternalUtilsTest$FormatObjectTest.testCreateInstanceFromClassName$thenNoConstructor(com.github.dakusui.pcond.ut.InternalUtilsTest$FormatObjectTest) (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.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.pcond.ut.ExceptionsTest.testWrapIfNecessaryWithCheckedException(com.github.dakusui.pcond.ut.ExceptionsTest) (1 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.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.pcond.ut.InternalUtilsTest$FormatObjectTest.testCreateInstanceFromClassName$thenNotInstance(com.github.dakusui.pcond.ut.InternalUtilsTest$FormatObjectTest) (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.compatibility.StringTest.testEndsWith(com.github.dakusui.ut.valid8j.compatibility.StringTest) (0 ms)
com.github.dakusui.ut.valid8j.ut.ValidatesTest.test(com.github.dakusui.ut.valid8j.ut.ValidatesTest) (3 ms)
com.github.dakusui.pcond.NegateTest.whenInvertedTransformingPredicateFails_thenPrintDesignedMessage$transformIsntLeafAndNotMerged(com.github.dakusui.pcond.NegateTest) (11 ms)
com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100$whenShorterThan10(com.github.dakusui.pcond.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.dakusui.pcond.ut.CurryingTest.test4_b(com.github.dakusui.pcond.ut.CurryingTest) (2 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.ut.valuechecker.Opentest4jTest.test_testSkippedException$Explanation(com.github.dakusui.pcond.ut.valuechecker.Opentest4jTest) (0 ms)
com.github.dakusui.ut.thincrest.ut.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.dakusui.ut.thincrest.ut.ReportDetailTest) (2 ms)
com.github.dakusui.pcond.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[0: whenOnePredicateReturningFalseUnderAnyOf_whenComparisonFailure](com.github.dakusui.pcond.propertybased.tests.AnyOfPredicateTest) (3 ms)
com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assumeThatTest_failed(com.github.dakusui.ut.thincrest.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (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)

Report generated by PIT 1.7.3

1		package com.github.dakusui.pcond.validator;
2
3		import com.github.dakusui.pcond.core.DebuggingUtils;
4		import com.github.dakusui.pcond.core.EvaluationEntry;
5		import com.github.dakusui.pcond.fluent.ValueHolder;
6		import com.github.dakusui.pcond.internals.InternalUtils;
7
8		import java.util.*;
9		import java.util.concurrent.atomic.AtomicInteger;
10		import java.util.concurrent.atomic.AtomicReference;
11		import java.util.function.Function;
12		import java.util.function.Supplier;
13
14		import static com.github.dakusui.pcond.internals.InternalUtils.*;
15		import static java.lang.Math.max;
16		import static java.lang.Math.min;
17		import static java.lang.String.format;
18		import static java.util.Collections.emptyList;
19		import static java.util.Collections.unmodifiableList;
20		import static java.util.stream.Collectors.joining;
21		import static java.util.stream.Collectors.toList;
22
23		public interface ReportComposer {
24		default Explanation explanationFromMessage(String msg) {
25	1 1. explanationFromMessage : replaced return value with null for com/github/dakusui/pcond/validator/ReportComposer::explanationFromMessage → KILLED	return Explanation.fromMessage(msg);
26		}
27
28		default Explanation composeExplanation(String message, List<EvaluationEntry> evaluationEntries) {
29	1 1. composeExplanation : replaced return value with null for com/github/dakusui/pcond/validator/ReportComposer::composeExplanation → KILLED	return Utils.composeExplanation(this, message, evaluationEntries);
30		}
31
32		default FormattedEntry createFormattedEntryForExpectation(EvaluationEntry evaluationEntry) {
33	1 1. createFormattedEntryForExpectation : replaced return value with null for com/github/dakusui/pcond/validator/ReportComposer::createFormattedEntryForExpectation → KILLED	return Utils.createFormattedEntryForExpectation(this, evaluationEntry);
34		}
35
36		default FormattedEntry createFormattedEntryForActualValue(EvaluationEntry evaluationEntry) {
37	1 1. createFormattedEntryForActualValue : replaced return value with null for com/github/dakusui/pcond/validator/ReportComposer::createFormattedEntryForActualValue → KILLED	return Utils.createFormattedEntryForActualValue(this, evaluationEntry);
38		}
39
40		default boolean requiresExplanation(EvaluationEntry evaluationEntry) {

ReportComposer.java

Mutations

Active mutators

Tests examined