Validator.java

package com.github.valid8j.pcond.validator;

import com.github.valid8j.pcond.core.*;
import com.github.valid8j.pcond.forms.Predicates;
import com.github.valid8j.pcond.internals.InternalUtils;

import java.io.IOException;
import java.io.InputStream;
import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

import static com.github.valid8j.pcond.validator.Validator.Configuration.Utils.instantiate;
import static com.github.valid8j.pcond.validator.Validator.Configuration.Utils.loadPcondProperties;
import static java.lang.String.format;
import static java.util.Collections.emptyList;

/**
 * An interface of a policy for behaviours on 'contract violations'.
 */
public interface Validator {
  /**
   * A constant field that holds the default provider instance.
   */
  ThreadLocal<Validator> INSTANCE = ThreadLocal.withInitial(() -> create(loadPcondProperties()));


  /**
   * Returns a configuration object that determines behaviors of this object.
   *
   * @return A configuration object.
   */
  Configuration configuration();

  /**
   * Returns a provider instance created from a given `Properties` object.
   * This method reads the value for the FQCN of this class (`com.github.valid8j.pcond.provider.AssertionProvider`) and creates an instance of a class specified by the value.
   * If the value is not set, this value instantiates an object of `DefaultAssertionProvider` and returns it.
   *
   * @param properties A {@code Properties} object from which an {@code AssertionProvider} is created
   * @return Created provider instance.
   */
  static Validator create(Properties properties) {
    return new Impl(configurationFromProperties(properties));
  }

  /**
   * Checks a value if it is {@code null} or not.
   * If it is not a {@code null}, this method returns the given value itself.
   *
   * @param value The given value.
   * @param <T>   The type of the value.
   * @return The {@code value}.
   */
  default <T> T requireNonNull(T value) {
    return require(value, Predicates.isNotNull(), configuration().exceptionComposer().forRequire()::exceptionForNonNullViolation);
  }

  /**
   * Checks a value if it meets a requirement specified by {@code cond}.
   * If it does, the value itself will be returned.
   *
   * @param value The value to be checked.
   * @param cond  The requirement to check the {@code value}.
   * @param <T>   The type of the value.
   * @return The value.
   */
  default <T> T requireArgument(T value, Predicate<? super T> cond) {
    return require(value, cond, configuration().exceptionComposer().forRequire()::exceptionForIllegalArgument);
  }

  /**
   * Checks a value if it meets a requirement specified by {@code cond}.
   * If it does, the value itself will be returned.
   *
   * @param value The value to be checked.
   * @param cond  The requirement to check the {@code value}.
   * @param <T>   The type of the value.
   * @return The value.
   */
  default <T> T requireState(T value, Predicate<? super T> cond) {
    return require(value, cond, configuration().exceptionComposer().forRequire()::exceptionForIllegalState);
  }

  /**
   * A method to check if a given `value` satisfies a precondition given as `cond`.
   * If the `cond` is satisfied, the `value` itself will be returned.
   * Otherwise, an exception returned by `configuration().exceptionComposer().forRequire().exceptionForGeneralViolation(String)`
   * will be thrown.
   *
   * @param value A value to be checked.
   * @param cond  A condition to check if `value` satisfies.
   * @param <T>   The of the `value`.
   * @return The `value`, if `cond` is satisfied.
   */
  default <T> T require(T value, Predicate<? super T> cond) {
    return require(value, cond, msg -> configuration().exceptionComposer().forRequire().exceptionForGeneralViolation(msg));
  }

  /**
   * A method to check if a given `value` satisfies a precondition given as `cond`.
   * If the `cond` is satisfied, the `value` itself will be returned.
   * Otherwise, an exception created by `exceptionFactory` is thrown.
   *
   * @param value            A value to be checked.
   * @param cond             A condition to check if `value` satisfies.
   * @param exceptionFactory A function to create an exception thrown when `cond`
   *                         is not satisfied by `value`.
   * @param <T>              The of the `value`.
   * @return The `value`, if `cond` is satisfied.
   */
  default <T> T require(T value, Predicate<? super T> cond, Function<String, Throwable> exceptionFactory) {
    return checkValueAndThrowIfFails(
        value,
        cond,
        this.configuration().messageComposer()::composeMessageForPrecondition,
        explanation -> squashStackTraceElements(exceptionFactory.apply(explanation.toString())));
  }

  /**
   * Validates the given `value`.
   * If the value satisfies a condition `cond`, the value itself will be returned.
   * Otherwise, an exception created by `forValidate.exceptionForGeneralViolation()`
   * will be thrown.
   * This method is intended to be used by {@code Validates#validate(Object, Predicate, Function)}
   * method in `valid8j` library.
   *
   * @param value       The value to be checked.
   * @param cond        A condition to validate the `value`.
   * @param forValidate An exception composer for "validate" methods.
   * @param <T>         The type of the value.
   * @return The value itself.
   */
  default <T> T validate(T value, Predicate<? super T> cond, ExceptionComposer.ForValidate forValidate) {
    return validate(value, cond, forValidate::exceptionForGeneralViolation);
  }

  /**
   * Validates the given `value`.
   * If the value is not `null`, the value itself will be returned.
   * Otherwise, an exception created by `forValidate.exceptionForGeneralViolation()`
   * will be thrown.
   * This method is intended to be used by {@code Validates#validateNonNull(Object)}
   * method in the **valid8j** library.
   *
   * @param value       The value to be checked.
   * @param forValidate An exception composer for "validate" methods.
   * @param <T>         The type of the value.
   * @return The value itself.
   */
  default <T> T validateNonNull(T value, ExceptionComposer.ForValidate forValidate) {
    return validate(value, Predicates.isNotNull(), forValidate::exceptionForNonNullViolation);
  }

  /**
   * Validates the given argument variable `value`.
   * If the value satisfies a condition `cond` for checking an argument variable, the value itself will be returned.
   * Otherwise, an exception created by `forValidate.exceptionForIllegalArgument()`
   * will be thrown.
   * This method is intended to be used by {@code Validates#validateArgument(Object, Predicate)}
   * method in `valid8j` library.
   *
   * @param value       The value to be checked.
   * @param cond        A condition to validate the `value`.
   * @param forValidate An exception composer for "validate" methods.
   * @param <T>         The type of the value.
   * @return The value itself.
   */
  default <T> T validateArgument(T value, Predicate<? super T> cond, ExceptionComposer.ForValidate forValidate) {
    return validate(value, cond, forValidate::exceptionForIllegalArgument);
  }

  /**
   * Validates the given state variable `value`.
   * If the value satisfies a condition `cond` for checking a state, the value itself will be returned.
   * Otherwise, an exception created by `forValidate.exceptionForIllegalState()`
   * will be thrown.
   * This method is intended to be used by {@code Validates#validateState(Object, Predicate)}
   * method in valid8j library.
   *
   * @param value       The value to be checked.
   * @param cond        A condition to validate the `value`.
   * @param forValidate An exception composer for "validate" methods.
   * @param <T>         The type of the value.
   * @return The value itself.
   */
  default <T> T validateState(T value, Predicate<? super T> cond, ExceptionComposer.ForValidate forValidate) {
    return validate(value, cond, forValidate::exceptionForIllegalState);
  }

  /**
   * Validates the given variable `value`.
   * If the value satisfies a condition `cond`, the value itself will be returned.
   * Otherwise, an exception created by `exceptionFactory` will be thrown.
   * This method is intended to be used by {@code Validates#validate(Object, Predicate, Function)}
   * method in the **valid8j** library.
   *
   * @param value            The value to be checked.
   * @param cond             A condition to validate the `value`.
   * @param exceptionFactory A function to create an exception when the `cond` is not satisfied.
   * @param <T>              The type of the value.
   * @return The value itself.
   */
  default <T> T validate(T value, Predicate<? super T> cond, Function<String, Throwable> exceptionFactory) {
    return validate_2(value, cond, explanation -> squashStackTraceElements(exceptionFactory.apply(explanation.toString())));
  }

  static Throwable squashStackTraceElements(Throwable throwable) {
    StackTraceElement[] stackTraceElements = throwable.getStackTrace();
    StackTraceElement first = stackTraceElements[0];
    throwable.setStackTrace(Stream.concat(Stream.of(new StackTraceElement(first.getClassName(), "STACKTRACE_WAS_SQUASHED", first.getFileName(), first.getLineNumber())),
                                      Arrays.stream(stackTraceElements)
                                            .filter(e -> !e.getClassName().startsWith("com.github.valid8j.")))
                                  .toArray(StackTraceElement[]::new));
    return throwable;
  }

  default <T> T validate_2(T value, Predicate<? super T> cond, ExceptionFactory<Throwable> exceptionFactory) {
    return checkValueAndThrowIfFails(
        value,
        cond,
        configuration().messageComposer()::composeMessageForValidation,
        exceptionFactory);
  }

  /**
   * Checks a value if it is not `null`.
   * If it is not `null`, the value itself will be returned.
   * If it is, an exception created by `configuration().exceptionComposer().forEnsure().exceptionForNonNullViolation()` will be thrown.
   * This method is intended for ensuring a "post-condition".
   *
   * @param value The value to be checked.
   * @param <T>   The type of the value.
   * @return The value.
   */
  default <T> T ensureNonNull(T value) {
    return ensure(value, Predicates.isNotNull(), configuration().exceptionComposer().forEnsure()::exceptionForNonNullViolation);
  }

  /**
   * Checks a value if it meets a requirement specified by {@code cond}.
   * If it does, the value itself will be returned.
   * If it does not, an exception created by `configuration().exceptionComposer().forEnsure().exceptionForIllegalState()` will be thrown.
   * This method is intended for ensuring a "post-condition" of a state.
   *
   * @param value The value to be checked.
   * @param cond  The requirement to check the {@code value}.
   * @param <T>   The type of the value.
   * @return The value.
   */
  default <T> T ensureState(T value, Predicate<? super T> cond) {
    return ensure(value, cond, configuration().exceptionComposer().forEnsure()::exceptionForIllegalState);
  }

  /**
   * Checks a value if it meets a requirement specified by {@code cond}.
   * If it does, the value itself will be returned.
   * If it does not, an exception created by `configuration().exceptionComposer().forEnsure().exceptionForGeneralViolation()` will be thrown.
   * This method is intended for ensuring a "post-condition".
   *
   * @param value The value to be checked.
   * @param cond  The requirement to check the {@code value}.
   * @param <T>   The type of the value.
   * @return The value.
   */
  default <T> T ensure(T value, Predicate<? super T> cond) {
    return ensure(value, cond, msg -> configuration().exceptionComposer().forEnsure().exceptionForGeneralViolation(msg));
  }

  /**
   * Checks a value if it meets a requirement specified by {@code cond}.
   * If it does, the value itself will be returned.
   * If it does not, an exception created by `exceptionComposer` will be thrown.
   * This method is intended for ensuring a "post-condition".
   *
   * @param value             The value to be checked.
   * @param cond              The requirement to check the {@code value}.
   * @param exceptionComposer A function to create an exception to be thrown when
   *                          `cond` is not met.
   * @param <T>               The type of the value.
   * @return The value.
   */
  default <T> T ensure(T value, Predicate<? super T> cond, Function<String, Throwable> exceptionComposer) {
    return checkValueAndThrowIfFails(
        value,
        cond,
        configuration().messageComposer()::composeMessageForPostcondition,
        explanation -> squashStackTraceElements(exceptionComposer.apply(explanation.toString())));
  }

  /**
   * A method to check if a `value` satisfies a predicate `cond`.
   *
   * This method is intended to be used by {@code Assertions#that(Object, Predicate)} in valid8j library.
   * If the condition is not satisfied, an exception created by `this.exceptionComposer().forAssert().exceptionInvariantConditionViolation()`
   * method will be thrown.
   *
   * @param value A value to be checked.
   * @param cond  A condition to check the `value`.
   * @param <T>   The type of `value`.
   */
  default <T> void checkInvariant(T value, Predicate<? super T> cond) {
    checkValueAndThrowIfFails(
        value,
        cond,
        configuration().messageComposer()::composeMessageForAssertion,
        explanation -> configuration().exceptionComposer().forAssert().exceptionInvariantConditionViolation(explanation.toString()));
  }

  /**
   * A method to check if a `value` satisfies a predicate `cond`.
   *
   * This method is intended to be used by {@code Assertions#precondition(Object, Predicate)} in valid8j library.
   * If the condition is not satisfied, an exception created by `this.exceptionComposer().forAssert().exceptionPreconditionViolation()`
   * method will be thrown.
   *
   * @param value A value to be checked.
   * @param cond  A condition to check the `value`.
   * @param <T>   The type of `value`.
   */
  default <T> void checkPrecondition(T value, Predicate<? super T> cond) {
    checkValueAndThrowIfFails(
        value,
        cond,
        configuration().messageComposer()::composeMessageForPrecondition,
        explanation -> configuration().exceptionComposer().forAssert().exceptionPreconditionViolation(explanation.toString()));
  }

  /**
   * A method to check if a `value` satisfies a predicate `cond`.
   *
   * This method is intended to be used by {@code Assertions#postcondition(Object, Predicate)} in valid8j library.
   * If the condition is not satisfied, an exception created by `this.exceptionComposer().forAssert().exceptionPostconditionViolation()`
   * method will be thrown.
   *
   * @param value A value to be checked.
   * @param cond  A condition to check the `value`.
   * @param <T>   The type of `value`.
   */
  default <T> void checkPostcondition(T value, Predicate<? super T> cond) {
    checkValueAndThrowIfFails(
        value,
        cond,
        configuration().messageComposer()::composeMessageForPostcondition,
        explanation -> configuration().exceptionComposer().forAssert().exceptionPostconditionViolation(explanation.toString()));
  }

  /**
   * Executes a test assertion for a given `value` using a predicate `cond`.
   * If the `cond` is not satisfied by the `value`, an exception created by `configuration().messageComposer().composeMessageForAssertion()`
   * will be thrown.
   *
   * @param value A value to be checked.
   * @param cond  A predicate to check a given `value`.
   * @param <T>   The type of the `value`.
   */
  default <T> void assertThat(T value, Predicate<? super T> cond) {
    checkValueAndThrowIfFails(
        value,
        cond,
        configuration().messageComposer()::composeMessageForAssertion,
        explanation -> configuration().exceptionComposer().forAssertThat().testFailedException(explanation, configuration().reportComposer()));
  }

  /**
   * Executes a test assumption check for a given `value` using a predicate `cond`.
   * If the `cond` is not satisfied by the `value`, an exception created by `configuration().messageComposer().composeMessageForAssertion()`
   * will be thrown.
   *
   * @param value A value to be checked.
   * @param cond  A predicate to check a given `value`.
   * @param <T>   The type of the `value`.
   */
  default <T> void assumeThat(T value, Predicate<? super T> cond) {
    checkValueAndThrowIfFails(
        value,
        cond,
        configuration().messageComposer()::composeMessageForAssertion,
        explanation -> configuration().exceptionComposer().forAssertThat().testSkippedException(explanation, configuration().reportComposer()));
  }

  /**
   * The core method of the `ValueChecker`.
   * This method checks if the given `evaluationContext` satisfies a condition, passed as `cond`.
   * If it does, the `evaluationContext` itself will be returned.
   * If not, an appropriate message will be composed based on the `evaluationContext` and `cond` by the `messageComposerFunction`.
   * Internally in this method, an `Explanation` of the failure is created by a {@link ReportComposer}
   * object returned by `configuration().reportComposer()` method.
   * The `Explanation` is passed to the `exceptionComposerFunction` and the exception
   * created by the function will be thrown.
   *
   * @param <T>                       The type of the `evaluationContext`.
   * @param value                     A value to be checked.
   * @param cond                      A predicate that checks the `evaluationContext`.
   * @param messageComposerFunction   A function that composes an error message from the `evaluationContext` and the predicate `cond`.
   * @param exceptionComposerFunction A function that creates an exception from a failure report created inside this method.
   * @return The `evaluationContext` itself.
   */
  @SuppressWarnings("unchecked")
  default <T> T checkValueAndThrowIfFails(
      T value,
      Predicate<? super T> cond,
      BiFunction<T, Predicate<? super T>, String> messageComposerFunction,
      ExceptionFactory<Throwable> exceptionComposerFunction) {
    ValueHolder<T> valueHolder = ValueHolder.forValue(value);
    Evaluable<T> evaluable = InternalUtils.toEvaluableIfNecessary(cond);
    EvaluableIo<T, Evaluable<T>, Boolean> evaluableIo = new EvaluableIo<>(valueHolder, EvaluationContext.resolveEvaluationEntryType(evaluable), evaluable);
    EvaluationContext<T> evaluationContext = new EvaluationContext<>();
    if (this.configuration().useEvaluator() && cond instanceof Evaluable) {
      Evaluator evaluator = Evaluator.create();
      ((Evaluable<T>) cond).accept(evaluableIo, evaluationContext, evaluator);
      if (evaluableIo.output().isValueReturned() && Objects.equals(true, evaluableIo.output().value()))
        return value;
      List<EvaluationEntry> entries = evaluationContext.resultEntries();
      throw exceptionComposerFunction.create(configuration()
          .reportComposer()
          .composeExplanation(
              messageComposerFunction.apply(value, cond),
              entries
          ));
    } else {
      if (!cond.test(valueHolder.returnedValue()))
        throw exceptionComposerFunction.create(configuration()
            .reportComposer()
            .composeExplanation(
                messageComposerFunction.apply(value, cond),
                emptyList()
            ));
      return value;
    }
  }

  static Validator instance() {
    return INSTANCE.get();
  }

  static void reconfigure(Consumer<Configuration.Builder> configurator) {
    Configuration.Builder b = instance().configuration().parentBuilder();
    reconfigure(configurator, b);
  }

  static void reconfigure(Consumer<Configuration.Builder> configurator, Configuration.Builder b) {
    Objects.requireNonNull(configurator).accept(b);
    INSTANCE.set(new Impl(b.build()));
  }

  static void resetToDefault() {
    reconfigure(b -> {
    });
  }

  static Configuration configurationFromProperties(Properties properties) {
    return Configuration.Builder.fromProperties(properties).build();
  }

  interface ExceptionFactory<E extends Throwable> extends Function<Explanation, E> {
    default RuntimeException create(Explanation explanation) {
      return createException(this, explanation);
    }

    static RuntimeException createException(ExceptionFactory<?> exceptionFactory, Explanation explanation) {
      Throwable t = squashStackTraceElements(exceptionFactory.apply(explanation));
      if (t instanceof Error)
        throw (Error) t;
      if (t instanceof RuntimeException)
        throw (RuntimeException) t;
      throw new AssertionError(format("Checked exception(%s) cannot be used for validation.", t.getClass()), t);
    }
  }

  interface Configuration {
    /**
     * When `com.github.valid8j.pcond.debug` is not `true`, it is assumed that those methods in this interface return `false`.
     */
    interface Debugging {
      default boolean suppressSquashing() {
        return true;
      }

      default boolean enableDebugLog() {
        return true;
      }

      default boolean showEvaluableDetail() {
        return true;
      }

      default boolean reportIgnoredEntries() {
        return true;
      }

      default boolean passThroughComparisonFailure() {
        return true;
      }
    }

    int summarizedStringLength();

    boolean useEvaluator();

    /**
     * Returns a message composer, which is responsible for composing an appropriate message for
     * a context.
     *
     * @return A message composer.
     */
    MessageComposer messageComposer();

    /**
     * Returns a report composer, which is responsible for composing an appropriate "report" for
     * a context.
     *
     * @return A report composer
     */
    ReportComposer reportComposer();

    /**
     * Returns an exception composer, which is responsible for creating an exception
     * object of an appropriate type for a context.
     *
     * @return An exception composer.
     */
    ExceptionComposer exceptionComposer();

    Optional<Debugging> debugging();

    Builder parentBuilder();

    enum Utils {
      ;

      @SuppressWarnings("unchecked")
      static <E> E instantiate(@SuppressWarnings("unused") Class<E> baseClass, String className) {
        try {
          return (E) Class.forName(className).newInstance();
        } catch (InstantiationException | IllegalAccessException |
                 ClassNotFoundException e) {
          throw new RuntimeException(e);
        }
      }

      public static Properties loadPcondProperties() {
        try {
          Properties ret = new Properties();
          System.getProperties().forEach((k, v) -> {
            String key = Objects.toString(k);
            String value = Objects.toString(v);
            String prefix = "com.github.valid8j.pcond.";
            if (key.startsWith(prefix)) {
              ret.put(key.replace(prefix, ""), value);
            }
          });
          try (InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("pcond.properties")) {
            if (inputStream == null)
              return ret;
            ret.load(inputStream);
            return ret;
          }
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
    }

    class Builder implements Cloneable {
      boolean useEvaluator;
      int summarizedStringLength;


      MessageComposer messageComposer;
      ReportComposer reportComposer;
      private ExceptionComposer.ForRequire exceptionComposerForRequire;
      private ExceptionComposer.ForEnsure exceptionComposerForEnsure;
      private ExceptionComposer.ForValidate defaultExceptionComposerForValidate;
      private ExceptionComposer.ForAssertion exceptionComposerForAssert;
      private ExceptionComposer.ForTestAssertion exceptionComposerForTestFailures;

      public Builder() {
      }


      public Builder useEvaluator(boolean useEvaluator) {
        this.useEvaluator = useEvaluator;
        return this;
      }

      public Builder summarizedStringLength(int summarizedStringLength) {
        this.summarizedStringLength = summarizedStringLength;
        return this;
      }

      public Builder exceptionComposerForRequire(ExceptionComposer.ForRequire exceptionComposerForRequire) {
        this.exceptionComposerForRequire = exceptionComposerForRequire;
        return this;
      }

      public Builder exceptionComposerForEnsure(ExceptionComposer.ForEnsure exceptionComposerForEnsure) {
        this.exceptionComposerForEnsure = exceptionComposerForEnsure;
        return this;
      }

      public Builder defaultExceptionComposerForValidate(ExceptionComposer.ForValidate exceptionComposerForValidate) {
        this.defaultExceptionComposerForValidate = exceptionComposerForValidate;
        return this;
      }

      public Builder exceptionComposerForAssert(ExceptionComposer.ForAssertion exceptionComposerForAssert) {
        this.exceptionComposerForAssert = exceptionComposerForAssert;
        return this;
      }

      public Builder exceptionComposerForAssertThat(ExceptionComposer.ForTestAssertion exceptionComposerForAssertThat) {
        this.exceptionComposerForTestFailures = exceptionComposerForAssertThat;
        return this;
      }

      public Builder messageComposer(MessageComposer messageComposer) {
        this.messageComposer = messageComposer;
        return this;
      }

      public Builder reportComposer(ReportComposer reportComposer) {
        this.reportComposer = reportComposer;
        return this;
      }

      public Builder useOpentest4J() {
        this.exceptionComposerForTestFailures = new ExceptionComposer.ForTestAssertion.Opentest4J();
        return this;
      }

      public Configuration build() {
        if (!isClassPresent("org.junit.ComparisonFailure"))
          this.useOpentest4J();
        return new Configuration() {
          private final Debugging debugging = new Debugging() {
          };

          private final ExceptionComposer exceptionComposer = new ExceptionComposer.Impl(
              exceptionComposerForRequire,
              exceptionComposerForEnsure,
              defaultExceptionComposerForValidate,
              exceptionComposerForAssert,
              exceptionComposerForTestFailures
          );

          @Override
          public int summarizedStringLength() {
            return Builder.this.summarizedStringLength;
          }

          @Override
          public boolean useEvaluator() {
            return Builder.this.useEvaluator;
          }

          /**
           * Returns an exception composer, which is responsible for creating an exception
           * object of an appropriate type for a context.
           *
           * @return An exception composer.
           */
          public ExceptionComposer exceptionComposer() {
            return this.exceptionComposer;
          }

          @Override
          public Optional<Debugging> debugging() {
            if (Boolean.parseBoolean(System.getProperty("com.github.valid8j.pcond.debug"))) {
              return Optional.of(this.debugging);
            }
            return Optional.empty();
          }

          @Override
          public MessageComposer messageComposer() {
            return Builder.this.messageComposer;
          }

          @Override
          public ReportComposer reportComposer() {
            return Builder.this.reportComposer;
          }

          @Override
          public Builder parentBuilder() {
            return Builder.this.clone();
          }
        };
      }

      private static boolean isClassPresent(String s) {
        try {
          Class.forName(s);
          return true;
        } catch (ClassNotFoundException e) {
          return false;
        }
      }

      @Override
      public Builder clone() {
        try {
          return (Builder) super.clone();
        } catch (CloneNotSupportedException e) {
          throw new AssertionError();
        }
      }

      static Builder fromProperties(Properties properties) {
        return new Builder()
            .useEvaluator(Boolean.parseBoolean(properties.getProperty("useEvaluator", "true")))
            .summarizedStringLength(Integer.parseInt(properties.getProperty("summarizedStringLength", "40")))
            .exceptionComposerForRequire(instantiate(ExceptionComposer.ForRequire.class, properties.getProperty("exceptionComposerForRequire", "com.github.valid8j.pcond.validator.ExceptionComposer$ForRequire$Default")))
            .exceptionComposerForEnsure(instantiate(ExceptionComposer.ForEnsure.class, properties.getProperty("exceptionComposerForEnsure", "com.github.valid8j.pcond.validator.ExceptionComposer$ForEnsure$Default")))
            .defaultExceptionComposerForValidate(instantiate(ExceptionComposer.ForValidate.class, properties.getProperty("defaultExceptionComposerForValidate", "com.github.valid8j.pcond.validator.ExceptionComposer$ForValidate$Default")))
            .exceptionComposerForAssert(instantiate(ExceptionComposer.ForAssertion.class, properties.getProperty("exceptionComposerForAssert", "com.github.valid8j.pcond.validator.ExceptionComposer$ForAssertion$Default")))
            .exceptionComposerForAssertThat(instantiate(ExceptionComposer.ForTestAssertion.class, properties.getProperty("exceptionComposerForTestFailures", "com.github.valid8j.pcond.validator.ExceptionComposer$ForTestAssertion$JUnit4")))
            .messageComposer(instantiate(MessageComposer.class, properties.getProperty("messageComposer", "com.github.valid8j.pcond.validator.MessageComposer$Default")))
            .reportComposer(instantiate(ReportComposer.class, properties.getProperty("reportComposer", "com.github.valid8j.pcond.validator.ReportComposer$Default")));
      }
    }
  }

  class Impl implements Validator {

    private final Configuration configuration;

    public Impl(Configuration configuration) {
      this.configuration = Objects.requireNonNull(configuration);
    }

    @Override
    public Configuration configuration() {
      return this.configuration;
    }
  }
}

















































































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.internal.ParameterizedPredicatesTest.exercisePredicate[1](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[80: Given:<"123.4">:When:identity->castTo[Float] THEN:=[123.4]>:Then:identicalWith(value:123.4)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.types.FloatTest.floatSatisfiesTest(com.github.valid8j.ut.types.FloatTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[104: REQUIRE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[216: UNLESS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[12: DOLLAR: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[195: ENSURE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[205: UNLESS_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.object_assertThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[121: REQUIRE_ARGUMENT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[40: PRECONDITION: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[64: INVARIANT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[217: UNLESS: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[48: INVARIANTS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[2: ALL: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest.givenSomeFoundSomeNotFound$whenFindRegexes$thenFailed(com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[214: UNLESS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[155: HOLD_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[48: Given:<"A:B:C">:When::Then:identicalWith(value:A:B:C)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[168: HOLD: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[90: REQUIRE_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[80: POSTCONDITION: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[66: POSTCONDITIONS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[202: UNLESS_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[224: EXPECT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[40: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[216: UNLESS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$GtTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$GtTest) (0 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello4(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[208: UNLESS_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[12](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenIllegalValue_whenEnsure_thenPostconditionViolationThrown(com.github.valid8j.entrypoints.EnsuresTest) (3 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_that(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[150: REQUIRE_STATE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 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.ExpectationsTest.testPassingValue[188: ENSURE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[155: HOLD_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireArgumentsTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[146: REQUIRE_STATE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[71: POSTCONDITIONS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[4](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assertAll_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$IsInstanceOfTest.test(com.github.valid8j.ut.utilstest.PredicatesTest$IsInstanceOfTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[24: PRECONDITIONS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test6(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[114: REQUIRE_ARGUMENTS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[83: Given:<"123.5">:When:identity->castTo[Double] THEN:=[123.4]>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[176: ENSURE_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[23: PRECONDITIONS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 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.experimentals.DbCCurriedFunctionsTest.givenStreamOfSingleString$hello$_whenRequireNonNullIsFound_thenPassing(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureValue_passing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[213: UNLESS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[79: POSTCONDITION: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[179: ENSURE_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.RequiresTest.givenValidArgument_whenRequireArgument_thenValueReturned(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.entrypoints.ValidatesTest.testValidateMethod$failing(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[143: REQUIRE_STATE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[124: REQUIRE_ARGUMENT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.reqireState_passing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[143: REQUIRE_STATE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.givenString$hello$_whenTransformToContextAndCheckContextValueIsNull_thenPreconditionViolationWithCorrectMessageThrown(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[33](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[124: REQUIRE_ARGUMENT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[161: HOLD_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100$whenShorterThan10(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[139: REQUIRE_STATES: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.NullValueHandlingTest.givenNull_whenStatementIsExamined_thenProcessedCorrectly3(com.github.valid8j.ut.NullValueHandlingTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[39: PRECONDITION: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[3: ALL: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[202: UNLESS_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[221: EXPECT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[12: DOLLAR: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$NoneMatchTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$NoneMatchTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[74: Given:<"123">:When:identity->castTo[Long] THEN:=[123]>:Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[185: ENSURE_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[33: PRECONDITION: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[68: Given:<"HELLO">:When:,<>)>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testWrapperIsTrue(com.github.valid8j.ut.typesupports.BooleanTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[23: PRECONDITIONS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[187: ENSURE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.internal.TransformingPredicateTest.givenNonNullName$whenToString$thenLooksGood(com.github.valid8j.ut.internal.TransformingPredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[55: INVARIANT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[90: REQUIRE_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test5(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.ut.typesupports.StringTest.testEqualsIgnoreCase(com.github.valid8j.ut.typesupports.StringTest) (1 ms)
com.github.valid8j.ut.types.StreamTest.streamTestFailure(com.github.valid8j.ut.types.StreamTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[181: ENSURE_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenNonNull$whenEnsureNonNull$thenPasses(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.entrypoints.ExpectationsTest.testPassingValue[16: DOLLAR: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[199: UNLESS_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[47: INVARIANTS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[2: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[123: REQUIRE_ARGUMENT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[169: HOLD: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[17](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[185: ENSURE_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[182: ENSURE_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[67: POSTCONDITIONS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.valid8j.ut.utilstest.ReportDetailTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenValidValue$whenEnsure$thenPasses(com.github.valid8j.entrypoints.EnsuresTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[66: Given:<"hello">:When:,<>)->castTo[Boolean] THEN:isTrue>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[34: PRECONDITION: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.NullValueHandlingTest.givenNull_whenStatementIsExamined_thenProcessedCorrectly2(com.github.valid8j.ut.NullValueHandlingTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[48: INVARIANTS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[105: REQUIRE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[154: HOLD_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.ut.typesupports.StringTest.testMatchesRegex(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[6: Given:<["A","B","C"]>:When::Then:identicalWith(value:[A, B, C])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[25](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[163: HOLD_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[116: REQUIRE_ARGUMENTS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[196: ENSURE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.typesupports.StringTest.testIsEmptyOrNullString(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[82: POSTCONDITION: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[159: HOLD_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_b3(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[127: REQUIRE_ARGUMENT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[60: INVARIANT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[110: REQUIRE_ARGUMENTS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[10: ALL: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[6: ALL: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[223: EXPECT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.TransformingPredicateTest.givenNullForName$whenToString$thenLooksGood(com.github.valid8j.ut.internal.TransformingPredicateTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[67: Given:<"hello">:When:<<>.equals()->castTo[Boolean] THEN:isTrue>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[146: REQUIRE_STATE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[160: HOLD_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed.testFailureFromAndThenStructureInTransformer(com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[150: REQUIRE_STATE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[228: EXPECT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[43: PRECONDITION: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.nullReturningFunctionAsPredicate(com.github.valid8j.ut.internal.CallTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[4: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[89: REQUIRE_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.RequiresTest.givenValidValue_whenRequire_thenValueReturned(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[88: REQUIRE_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[110: REQUIRE_ARGUMENTS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[76: Given:<"123">:When:identity->castTo[Short] THEN:=[123]>:Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[111: REQUIRE_ARGUMENTS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[115: REQUIRE_ARGUMENTS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[2](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[142: REQUIRE_STATES: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.EnsuresTest.testEnsure(com.github.valid8j.entrypoints.EnsuresTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[0](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ValidatesTest.testY(com.github.valid8j.entrypoints.ValidatesTest) (1 ms)
com.github.valid8j.entrypoints.EnsuresTest.testEnsureState(com.github.valid8j.entrypoints.EnsuresTest) (0 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest.testFormatObject$boundaryLengthString(com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[51: INVARIANTS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[5](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireWithCustomStringTransformingPredicateAndSatisfyingValue(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[7: ALL: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[148: REQUIRE_STATE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.nullCanMatch(com.github.valid8j.ut.internal.CallTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[119: REQUIRE_ARGUMENTS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[117: REQUIRE_ARGUMENTS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[9: ALL: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello5(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[171: HOLD: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[199: UNLESS_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (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.styles.fluent.GeneralFluentTest.exerciseTestCase[50: Given:<"A:B">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[27: PRECONDITIONS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[204: UNLESS_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[14: Given:<["X"]>:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.ut.NullValueHandlingTest.givenNull_whenStatementIsExamined_thenProcessedCorrectly(com.github.valid8j.ut.NullValueHandlingTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[193: ENSURE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[22](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[91: REQUIRE_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.types.StreamTest.streamTransformerTestFailure(com.github.valid8j.ut.types.StreamTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_postconditions(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[77: POSTCONDITION: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[1: Given::When::Then:identicalWith(value:true)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[10: ALL: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[72: POSTCONDITIONS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[134: REQUIRE_STATES: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[177: ENSURE_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[220: EXPECT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[225: EXPECT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[25: Given:<"456">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[210: UNLESS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[130: REQUIRE_ARGUMENT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test2(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[87: POSTCONDITION: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[13: DOLLAR: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[21](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[53: INVARIANTS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[4: ALL: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assumeThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[47: Given:<"A:B:C">:When::Then:identicalWith(value:A:B:C)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[103: REQUIRE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[39: PRECONDITION: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[129: REQUIRE_ARGUMENT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest.parameterizedPredicate_(com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest) (0 ms)
com.github.valid8j.ut.typesupports.StringTest.testEndsWith(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[18: DOLLAR: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[166: HOLD: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello3(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[24: Given:<"123">:When::Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[164: HOLD_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[21: DOLLAR: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.types.FloatTest.toFloatTest(com.github.valid8j.ut.types.FloatTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testComparison(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[21: Given:<"123">:When::Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_columns100$whenNull(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[35: PRECONDITION: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[101: REQUIRE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_Double(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[102: REQUIRE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[170: HOLD: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[183: ENSURE_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[13](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[137: REQUIRE_STATES: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[83: POSTCONDITION: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[214: UNLESS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[27: PRECONDITIONS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[224: EXPECT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validate_pass(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.examples.test.ExamplesTest.testMetarmorExampleFailing(com.github.valid8j.examples.test.ExamplesTest) (60 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[75: POSTCONDITIONS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[171: HOLD: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello2(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[22: PRECONDITIONS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.internal.PrintablesTest$PredicateTest.givenPredicateReturnedByAnd$whenToString$thenLooksGood(com.github.valid8j.ut.internal.PrintablesTest$PredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[123: REQUIRE_ARGUMENT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest.exerciseTestCase[2: whenPredicatesAllReturningTrueUnderAllOf_thenPasses](com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[108: REQUIRE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[11](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[107: REQUIRE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[106: REQUIRE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[46: INVARIANTS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[37](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[187: ENSURE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[227: EXPECT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$EqTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$EqTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireValue_passing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[99: REQUIRE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[119: REQUIRE_ARGUMENTS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest.exerciseTestCase[1: whenOnePredicateThrowingExceptionUnderAllOf_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.AllOfPredicateTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[157: HOLD_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.methodAmbiguous_primitiveBoxed_negated(com.github.valid8j.ut.internal.CallTest) (1 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.entrypoints.ExpectationsTest.testPassingThat[230: EXPECT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[15: DOLLAR: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_b_e5(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (3 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[38: Given::When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[197: ENSURE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[201: UNLESS_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[45: INVARIANTS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[17: Given:<[]>:When:] THEN:isEmpty>:Then:identicalWith(value:[])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[10](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[134: REQUIRE_STATES: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[100: REQUIRE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (6 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[23: Given:<"123">:When::Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[165: HOLD: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[113: REQUIRE_ARGUMENTS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (8 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[211: UNLESS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireWithTransformingPredicateAndSatisfyingValue(com.github.valid8j.entrypoints.RequiresTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[44: INVARIANTS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[39: PRECONDITION: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectedExceptionThrown_testPassing(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (2 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_matchesRegex(com.github.valid8j.ut.styles.MoreFluentStringTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[43: Given:<"true">:When::Then:identicalWith(value:true)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[49: Given:<"A:B:C">:When::Then:identicalWith(value:A:B:C)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[209: UNLESS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (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.valuechecker.DefaultValidatorTest.withEvaluator_disj_thenPass(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[113: REQUIRE_ARGUMENTS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[62: Given:<"hello">:When:,<>)->castTo[Boolean] THEN:isTrue>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[93: REQUIRE_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[219: UNLESS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[34: Given:<"A">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[189: ENSURE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.TestAssertionsTest.testAnyOf(com.github.valid8j.ut.utilstest.TestAssertionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[31: PRECONDITIONS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[46: INVARIANTS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[85: POSTCONDITION: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[41](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[98: REQUIRE_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_lessThanOrEqualTo(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentListTest.test_elementAt(com.github.valid8j.ut.styles.MoreFluentListTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[180: ENSURE_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[37: PRECONDITION: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[14: DOLLAR: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.types.StreamTest.streamTest(com.github.valid8j.ut.types.StreamTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[200: UNLESS_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.string_assertThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[170: HOLD: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[7](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[8: Given:<["A","B"]>:When::Then:identicalWith(value:[A, B])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[94: REQUIRE_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[84: POSTCONDITION: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[53: INVARIANTS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[24: PRECONDITIONS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[135: REQUIRE_STATES: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[152: REQUIRE_STATE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[186: ENSURE_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[159: HOLD_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_b(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_equalTo(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[98: REQUIRE_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[153: REQUIRE_STATE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest.testFormatObject$InnerClassObject(com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest) (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.ParameterizedPredicatesTest.exerciseToString[1](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[145: REQUIRE_STATE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[46: INVARIANTS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (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.entrypoints.ExpectationsTest.testPassingValue[121: REQUIRE_ARGUMENT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[166: HOLD: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test6(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[13: DOLLAR: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[102: REQUIRE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[194: ENSURE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[9: ALL: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[72: Given::When::Then:identicalWith(value:null)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[6: ALL: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[62: INVARIANT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[99: REQUIRE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.boolean_assertThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[131: REQUIRE_ARGUMENT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[194: ENSURE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[50: INVARIANTS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireWithSatisfyingValue(com.github.valid8j.entrypoints.RequiresTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[198: UNLESS_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[94: REQUIRE_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequire(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.ut.typesupports.ListTest.testAllMatch(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[11: DOLLAR: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[136: REQUIRE_STATES: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[160: HOLD_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[69: POSTCONDITIONS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[79: POSTCONDITION: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[120: REQUIRE_ARGUMENTS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[37: PRECONDITION: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[31: PRECONDITIONS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[115: REQUIRE_ARGUMENTS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssertAll_failed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[71: Given:<"HELLO">:When:<<>.equals()->castTo[Boolean] THEN:isTrue>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[156: HOLD_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[147: REQUIRE_STATE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[29: Given:<"456">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[64: INVARIANT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[215: UNLESS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.types.FloatTest.floatTransformerTestFail(com.github.valid8j.ut.types.FloatTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[61: INVARIANT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[28: PRECONDITIONS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[172: HOLD: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[9](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[128: REQUIRE_ARGUMENT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[5: ALL: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_disj$or$_thenFail(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[14](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[11: Given:<[]>:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (8 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[58: INVARIANT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[25: PRECONDITIONS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[82: Given:<"123.5">:When:identity->castTo[Float] THEN:=[123.4]>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.AssertionsTest$Failing (39 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[80: POSTCONDITION: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[125: REQUIRE_ARGUMENT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[190: ENSURE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[11: DOLLAR: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[137: REQUIRE_STATES: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[218: UNLESS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[201: UNLESS_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.typesupports.StringTest.testEqualTo(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[128: REQUIRE_ARGUMENT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.AssertionsTest$Passing.testAssertPrecondition$thenPassing(com.github.valid8j.entrypoints.AssertionsTest$Passing) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[14: DOLLAR: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_isNullOrEmpty(com.github.valid8j.ut.styles.MoreFluentStringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[102: REQUIRE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (6 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[21: DOLLAR: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[134: REQUIRE_STATES: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[40](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[145: REQUIRE_STATE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[13: Given:<[]>:When::Then:identicalWith(value:[])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (10 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[132: REQUIRE_STATES: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[141: REQUIRE_STATES: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[51: Given:<"A:B">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[141: REQUIRE_STATES: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.internal.CallTest.methodNotFound(com.github.valid8j.ut.internal.CallTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.givenNonNullValue_whenRequireNonNull_thenValueReturned(com.github.valid8j.entrypoints.RequiresTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[15](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[15: Given:<[]>:When:] THEN:isEmpty>:Then:identicalWith(value:[])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[16: DOLLAR: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ValidatesTest.test(com.github.valid8j.entrypoints.ValidatesTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[149: REQUIRE_STATE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[6](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[58: Given:<"hello">:When:<==[hello]>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[20: DOLLAR: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[115: REQUIRE_ARGUMENTS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[116: REQUIRE_ARGUMENTS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[56: Given:<"hello">:When:<==[hello]>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[120: REQUIRE_ARGUMENTS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[16](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[103: REQUIRE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[3: ALL: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[92: REQUIRE_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[45: INVARIANTS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[87: POSTCONDITION: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_Integer(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$ContainsStringTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$ContainsStringTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[20: Given:<"123">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[215: UNLESS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[203: UNLESS_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_c(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat_usingFluentStyle(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[13: DOLLAR: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[183: ENSURE_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[188: ENSURE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[194: ENSURE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[0: givenChainedTransformingPredicate_whenNonExpectedValue_thenComparisonFailure](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.list_assertThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[144: REQUIRE_STATE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[77: POSTCONDITION: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[78: POSTCONDITION: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[56: INVARIANT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[174: HOLD: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[155: HOLD_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[20: DOLLAR: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[137: REQUIRE_STATES: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_precondition(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[42: PRECONDITION: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[45: Given:<"XYZ">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_isEmpty(com.github.valid8j.ut.styles.MoreFluentStringTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.given$hello$_$world$_whenRequireNestedStreamImpossibleConditions_thenPreconditionViolationExceptionWithCorrectMessage(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[88: REQUIRE_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[126: REQUIRE_ARGUMENT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[53: INVARIANTS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[10: Given:<["X"]>:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (9 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[164: HOLD_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[70: POSTCONDITIONS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[186: ENSURE_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[197: ENSURE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[175: HOLD: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.int_assertThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[82: POSTCONDITION: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[73: POSTCONDITIONS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.typesupports.ListTest.testCollectionContains(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[59: INVARIANT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[205: UNLESS_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest.testFormatObject$collection4(com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[132: REQUIRE_STATES: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[210: UNLESS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[129: REQUIRE_ARGUMENT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[35: PRECONDITION: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[5: ALL: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[3](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[130: REQUIRE_ARGUMENT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[47: INVARIANTS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[62: INVARIANT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[180: ENSURE_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_findRegexes(com.github.valid8j.ut.styles.MoreFluentStringTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[230: EXPECT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[122: REQUIRE_ARGUMENT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[171: HOLD: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$MatchesRegexTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$MatchesRegexTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[76: POSTCONDITIONS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[15: DOLLAR: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.currying.CurryingUtilsTest.returnedValueIsInvalid(com.github.valid8j.ut.currying.CurryingUtilsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[217: UNLESS: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[89: REQUIRE_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_endingWith(com.github.valid8j.ut.styles.MoreFluentStringTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[200: UNLESS_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[218: UNLESS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$GeTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$GeTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[33: Given:<"A">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenValidState_whenEnsureState_thenStateReturned(com.github.valid8j.entrypoints.EnsuresTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[54: INVARIANTS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.types.StreamTest.streamTransformerTest(com.github.valid8j.ut.types.StreamTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[85: POSTCONDITION: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[105: REQUIRE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[41: PRECONDITION: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[228: EXPECT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[176: ENSURE_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[128: REQUIRE_ARGUMENT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[30](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[57: Given:<"hello">:When::Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[223: EXPECT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[86: POSTCONDITION: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[50: INVARIANTS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[141: REQUIRE_STATES: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[97: REQUIRE_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[16: Given:<["X"]>:When:] THEN:isEmpty>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[139: REQUIRE_STATES: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureState_passing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[153: REQUIRE_STATE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$LtTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$LtTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[18: Given:<["X"]>:When:] THEN:isEmpty>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[69: POSTCONDITIONS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[20](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[2](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest.testFormatObject$longString(com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[78: POSTCONDITION: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[148: REQUIRE_STATE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[129: REQUIRE_ARGUMENT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[136: REQUIRE_STATES: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[36](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[79: POSTCONDITION: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[183: ENSURE_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.examples.test.JUnitBasedExamplesTest.testExampleUT(com.github.valid8j.examples.test.JUnitBasedExamplesTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[0: ALL: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[209: UNLESS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[73: Given:<"HELLO">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[229: EXPECT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[125: REQUIRE_ARGUMENT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[41: PRECONDITION: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[20: DOLLAR: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[68: POSTCONDITIONS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[210: UNLESS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[207: UNLESS_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[58: INVARIANT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[170: HOLD: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[95: REQUIRE_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[6: ALL: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testIsTrue(com.github.valid8j.ut.typesupports.BooleanTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[190: ENSURE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[204: UNLESS_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.internal.PrintablePredicateTest$And (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[108: REQUIRE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[101: REQUIRE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[26](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[60: INVARIANT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[90: REQUIRE_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[156: HOLD_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[16](com.github.valid8j.ut.equallness.EqualnessTest) (2 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.experimentals.TestAssertionsCurriedFunctionsTest.parameterizedPredicateTest(com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[59: Given:<"hello">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[130: REQUIRE_ARGUMENT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[173: HOLD: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.AssertionsTest$MessageTest.givenLambda$whenPreconditionExercised_thenTrueReturned(com.github.valid8j.entrypoints.AssertionsTest$MessageTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[2: ALL: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (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.internal.ParameterizedPredicatesTest.exerciseToString[0](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[33: PRECONDITION: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
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.entrypoints.ExpectationsTest.testPassingStatement[63: INVARIANT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest.testFormatObject$array4(com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[27](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[107: REQUIRE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_disj$anyOf$_thenFail(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenTrue_whenIsTrue_thenPass(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (0 ms)
com.github.valid8j.entrypoints.AssertionsTest$Passing.testAssertThatValue$thenPass(com.github.valid8j.entrypoints.AssertionsTest$Passing) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_preconditions(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[124: REQUIRE_ARGUMENT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[81: POSTCONDITION: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[10: ALL: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[230: EXPECT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_greaterThan(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.givenStreamOfSingleString$hello$_whenRequireNullIsFound_thenPreconditionViolationWithCorrectMessageIsThrown(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[169: HOLD: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[51: INVARIANTS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[157: HOLD_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[3: whenPredicatesFirstReturningFalseRestReturningTrueUnderAnyOf_thenPass](com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[2: ALL: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[136: REQUIRE_STATES: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello3_b(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[54: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_greaterThanOrEqualTo(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[167: HOLD: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[187: ENSURE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[43: PRECONDITION: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[19](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[38: PRECONDITION: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[36: PRECONDITION: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[154: HOLD_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[151: REQUIRE_STATE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validateNonNull_pass(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[131: REQUIRE_ARGUMENT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[25: PRECONDITIONS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[43](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[73: POSTCONDITIONS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[193: ENSURE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[208: UNLESS_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[51: INVARIANTS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_equalsIgnoreCase(com.github.valid8j.ut.styles.MoreFluentStringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[61: INVARIANT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentListTest.test_stream(com.github.valid8j.ut.styles.MoreFluentListTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[168: HOLD: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.types.FloatTest.floatTransformerTest(com.github.valid8j.ut.types.FloatTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[84: Given:<"Hello">:When::Then:identicalWith(value:Hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.MoreFluentListTest.test_isEmpty(com.github.valid8j.ut.styles.MoreFluentListTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[212: UNLESS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[57: INVARIANT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssumeAll_failed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[14](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 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.ExpectationsTest.testPassingValue[197: ENSURE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[211: UNLESS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.NegatedPredicateTest.exerciseTestCase[0: givenNegatedSimplePredicateReturningFalse_whenExpectedValue_thenValueReturned](com.github.valid8j.ut.propertybased.tests.NegatedPredicateTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.testEnsureNonNull(com.github.valid8j.entrypoints.EnsuresTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_lessThan(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[177: ENSURE_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withoutEvaluator_conj_thenPass(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[173: HOLD: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[225: EXPECT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectingDifferentException_testFailing(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[181: ENSURE_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[81: Given:<"123.4">:When:identity->castTo[Double] THEN:=[123.4]>:Then:identicalWith(value:123.4)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[43: PRECONDITION: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[42: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[32: Given:<"A">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
com.github.valid8j.entrypoints.RequiresTest.givenValidState$whenRequireState$thenPass(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[28: PRECONDITIONS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.propertybased.tests.SimplePredicateTest.exerciseTestCase[0: givenSimplePredicate_whenExpectedValue_thenValueReturned](com.github.valid8j.ut.propertybased.tests.SimplePredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[212: UNLESS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (6 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[205: UNLESS_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.typesupports.StringTest.testContainsString(com.github.valid8j.ut.typesupports.StringTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[1: ALL: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[192: ENSURE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[76: POSTCONDITIONS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[63: INVARIANT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testIsFalse(com.github.valid8j.ut.typesupports.BooleanTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[178: ENSURE_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[175: HOLD: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[15: DOLLAR: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[169: HOLD: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[173: HOLD: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 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.entrypoints.ExpectationsTest.testPassingValue[9: ALL: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[17](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[61: INVARIANT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[104: REQUIRE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 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.entrypoints.ExpectationsTest.testPassingStatement[95: REQUIRE_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[135: REQUIRE_STATES: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[5: Given:<["A","B","C"]>:When::Then:identicalWith(value:[A, B, C])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[32: PRECONDITIONS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_findRegexPatterns(com.github.valid8j.ut.styles.MoreFluentStringTest) (7 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[13](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[73: POSTCONDITIONS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[181: ENSURE_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[157: HOLD_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.RequiresTest.givenInvalidState$whenRequireState$thenIllegalStateExceptionThrown(com.github.valid8j.entrypoints.RequiresTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[12: DOLLAR: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[104: REQUIRE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[82: POSTCONDITION: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[172: HOLD: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (8 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[211: UNLESS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[65: INVARIANT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[227: EXPECT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 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.examples.test.ExamplesTest.testMetarmorExamplePassing(com.github.valid8j.examples.test.ExamplesTest) (7 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[83: POSTCONDITION: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[185: ENSURE_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[29: PRECONDITIONS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[101: REQUIRE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_Short(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[35](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[81: POSTCONDITION: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[67: POSTCONDITIONS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[61: Given:<"hello">:When:<<>.equals()>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[34: PRECONDITION: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[154: HOLD_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.givenIllegalArgument_whenRequireArgument_thenIllegalArgumentThrown(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[38: PRECONDITION: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[24: PRECONDITIONS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[27: Given:<"456">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[71: POSTCONDITIONS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[111: REQUIRE_ARGUMENTS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenNonNullValue_whenEnsureNonNull_thenValueReturned(com.github.valid8j.entrypoints.EnsuresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[221: EXPECT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_all(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[202: UNLESS_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[7: Given:<["A","B"]>:When::Then:identicalWith(value:[A, B])]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[177: ENSURE_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[27: PRECONDITIONS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test3(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.ut.typesupports.StringTest.testSameAs(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[100: REQUIRE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[119: REQUIRE_ARGUMENTS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[161: HOLD_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[203: UNLESS_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[109: REQUIRE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[127: REQUIRE_ARGUMENT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[84: POSTCONDITION: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[53: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[224: EXPECT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[106: REQUIRE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[29: PRECONDITIONS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.PrintablesTest$PredicateTest.givenPredicateReturnedByNegate$whenToString$thenWorksRight(com.github.valid8j.ut.internal.PrintablesTest$PredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[92: REQUIRE_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest.testFormatObject$collection3(com.github.valid8j.ut.internal.InternalUtilsTest$FormatObjectTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[158: HOLD_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[159: HOLD_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[15](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[31: Given:<"A">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.ut.typesupports.ListTest.testAnyMatch(com.github.valid8j.ut.typesupports.ListTest) (1 ms)
com.github.valid8j.ut.internal.PrintablesTest$PredicateTest.givenPredicateReturnedByOr$whenToString$thenWorksRight(com.github.valid8j.ut.internal.PrintablesTest$PredicateTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[70: Given:<"HELLO">:When:,<>)->castTo[Boolean] THEN:isTrue>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[151: REQUIRE_STATE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[226: EXPECT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[142: REQUIRE_STATES: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[163: HOLD_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[110: REQUIRE_ARGUMENTS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenToBooleanIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[105: REQUIRE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[8](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[127: REQUIRE_ARGUMENT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[198: UNLESS_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[174: HOLD: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[112: REQUIRE_ARGUMENTS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest.givenAllFound$whenFindString$thenPassed(com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.expectingExceptionButNotThrown_testFailing(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (4 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[19: Given:<"123">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[37: PRECONDITION: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assertAllDifferentTypes_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[192: ENSURE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[180: ENSURE_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[68: POSTCONDITIONS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[229: EXPECT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[5](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[163: HOLD_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[196: ENSURE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[97: REQUIRE_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[201: UNLESS_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[188: ENSURE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_transforming_thenFail(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (0 ms)
com.github.valid8j.entrypoints.ValidatesTest.test2(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[152: REQUIRE_STATE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_a(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[189: ENSURE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[32: PRECONDITIONS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[65: Given:<"hello">:When:<<>.equals()>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireArgument_passing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[182: ENSURE_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindElementsTest.givenSomeToBeFoundSomeNotToBe$whenFindElements$thenFailed(com.github.valid8j.ut.utilstest.PredicatesTest$FindElementsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[152: REQUIRE_STATE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[95: REQUIRE_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.it.SmokeTest.givenBook_whenCheckTitleAndAbstract_thenTheyAreNotNullAndAppropriateLength_2(com.github.valid8j.it.SmokeTest) (12 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[58: INVARIANT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[100: REQUIRE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[11: DOLLAR: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[85: POSTCONDITION: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[49: INVARIANTS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[91: REQUIRE_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[149: REQUIRE_STATE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[59: INVARIANT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[195: ENSURE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[75: POSTCONDITIONS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[165: HOLD: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[26: PRECONDITIONS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[175: HOLD: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[38: PRECONDITION: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[93: REQUIRE_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[47: INVARIANTS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[126: REQUIRE_ARGUMENT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[178: ENSURE_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[37: Given::When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[116: REQUIRE_ARGUMENTS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.EnsuresTest.test(com.github.valid8j.entrypoints.EnsuresTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[8](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[24](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[3: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[80: POSTCONDITION: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[50: INVARIANTS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[6](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[149: REQUIRE_STATE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[44: INVARIANTS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[26: PRECONDITIONS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.typesupports.ListTest.testNoneMatch(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[204: UNLESS_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[81: POSTCONDITION: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello3_a(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[220: EXPECT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[219: UNLESS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exerciseToString[9](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.ut.internal.PrintablesFunctionTest$Simple.testHandleNull(com.github.valid8j.ut.internal.PrintablesFunctionTest$Simple) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[213: UNLESS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[112: REQUIRE_ARGUMENTS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[16: DOLLAR: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[88: REQUIRE_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.examples.test.ExamplesTest.testFluentExample(com.github.valid8j.examples.test.ExamplesTest) (4 ms)
com.github.valid8j.ut.valuechecker.DefaultValidatorTest.withEvaluator_nativePredicate(com.github.valid8j.ut.valuechecker.DefaultValidatorTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[66: POSTCONDITIONS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.test_postcondition(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[77: POSTCONDITION: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validateState_pass(com.github.valid8j.entrypoints.ValidatesTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$LeTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$LeTest) (0 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.performCurriedPredicate(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.bugfixes.Issue42Test.givenPrivateClassOverridingPublicMethod$whenPublicMethodIsCalled$thenCallSucceeds(com.github.valid8j.ut.bugfixes.Issue42Test) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[133: REQUIRE_STATES: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (6 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[31](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[223: EXPECT: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validateArgument_pass(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[66: POSTCONDITIONS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.types.FloatTest.floatTestFail(com.github.valid8j.ut.types.FloatTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[186: ENSURE_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[214: UNLESS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[222: EXPECT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.typesupports.BooleanTest.testWrapperIsFalse(com.github.valid8j.ut.typesupports.BooleanTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[200: UNLESS_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[86: POSTCONDITION: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[78: Given:<"124">:When:identity->castTo[Integer] THEN:=[123]>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[7](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$IsInstanceOfTest.whenIsInstanceOfUsedInComposite_thenNoExplicitTypeParameterIsNeeded(com.github.valid8j.ut.utilstest.PredicatesTest$IsInstanceOfTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[92: REQUIRE_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireStatesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[160: HOLD_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[67: POSTCONDITIONS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[147: REQUIRE_STATE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[21: DOLLAR: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[1: ALL: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[60: INVARIANT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[7: ALL: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[216: UNLESS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[126: REQUIRE_ARGUMENT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[225: EXPECT: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[117: REQUIRE_ARGUMENTS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_findSubstrings(com.github.valid8j.ut.styles.MoreFluentStringTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test7(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[148: REQUIRE_STATE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[166: HOLD: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[3: ALL: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[30: Given:<"456">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[52: Given:<"A:B">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[174: HOLD: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 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.equallness.EqualnessTest.print[42](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[131: REQUIRE_ARGUMENT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[207: UNLESS_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[87: POSTCONDITION: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[28: PRECONDITIONS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[191: ENSURE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[120: REQUIRE_ARGUMENTS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.styles.MoreFluentListTest.test_size(com.github.valid8j.ut.styles.MoreFluentListTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_Long(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[11](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[103: REQUIRE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest.helloError(com.github.valid8j.ut.experimentals.TestAssertionsCurriedFunctionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[218: UNLESS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[156: HOLD_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[114: REQUIRE_ARGUMENTS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[226: EXPECT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[34](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_startingWith(com.github.valid8j.ut.styles.MoreFluentStringTest) (0 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test3(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[22: Given:<"123">:When::Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[158: HOLD_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[222: EXPECT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenTransformIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[68: POSTCONDITIONS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ValidatesTest.testValidateMethod$passing(com.github.valid8j.entrypoints.ValidatesTest) (1 ms)
com.github.valid8j.ut.bugfixes.Issue11Test.whenReproduceIssue(com.github.valid8j.ut.bugfixes.Issue11Test) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[172: HOLD: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[54: INVARIANTS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed.testFailureFromComposeStructureInTransformer(com.github.valid8j.ut.internal.PrintablesFunctionTest$Composed) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[213: UNLESS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[99: REQUIRE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[190: ENSURE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.FluentUtilsTest.expectationFlipping(com.github.valid8j.ut.utilstest.FluentUtilsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[207: UNLESS_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest.exerciseTestCase[2: whenPredicatesAllReturningTrueUnderAnyOf_thenPasses](com.github.valid8j.ut.propertybased.tests.AnyOfPredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[59: INVARIANT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[32: PRECONDITIONS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.nestedLoop_success(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[28](com.github.valid8j.ut.equallness.EqualnessTest) (1 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.ExpectationsTest.testPassingStatement[54: INVARIANTS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[176: ENSURE_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[139: REQUIRE_STATES: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validate_fail(com.github.valid8j.entrypoints.ValidatesTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest.givenAllFound$whenFindRegexes$thenPassed(com.github.valid8j.ut.utilstest.PredicatesTest$FindStringsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[144: REQUIRE_STATE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[44: Given:<"false">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[122: REQUIRE_ARGUMENT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[34: PRECONDITION: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[167: HOLD: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[111: REQUIRE_ARGUMENTS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[45: INVARIANTS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.typesupports.StringTest.testIsEmptyString(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[109: REQUIRE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[106: REQUIRE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[164: HOLD_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.AssertionsTest$MessageTest.composeMessage$thenComposed(com.github.valid8j.entrypoints.AssertionsTest$MessageTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[4](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireNonNull(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[0: ALL: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenString_whenFails_then_2(com.github.valid8j.ut.utilstest.ReportDetailTest) (0 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[18](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.types.FloatTest.floatTest(com.github.valid8j.ut.types.FloatTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[63: Given:<"hello">:When:<<>.equals()->castTo[Boolean] THEN:isTrue>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[138: REQUIRE_STATES: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[41: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest.exerciseTestCase[0: givenStreamPredicate_whenExpectedValue_thenValueReturned](com.github.valid8j.ut.propertybased.tests.StreamAllMatchPredicateTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[191: ENSURE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[7: ALL: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[222: EXPECT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[41: PRECONDITION: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[189: ENSURE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (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.entrypoints.ExpectationsTest.testPassingThat[145: REQUIRE_STATE: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[165: HOLD: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[179: ENSURE_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[9: Given:<["X"]>:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequire$thenError(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test8(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[32](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[3](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[22: PRECONDITIONS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[26: Given:<"456">:When:parseBoolean THEN:(isInstanceOf[class java.lang.Short]&&=[23])>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.ut.internal.NegateTest.whenInvertedTransformingPredicateFails_thenPrintDesignedMessage$transformIsntLeafAndNotMerged(com.github.valid8j.ut.internal.NegateTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[62: INVARIANT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[70: POSTCONDITIONS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[75: POSTCONDITIONS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[10](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[138: REQUIRE_STATES: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[142: REQUIRE_STATES: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test4(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.ut.typesupports.StringTest.testStartsWith(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[69: Given:<"HELLO">:When:<<>.equals()>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireWithTransformingPredicate(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.ut.styles.fluent.FluentBooleanTest.givenFalse_whenCheckIsTrue_thenComparisonFailure(com.github.valid8j.ut.styles.fluent.FluentBooleanTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[215: UNLESS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[77: Given:<"124">:When:identity->castTo[Long] THEN:=[123]>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[60: Given:<"hello">:When:,<>)>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[75: Given:<"123">:When:identity->castTo[Integer] THEN:=[123]>:Then:identicalWith(value:123)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[226: EXPECT: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[38](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello6(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[158: HOLD_: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.multiAssumeAll_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[56: INVARIANT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[42: PRECONDITION: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[192: ENSURE: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.propertybased.tests.CurriedContextPredicateTest.exerciseTestCase[0: givenVariableBundlePredicate_whenExpectedValue_thenValueReturned](com.github.valid8j.ut.propertybased.tests.CurriedContextPredicateTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[12](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[55: INVARIANT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[114: REQUIRE_ARGUMENTS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[17: DOLLAR: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[91: REQUIRE_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_isEqualTo(com.github.valid8j.ut.styles.MoreFluentStringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[133: REQUIRE_STATES: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[69: POSTCONDITIONS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[86: POSTCONDITION: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$AnyMatchTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$AnyMatchTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[113: REQUIRE_ARGUMENTS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_b2(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[25: PRECONDITIONS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[64: Given:<"hello">:When:,<>)>:Then:identicalWith(value:hello)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[217: UNLESS: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[31: PRECONDITIONS: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[78: POSTCONDITION: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[56: INVARIANT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[26: PRECONDITIONS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[36: PRECONDITION: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[97: REQUIRE_: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.RequiresTest.givenValidState_whenRequireState_thenStateReturned(com.github.valid8j.entrypoints.RequiresTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[153: REQUIRE_STATE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessUsingCustomPredicateWithSlightlyDifferentString_thenFailWithDetailsArePrinted(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[18: DOLLAR: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[33: PRECONDITION: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.typesupports.ListTest.testListContains(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[57: INVARIANT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.CallTest.methodAmbiguous_primitiveBoxed(com.github.valid8j.ut.internal.CallTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[36: PRECONDITION: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[39](com.github.valid8j.ut.equallness.EqualnessTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[219: UNLESS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireArgument(com.github.valid8j.entrypoints.RequiresTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[72: POSTCONDITIONS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[28: Given:<"456">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[182: ENSURE_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[4: ALL: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[151: REQUIRE_STATE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest.requireValuesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForRequiresTest) (2 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.assumeThatTest_failed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[138: REQUIRE_STATES: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[209: UNLESS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[117: REQUIRE_ARGUMENTS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[55: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessUsingCustomPredicateWithSlightlyDifferentString_thenExpectationSpecificFragmentsContainedOnlyByExplanationForExpectationAndActualValuesAreAlsoSo(com.github.valid8j.ut.utilstest.ReportDetailTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello_d_1(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (1 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureStatesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[191: ENSURE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.RequiresTest.testRequireWithCustomStringTransformingPredicate(com.github.valid8j.entrypoints.RequiresTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[23](com.github.valid8j.ut.equallness.EqualnessTest) (2 ms)
com.github.valid8j.ut.utilstest.FluentUtilsTest.example2(com.github.valid8j.ut.utilstest.FluentUtilsTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[23: PRECONDITIONS: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[14: DOLLAR: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[40: PRECONDITION: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[39: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[5: ALL: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[203: UNLESS_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[108: REQUIRE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[1: ALL: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.TestAssertionsTest.testAllOf(com.github.valid8j.ut.utilstest.TestAssertionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[76: POSTCONDITIONS: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[65: INVARIANT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.AssertionsTest$Passing.testAssertPostcondition$thenPassing(com.github.valid8j.entrypoints.AssertionsTest$Passing) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[123: REQUIRE_ARGUMENT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[112: REQUIRE_ARGUMENTS: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[98: REQUIRE_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.utilstest.ReportDetailTest.givenLongString_whenCheckEqualnessWithSlightlyDifferentString_thenFailWithDetailsArePrinted$assertThat(com.github.valid8j.ut.utilstest.ReportDetailTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[147: REQUIRE_STATE: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.typesupports.StringTest.testIsInstanceOf(com.github.valid8j.ut.typesupports.StringTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[64: INVARIANT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test1(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (2 ms)
com.github.valid8j.ut.internal.NegateTest.whenInvertedTrasformingPredicateFails_thenPrintDesignedMessage$mergedWhenNotMismatch(com.github.valid8j.ut.internal.NegateTest) (1 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenValidState$whenEnsureState$thenPasses(com.github.valid8j.entrypoints.EnsuresTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[15](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[4: ALL: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[40: PRECONDITION: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test2(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[198: UNLESS_: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (5 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test7(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (0 ms)
com.github.valid8j.ut.styles.MoreFluentStreamTest.test_anyMatch(com.github.valid8j.ut.styles.MoreFluentStreamTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[85: Given:<"Bye">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[146: REQUIRE_STATE: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.examples.test.ExamplesTest.testClassicExample(com.github.valid8j.examples.test.ExamplesTest) (34 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test1(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[227: EXPECT: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[79: Given:<"124">:When:identity->castTo[Short] THEN:=[123]>:Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[17: DOLLAR: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[150: REQUIRE_STATE: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[12: Given:<[]>:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (9 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[144: REQUIRE_STATE: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[228: EXPECT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$AllMatchTest.whenToString$thenLooksGood(com.github.valid8j.ut.utilstest.PredicatesTest$AllMatchTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[35: PRECONDITION: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[89: REQUIRE_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[0: ALL: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (15 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[161: HOLD_: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[193: ENSURE: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test5(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[125: REQUIRE_ARGUMENT: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[49: INVARIANTS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[178: ENSURE_: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 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.entrypoints.ExpectationsTest.testPassingValue[212: UNLESS: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[16](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (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.entrypoints.ExpectationsTest.testPassingStatement[71: POSTCONDITIONS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$MessageTest.testFormat(com.github.valid8j.ut.utilstest.PredicatesTest$MessageTest) (0 ms)
com.github.valid8j.entrypoints.EnsuresTest.givenValidArgument_whenEnsure_thenValueReturned(com.github.valid8j.entrypoints.EnsuresTest) (0 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[0: Given::When::Then:identicalWith(value:true)]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (9 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[55: INVARIANT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[135: REQUIRE_STATES: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[18: DOLLAR: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[133: REQUIRE_STATES: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[84: POSTCONDITION: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[35: Given:<"A">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[17: DOLLAR: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.MoreFluentStreamTest.test_noneMatche(com.github.valid8j.ut.styles.MoreFluentStreamTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[44: INVARIANTS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[29: PRECONDITIONS: LIST_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[93: REQUIRE_: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.givenStream_whenRequireConditionResultingInNPE_thenInternalExceptionWithCorrectMessageAndNpeAsNestedException(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.ut.styles.MoreFluentStringTest.test_contains(com.github.valid8j.ut.styles.MoreFluentStringTest) (0 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Singular.test8(com.github.valid8j.entrypoints.ValidationFluentsTest$Singular) (1 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.stream_assertThatTest_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.ut.utilstest.PredicatesTest$FindElementsTest.givenAllFound$whenFindElements$thenPassed(com.github.valid8j.ut.utilstest.PredicatesTest$FindElementsTest) (2 ms)
com.github.valid8j.entrypoints.ValidatesTest.test_validateArgument_fail(com.github.valid8j.entrypoints.ValidatesTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[167: HOLD: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[122: REQUIRE_ARGUMENT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[70: POSTCONDITIONS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[221: EXPECT: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[49: INVARIANTS: DOUBLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[195: ENSURE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.currying.CurryingTest.givenCurriedFunction$whenApplyWithInvalidArg$thenThrown(com.github.valid8j.ut.currying.CurryingTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[46: Given::When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[94: REQUIRE_: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[22: PRECONDITIONS: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[229: EXPECT: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[179: ENSURE_: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.styles.fluent.GeneralFluentTest.exerciseTestCase[36: Given:<"A">:When::Then:greaterThanOrEqualTo(1), numbersOfExpectAndActualSummaries=>areEqual, numbersOfExpectAndActualSummariesWithDetails=>areEqual, numberOfExpectDetails=>greaterThanOrEqualTo(1), numbersOfExpectAndActualDetails=>areEqual]>](com.github.valid8j.ut.styles.fluent.GeneralFluentTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[72: POSTCONDITIONS: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[208: UNLESS_: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest.test_Float(com.github.valid8j.ut.styles.MoreFluentComparableNumberCheckerTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[132: REQUIRE_STATES: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[199: UNLESS_: SHORT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.ut.utilstest.FluentUtilsTest.test4(com.github.valid8j.ut.utilstest.FluentUtilsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[83: POSTCONDITION: STRING_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[107: REQUIRE: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (9 ms)
com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest.string_assertThat_useValue_passed(com.github.valid8j.ut.styles.FluentStyleTestAssertionTest$ForTestAssertionsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[121: REQUIRE_ARGUMENT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (3 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[65: INVARIANT: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.hello4_a(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) (0 ms)
com.github.valid8j.entrypoints.ValidationFluentsTest$Plural.test4(com.github.valid8j.entrypoints.ValidationFluentsTest$Plural) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[42: PRECONDITION: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[57: INVARIANT: INT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[63: INVARIANT: STREAM_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest.exerciseTestCase[2: givenTransformingPredicate_whenExpectedValue_thenValueReturned](com.github.valid8j.ut.propertybased.tests.TransformAndCheckPredicateTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[109: REQUIRE: THROWABLE_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingValue[143: REQUIRE_STATE: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[220: EXPECT: BOOLEAN_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.styles.MoreFluentStreamTest.test_allMatch(com.github.valid8j.ut.styles.MoreFluentStreamTest) (0 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingStatement[168: HOLD: LONG_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (4 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[48: INVARIANTS: FLOAT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (2 ms)
com.github.valid8j.ut.equallness.EqualnessTest.print[29](com.github.valid8j.ut.equallness.EqualnessTest) (0 ms)
com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest.ensureValuesTest_failing(com.github.valid8j.ut.styles.FluentStyleDbCTest$ForEnsuresTest) (2 ms)
com.github.valid8j.entrypoints.ExpectationsTest.testPassingThat[196: ENSURE: OBJECT_STATEMENT](com.github.valid8j.entrypoints.ExpectationsTest) (1 ms)
com.github.valid8j.ut.typesupports.ListTest.testEmpty(com.github.valid8j.ut.typesupports.ListTest) (0 ms)
com.github.valid8j.ut.internal.ParameterizedPredicatesTest.exercisePredicate[17](com.github.valid8j.ut.internal.ParameterizedPredicatesTest) (0 ms)

Report generated by PIT 1.7.3

Validator.java

Mutations

Active mutators

Tests examined