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 com.github.valid8j.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<EvaluationEntry> nonTrivialEvaluationHistory = evaluationHistory.stream().filter(each -> !each.isTrivial()).collect(toList());
      List<FormattedEntry> summaryDataForExpectations = formatEvaluationEntries(detailsForExpectation,
                                                                                reportComposer,
                                                                                nonTrivialEvaluationHistory,
                                                                                reportComposer::createFormattedEntryForExpectation,
                                                                                each -> each::detailOutputExpectation);
      String textSummaryForExpectations = composeSummary(minimizeIndentation(summaryDataForExpectations));
      
      List<Object> detailsForActual = new LinkedList<>();
      List<FormattedEntry> summaryForActual = formatEvaluationEntries(detailsForActual,
                                                                      reportComposer,
                                                                      nonTrivialEvaluationHistory,
                                                                      reportComposer::createFormattedEntryForActualValue,
                                                                      each -> each::detailOutputActualValue);
      String textSummaryForActualResult = composeSummary(minimizeIndentation(summaryForActual));
      return new Explanation(message,
                             composeReport(textSummaryForExpectations, detailsForExpectation),
                             composeReport(textSummaryForActualResult, detailsForActual));
    }
    
    private static List<FormattedEntry> formatEvaluationEntries(List<Object> detailsOutput,
                                                                ReportComposer reportComposer,
                                                                List<EvaluationEntry> nonTrivialEvaluationHistory,
                                                                Function<EvaluationEntry, FormattedEntry> evaluationEntryFormatter,
                                                                Function<EvaluationEntry, Supplier<Object>> detailGenerator) {
      return squashEntriesWhenPossible(reportComposer, nonTrivialEvaluationHistory)
          .stream()
          .peek((EvaluationEntry each) -> addToDetailsListIfExplanationIsRequired(reportComposer, detailsOutput, each, detailGenerator.apply(each)))
          .map(evaluationEntryFormatter)
          .collect(toList());
    }
    
    public static FormattedEntry createFormattedEntryForExpectation(ReportComposer reportComposer, EvaluationEntry entry) {
      return new FormattedEntry(formatObject(entry.inputExpectation()),
                                entry.formName(),
                                InternalUtils.indent(entry.level()),
                                formatObject(entry.outputExpectation()),
                                reportComposer.requiresExplanation(entry));
    }
    
    public static FormattedEntry createFormattedEntryForActualValue(ReportComposer reportComposer, EvaluationEntry entry) {
      return new FormattedEntry(formatObject(entry.inputActualValue()),
                                entry.formName(),
                                InternalUtils.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 FormattedEntry(e.input, e.formName(), e.indent().replaceFirst(minIndent, ""), e.output, e.requiresExplanation()))
                             .collect(toList());
    }
    
    private static List<EvaluationEntry> squashEntriesWhenPossible(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, 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 composeSummaryForExpectations(List<FormattedEntry> formattedEntries) {
      return composeSummary(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() + "]" : "") :
           "") +
              formatFields(inputColumnWidth, formNameColumnLength, outputColumnLength, formattedEntry);
    }
    
    private static String formatFields(int inputColumnWidth, int formNameColumnLength, int outputColumnLength, FormattedEntry formattedEntry) {
      return formatInSpecifiedWidth(max(2, inputColumnWidth), formattedEntry.input()
                                                                            .orElse("")) +
          formatInSpecifiedWidth(formNameColumnLength + 2, formattedEntry.input()
                                                                         .map(v -> "->")
                                                                         .orElse("  ") + formatObject(toNonStringObject(formattedEntry.indent() + formattedEntry.formName()), formNameColumnLength - 2)) +
          formatInSpecifiedWidth(max(2, outputColumnLength), 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) (2 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) (1 ms)
com.github.valid8j.examples.test.ExamplesTest.testIntroductionExample(com.github.valid8j.examples.test.ExamplesTest) (6 ms)
com.github.valid8j.ut.internal.CallTest.methodAmbiguous_primitiveBoxed(com.github.valid8j.ut.internal.CallTest) (1 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) (0 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.givenStreamOfSingleString$hello$_whenRequireNullIsFound_thenPreconditionViolationWithCorrectMessageIsThrown(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (2 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) (0 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) (0 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) (2 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenIsTrueAndIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (1 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest.testCreateInstanceFromClassName$thenNoConstructor(com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureStatesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (1 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) (2 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenToBooleanIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest.exerciseTestCase[1: givenStreamPredicate_whenUnexpectedNullValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest) (1 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) (1 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) (3 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) (3 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$CreateInstanceFromClassNameTest.testUndefinedConstructor(com.github.valid8j.ut.internal.InternalUtilsTest$CreateInstanceFromClassNameTest) (1 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) (1 ms)
com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest.exerciseTestCase[3: whenPredicatesFirstReturningFalseRestReturningTrueUnderAllOf_whenComparisonFailure](com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest) (1 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100_conj(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 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) (1 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 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) (3 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validate_fail(com.github.valid8j.entrypoints.ValidatesTest) (1 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) (1 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) (1 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) (22 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) (1 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testWrapperIsTrue(com.github.valid8j.ut.typesupports.BooleanTest) (1 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) (1 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) (0 ms)
com.github.valid8j.ut.propertybased.tests.NegatedPredicateTest.exerciseTestCase[1: givenNegatedSimplePredicateReturningTrue_whenUnexpectedValue_thenComparisonFailureThrown](com.github.valid8j.ut.propertybased.tests.NegatedPredicateTest) (0 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireNonNull(com.github.valid8j.entrypoints.RequiresTest) (1 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) (0 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) (1 ms)
com.github.valid8j.entrypoints.EnsuresTest.testEnsureNonNull(com.github.valid8j.entrypoints.EnsuresTest) (0 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) (67 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) (3 ms)
com.github.valid8j.examples.test.ExamplesTest.testMetarmorExampleFailing(com.github.valid8j.examples.test.ExamplesTest) (123 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 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) (1 ms)
com.github.valid8j.entrypoints.AssertionsTest$Failing (48 ms)
com.github.valid8j.ut.NullValueHandlingTest.givenNull_whenStatementIsExamined_thenProcessedCorrectly2(com.github.valid8j.ut.NullValueHandlingTest) (1 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) (3 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$MessageTest.testFormat(com.github.valid8j.ut.utilstest.PredicatesTest$MessageTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequire$thenError(com.github.valid8j.entrypoints.RequiresTest) (1 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) (0 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) (1 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest.testCreateInstanceFromClassName$thenConstructorFails(com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest) (0 ms)
com.github.valid8j.ut.typesupports.StringTest.testIsEmptyOrNullString(com.github.valid8j.ut.typesupports.StringTest) (1 ms)
com.github.valid8j.examples.test.JUnitBasedExamplesTest.testExampleUT(com.github.valid8j.examples.test.JUnitBasedExamplesTest) (4 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) (2 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[3: givenTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (1 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) (2 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) (1 ms)
com.github.valid8j.ut.propertybased.tests.SimplePredicateTest.exerciseTestCase[1: givenSimplePredicate_whenUnexpectedValue_thenComparisonFailureThrown](com.github.valid8j.ut.propertybased.tests.SimplePredicateTest) (0 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) (0 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) (10 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_b_e5(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (2 ms)
com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed.testFailureFromAndThenStructureInTransformer(com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed) (1 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) (1 ms)
com.github.valid8j.ut.internal.CallTest.methodNotFound(com.github.valid8j.ut.internal.CallTest) (0 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) (0 ms)
com.github.valid8j.entrypoints.ValidatesTest.test(com.github.valid8j.entrypoints.ValidatesTest) (1 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) (2 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireStatesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (1 ms)
com.github.valid8j.ut.valuechecker.Opentest4jTest.test_testSkippedException$String(com.github.valid8j.ut.valuechecker.Opentest4jTest) (1 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) (1 ms)
com.github.valid8j.ut.utilstest.TestAssertionsTest.testAnyOf(com.github.valid8j.ut.utilstest.TestAssertionsTest) (1 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) (2 ms)
com.github.valid8j.ut.valuechecker.Opentest4jTest.test_testFailedException(com.github.valid8j.ut.valuechecker.Opentest4jTest) (2 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat_usingFluentStyle(com.github.valid8j.ut.utilstest.ReportDetailTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureValuesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (1 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) (1 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) (1 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[0: givenChainedTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (1 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 com.github.valid8j.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/valid8j/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/valid8j/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/valid8j/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/valid8j/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