MetamorphicTestCaseFactoryWithPreformer.java

package com.github.valid8j.metamor;


import com.github.valid8j.metamor.internals.InternalUtils;
import com.github.valid8j.pcond.forms.Printables;

import java.text.MessageFormat;
import java.util.Arrays;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;

import static java.util.Objects.requireNonNull;

public interface MetamorphicTestCaseFactoryWithPreformer<X, I, O, P, R> extends MetamorphicTestCaseFactory<X, I, O, R> {
  Function<IoPair<I, O>, P> metamorphicPreformer();

  Function<Dataset<P>, R> metamorphicReducer();

  @Override
  default Function<Dataset<IoPair<I, O>>, R> metamorphicTransformer() {
    return metamorphicPreformerStage().andThen(metamorphicReducer());
  }

  default Function<Dataset<IoPair<I, O>>, Dataset<P>> metamorphicPreformerStage() {
    return InternalUtils.createObservableProcessingPipeline(
        "preform",
        metamorphicPreformerToIoContextCallback(metamorphicPreformer()),
        inputResolverSequenceFactory().count(),
        ioVariableNameFormatter(),
        ioVariableName());
  }

  default Function<IoContext<IoPair<I, O>, P>, Function<IoPair<I, O>, P>> metamorphicPreformerToIoContextCallback(Function<IoPair<I, O>, P> preformer) {
    return Printables.function(
        () -> "  " + preformer,
        c -> Printables.function(
            () -> String.format("preform[%s]:%s", c, preformer),
            preformer));
  }

  IntFunction<String> ioVariableNameFormatter();

  class Impl<X, I, O, P, R> implements MetamorphicTestCaseFactoryWithPreformer<X, I, O, P, R> {

    private final Function<I, O>                          fut;
    private final InputResolver.Sequence.Factory<X, I, O> inputResolverSequenceFactory;
    private final Function<IoPair<I, O>, P>               preformer;
    private final Function<Dataset<P>, R>                 reducer;
    private final Predicate<R>                            checker;
    private final String                                  ioVariableName;
    private final String                                  inputVariableName;

    public Impl(Function<I, O> fut, InputResolver.Sequence.Factory<X, I, O> inputResolverSequenceFactory, Function<IoPair<I, O>, P> preformer, Function<Dataset<P>, R> reducer, Predicate<R> checker, String inputVariableName, String ioVariableName) {
      this.fut = requireNonNull(fut);
      this.inputResolverSequenceFactory = inputResolverSequenceFactory;
      this.preformer = requireNonNull(preformer);
      this.reducer = requireNonNull(reducer);
      this.checker = requireNonNull(checker);
      this.inputVariableName = requireNonNull(inputVariableName);
      this.ioVariableName = requireNonNull(ioVariableName);
    }


    @Override
    public Function<I, O> fut() {
      return this.fut;
    }

    @Override
    public InputResolver.Sequence.Factory<X, I, O> inputResolverSequenceFactory() {
      return this.inputResolverSequenceFactory;
    }

    @Override
    public Function<IoPair<I, O>, P> metamorphicPreformer() {
      return this.preformer;
    }

    @Override
    public Function<Dataset<P>, R> metamorphicReducer() {
      return Printables.function(() -> "reduce:" + reducer, this.reducer);
    }

    @Override
    public Predicate<R> metamorphicChecker() {
      return this.checker;
    }

    @Override
    public String inputVariableName() {
      return this.inputVariableName;
    }

    @Override
    public IntFunction<String> inputVariableNameFormatter() {
      return i -> this.inputVariableName + "[" + i + "]";
    }

    @Override
    public String ioVariableName() {
      return this.ioVariableName;
    }

    @Override
    public IntFunction<String> ioVariableNameFormatter() {
      return i -> this.ioVariableName + "[" + i + "]";
    }
  }

  class Builder<X, I, O, P, R> extends BuilderBase<Builder<X, I, O, P, R>, X, I, O, R> {
    private Function<Dataset<P>, R>   reducer;
    private Function<IoPair<I, O>, P> preformer;

    public Builder() {
    }

    @SuppressWarnings("unchecked")
    @Override
    public <BB extends BuilderBase<BB, XX, I, O, R>, XX> BB sourceValueType(XX sourceType) {
      return (BB) this.<Builder<XX, I, O, P, R>, XX>newBuilderWithSpecifiedSourceType(Builder::new);
    }

    @Override
    public <PP> Builder<X, I, O, PP, R> preformer(Function<IoPair<I, O>, PP> preformer) {
      Builder<X, I, O, PP, R> ret = this.withPreformer();
      ret.preformer = preformer;
      return ret;
    }

    public <QQ> Builder<X, I, O, QQ, R> preform(Function<P, QQ> preformer) {
      Function<IoPair<I, O>, P> currentPreformer = this.preformer;
      if (currentPreformer == null)
        throw new IllegalStateException();
      Builder<X, I, O, QQ, R> ret = this.withPreformer();
      ret.preformer = currentPreformer.andThen(preformer);
      return ret;
    }

    public <QQ> Builder<X, I, O, QQ, R> preform(String name, Function<P, QQ> preformer) {
      return this.preform(Printables.function(name, preformer));
    }

    public Builder<X, I, O, P, R> reducer(Function<Dataset<P>, R> reducer) {
      this.reducer = requireNonNull(reducer);
      return this;
    }

    public Builder<X, I, O, P, R> reduce(Function<Dataset<P>, R> reducer) {
      return this.reducer(reducer);
    }

    public Builder<X, I, O, P, R> reduce(String reducerName, Function<Dataset<P>, R> reducer) {
      return this.reduce(Printables.function(reducerName, reducer));
    }

    public Builder<X, I, O, P, Proposition> propositionFactory(Function<Dataset<P>, Proposition> pf) {
      return this
          .<Builder<X, I, O, P, Proposition>, Proposition>newBuilderWithSpecifiedRelationType(Builder::new)
          .preformer(this.preformer)
          .reducer(pf)
          .checker(PropositionPredicate.INSTANCE);
    }

    public MetamorphicTestCaseFactory<X, I, O, Proposition> proposition(Function<Object[], String> propositionFormatter, Predicate<Dataset<P>> p) {
      return this.propositionFactory(
          Proposition.Factory.create(
              p,
              propositionFormatter,
              i -> this.outputVariableName + "[" + i + "]",
              this.inputResolverSequenceFactoryProvider.count()))
          .build();
    }

    public MetamorphicTestCaseFactory<X, I, O, Proposition> proposition(String propositionName, Predicate<Dataset<P>> p) {
      return this.proposition(args -> MessageFormat.format(propositionName, Arrays.stream(args).map(Objects::toString).toArray()), p);
    }

    public MetamorphicTestCaseFactoryWithPreformer<X, I, O, P, R> build() {
      return new Impl<>(fut, inputResolverSequenceFactoryProvider.get(), preformer, reducer, checker, inputVariableName, ioVariableName);
    }
  }
}






























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.examples.test.ExamplesTest.testMetarmorExamplePassing(com.github.valid8j.examples.test.ExamplesTest) (7 ms)
com.github.valid8j.examples.test.ExamplesTest.testMetarmorExampleFailing(com.github.valid8j.examples.test.ExamplesTest) (60 ms)

Report generated by PIT 1.7.3

1		package com.github.valid8j.metamor;
2
3
4		import com.github.valid8j.metamor.internals.InternalUtils;
5		import com.github.valid8j.pcond.forms.Printables;
6
7		import java.text.MessageFormat;
8		import java.util.Arrays;
9		import java.util.Objects;
10		import java.util.function.Function;
11		import java.util.function.IntFunction;
12		import java.util.function.Predicate;
13
14		import static java.util.Objects.requireNonNull;
15
16		public interface MetamorphicTestCaseFactoryWithPreformer<X, I, O, P, R> extends MetamorphicTestCaseFactory<X, I, O, R> {
17		Function<IoPair<I, O>, P> metamorphicPreformer();
18
19		Function<Dataset<P>, R> metamorphicReducer();
20
21		@Override
22		default Function<Dataset<IoPair<I, O>>, R> metamorphicTransformer() {
23	1 1. metamorphicTransformer : replaced return value with null for com/github/valid8j/metamor/MetamorphicTestCaseFactoryWithPreformer::metamorphicTransformer → KILLED	return metamorphicPreformerStage().andThen(metamorphicReducer());
24		}
25
26		default Function<Dataset<IoPair<I, O>>, Dataset<P>> metamorphicPreformerStage() {
27	1 1. metamorphicPreformerStage : replaced return value with null for com/github/valid8j/metamor/MetamorphicTestCaseFactoryWithPreformer::metamorphicPreformerStage → KILLED	return InternalUtils.createObservableProcessingPipeline(
28		"preform",
29		metamorphicPreformerToIoContextCallback(metamorphicPreformer()),
30		inputResolverSequenceFactory().count(),
31		ioVariableNameFormatter(),
32		ioVariableName());
33		}
34
35		default Function<IoContext<IoPair<I, O>, P>, Function<IoPair<I, O>, P>> metamorphicPreformerToIoContextCallback(Function<IoPair<I, O>, P> preformer) {
36	1 1. metamorphicPreformerToIoContextCallback : replaced return value with null for com/github/valid8j/metamor/MetamorphicTestCaseFactoryWithPreformer::metamorphicPreformerToIoContextCallback → KILLED	return Printables.function(
37	1 1. lambda$metamorphicPreformerToIoContextCallback$0 : replaced return value with "" for com/github/valid8j/metamor/MetamorphicTestCaseFactoryWithPreformer::lambda$metamorphicPreformerToIoContextCallback$0 → SURVIVED	() -> " " + preformer,
38	1 1. lambda$metamorphicPreformerToIoContextCallback$2 : replaced return value with null for com/github/valid8j/metamor/MetamorphicTestCaseFactoryWithPreformer::lambda$metamorphicPreformerToIoContextCallback$2 → KILLED	c -> Printables.function(
39	1 1. lambda$null$1 : replaced return value with "" for com/github/valid8j/metamor/MetamorphicTestCaseFactoryWithPreformer::lambda$null$1 → NO_COVERAGE	() -> String.format("preform[%s]:%s", c, preformer),
40		preformer));

MetamorphicTestCaseFactoryWithPreformer.java

Mutations

Active mutators

Tests examined