Evaluable.java

1 
package com.github.valid8j.pcond.core;
2
3 
import com.github.valid8j.pcond.experimentals.currying.context.CurriedContext;
4
5 
import java.util.List;
6 
import java.util.Optional;
7 
import java.util.function.Function;
8 
import java.util.function.Predicate;
9 
import java.util.stream.Stream;
10
11 
/**
12 
 * // @formatter:off
13 
 * An interface that models "forms".
14 
 * A form is a general idea that covers predicates, functions, and "special-forms".
15 
 *
16 
 * A simple form (such as one returned by {@link Predicate#isEqual(Object)}) is
17 
 * modeled as and held by {@link LeafPred}.
18 
 * The framework just delegates the evaluation to the object.
19 
 *
20 
 * However, for a form which has an internal structure, such as one returned by
21 
 * {@link Predicate#and(Predicate)}, this approach doesn't work.
22 
 * Because, in order to make the evaluation process visible and readable for human,
23 
 * we need intermediate evaluation results.
24 
 *
25 
 * That is, when we evaluate a form `v != null && v.startsWith("hello")`, we want
26 
 * information about which predicate was violated.
27 
 * Just showing the actual value of `v` is not sufficient, because the `v` and the
28 
 * predicates in the evaluation might have internal structures or logics that make
29 
 * it difficult/impossible to infer which predicate is violated.
30 
 * // @formatter:on
31 
 *
32 
 * @param <T> The type of the value evaluated by this object.
33 
 */
34 
public interface Evaluable<T> {
35 
  /**
36 
   * Performs an evaluation of the `evaluationContext` with a given `evaluator`.
37 
   *
38 
   * @param evaluableIo       An execution occurrence of an evaluable.
39 
   * @param evaluationContext An evaluation context.
40 
   * @param evaluator         An evaluator with which the `evaluationContext` is evaluated.
41 
   */
42 
  <O> void accept(EvaluableIo<T, Evaluable<T>, O> evaluableIo, EvaluationContext<T> evaluationContext, Evaluator evaluator);
43
44 
  /**
45 
   * Returns if this object can be folded in a test failure report.
46 
   *
47 
   * @return true - squashable / false - otherwise.
48 
   */
49 
  default boolean isSquashable() {
50 1 1. isSquashable : replaced boolean return with true for com/github/valid8j/pcond/core/Evaluable::isSquashable → NO_COVERAGE
 
    return false;
51 
  }
52
53 
  /**
54 
   * Returns if this object can be skipped in a test failure report.
55 
   *
56 
   * @return true - can be skipped / false - otherwise.
57 
   */
58 
  default boolean isTrivial() {
59 1 1. isTrivial : replaced boolean return with true for com/github/valid8j/pcond/core/Evaluable::isTrivial → NO_COVERAGE
 
    return false;
60 
  }
61
62
63 
  /**
64 
   * Marks this object squashable so that an entry in a failure report can be folded where possible.
65 
   * This method is overridden by an implementation that allows the behavior described above.
66 
   *
67 
   * @return A cloned object marked squashable.
68 
   */
69 
  default Evaluable<T> markSquashable() {
70 
    throw new UnsupportedOperationException();
71 
  }
72
73
74 
  /**
75 
   * Marks this object trivial so that an entry in a failure report can be skipped.
76 
   * This method is overridden by an implementation that allows the behavior described above.
77 
   *
78 
   * @return A cloned object marked ignored.
79 
   */
80 
  default Evaluable<T> markTrivial() {
81 
    throw new UnsupportedOperationException();
82 
  }
83
84
85 
  /**
86 
   * A base interface to model all the predicates in the model of the evaluation
87 
   * framework.
88 
   *
89 
   * @param <T> The type of the value to be tested.
90 
   */
91 
  interface Pred<T> extends Evaluable<T> {
92 
  }
93
94 
  /**
95 
   * A base interface for conjunction (and) and disjunction (or) of predicates.
96 
   *
97 
   * @param <T> The type of the value to be evaluated.
98 
   */
99 
  interface Composite<T> extends Pred<T> {
100 
    /**
101 
     * Returns the predicates with which the target value is evaluated.
102 
     *
103 
     * @return The list of the child predicates.
104 
     */
105 
    List<Evaluable<T>> children();
106
107 
    /**
108 
     * // @formatter:on
109 
     *
110 
     * Returns `true` if the "shortcut" evaluation is enabled.
111 
     *
112 
     * Suppose you have a following predicate.
113 
     *
114 
     * ----
115 
     * a && b && c
116 
     * ----
117 
     *
118 
     * If the `a` results in `false`, the `b` and `c` doesn't need to be evaluated.
119 
     * The optimization, where the evaluations for the `b` and `c` are skipped,
120 
     * is called "shortcut".
121 
     *
122 
     * However, in the context of testing, sometimes we want to know the evaluation
123 
     * results for the `b` and `c`.
124 
     * Otherwise, we cannot avoid getting into a fail->fix->run->fail... loop,
125 
     * sometimes.
126 
     *
127 
     * // @formatter:off
128 
     * @return `true` if the "shortcut" evaluation is enabled.
129 
     */
130 
    boolean shortcut();
131
132 
    @Override
133 
    default boolean isSquashable() {
134 3 1. isSquashable : changed conditional boundary → NO_COVERAGE
2. isSquashable : negated conditional → NO_COVERAGE
3. isSquashable : replaced boolean return with true for com/github/valid8j/pcond/core/Evaluable$Composite::isSquashable → NO_COVERAGE
 
      return children().size() <= 1;
135 
    }
136 
  }
137
138 
  /**
139 
   * An interface to model a conjunction (`and`, `&&`) predicate.
140 
   *
141 
   * @param <T> The type of the value to be evaluated.
142 
   */
143 
  interface Conjunction<T> extends Composite<T> {
144 
    @SuppressWarnings({"unchecked", "rawtypes"})
145 
    @Override
146 
    default <O> void accept(EvaluableIo<T, Evaluable<T>, O> evaluableIo, EvaluationContext<T> evaluationContext, Evaluator evaluator) {
147 1 1. accept : removed call to com/github/valid8j/pcond/core/Evaluator::evaluateConjunction → KILLED
 
      evaluator.evaluateConjunction((EvaluableIo<T, Conjunction<T>, Boolean>) (EvaluableIo) evaluableIo, evaluationContext);
148 
    }
149 
  }
150
151 
  /**
152 
   * An interface to model a disjunction (`or`, `||`) predicate.
153 
   *
154 
   * @param <T> The type of the value to be evaluated.
155 
   */
156 
  interface Disjunction<T> extends Composite<T> {
157 
    @SuppressWarnings({"unchecked", "rawtypes"})
158 
    @Override
159 
    default <O> void accept(EvaluableIo<T, Evaluable<T>, O> evaluableIo, EvaluationContext<T> evaluationContext, Evaluator evaluator) {
160 1 1. accept : removed call to com/github/valid8j/pcond/core/Evaluator::evaluateDisjunction → KILLED
 
      evaluator.evaluateDisjunction((EvaluableIo<T, Disjunction<T>, Boolean>) (EvaluableIo) evaluableIo, evaluationContext);
161 
    }
162 
  }
163
164 
  /**
165 
   * An interface to model a negation (`not`, `negate`, `!`) of a predicate.
166 
   *
167 
   * @param <T> The type of the value to be evaluated.
168 
   */
169 
  interface Negation<T> extends Pred<T> {
170 
    @SuppressWarnings({"unchecked", "rawtypes"})
171 
    @Override
172 
    default <O> void accept(EvaluableIo<T, Evaluable<T>, O> evaluableIo, EvaluationContext<T> evaluationContext, Evaluator evaluator) {
173 1 1. accept : removed call to com/github/valid8j/pcond/core/Evaluator::evaluateNegation → KILLED
 
      evaluator.evaluateNegation((EvaluableIo<T, Negation<T>, Boolean>) (EvaluableIo) evaluableIo, evaluationContext);
174 
    }
175
176 
    /**
177 
     * The predicate the negation is applied.
178 
     *
179 
     * @return A target predicate.
180 
     */
181 
    Evaluable<T> target();
182
183 
    @Override
184 
    default boolean isSquashable() {
185 1 1. isSquashable : replaced boolean return with false for com/github/valid8j/pcond/core/Evaluable$Negation::isSquashable → NO_COVERAGE
 
      return true;
186 
    }
187 
  }
188
189 
  /**
190 
   * An interface to model a simple predicate in the evaluation framework.
191 
   *
192 
   * @param <T> The type of the value to be evaluated.
193 
   */
194 
  interface LeafPred<T> extends Pred<T> {
195 
    @SuppressWarnings({"unchecked", "rawtypes"})
196 
    @Override
197 
    default <O> void accept(EvaluableIo<T, Evaluable<T>, O> evaluableIo, EvaluationContext<T> evaluationContext, Evaluator evaluator) {
198 1 1. accept : removed call to com/github/valid8j/pcond/core/Evaluator::evaluateLeaf → KILLED
 
      evaluator.evaluateLeaf((EvaluableIo<T, LeafPred<T>, Boolean>) (EvaluableIo) evaluableIo, evaluationContext);
199 
    }
200
201 
    /**
202 
     * Returns an actual predicate modeled by this interface.
203 
     *
204 
     * @return The predicate modeled by this interface.
205 
     */
206 
    Predicate<? super T> predicate();
207 
  }
208
209 
  /**
210 
   * An interface to model a predicate for {@link CurriedContext}.
211 
   *
212 
   * @see CurriedContext
213 
   */
214 
  interface CurriedContextPred extends Pred<CurriedContext> {
215 
    @SuppressWarnings({"unchecked", "rawtypes"})
216 
    @Override
217 
    default <O> void accept(EvaluableIo<CurriedContext, Evaluable<CurriedContext>, O> evaluableIo, EvaluationContext<CurriedContext> evaluationContext, Evaluator evaluator) {
218 1 1. accept : removed call to com/github/valid8j/pcond/core/Evaluator::evaluateCurriedContextPredicate → KILLED
 
      evaluator.evaluateCurriedContextPredicate((EvaluableIo<CurriedContext, CurriedContextPred, Boolean>) (EvaluableIo) evaluableIo, evaluationContext);
219 
    }
220
221 
    <T> Evaluable<T> enclosed();
222
223 
    int argIndex();
224 
  }
225
226 
  /**
227 
   * An interface to model a predicate for {@link Stream}.
228 
   *
229 
   * @param <E> The type of elements in the stream to be evaluated.
230 
   */
231 
  interface StreamPred<E> extends Pred<Stream<E>> {
232 
    @SuppressWarnings({"unchecked", "rawtypes"})
233 
    @Override
234 
    default <O> void accept(EvaluableIo<Stream<E>, Evaluable<Stream<E>>, O> evaluableIo, EvaluationContext<Stream<E>> evaluationContext, Evaluator evaluator) {
235 1 1. accept : removed call to com/github/valid8j/pcond/core/Evaluator::evaluateStreamPredicate → KILLED
 
      evaluator.evaluateStreamPredicate((EvaluableIo<Stream<E>, StreamPred<E>, Boolean>) (EvaluableIo) evaluableIo, evaluationContext);
236 
    }
237
238 
    /**
239 
     * Returns a default value returned as the entire result of this predicate.
240 
     * The `value` is used when a "cut" happens.
241 
     *
242 
     * @return a default value to fallback of this object.
243 
     */
244 
    boolean defaultValue();
245
246 
    /**
247 
     * Returns an evaluable object which makes "cut" happen.
248 
     * If the result of the evaluation of the returned object becomes equal to the
249 
     * returned value of the {@link StreamPred#valueToCut()}, a "cut" will actually happen.
250 
     *
251 
     * @return An evaluable which triggers a "cut".
252 
     */
253 
    Evaluable<E> cut();
254
255 
    /**
256 
     * // @formatter:off
257 
     * Returns a value to make a "cut" happen.
258 
     *
259 
     * A "cut" is a situation, where an evaluation process for the elements in the
260 
     * stream is ended without reaching the last one.
261 
     * This is necessary to model a functionalities of `Stream`, such as
262 
     * `allMatch`, `noneMatch`, and `anyMatch`.
263 
     * // @formatter:on
264 
     *
265 
     * @return value ( `true` / `false` ) to make a "cut" happen.
266 
     */
267 
    boolean valueToCut();
268
269 
    /**
270 
     * // @formatter:off
271 
     * In order to generate an informative report, the framework needs information
272 
     * about the expected value for each predicate.
273 
     *
274 
     * The "expected" value of a predicate can be different inside the tree of the `Evaluables`,
275 
     * when a negation is used.
276 
     *
277 
     * If this `Evaluable` node requests to flip the expectation value under the node,
278 
     * this method should return `true`.
279 
     * // @formatter:on
280 
     *
281 
     * @return `true`, if the expectation flip is requested.
282 
     */
283 
    default boolean requestExpectationFlip() {
284 1 1. requestExpectationFlip : replaced boolean return with true for com/github/valid8j/pcond/core/Evaluable$StreamPred::requestExpectationFlip → KILLED
 
      return false;
285 
    }
286 
  }
287
288 
  /**
289 
   * An interface to model a "transforming predicate", which models the "transform and check" style of value validation.
290 
   * The idea of the style is to first  transform a value into a type, which is easy to read for human and to check for machine, such as list, integer, string, etc., in order to validate a value.
291 
   *
292 
   * @param <T> The type of the value to be evaluated.
293 
   * @param <R> The type to which the value (`T`) is transformed and then tested.
294 
   */
295 
  interface Transformation<T, R> extends Pred<T> {
296 
    @SuppressWarnings({"unchecked", "rawtypes"})
297 
    @Override
298 
    default <O> void accept(EvaluableIo<T, Evaluable<T>, O> evaluableIo, EvaluationContext<T> evaluationContext, Evaluator evaluator) {
299 1 1. accept : removed call to com/github/valid8j/pcond/core/Evaluator::evaluateTransformation → KILLED
 
      evaluator.evaluateTransformation((EvaluableIo<T, Transformation<T, R>, Boolean>) (EvaluableIo) evaluableIo, evaluationContext);
300 
    }
301
302 
    /**
303 
     * Returns a transformer of this object.
304 
     *
305 
     * @return A transformer function.
306 
     */
307 
    Evaluable<T> mapper();
308
309 
    Evaluable<R> checker();
310
311 
    /**
312 
     * Returns a name of a transformer, if any.
313 
     *
314 
     * @return An optional to store a name of the transformer.
315 
     */
316 
    Optional<String> mapperName();
317
318 
    /**
319 
     * Returns a name of a checker, if any.
320 
     *
321 
     * @return An optional to store a name of the checker.
322 
     */
323 
    Optional<String> checkerName();
324 
  }
325
326 
  /**
327 
   * An interface to model a function ({@link Function}) in the evaluation framework
328 
   * of the `pcond`.
329 
   *
330 
   * @param <T> The type of the value to be evaluated.
331 
   */
332 
  interface Func<T> extends Evaluable<T> {
333 
    @SuppressWarnings({"unchecked", "rawtypes"})
334 
    @Override
335 
    default <O> void accept(EvaluableIo<T, Evaluable<T>, O> evaluableIo, EvaluationContext<T> evaluationContext, Evaluator evaluator) {
336 1 1. accept : removed call to com/github/valid8j/pcond/core/Evaluator::evaluateFunction → KILLED
 
      evaluator.evaluateFunction((EvaluableIo<T, Func<T>, O>) (EvaluableIo) evaluableIo, evaluationContext);
337 
    }
338
339 
    Function<? super T, Object> head();
340
341 
    Optional<Evaluable<Object>> tail();
342 
  }
343 
}

Mutations

50

1.1
Location : isSquashable
Killed by : none replaced boolean return with true for com/github/valid8j/pcond/core/Evaluable::isSquashable → NO_COVERAGE
59

1.1
Location : isTrivial
Killed by : none replaced boolean return with true for com/github/valid8j/pcond/core/Evaluable::isTrivial → NO_COVERAGE
134

1.1
Location : isSquashable
Killed by : none changed conditional boundary → NO_COVERAGE

2.2
Location : isSquashable
Killed by : none negated conditional → NO_COVERAGE

3.3
Location : isSquashable
Killed by : none replaced boolean return with true for com/github/valid8j/pcond/core/Evaluable$Composite::isSquashable → NO_COVERAGE
147

1.1
Location : accept
Killed by : com.github.valid8j.entrypoints.AssertionsTest$Passing.testAssertPostcondition$thenPassing(com.github.valid8j.entrypoints.AssertionsTest$Passing) removed call to com/github/valid8j/pcond/core/Evaluator::evaluateConjunction → KILLED
160

1.1
Location : accept
Killed by : com.github.valid8j.ut.utilstest.PredicatesTest$IsInstanceOfTest.whenIsInstanceOfUsedInComposite_thenNoExplicitTypeParameterIsNeeded(com.github.valid8j.ut.utilstest.PredicatesTest$IsInstanceOfTest) removed call to com/github/valid8j/pcond/core/Evaluator::evaluateDisjunction → KILLED
173

1.1
Location : accept
Killed by : com.github.valid8j.entrypoints.AssertionsTest$MessageTest.givenLambda$whenPreconditionExercised_thenTrueReturned(com.github.valid8j.entrypoints.AssertionsTest$MessageTest) removed call to com/github/valid8j/pcond/core/Evaluator::evaluateNegation → KILLED
185

1.1
Location : isSquashable
Killed by : none replaced boolean return with false for com/github/valid8j/pcond/core/Evaluable$Negation::isSquashable → NO_COVERAGE
198

1.1
Location : accept
Killed by : com.github.valid8j.entrypoints.EnsuresTest.givenValidValue$whenEnsure$thenPasses(com.github.valid8j.entrypoints.EnsuresTest) removed call to com/github/valid8j/pcond/core/Evaluator::evaluateLeaf → KILLED
218

1.1
Location : accept
Killed by : com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.givenStreamOfSingleString$hello$_whenRequireNonNullIsFound_thenPassing(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) removed call to com/github/valid8j/pcond/core/Evaluator::evaluateCurriedContextPredicate → KILLED
235

1.1
Location : accept
Killed by : com.github.valid8j.ut.styles.MoreFluentStreamTest.test_allMatch(com.github.valid8j.ut.styles.MoreFluentStreamTest) removed call to com/github/valid8j/pcond/core/Evaluator::evaluateStreamPredicate → KILLED
284

1.1
Location : requestExpectationFlip
Killed by : com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest.givenStreamOfSingleString$hello$_whenRequireNullIsFound_thenPreconditionViolationWithCorrectMessageIsThrown(com.github.valid8j.ut.experimentals.DbCCurriedFunctionsTest) replaced boolean return with true for com/github/valid8j/pcond/core/Evaluable$StreamPred::requestExpectationFlip → KILLED
299

1.1
Location : accept
Killed by : com.github.valid8j.entrypoints.RequiresTest.testRequireWithCustomStringTransformingPredicateAndSatisfyingValue(com.github.valid8j.entrypoints.RequiresTest) removed call to com/github/valid8j/pcond/core/Evaluator::evaluateTransformation → KILLED
336

1.1
Location : accept
Killed by : com.github.valid8j.entrypoints.RequiresTest.testRequireWithCustomStringTransformingPredicateAndSatisfyingValue(com.github.valid8j.entrypoints.RequiresTest) removed call to com/github/valid8j/pcond/core/Evaluator::evaluateFunction → KILLED

Active mutators

Tests examined


Report generated by PIT 1.7.3