ReportComposer.java

package com.github.valid8j.pcond.validator;

import com.github.valid8j.pcond.core.DebuggingUtils;
import com.github.valid8j.pcond.core.EvaluationEntry;
import com.github.valid8j.pcond.fluent.ValueHolder;
import com.github.valid8j.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 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<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<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 FormattedEntry createFormattedEntryForExpectation(ReportComposer reportComposer, EvaluationEntry entry) {
      return new FormattedEntry(
          InternalUtils.formatObject(entry.inputExpectation()),
          entry.formName(),
          InternalUtils.indent(entry.level()),
          InternalUtils.formatObject(entry.outputExpectation()),
          reportComposer.requiresExplanation(entry));
    }

    public static FormattedEntry createFormattedEntryForActualValue(ReportComposer reportComposer, EvaluationEntry entry) {
      return new FormattedEntry(
          InternalUtils.formatObject(entry.inputActualValue()),
          entry.formName(),
          InternalUtils.indent(entry.level()),
          InternalUtils.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 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 Report.create(summary, stringFormDetails);
    }

    private static String composeSummaryForActualResults(List<FormattedEntry> formattedEntries) {
      return composeSummary(formattedEntries);
    }

    private static String composeSummaryForExpectations(List<FormattedEntry> formattedEntries) {
      return composeSummaryForActualResults(formattedEntries);
    }

    private static String composeSummary(List<FormattedEntry> formattedEntries) {
      AtomicInteger mismatchExplanationCount = new AtomicInteger(0);
      boolean mismatchExplanationFound = formattedEntries
          .stream()
          .anyMatch(FormattedEntry::requiresExplanation);
      return evaluatorEntriesToString(
          hideInputValuesWhenRepeated(formattedEntries),
          columnLengths -> formattedEntryToString(
              columnLengths[0],
              columnLengths[1],
              columnLengths[2],
              mismatchExplanationCount,
              mismatchExplanationFound));
    }

    private static Function<FormattedEntry, String> formattedEntryToString(
        int inputColumnWidth,
        int formNameColumnLength,
        int outputColumnLength,
        AtomicInteger i,
        boolean mismatchExplanationFound) {
      return (FormattedEntry formattedEntry) ->
          (mismatchExplanationFound ?
              format("%-4s", formattedEntry.requiresExplanation ?
                  "[" + i.getAndIncrement() + "]" : "") :
              "") +
              String.format("%-" + max(2, inputColumnWidth) + "s" +
                      "%-" + (formNameColumnLength + 2) + "s" +
                      "%-" + max(2, outputColumnLength) + "s",
                  formattedEntry.input().orElse(""),
                  formattedEntry.input()
                      .map(v -> "->")
                      .orElse("  ") + InternalUtils.formatObject(InternalUtils.toNonStringObject(formattedEntry.indent() + formattedEntry.formName()), formNameColumnLength - 2),
                  formattedEntry
                      .output()
                      .map(v -> "->" + v).orElse(""));
    }

    private static String evaluatorEntriesToString(List<FormattedEntry> formattedEntries, Function<int[], Function<FormattedEntry, String>> formatterFactory) {
      int maxInputLength = 0, maxIndentAndFormNameLength = 0, maxOutputLength = 0;
      for (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 = Math.max(
          DebuggingUtils.showEvaluableDetail() ? 80 : 12,
          Math.min(InternalUtils.summarizedStringLength(), maxIndentAndFormNameLength))) + formNameColumnLength % 2;
      Function<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<FormattedEntry> hideInputValuesWhenRepeated(List<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 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.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[2: givenStreamPredicate$hello_b_e_2$_whenUnexpectedValue_thenComparisonFailure2](com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest) (3 ms)
com.github.valid8j.ut.typesupports.ListTest.testListContains(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.ut.utilstest.TestAssertionsTest.testAssumeThat(com.github.valid8j.ut.utilstest.TestAssertionsTest) (0 ms)
com.github.valid8j.examples.test.ExamplesTest.testIntroductionExample(com.github.valid8j.examples.test.ExamplesTest) (3 ms)
com.github.valid8j.ut.internal.CallTest.methodAmbiguous_primitiveBoxed(com.github.valid8j.ut.internal.CallTest) (2 ms)
com.github.valid8j.ut.currying.CurryingTest.undefinedMethod(com.github.valid8j.ut.currying.CurryingTest) (0 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_disj$anyOf$_thenFail(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.ut.NullValueHandlingTest.givenNull_whenStatementIsExamined_thenProcessedCorrectly(com.github.valid8j.ut.NullValueHandlingTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireArgument(com.github.valid8j.entrypoints.RequiresTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.givenStreamOfSingleString$hello$_whenRequireNullIsFound_thenPreconditionViolationWithCorrectMessageIsThrown(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.typesupports.ListTest.testAnyMatch(com.github.valid8j.ut.typesupports.ListTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest.givenSomeFoundSomeNotFound$whenFindRegexes$thenFailed(com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest) (1 ms)
com.github.valid8j.ut.types.StreamTest.streamTransformerTestFailure(com.github.valid8j.ut.types.StreamTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireValuesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (2 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.given$hello$_$world$_whenRequireNestedStreamImpossibleConditions_thenPreconditionViolationExceptionWithCorrectMessage(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (5 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assumeThatTest_failed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest.helloError(com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessUsingCustomPredicateWithSlightlyDifferentString_thenExpectationSpecificFragmentsContainedOnlyByExplanationForExpectationAndActualValuesAreAlsoSo(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenIsTrueAndIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest.testCreateInstanceFromClassName$thenNoConstructor(com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureStatesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (2 ms)
com.github.valid8j.ut.valuechecker.Opentest4jTest.test_testSkippedException$Explanation(com.github.valid8j.ut.valuechecker.Opentest4jTest) (0 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$WrapIfNecessaryTest.testWrapIfNecessary(com.github.valid8j.ut.internal.InternalUtilsTest$WrapIfNecessaryTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenIllegalValue_whenEnsure_thenPostconditionViolationThrown(com.github.valid8j.entrypoints.EnsuresTest) (3 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenToBooleanIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest.exerciseTestCase[1: givenStreamPredicate_whenUnexpectedNullValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest) (2 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireWithCustomStringTransformingPredicate(com.github.valid8j.entrypoints.RequiresTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireArgumentsTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (2 ms)
com.github.valid8j.ut.utilstest.FluentUtilsTest.example2(com.github.valid8j.ut.utilstest.FluentUtilsTest) (0 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenTransformIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[4: givenTwoChainedTransformingPredicates_whenNonExpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (6 ms)
com.github.valid8j.ut.typesupports.ListTest.testCollectionContains(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.ut.bugfixes.Issue11Test.whenReproduceIssue(com.github.valid8j.ut.bugfixes.Issue11Test) (2 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectingExceptionButNotThrown_testFailing(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (4 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$CreateInstanceFromClassNameTest.testUndefinedConstructor(com.github.valid8j.ut.internal.InternalUtilsTest$CreateInstanceFromClassNameTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$IsInstanceOfTest.test(com.github.valid8j.ut.utilstest.PredicatesTest$IsInstanceOfTest) (1 ms)
com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed.testFailureFromComposeStructureInTransformer(com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed) (0 ms)
com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest.exerciseTestCase[3: whenPredicatesFirstReturningFalseRestReturningTrueUnderAllOf_whenComparisonFailure](com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest) (2 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100_conj(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (0 ms)
com.github.valid8j.entrypoints.ValidatesTest.testX(com.github.valid8j.entrypoints.ValidatesTest) (5 ms)
com.github.valid8j.ut.utilstest.TestAssertionsTest.testAllOf(com.github.valid8j.ut.utilstest.TestAssertionsTest) (1 ms)
com.github.valid8j.ut.utilstest.FluentUtilsTest.expectationFlipping(com.github.valid8j.ut.utilstest.FluentUtilsTest) (0 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_transforming_thenFail(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (0 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat(com.github.valid8j.ut.utilstest.ReportDetailTest) (0 ms)
com.github.valid8j.entrypoints.ValidatesTest.testValidateMethod$failing(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[3: givenStreamPredicate$hello_b_e_4$_whenUnexpectedValue_thenComparisonFailure2](com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest) (2 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validate_fail(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.givenString$hello$_whenTransformToContextAndCheckContextValueIsNull_thenPreconditionViolationWithCorrectMessageThrown(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testEndsWith(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100$whenShorterThan10(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.ut.NullValueHandlingTest.givenNull_whenStatementIsExamined_thenProcessedCorrectly3(com.github.valid8j.ut.NullValueHandlingTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindElementsTest.givenSomeToBeFoundSomeNotToBe$whenFindElements$thenFailed(com.github.valid8j.ut.utilstest.PredicatesTest$FindElementsTest) (1 ms)
com.github.valid8j.ut.internal.NegateTest.whenInvertedTrasformingPredicateFails_thenPrintDesignedMessage$mergedWhenNotMismatch(com.github.valid8j.ut.internal.NegateTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testIsEmptyString(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.typesupports.ListTest.testAllMatch(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.it.SmokeTest.givenBook_whenCheckTitleAndAbstract_thenTheyAreNotNullAndAppropriateLength_2(com.github.valid8j.it.SmokeTest) (12 ms)
com.github.valid8j.ut.types.FloatTest.toFloatTest(com.github.valid8j.ut.types.FloatTest) (1 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest.testCreateInstanceFromClassName$thenNotFound(com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest) (0 ms)
com.github.valid8j.ut.typesupports.StringTest.testComparison(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testWrapperIsTrue(com.github.valid8j.ut.typesupports.BooleanTest) (0 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100$whenNull(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssertAll_failed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$GetMethodTest.testGetMethod(com.github.valid8j.ut.internal.InternalUtilsTest$GetMethodTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssumeAll_failed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testEqualsIgnoreCase(com.github.valid8j.ut.typesupports.StringTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.NegatedPredicateTest.exerciseTestCase[1: givenNegatedSimplePredicateReturningTrue_whenUnexpectedValue_thenComparisonFailureThrown](com.github.valid8j.ut.propertybased.tests.NegatedPredicateTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireNonNull(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.ut.types.StreamTest.streamTestFailure(com.github.valid8j.ut.types.StreamTest) (1 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$CreateInstanceFromClassNameTest.testConstructorThrowingException(com.github.valid8j.ut.internal.InternalUtilsTest$CreateInstanceFromClassNameTest) (1 ms)
com.github.valid8j.ut.types.FloatTest.floatTransformerTestFail(com.github.valid8j.ut.types.FloatTest) (0 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenString_whenFails_then_2(com.github.valid8j.ut.utilstest.ReportDetailTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.testEnsureNonNull(com.github.valid8j.entrypoints.EnsuresTest) (1 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenString_whenFails_then(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 ms)
com.github.valid8j.examples.test.ExamplesTest.testClassicExample(com.github.valid8j.examples.test.ExamplesTest) (34 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_disj$or$_thenFail(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectingDifferentException_testFailing(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (2 ms)
com.github.valid8j.examples.test.ExamplesTest.testMetarmorExampleFailing(com.github.valid8j.examples.test.ExamplesTest) (60 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.valid8j.ut.utilstest.ReportDetailTest) (0 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (1 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest.testCreateInstanceFromClassName$thenNotInstance(com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[0: givenStreamPredicate$RequireConditionResultingInNPE$_whenUnexpectedValue_thenComparisonFailure2](com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest) (2 ms)
com.github.valid8j.ut.typesupports.ListTest.testNoneMatch(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.entrypoints.AssertionsTest$Failing (39 ms)
com.github.valid8j.ut.NullValueHandlingTest.givenNull_whenStatementIsExamined_thenProcessedCorrectly2(com.github.valid8j.ut.NullValueHandlingTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[1: givenDoubleChainedTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (2 ms)
com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest.exerciseTestCase[1: givenStreamPredicate$hello_b_e$_whenUnexpectedValue_thenComparisonFailure2](com.github.valid8j.ut.propertybased.tests.StreamNoneMatchPredicateTest) (2 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$MessageTest.testFormat(com.github.valid8j.ut.utilstest.PredicatesTest$MessageTest) (0 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequire$thenError(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.ut.typesupports.StringTest.testMatchesRegex(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.typesupports.StringTest.testContainsString(com.github.valid8j.ut.typesupports.StringTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testEqualTo(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.internal.NegateTest.whenInvertedTransformingPredicateFails_thenPrintDesignedMessage$transformIsntLeafAndNotMerged(com.github.valid8j.ut.internal.NegateTest) (1 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testIsFalse(com.github.valid8j.ut.typesupports.BooleanTest) (0 ms)
com.github.valid8j.ut.internal.PrintablesFunctionTest$Simple.testHandleNull(com.github.valid8j.ut.internal.PrintablesFunctionTest$Simple) (0 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest.testCreateInstanceFromClassName$thenConstructorFails(com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testIsEmptyOrNullString(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.examples.test.JUnitBasedExamplesTest.testExampleUT(com.github.valid8j.examples.test.JUnitBasedExamplesTest) (3 ms)
com.github.valid8j.ut.internal.NegateTest.whenInvertedTrasformingPredicateFails_thenPrintDesignedMessage$notMergedWhenMismatch(com.github.valid8j.ut.internal.NegateTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest.givenSomeFoundSomeNot$whenFindString$thenFailed(com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[3: givenTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (3 ms)
com.github.valid8j.ut.internal.exceptionhandling.ExceptionsTest.testWrapIfNecessaryWithCheckedException(com.github.valid8j.ut.internal.exceptionhandling.ExceptionsTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest.exerciseTestCase[1: whenOnePredicateThrowingExceptionUnderAllOf_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest) (3 ms)
com.github.valid8j.ut.typesupports.StringTest.testStartsWith(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validateArgument_fail(com.github.valid8j.entrypoints.ValidatesTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.methodAmbiguous_primitiveBoxed_negated(com.github.valid8j.ut.internal.CallTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireWithTransformingPredicate(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.SimplePredicateTest.exerciseTestCase[1: givenSimplePredicate_whenUnexpectedValue_thenComparisonFailureThrown](com.github.valid8j.ut.propertybased.tests.SimplePredicateTest) (1 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenCheckIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withoutEvaluator_conj_thenFail(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.nestedLoop_fail(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.examples.test.ExamplesTest.testFluentExample(com.github.valid8j.examples.test.ExamplesTest) (4 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_b_e5(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (3 ms)
com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed.testFailureFromAndThenStructureInTransformer(com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed) (2 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$CreateInstanceFromClassNameTest.testConstructorPrivate(com.github.valid8j.ut.internal.InternalUtilsTest$CreateInstanceFromClassNameTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.nullReturningFunctionAsPredicate(com.github.valid8j.ut.internal.CallTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.givenInvalidState$whenRequireState$thenIllegalStateExceptionThrown(com.github.valid8j.entrypoints.RequiresTest) (3 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testIsTrue(com.github.valid8j.ut.typesupports.BooleanTest) (0 ms)
com.github.valid8j.ut.types.FloatTest.floatTestFail(com.github.valid8j.ut.types.FloatTest) (0 ms)
com.github.valid8j.ut.internal.CallTest.methodNotFound(com.github.valid8j.ut.internal.CallTest) (1 ms)
com.github.valid8j.ut.utilstest.FluentUtilsTest.test4(com.github.valid8j.ut.utilstest.FluentUtilsTest) (1 ms)
com.github.valid8j.entrypoints.EnsuresTest.testEnsure(com.github.valid8j.entrypoints.EnsuresTest) (1 ms)
com.github.valid8j.entrypoints.ValidatesTest.test(com.github.valid8j.entrypoints.ValidatesTest) (2 ms)
com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest.exerciseTestCase[2: givenStreamPredicate_whenUnexpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest) (2 ms)
com.github.valid8j.entrypoints.ValidatesTest.testY(com.github.valid8j.entrypoints.ValidatesTest) (1 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testWrapperIsFalse(com.github.valid8j.ut.typesupports.BooleanTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.testEnsureState(com.github.valid8j.entrypoints.EnsuresTest) (0 ms)
com.github.valid8j.ut.currying.CurryingTest.givenExceptionThrowingFunction$whenApplythenThrown(com.github.valid8j.ut.currying.CurryingTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireStatesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (2 ms)
com.github.valid8j.ut.valuechecker.Opentest4jTest.test_testSkippedException$String(com.github.valid8j.ut.valuechecker.Opentest4jTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest.exerciseTestCase[0: whenOnePredicateReturningFalseUnderAllOf_whenComparisonFailure](com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest) (3 ms)
com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[1: whenOnePredicateThrowingExceptionUnderAnyOf_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest) (2 ms)
com.github.valid8j.ut.utilstest.TestAssertionsTest.testAnyOf(com.github.valid8j.ut.utilstest.TestAssertionsTest) (0 ms)
com.github.valid8j.entrypoints.RequiresTest.givenIllegalArgument_whenRequireArgument_thenIllegalArgumentThrown(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.ut.currying.CurryingTest.test4_b(com.github.valid8j.ut.currying.CurryingTest) (0 ms)
com.github.valid8j.ut.valuechecker.Opentest4jTest.test_testFailedException(com.github.valid8j.ut.valuechecker.Opentest4jTest) (1 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat_usingFluentStyle(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureValuesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (2 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello5(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testSameAs(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.string_assertThatTest_failed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessUsingCustomPredicateWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[0: whenOnePredicateReturningFalseUnderAnyOf_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest) (1 ms)
com.github.valid8j.ut.typesupports.ListTest.testEmpty(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[0: givenChainedTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (2 ms)

Report generated by PIT 1.7.3

1		package com.github.valid8j.pcond.validator;
2
3		import com.github.valid8j.pcond.core.DebuggingUtils;
4		import com.github.valid8j.pcond.core.EvaluationEntry;
5		import com.github.valid8j.pcond.fluent.ValueHolder;
6		import com.github.valid8j.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 java.lang.Math.max;
15		import static java.lang.Math.min;
16		import static java.lang.String.format;
17		import static java.util.Collections.emptyList;
18		import static java.util.Collections.unmodifiableList;
19		import static java.util.stream.Collectors.joining;
20		import static java.util.stream.Collectors.toList;
21
22		public interface ReportComposer {
23		default Explanation explanationFromMessage(String msg) {
24	1 1. explanationFromMessage : replaced return value with null for com/github/valid8j/pcond/validator/ReportComposer::explanationFromMessage → KILLED	return Explanation.fromMessage(msg);
25		}
26
27		default Explanation composeExplanation(String message, List<EvaluationEntry> evaluationEntries) {
28	1 1. composeExplanation : replaced return value with null for com/github/valid8j/pcond/validator/ReportComposer::composeExplanation → KILLED	return Utils.composeExplanation(this, message, evaluationEntries);
29		}
30
31		default FormattedEntry createFormattedEntryForExpectation(EvaluationEntry evaluationEntry) {
32	1 1. createFormattedEntryForExpectation : replaced return value with null for com/github/valid8j/pcond/validator/ReportComposer::createFormattedEntryForExpectation → KILLED	return Utils.createFormattedEntryForExpectation(this, evaluationEntry);
33		}
34
35		default FormattedEntry createFormattedEntryForActualValue(EvaluationEntry evaluationEntry) {
36	1 1. createFormattedEntryForActualValue : replaced return value with null for com/github/valid8j/pcond/validator/ReportComposer::createFormattedEntryForActualValue → KILLED	return Utils.createFormattedEntryForActualValue(this, evaluationEntry);
37		}
38
39		default boolean requiresExplanation(EvaluationEntry evaluationEntry) {
40	2 1. requiresExplanation : replaced boolean return with false for com/github/valid8j/pcond/validator/ReportComposer::requiresExplanation → KILLED 2. requiresExplanation : replaced boolean return with true for com/github/valid8j/pcond/validator/ReportComposer::requiresExplanation → KILLED	return evaluationEntry.requiresExplanation();

ReportComposer.java

Mutations

Active mutators

Tests examined