PatchCommandEncoder.java

1 
/*******************************************************************************
2 
 * Copyright (C) 2026, Leo Galambos
3 
 * All rights reserved.
4 
 *
5 
 * Redistribution and use in source and binary forms, with or without
6 
 * modification, are permitted provided that the following conditions are met:
7 
 *
8 
 * 1. Redistributions of source code must retain the above copyright notice,
9 
 *    this list of conditions and the following disclaimer.
10 
 *
11 
 * 2. Redistributions in binary form must reproduce the above copyright notice,
12 
 *    this list of conditions and the following disclaimer in the documentation
13 
 *    and/or other materials provided with the distribution.
14 
 *
15 
 * 3. Neither the name of the copyright holder nor the names of its contributors
16 
 *    may be used to endorse or promote products derived from this software
17 
 *    without specific prior written permission.
18 
 *
19 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20 
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23 
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 
 * POSSIBILITY OF SUCH DAMAGE.
30 
 ******************************************************************************/
31 
package org.egothor.stemmer;
32
33 
import java.util.Objects;
34 
import java.util.concurrent.locks.ReentrantLock;
35
36 
/**
37 
 * Encodes a compact patch command that transforms one word form into another
38 
 * and applies such commands back to source words.
39 
 *
40 
 * <p>
41 
 * The historical Egothor patch language is defined for backward traversal, that
42 
 * is, from the logical end of a word toward its beginning. This implementation
43 
 * preserves that proven opcode semantics as the single internal representation.
44 
 * Forward traversal is implemented by translating source and target words to
45 
 * the equivalent reversed logical form at the API boundary and then delegating
46 
 * to the same backward encoder and decoder.
47 
 * </p>
48 
 *
49 
 * <p>
50 
 * This design keeps the patch language stable, avoids maintaining two distinct
51 
 * opcode interpreters, and guarantees that forward traversal is semantically
52 
 * equivalent to running the historical algorithm on the reversed logical word
53 
 * form.
54 
 * </p>
55 
 *
56 
 * <p>
57 
 * The encoder computes a minimum-cost edit script using weighted insert,
58 
 * delete, replace, and match transitions. The resulting trace is then
59 
 * serialized into the compact patch language.
60 
 * </p>
61 
 *
62 
 * <p>
63 
 * This class is stateful and reuses internal dynamic-programming matrices
64 
 * across invocations to reduce allocation pressure during repeated use.
65 
 * Instances are therefore not suitable for unsynchronized concurrent access.
66 
 * The {@link #encode(String, String)} method is synchronized so that a shared
67 
 * instance can still be used safely when needed.
68 
 * </p>
69 
 */
70 
@SuppressWarnings({ "PMD.AvoidLiteralsInIfCondition", "PMD.CyclomaticComplexity", "PMD.ForLoopVariableCount" })
71 
public final class PatchCommandEncoder {
72
73 
    /**
74 
     * Serialized opcode for deleting one or more characters.
75 
     */
76 
    private static final char DELETE_OPCODE = 'D';
77
78 
    /**
79 
     * Serialized opcode for inserting one character.
80 
     */
81 
    private static final char INSERT_OPCODE = 'I';
82
83 
    /**
84 
     * Serialized opcode for replacing one character.
85 
     */
86 
    private static final char REPLACE_OPCODE = 'R';
87
88 
    /**
89 
     * Serialized opcode for skipping one or more unchanged characters.
90 
     */
91 
    private static final char SKIP_OPCODE = '-';
92
93 
    /**
94 
     * Sentinel placed immediately before {@code 'a'} and used to accumulate compact
95 
     * counts in the patch format.
96 
     */
97 
    private static final char COUNT_SENTINEL = (char) ('a' - 1);
98
99 
    /**
100 
     * Serialized opcode for a canonical no-operation patch.
101 
     */
102 
    private static final char NOOP_OPCODE = 'N';
103
104 
    /**
105 
     * Canonical argument used by the serialized no-operation patch.
106 
     */
107 
    private static final char NOOP_ARGUMENT = 'a';
108
109 
    /**
110 
     * Canonical serialized no-operation patch.
111 
     */
112 
    /* default */ static final String NOOP_PATCH = String.valueOf(new char[] { NOOP_OPCODE, NOOP_ARGUMENT });
113
114 
    /**
115 
     * Return value used by
116 
     * {@link #applyTo(CharSequence, String, WordTraversalDirection, char[], int, int)}
117 
     * when the caller-owned output range is too small for the transformed text.
118 
     */
119 
    public static final int APPLY_INSUFFICIENT_CAPACITY = -1;
120
121 
    /**
122 
     * Prefix used in unsupported NOOP patch argument exceptions.
123 
     */
124 
    private static final String MSG_NOOP = "Unsupported NOOP patch argument: ";
125
126 
    /**
127 
     * Prefix used in unsupported patch opcode exceptions.
128 
     */
129 
    private static final String MSG_OPCODE = "Unsupported patch opcode: ";
130
131 
    /**
132 
     * Safety penalty used to prevent a mismatch from being selected as a match.
133 
     */
134 
    private static final int MISMATCH_PENALTY = 100;
135
136 
    /**
137 
     * Extra matrix headroom reserved beyond the immediately required dimensions.
138 
     */
139 
    private static final int CAPACITY_MARGIN = 8;
140
141 
    /**
142 
     * Cost of inserting one character.
143 
     */
144 
    private final int insertCost;
145
146 
    /**
147 
     * Cost of deleting one character.
148 
     */
149 
    private final int deleteCost;
150
151 
    /**
152 
     * Cost of replacing one character.
153 
     */
154 
    private final int replaceCost;
155
156 
    /**
157 
     * Cost of keeping one matching character unchanged.
158 
     */
159 
    private final int matchCost;
160
161 
    /**
162 
     * Direction in which words are traversed during both patch serialization and
163 
     * patch application.
164 
     */
165 
    private final WordTraversalDirection traversalDirection;
166
167 
    /**
168 
     * Whether this instance applies patch commands in backward traversal order.
169 
     */
170 
    private final boolean backwardTraversal;
171
172 
    /**
173 
     * Currently allocated source dimension of reusable matrices.
174 
     */
175 
    private int sourceCapacity;
176
177 
    /**
178 
     * Currently allocated target dimension of reusable matrices.
179 
     */
180 
    private int targetCapacity;
181
182 
    /**
183 
     * Dynamic-programming matrix containing cumulative minimum costs.
184 
     */
185 
    private int[][] costMatrix;
186
187 
    /**
188 
     * Matrix storing the chosen transition for each dynamic-programming cell.
189 
     */
190 
    private Trace[][] traceMatrix;
191
192 
    /**
193 
     * Reentrant lock for {@link #encode(String, String)} exclusive operation.
194 
     */
195 
    private final ReentrantLock lock = new ReentrantLock();
196
197 
    /**
198 
     * Internal dynamic-programming transition selected for one matrix cell.
199 
     */
200 
    private enum Trace {
201
202 
        /** Deletes one character from the source sequence. */
203 
        DELETE,
204
205 
        /** Inserts one character from the target sequence. */
206 
        INSERT,
207
208 
        /** Replaces one source character with one target character. */
209 
        REPLACE,
210
211 
        /** Keeps one matching character unchanged. */
212 
        MATCH
213 
    }
214
215 
    private PatchCommandEncoder(final Builder builder) {
216 
        this.traversalDirection = Objects.requireNonNull(builder.traversalDirection, "traversalDirection");
217 
        final int insertCost = builder.insertCost;
218 2 1. <init> : changed conditional boundary → SURVIVED
2. <init> : negated conditional → KILLED
 
        if (insertCost < 0) {
219 
            throw new IllegalArgumentException("insertCost must be non-negative.");
220 
        }
221 
        final int deleteCost = builder.deleteCost;
222 2 1. <init> : changed conditional boundary → SURVIVED
2. <init> : negated conditional → KILLED
 
        if (deleteCost < 0) {
223 
            throw new IllegalArgumentException("deleteCost must be non-negative.");
224 
        }
225 
        final int replaceCost = builder.replaceCost;
226 2 1. <init> : changed conditional boundary → SURVIVED
2. <init> : negated conditional → KILLED
 
        if (replaceCost < 0) {
227 
            throw new IllegalArgumentException("replaceCost must be non-negative.");
228 
        }
229 
        final int matchCost = builder.matchCost;
230 2 1. <init> : negated conditional → KILLED
2. <init> : changed conditional boundary → KILLED
 
        if (matchCost < 0) {
231 
            throw new IllegalArgumentException("matchCost must be non-negative.");
232 
        }
233
234 
        this.insertCost = insertCost;
235 
        this.deleteCost = deleteCost;
236 
        this.replaceCost = replaceCost;
237 
        this.matchCost = matchCost;
238 1 1. <init> : negated conditional → KILLED
 
        this.backwardTraversal = this.traversalDirection == WordTraversalDirection.BACKWARD;
239 
        this.sourceCapacity = 0;
240 
        this.targetCapacity = 0;
241 
        this.costMatrix = new int[0][0];
242 
        this.traceMatrix = new Trace[0][0];
243 
    }
244
245 
    /**
246 
     * Creates a fluent builder for constructing a direction-specialized encoder.
247 
     *
248 
     * @return new builder instance
249 
     */
250 
    public static Builder builder() {
251 1 1. builder : replaced return value with null for org/egothor/stemmer/PatchCommandEncoder::builder → KILLED
 
        return new Builder();
252 
    }
253
254 
    /**
255 
     * Produces a compact patch command that transforms {@code source} into
256 
     * {@code target}.
257 
     *
258 
     * @param source source word form
259 
     * @param target target word form
260 
     * @return compact patch command, or {@code null} when any argument is
261 
     *         {@code null}
262 
     */
263 
    public String encode(final String source, final String target) {
264 2 1. encode : negated conditional → KILLED
2. encode : negated conditional → KILLED
 
        if (source == null || target == null) {
265 1 1. encode : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encode → KILLED
 
            return null;
266 
        }
267 1 1. encode : negated conditional → KILLED
 
        if (source.equals(target)) {
268 1 1. encode : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encode → KILLED
 
            return NOOP_PATCH;
269 
        }
270
271 1 1. encode : negated conditional → KILLED
 
        if (this.traversalDirection == WordTraversalDirection.BACKWARD) {
272 1 1. encode : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encode → KILLED
 
            return encodeBackward(source, target);
273 
        }
274 1 1. encode : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encode → KILLED
 
        return encodeForward(source, target);
275 
    }
276
277 
    /**
278 
     * Applies a compact patch command using this encoder instance traversal
279 
     * direction.
280 
     *
281 
     * <p>
282 
     * This is the instance-level fast path for repeated patch application in a
283 
     * known traversal direction. It avoids the static API null and direction
284 
     * validation path and calls the selected decoder directly.
285 
     * </p>
286 
     *
287 
     * @param source       original source word
288 
     * @param patchCommand compact patch command
289 
     * @return transformed word, or {@code null} when {@code source} is {@code null}
290 
     * @deprecated Since 2.3.0. Runtime stemming should compile
291 
     *             {@code patchCommand} once through {@link #compile(String)} and
292 
     *             reuse {@link CompiledPatchCommand#apply(String)}. The
293 
     *             String-based application path reparses the patch command on every
294 
     *             call and is kept only for source compatibility before the 3.0.0
295 
     *             migration.
296 
     */
297 
    @Deprecated(since = "2.3.0", forRemoval = false)
298 
    public String applyWithConfiguredDirection(final String source, final String patchCommand) {
299 1 1. applyWithConfiguredDirection : negated conditional → KILLED
 
        if (source == null) {
300 1 1. applyWithConfiguredDirection : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyWithConfiguredDirection → NO_COVERAGE
 
            return null;
301 
        }
302 1 1. applyWithConfiguredDirection : negated conditional → KILLED
 
        if (this.backwardTraversal) {
303 1 1. applyWithConfiguredDirection : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyWithConfiguredDirection → NO_COVERAGE
 
            return applyBackwardNonNull(source, patchCommand);
304 
        }
305 1 1. applyWithConfiguredDirection : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyWithConfiguredDirection → KILLED
 
        return applyForwardNonNull(source, patchCommand);
306 
    }
307
308 
    /**
309 
     * Compiles a patch command for repeated application with this encoder
310 
     * instance traversal direction.
311 
     *
312 
     * @param patchCommand compact patch command
313 
     * @return immutable compiled patch command
314 
     * @throws IllegalArgumentException if the serialized command contains an
315 
     *                                  unsupported opcode or invalid NOOP argument
316 
     */
317 
    public CompiledPatchCommand compile(final String patchCommand) {
318 1 1. compile : replaced return value with null for org/egothor/stemmer/PatchCommandEncoder::compile → KILLED
 
        return CompiledPatchCommand.compile(patchCommand, this.traversalDirection);
319 
    }
320
321 
    /**
322 
     * Applies a compact patch command to the supplied source word using the
323 
     * historical backward traversal direction.
324 
     *
325 
     * @param source       original source word
326 
     * @param patchCommand compact patch command
327 
     * @return transformed word, or {@code null} when {@code source} is {@code null}
328 
     * @deprecated Since 2.3.0. Runtime stemming should use
329 
     *             {@link CompiledPatchCommand#compile(String, WordTraversalDirection)}
330 
     *             once and then reuse {@link CompiledPatchCommand#apply(String)}.
331 
     *             This method repeatedly interprets the serialized patch-command
332 
     *             string and is retained only for compatibility before the 3.0.0
333 
     *             migration.
334 
     */
335 
    @Deprecated(since = "2.3.0", forRemoval = false)
336 
    public static String apply(final String source, final String patchCommand) {
337 1 1. apply : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::apply → KILLED
 
        return apply(source, patchCommand, WordTraversalDirection.BACKWARD);
338 
    }
339
340 
    /**
341 
     * Applies a compact patch command to the supplied source word using the
342 
     * specified traversal direction.
343 
     *
344 
     * <p>
345 
     * The implementation uses dedicated direction-specific patch decoders.
346 
     * </p>
347 
     *
348 
     * @param source             original source word
349 
     * @param patchCommand       compact patch command
350 
     * @param traversalDirection traversal direction used by the patch command
351 
     * @return transformed word, or {@code null} when {@code source} is {@code null}
352 
     * @deprecated Since 2.3.0. Runtime stemming should use
353 
     *             {@link CompiledPatchCommand#compile(String, WordTraversalDirection)}
354 
     *             once and then reuse {@link CompiledPatchCommand#apply(String)}.
355 
     *             This method repeatedly interprets the serialized patch-command
356 
     *             string and is retained only for compatibility before the 3.0.0
357 
     *             migration.
358 
     */
359 
    @Deprecated(since = "2.3.0", forRemoval = false)
360 
    public static String apply(final String source, final String patchCommand,
361 
            final WordTraversalDirection traversalDirection) {
362 
        Objects.requireNonNull(traversalDirection, "traversalDirection");
363 1 1. apply : negated conditional → KILLED
 
        if (source == null) {
364 1 1. apply : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::apply → KILLED
 
            return null;
365 
        }
366 1 1. apply : negated conditional → KILLED
 
        if (traversalDirection == WordTraversalDirection.BACKWARD) {
367 1 1. apply : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::apply → KILLED
 
            return applyBackwardNonNull(source, patchCommand);
368 
        }
369 1 1. apply : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::apply → KILLED
 
        return applyForwardNonNull(source, patchCommand);
370 
    }
371
372 
    /**
373 
     * Compiles a patch command for repeated application with the supplied
374 
     * traversal direction.
375 
     *
376 
     * @param patchCommand       compact patch command
377 
     * @param traversalDirection traversal direction used by the patch command
378 
     * @return immutable compiled patch command
379 
     * @throws NullPointerException     if {@code traversalDirection} is
380 
     *                                  {@code null}
381 
     * @throws IllegalArgumentException if the serialized command contains an
382 
     *                                  unsupported opcode or invalid NOOP argument
383 
     */
384 
    public static CompiledPatchCommand compile(final String patchCommand,
385 
            final WordTraversalDirection traversalDirection) {
386 1 1. compile : replaced return value with null for org/egothor/stemmer/PatchCommandEncoder::compile → NO_COVERAGE
 
        return CompiledPatchCommand.compile(patchCommand, traversalDirection);
387 
    }
388
389 
    /**
390 
     * Applies a compact patch command into a caller-owned output buffer.
391 
     *
392 
     * <p>
393 
     * The output array is not retained. Capacity failure is reported by
394 
     * {@link #APPLY_INSUFFICIENT_CAPACITY} and leaves the output range unchanged.
395 
     * Malformed compatibility cases preserve the source exactly as
396 
     * {@link #apply(String, String, WordTraversalDirection)} does.
397 
     * </p>
398 
     *
399 
     * @param source             original source text
400 
     * @param patchCommand       compact patch command
401 
     * @param traversalDirection traversal direction used by the patch command
402 
     * @param output             caller-owned output storage
403 
     * @param outputOffset       first writable output offset
404 
     * @param outputLength       writable output capacity
405 
     * @return produced character count, or {@link #APPLY_INSUFFICIENT_CAPACITY}
406 
     *         when {@code outputLength} is too small
407 
     * @deprecated Since 2.3.0. Compile {@code patchCommand} once through
408 
     *             {@link #compile(String, WordTraversalDirection)} and call
409 
     *             {@link CompiledPatchCommand#applyTo(CharSequence, char[], int, int)}
410 
     *             or
411 
     *             {@link CompiledPatchCommand#applyTo(CharSequence, int, int, char[], int, int)}.
412 
     *             This String-based method reparses patch commands on every call and
413 
     *             is kept only for compatibility before the 3.0.0 migration.
414 
     */
415 
    @Deprecated(since = "2.3.0", forRemoval = false)
416 
    public static int applyTo(final CharSequence source, final String patchCommand,
417 
            final WordTraversalDirection traversalDirection, final char[] output, final int outputOffset,
418 
            final int outputLength) {
419 
        Objects.requireNonNull(source, "source");
420 
        Objects.requireNonNull(traversalDirection, "traversalDirection");
421 
        Objects.requireNonNull(output, "output");
422 
        Objects.checkFromIndexSize(outputOffset, outputLength, output.length);
423
424 
        final int sourceLength = source.length();
425 
        final int producedLength = computeAppliedLength(sourceLength, patchCommand, traversalDirection);
426 2 1. applyTo : negated conditional → KILLED
2. applyTo : changed conditional boundary → KILLED
 
        if (producedLength > outputLength) {
427 1 1. applyTo : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::applyTo → KILLED
 
            return APPLY_INSUFFICIENT_CAPACITY;
428 
        }
429 1 1. applyTo : removed call to org/egothor/stemmer/PatchCommandEncoder::applyToOutput → KILLED
 
        applyToOutput(source, 0, sourceLength, patchCommand, traversalDirection, output, outputOffset, producedLength);
430 1 1. applyTo : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::applyTo → KILLED
 
        return producedLength;
431 
    }
432
433 
    /**
434 
     * Applies a compact patch command from a caller-owned source slice into a
435 
     * caller-owned output buffer.
436 
     *
437 
     * @param source             source storage
438 
     * @param sourceOffset       first source character offset
439 
     * @param sourceLength       number of source characters
440 
     * @param patchCommand       compact patch command
441 
     * @param traversalDirection traversal direction used by the patch command
442 
     * @param output             caller-owned output storage
443 
     * @param outputOffset       first writable output offset
444 
     * @param outputLength       writable output capacity
445 
     * @return produced character count, or {@link #APPLY_INSUFFICIENT_CAPACITY}
446 
     *         when {@code outputLength} is too small
447 
     * @throws IllegalArgumentException when source and output ranges overlap in the
448 
     *                                  same array
449 
     * @deprecated Since 2.3.0. Compile {@code patchCommand} once through
450 
     *             {@link #compile(String, WordTraversalDirection)} and call
451 
     *             {@link CompiledPatchCommand#applyTo(char[], int, int, char[], int, int)}.
452 
     *             This String-based method reparses patch commands on every call and
453 
     *             is kept only for compatibility before the 3.0.0 migration.
454 
     */
455 
    @Deprecated(since = "2.3.0", forRemoval = false)
456 
    public static int applyTo(final char[] source, final int sourceOffset, final int sourceLength,
457 
            final String patchCommand, final WordTraversalDirection traversalDirection, final char[] output,
458 
            final int outputOffset, final int outputLength) {
459 
        Objects.requireNonNull(source, "source");
460 
        Objects.requireNonNull(traversalDirection, "traversalDirection");
461 
        Objects.requireNonNull(output, "output");
462 
        Objects.checkFromIndexSize(sourceOffset, sourceLength, source.length);
463 
        Objects.checkFromIndexSize(outputOffset, outputLength, output.length);
464 1 1. applyTo : removed call to org/egothor/stemmer/PatchCommandEncoder::validateNonOverlappingRanges → KILLED
 
        validateNonOverlappingRanges(source, sourceOffset, sourceLength, output, outputOffset, outputLength);
465
466 
        final int producedLength = computeAppliedLength(sourceLength, patchCommand, traversalDirection);
467 2 1. applyTo : changed conditional boundary → SURVIVED
2. applyTo : negated conditional → KILLED
 
        if (producedLength > outputLength) {
468 1 1. applyTo : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::applyTo → NO_COVERAGE
 
            return APPLY_INSUFFICIENT_CAPACITY;
469 
        }
470 1 1. applyTo : removed call to org/egothor/stemmer/PatchCommandEncoder::applyToOutput → KILLED
 
        applyToOutput(source, sourceOffset, sourceLength, patchCommand, traversalDirection, output, outputOffset,
471 
                producedLength);
472 1 1. applyTo : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::applyTo → KILLED
 
        return producedLength;
473 
    }
474
475 
    /**
476 
     * Encodes a patch command using the historical backward Egothor semantics.
477 
     *
478 
     * @param source source word form in legacy backward logical space
479 
     * @param target target word form in legacy backward logical space
480 
     * @return compact patch command
481 
     */
482 
    private String encodeBackward(final String source, final String target) {
483 
        final int sourceLength = source.length();
484 
        final int targetLength = target.length();
485
486 1 1. encodeBackward : removed call to java/util/concurrent/locks/ReentrantLock::lock → KILLED
 
        lock.lock();
487 
        try {
488 3 1. encodeBackward : removed call to org/egothor/stemmer/PatchCommandEncoder::ensureCapacity → KILLED
2. encodeBackward : Replaced integer addition with subtraction → KILLED
3. encodeBackward : Replaced integer addition with subtraction → KILLED
 
            ensureCapacity(sourceLength + 1, targetLength + 1);
489 1 1. encodeBackward : removed call to org/egothor/stemmer/PatchCommandEncoder::initializeBoundaryConditionsBackward → KILLED
 
            initializeBoundaryConditionsBackward(sourceLength, targetLength);
490
491 
            final char[] sourceCharacters = source.toCharArray();
492 
            final char[] targetCharacters = target.toCharArray();
493
494 1 1. encodeBackward : removed call to org/egothor/stemmer/PatchCommandEncoder::fillMatrices → KILLED
 
            fillMatrices(sourceCharacters, targetCharacters, sourceLength, targetLength,
495 
                    WordTraversalDirection.BACKWARD);
496
497 1 1. encodeBackward : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encodeBackward → KILLED
 
            return buildPatchCommandBackward(targetCharacters, sourceLength, targetLength);
498 
        } finally {
499 1 1. encodeBackward : removed call to java/util/concurrent/locks/ReentrantLock::unlock → SURVIVED
 
            lock.unlock();
500 
        }
501 
    }
502
503 
    /**
504 
     * Encodes a patch command using forward traversal semantics.
505 
     *
506 
     * @param source source word form
507 
     * @param target target word form
508 
     * @return compact patch command
509 
     */
510 
    private String encodeForward(final String source, final String target) {
511 
        final int sourceLength = source.length();
512 
        final int targetLength = target.length();
513
514 1 1. encodeForward : removed call to java/util/concurrent/locks/ReentrantLock::lock → KILLED
 
        lock.lock();
515 
        try {
516 3 1. encodeForward : Replaced integer addition with subtraction → SURVIVED
2. encodeForward : Replaced integer addition with subtraction → SURVIVED
3. encodeForward : removed call to org/egothor/stemmer/PatchCommandEncoder::ensureCapacity → KILLED
 
            ensureCapacity(sourceLength + 1, targetLength + 1);
517 1 1. encodeForward : removed call to org/egothor/stemmer/PatchCommandEncoder::initializeBoundaryConditionsForward → KILLED
 
            initializeBoundaryConditionsForward(sourceLength, targetLength);
518
519 
            final char[] sourceCharacters = source.toCharArray();
520 
            final char[] targetCharacters = target.toCharArray();
521
522 1 1. encodeForward : removed call to org/egothor/stemmer/PatchCommandEncoder::fillMatrices → KILLED
 
            fillMatrices(sourceCharacters, targetCharacters, sourceLength, targetLength,
523 
                    WordTraversalDirection.FORWARD);
524
525 1 1. encodeForward : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encodeForward → KILLED
 
            return buildPatchCommandForward(targetCharacters, sourceLength, targetLength);
526 
        } finally {
527 1 1. encodeForward : removed call to java/util/concurrent/locks/ReentrantLock::unlock → SURVIVED
 
            lock.unlock();
528 
        }
529 
    }
530
531 
    /**
532 
     * Applies a patch command using the historical backward Egothor semantics.
533 
     *
534 
     * @param source       non-null original source word in legacy backward logical
535 
     *                     space
536 
     * @param patchCommand compact patch command
537 
     * @return transformed word
538 
     */
539 
    private static String applyBackwardNonNull(final String source, final String patchCommand) {
540 1 1. applyBackwardNonNull : negated conditional → KILLED
 
        if (patchCommand == null) {
541 1 1. applyBackwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED
 
            return source;
542 
        }
543 
        final int patchLength = patchCommand.length();
544 3 1. applyBackwardNonNull : negated conditional → KILLED
2. applyBackwardNonNull : Replaced bitwise AND with OR → KILLED
3. applyBackwardNonNull : negated conditional → KILLED
 
        if (patchLength == 0 || (patchLength & 1) != 0) {
545 1 1. applyBackwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED
 
            return source;
546 
        }
547 1 1. applyBackwardNonNull : negated conditional → KILLED
 
        if (patchLength == 2) {
548 1 1. applyBackwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED
 
            return applySingleBackwardInstruction(source, patchCommand.charAt(0), patchCommand.charAt(1));
549 
        }
550
551 1 1. applyBackwardNonNull : negated conditional → KILLED
 
        if (source.isEmpty()) {
552 1 1. applyBackwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED
 
            return applyBackwardToEmptySource(patchCommand);
553 
        }
554
555 
        final StringBuilder result = new StringBuilder(source);
556
557 1 1. applyBackwardNonNull : Replaced integer subtraction with addition → KILLED
 
        int position = result.length() - 1;
558
559 
        try {
560 2 1. applyBackwardNonNull : changed conditional boundary → KILLED
2. applyBackwardNonNull : negated conditional → KILLED
 
            for (int patchIndex = 0; patchIndex < patchLength; patchIndex += 2) {
561 
                final char opcode = patchCommand.charAt(patchIndex);
562 1 1. applyBackwardNonNull : Replaced integer addition with subtraction → KILLED
 
                final char argument = patchCommand.charAt(patchIndex + 1);
563
564 
                switch (opcode) {
565 
                    case SKIP_OPCODE:
566 
                        final int skipCount = decodeEncodedCount(argument);
567 2 1. applyBackwardNonNull : changed conditional boundary → KILLED
2. applyBackwardNonNull : negated conditional → KILLED
 
                        if (skipCount < 1) {
568 1 1. applyBackwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → NO_COVERAGE
 
                            return source;
569 
                        }
570 2 1. applyBackwardNonNull : Replaced integer addition with subtraction → KILLED
2. applyBackwardNonNull : Replaced integer subtraction with addition → KILLED
 
                        position = position - skipCount + 1;
571 
                        break;
572
573 
                    case REPLACE_OPCODE:
574 1 1. applyBackwardNonNull : removed call to java/lang/StringBuilder::setCharAt → KILLED
 
                        result.setCharAt(position, argument);
575 
                        break;
576
577 
                    case DELETE_OPCODE:
578 
                        final int deleteCount = decodeEncodedCount(argument);
579 2 1. applyBackwardNonNull : changed conditional boundary → KILLED
2. applyBackwardNonNull : negated conditional → KILLED
 
                        if (deleteCount < 1) {
580 1 1. applyBackwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → NO_COVERAGE
 
                            return source;
581 
                        }
582 1 1. applyBackwardNonNull : Replaced integer addition with subtraction → KILLED
 
                        final int deleteEndExclusive = position + 1;
583 2 1. applyBackwardNonNull : Replaced integer subtraction with addition → KILLED
2. applyBackwardNonNull : Replaced integer subtraction with addition → KILLED
 
                        position -= deleteCount - 1;
584 
                        result.delete(position, deleteEndExclusive);
585 
                        break;
586
587 
                    case INSERT_OPCODE:
588 1 1. applyBackwardNonNull : Replaced integer addition with subtraction → KILLED
 
                        result.insert(position + 1, argument);
589 1 1. applyBackwardNonNull : Changed increment from 1 to -1 → KILLED
 
                        position++;
590 
                        break;
591
592 
                    case NOOP_OPCODE:
593 1 1. applyBackwardNonNull : negated conditional → NO_COVERAGE
 
                        if (argument != NOOP_ARGUMENT) {
594 
                            throw new IllegalArgumentException(MSG_NOOP + argument);
595 
                        }
596 1 1. applyBackwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → NO_COVERAGE
 
                        return source;
597
598 
                    default:
599 
                        throw new IllegalArgumentException(MSG_OPCODE + opcode);
600 
                }
601
602 1 1. applyBackwardNonNull : Changed increment from -1 to 1 → KILLED
 
                position--;
603 
            }
604 
        } catch (IndexOutOfBoundsException exception) {
605 1 1. applyBackwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED
 
            return source;
606 
        }
607
608 1 1. applyBackwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED
 
        return result.toString();
609 
    }
610
611 
    /**
612 
     * Applies a patch command using forward traversal semantics.
613 
     *
614 
     * @param source       non-null original source word
615 
     * @param patchCommand compact patch command
616 
     * @return transformed word
617 
     */
618 
    private static String applyForwardNonNull(final String source, final String patchCommand) {
619 1 1. applyForwardNonNull : negated conditional → KILLED
 
        if (patchCommand == null) {
620 1 1. applyForwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → NO_COVERAGE
 
            return source;
621 
        }
622 
        final int patchLength = patchCommand.length();
623 3 1. applyForwardNonNull : negated conditional → KILLED
2. applyForwardNonNull : Replaced bitwise AND with OR → KILLED
3. applyForwardNonNull : negated conditional → KILLED
 
        if (patchLength == 0 || (patchLength & 1) != 0) {
624 1 1. applyForwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → NO_COVERAGE
 
            return source;
625 
        }
626 1 1. applyForwardNonNull : negated conditional → KILLED
 
        if (patchLength == 2) {
627 1 1. applyForwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → KILLED
 
            return applySingleForwardInstruction(source, patchCommand.charAt(0), patchCommand.charAt(1));
628 
        }
629
630 1 1. applyForwardNonNull : negated conditional → KILLED
 
        if (source.isEmpty()) {
631 1 1. applyForwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → NO_COVERAGE
 
            return applyForwardToEmptySource(patchCommand);
632 
        }
633
634 
        final StringBuilder result = new StringBuilder(source);
635
636 
        int position = 0;
637
638 
        try {
639 2 1. applyForwardNonNull : negated conditional → KILLED
2. applyForwardNonNull : changed conditional boundary → KILLED
 
            for (int patchIndex = 0; patchIndex < patchLength; patchIndex += 2) {
640 
                final char opcode = patchCommand.charAt(patchIndex);
641 1 1. applyForwardNonNull : Replaced integer addition with subtraction → KILLED
 
                final char argument = patchCommand.charAt(patchIndex + 1);
642
643 
                switch (opcode) {
644 
                    case SKIP_OPCODE:
645 
                        final int skipCount = decodeEncodedCount(argument);
646 2 1. applyForwardNonNull : negated conditional → KILLED
2. applyForwardNonNull : changed conditional boundary → KILLED
 
                        if (skipCount < 1) {
647 1 1. applyForwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → NO_COVERAGE
 
                            return source;
648 
                        }
649 2 1. applyForwardNonNull : Replaced integer addition with subtraction → KILLED
2. applyForwardNonNull : Replaced integer subtraction with addition → KILLED
 
                        position = position + skipCount - 1;
650 
                        break;
651
652 
                    case REPLACE_OPCODE:
653 1 1. applyForwardNonNull : removed call to java/lang/StringBuilder::setCharAt → KILLED
 
                        result.setCharAt(position, argument);
654 
                        break;
655
656 
                    case DELETE_OPCODE:
657 
                        final int deleteCount = decodeEncodedCount(argument);
658 2 1. applyForwardNonNull : negated conditional → KILLED
2. applyForwardNonNull : changed conditional boundary → KILLED
 
                        if (deleteCount < 1) {
659 1 1. applyForwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → NO_COVERAGE
 
                            return source;
660 
                        }
661 1 1. applyForwardNonNull : Replaced integer addition with subtraction → KILLED
 
                        result.delete(position, position + deleteCount);
662 1 1. applyForwardNonNull : Changed increment from -1 to 1 → KILLED
 
                        position--;
663 
                        break;
664
665 
                    case INSERT_OPCODE:
666 
                        result.insert(position, argument);
667 
                        break;
668
669 
                    case NOOP_OPCODE:
670 1 1. applyForwardNonNull : negated conditional → NO_COVERAGE
 
                        if (argument != NOOP_ARGUMENT) {
671 
                            throw new IllegalArgumentException(MSG_NOOP + argument);
672 
                        }
673 1 1. applyForwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → NO_COVERAGE
 
                        return source;
674
675 
                    default:
676 
                        throw new IllegalArgumentException(MSG_OPCODE + opcode);
677 
                }
678
679 1 1. applyForwardNonNull : Changed increment from 1 to -1 → KILLED
 
                position++;
680 
            }
681 
        } catch (IndexOutOfBoundsException exception) {
682 1 1. applyForwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → KILLED
 
            return source;
683 
        }
684
685 1 1. applyForwardNonNull : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → KILLED
 
        return result.toString();
686 
    }
687
688 
    /**
689 
     * Applies a single backward-direction patch instruction.
690 
     *
691 
     * @param source   original source word
692 
     * @param opcode   patch opcode
693 
     * @param argument encoded patch argument
694 
     * @return transformed source after one instruction
695 
     */
696 
    private static String applySingleBackwardInstruction(final String source, final char opcode, final char argument) {
697 
        final int sourceLength = source.length();
698 
        final int encodedValue;
699
700 
        switch (opcode) {
701 
            case DELETE_OPCODE:
702 
                encodedValue = decodeEncodedCount(argument);
703 4 1. applySingleBackwardInstruction : changed conditional boundary → KILLED
2. applySingleBackwardInstruction : negated conditional → KILLED
3. applySingleBackwardInstruction : negated conditional → KILLED
4. applySingleBackwardInstruction : changed conditional boundary → KILLED
 
                if (encodedValue < 1 || encodedValue > sourceLength) {
704 1 1. applySingleBackwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED
 
                    return source;
705 
                }
706 2 1. applySingleBackwardInstruction : Replaced integer subtraction with addition → KILLED
2. applySingleBackwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED
 
                return source.substring(0, sourceLength - encodedValue);
707
708 
            case INSERT_OPCODE:
709 1 1. applySingleBackwardInstruction : Replaced integer addition with subtraction → KILLED
 
                final char[] insertTarget = new char[sourceLength + 1];
710 1 1. applySingleBackwardInstruction : removed call to java/lang/String::getChars → KILLED
 
                source.getChars(0, sourceLength, insertTarget, 0);
711 
                insertTarget[sourceLength] = argument;
712 1 1. applySingleBackwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED
 
                return new String(insertTarget);
713
714 
            case REPLACE_OPCODE:
715 1 1. applySingleBackwardInstruction : negated conditional → KILLED
 
                if (sourceLength == 0) {
716 1 1. applySingleBackwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → SURVIVED
 
                    return source;
717 
                }
718 
                final char[] replaceTarget = source.toCharArray();
719 1 1. applySingleBackwardInstruction : Replaced integer subtraction with addition → KILLED
 
                replaceTarget[sourceLength - 1] = argument;
720 1 1. applySingleBackwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED
 
                return new String(replaceTarget);
721
722 
            case SKIP_OPCODE:
723 1 1. applySingleBackwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED
 
                return source;
724
725 
            case NOOP_OPCODE:
726 1 1. applySingleBackwardInstruction : negated conditional → KILLED
 
                if (argument != NOOP_ARGUMENT) {
727 
                    throw new IllegalArgumentException(MSG_NOOP + argument);
728 
                }
729 1 1. applySingleBackwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED
 
                return source;
730
731 
            default:
732 
                throw new IllegalArgumentException(MSG_OPCODE + opcode);
733 
        }
734 
    }
735
736 
    /**
737 
     * Applies a single forward-direction patch instruction.
738 
     *
739 
     * @param source   original source word
740 
     * @param opcode   patch opcode
741 
     * @param argument encoded patch argument
742 
     * @return transformed source after one instruction
743 
     */
744 
    private static String applySingleForwardInstruction(final String source, final char opcode, final char argument) {
745 
        final int sourceLength = source.length();
746 
        final int encodedValue;
747
748 
        switch (opcode) {
749 
            case DELETE_OPCODE:
750 
                encodedValue = decodeEncodedCount(argument);
751 4 1. applySingleForwardInstruction : changed conditional boundary → SURVIVED
2. applySingleForwardInstruction : negated conditional → KILLED
3. applySingleForwardInstruction : negated conditional → KILLED
4. applySingleForwardInstruction : changed conditional boundary → KILLED
 
                if (encodedValue < 1 || encodedValue > sourceLength) {
752 1 1. applySingleForwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → NO_COVERAGE
 
                    return source;
753 
                }
754 1 1. applySingleForwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → KILLED
 
                return source.substring(encodedValue);
755
756 
            case INSERT_OPCODE:
757 1 1. applySingleForwardInstruction : Replaced integer addition with subtraction → KILLED
 
                final char[] insertTarget = new char[sourceLength + 1];
758 
                insertTarget[0] = argument;
759 1 1. applySingleForwardInstruction : removed call to java/lang/String::getChars → KILLED
 
                source.getChars(0, sourceLength, insertTarget, 1);
760 1 1. applySingleForwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → KILLED
 
                return new String(insertTarget);
761
762 
            case REPLACE_OPCODE:
763 1 1. applySingleForwardInstruction : negated conditional → KILLED
 
                if (sourceLength == 0) {
764 1 1. applySingleForwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → NO_COVERAGE
 
                    return source;
765 
                }
766 
                final char[] replaceTarget = source.toCharArray();
767 
                replaceTarget[0] = argument;
768 1 1. applySingleForwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → KILLED
 
                return new String(replaceTarget);
769
770 
            case SKIP_OPCODE:
771 1 1. applySingleForwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → KILLED
 
                return source;
772
773 
            case NOOP_OPCODE:
774 1 1. applySingleForwardInstruction : negated conditional → KILLED
 
                if (argument != NOOP_ARGUMENT) {
775 
                    throw new IllegalArgumentException(MSG_NOOP + argument);
776 
                }
777 1 1. applySingleForwardInstruction : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → KILLED
 
                return source;
778
779 
            default:
780 
                throw new IllegalArgumentException(MSG_OPCODE + opcode);
781 
        }
782 
    }
783
784 
    /**
785 
     * Applies a backward patch command to an empty source word.
786 
     *
787 
     * <p>
788 
     * Only insertion instructions are meaningful for an empty source. Skip,
789 
     * replace, and delete instructions are treated as malformed and therefore cause
790 
     * the original source to be preserved, consistent with the historical fallback
791 
     * behavior for index-invalid commands.
792 
     * </p>
793 
     *
794 
     * @param patchCommand compact patch command
795 
     * @return transformed word, or the original empty word when the patch is
796 
     *         malformed
797 
     */
798 
    private static String applyBackwardToEmptySource(final String patchCommand) {
799 1 1. applyBackwardToEmptySource : Replaced Shift Right with Shift Left → SURVIVED
 
        final StringBuilder result = new StringBuilder(patchCommand.length() >> 1);
800 
        try {
801 2 1. applyBackwardToEmptySource : changed conditional boundary → KILLED
2. applyBackwardToEmptySource : negated conditional → KILLED
 
            for (int patchIndex = 0, patchLength = patchCommand.length(); patchIndex < patchLength; patchIndex += 2) {
802 
                final char opcode = patchCommand.charAt(patchIndex);
803 1 1. applyBackwardToEmptySource : Replaced integer addition with subtraction → KILLED
 
                final char argument = patchCommand.charAt(patchIndex + 1);
804
805 
                switch (opcode) {
806 
                    case INSERT_OPCODE:
807 
                        result.insert(0, argument);
808 
                        break;
809
810 
                    case SKIP_OPCODE:
811 
                    case REPLACE_OPCODE:
812 
                    case DELETE_OPCODE:
813 
                        return "";
814
815 
                    case NOOP_OPCODE:
816 1 1. applyBackwardToEmptySource : negated conditional → NO_COVERAGE
 
                        if (argument != NOOP_ARGUMENT) {
817 
                            throw new IllegalArgumentException(MSG_NOOP + argument);
818 
                        }
819 
                        return "";
820
821 
                    default:
822 
                        throw new IllegalArgumentException(MSG_OPCODE + opcode);
823 
                }
824 
            }
825 
        } catch (IndexOutOfBoundsException exception) {
826 
            return "";
827 
        }
828
829 1 1. applyBackwardToEmptySource : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardToEmptySource → KILLED
 
        return result.toString();
830 
    }
831
832 
    /**
833 
     * Applies a forward patch command to an empty source word.
834 
     *
835 
     * @param patchCommand compact patch command
836 
     * @return transformed word, or the original empty word when the patch is
837 
     *         malformed
838 
     */
839 
    private static String applyForwardToEmptySource(final String patchCommand) {
840 1 1. applyForwardToEmptySource : Replaced Shift Right with Shift Left → SURVIVED
 
        final StringBuilder result = new StringBuilder(patchCommand.length() >> 1);
841 
        try {
842 2 1. applyForwardToEmptySource : changed conditional boundary → SURVIVED
2. applyForwardToEmptySource : negated conditional → KILLED
 
            for (int patchIndex = 0, patchLength = patchCommand.length(); patchIndex < patchLength; patchIndex += 2) {
843 
                final char opcode = patchCommand.charAt(patchIndex);
844 1 1. applyForwardToEmptySource : Replaced integer addition with subtraction → KILLED
 
                final char argument = patchCommand.charAt(patchIndex + 1);
845
846 
                switch (opcode) {
847 
                    case INSERT_OPCODE:
848 
                        result.append(argument);
849 
                        break;
850
851 
                    case SKIP_OPCODE:
852 
                    case REPLACE_OPCODE:
853 
                    case DELETE_OPCODE:
854 
                        return "";
855
856 
                    case NOOP_OPCODE:
857 1 1. applyForwardToEmptySource : negated conditional → KILLED
 
                        if (argument != NOOP_ARGUMENT) {
858 
                            throw new IllegalArgumentException(MSG_NOOP + argument);
859 
                        }
860 
                        return "";
861
862 
                    default:
863 
                        throw new IllegalArgumentException(MSG_OPCODE + opcode);
864 
                }
865 
            }
866 
        } catch (IndexOutOfBoundsException exception) {
867 
            return "";
868 
        }
869
870 1 1. applyForwardToEmptySource : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardToEmptySource → NO_COVERAGE
 
        return result.toString();
871 
    }
872
873 
    /**
874 
     * Computes the transformed length or the preserved source length for malformed
875 
     * compatibility cases.
876 
     *
877 
     * @param sourceLength       source length
878 
     * @param patchCommand       patch command
879 
     * @param traversalDirection traversal direction
880 
     * @return produced length
881 
     */
882 
    private static int computeAppliedLength(final int sourceLength, final String patchCommand,
883 
            final WordTraversalDirection traversalDirection) {
884 3 1. computeAppliedLength : negated conditional → KILLED
2. computeAppliedLength : negated conditional → KILLED
3. computeAppliedLength : negated conditional → KILLED
 
        if (patchCommand == null || patchCommand.isEmpty() || NOOP_PATCH.equals(patchCommand)
885 2 1. computeAppliedLength : Replaced bitwise AND with OR → KILLED
2. computeAppliedLength : negated conditional → KILLED
 
                || (patchCommand.length() & 1) != 0) {
886 1 1. computeAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeAppliedLength → KILLED
 
            return sourceLength;
887 
        }
888 1 1. computeAppliedLength : negated conditional → SURVIVED
 
        if (traversalDirection == WordTraversalDirection.BACKWARD) {
889 1 1. computeAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeAppliedLength → KILLED
 
            return computeBackwardAppliedLength(sourceLength, patchCommand);
890 
        }
891 1 1. computeAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeAppliedLength → KILLED
 
        return computeForwardAppliedLength(sourceLength, patchCommand);
892 
    }
893
894 
    /**
895 
     * Computes the backward traversal output length.
896 
     *
897 
     * @param sourceLength source length
898 
     * @param patchCommand patch command
899 
     * @return produced length
900 
     */
901 
    private static int computeBackwardAppliedLength(final int sourceLength, final String patchCommand) {
902 1 1. computeBackwardAppliedLength : negated conditional → KILLED
 
        if (patchCommand.length() == 2) {
903 1 1. computeBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → KILLED
 
            return computeSingleBackwardAppliedLength(sourceLength, patchCommand.charAt(0), patchCommand.charAt(1));
904 
        }
905 1 1. computeBackwardAppliedLength : negated conditional → KILLED
 
        if (sourceLength == 0) {
906 1 1. computeBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → KILLED
 
            return computeBackwardEmptyAppliedLength(patchCommand);
907 
        }
908
909 
        int currentLength = sourceLength;
910 1 1. computeBackwardAppliedLength : Replaced integer subtraction with addition → KILLED
 
        int position = sourceLength - 1;
911 2 1. computeBackwardAppliedLength : negated conditional → KILLED
2. computeBackwardAppliedLength : changed conditional boundary → KILLED
 
        for (int patchIndex = 0, patchLength = patchCommand.length(); patchIndex < patchLength; patchIndex += 2) {
912 
            final char opcode = patchCommand.charAt(patchIndex);
913 1 1. computeBackwardAppliedLength : Replaced integer addition with subtraction → KILLED
 
            final char argument = patchCommand.charAt(patchIndex + 1);
914
915 
            switch (opcode) {
916 
                case SKIP_OPCODE:
917 
                    final int skipCount = decodeEncodedCount(argument);
918 2 1. computeBackwardAppliedLength : changed conditional boundary → SURVIVED
2. computeBackwardAppliedLength : negated conditional → SURVIVED
 
                    if (skipCount < 1) {
919 1 1. computeBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → NO_COVERAGE
 
                        return sourceLength;
920 
                    }
921 2 1. computeBackwardAppliedLength : Replaced integer subtraction with addition → SURVIVED
2. computeBackwardAppliedLength : Replaced integer addition with subtraction → SURVIVED
 
                    position = position - skipCount + 1;
922 
                    break;
923
924 
                case REPLACE_OPCODE:
925 4 1. computeBackwardAppliedLength : negated conditional → SURVIVED
2. computeBackwardAppliedLength : changed conditional boundary → SURVIVED
3. computeBackwardAppliedLength : negated conditional → SURVIVED
4. computeBackwardAppliedLength : changed conditional boundary → SURVIVED
 
                    if (position < 0 || position >= currentLength) {
926 1 1. computeBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → NO_COVERAGE
 
                        return sourceLength;
927 
                    }
928 
                    break;
929
930 
                case DELETE_OPCODE:
931 
                    final int deleteCount = decodeEncodedCount(argument);
932 2 1. computeBackwardAppliedLength : changed conditional boundary → SURVIVED
2. computeBackwardAppliedLength : negated conditional → KILLED
 
                    if (deleteCount < 1) {
933 1 1. computeBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → NO_COVERAGE
 
                        return sourceLength;
934 
                    }
935 1 1. computeBackwardAppliedLength : Replaced integer addition with subtraction → KILLED
 
                    final int deleteEndExclusive = position + 1;
936 2 1. computeBackwardAppliedLength : Replaced integer subtraction with addition → KILLED
2. computeBackwardAppliedLength : Replaced integer subtraction with addition → KILLED
 
                    position -= deleteCount - 1;
937 6 1. computeBackwardAppliedLength : changed conditional boundary → SURVIVED
2. computeBackwardAppliedLength : changed conditional boundary → SURVIVED
3. computeBackwardAppliedLength : negated conditional → KILLED
4. computeBackwardAppliedLength : changed conditional boundary → KILLED
5. computeBackwardAppliedLength : negated conditional → KILLED
6. computeBackwardAppliedLength : negated conditional → KILLED
 
                    if (position < 0 || deleteEndExclusive > currentLength || position > deleteEndExclusive) {
938 1 1. computeBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → KILLED
 
                        return sourceLength;
939 
                    }
940 2 1. computeBackwardAppliedLength : Replaced integer subtraction with addition → KILLED
2. computeBackwardAppliedLength : Replaced integer subtraction with addition → KILLED
 
                    currentLength -= deleteEndExclusive - position;
941 
                    break;
942
943 
                case INSERT_OPCODE:
944 4 1. computeBackwardAppliedLength : changed conditional boundary → SURVIVED
2. computeBackwardAppliedLength : changed conditional boundary → SURVIVED
3. computeBackwardAppliedLength : negated conditional → KILLED
4. computeBackwardAppliedLength : negated conditional → KILLED
 
                    if (position < -1 || position >= currentLength) {
945 1 1. computeBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → NO_COVERAGE
 
                        return sourceLength;
946 
                    }
947 1 1. computeBackwardAppliedLength : Changed increment from 1 to -1 → KILLED
 
                    currentLength++;
948 1 1. computeBackwardAppliedLength : Changed increment from 1 to -1 → SURVIVED
 
                    position++;
949 
                    break;
950
951 
                case NOOP_OPCODE:
952 1 1. computeBackwardAppliedLength : negated conditional → NO_COVERAGE
 
                    if (argument != NOOP_ARGUMENT) {
953 
                        throw new IllegalArgumentException(MSG_NOOP + argument);
954 
                    }
955 1 1. computeBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → NO_COVERAGE
 
                    return sourceLength;
956
957 
                default:
958 
                    throw new IllegalArgumentException(MSG_OPCODE + opcode);
959 
            }
960
961 1 1. computeBackwardAppliedLength : Changed increment from -1 to 1 → KILLED
 
            position--;
962 
        }
963 1 1. computeBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → KILLED
 
        return currentLength;
964 
    }
965
966 
    /**
967 
     * Computes the forward traversal output length.
968 
     *
969 
     * @param sourceLength source length
970 
     * @param patchCommand patch command
971 
     * @return produced length
972 
     */
973 
    private static int computeForwardAppliedLength(final int sourceLength, final String patchCommand) {
974 1 1. computeForwardAppliedLength : negated conditional → KILLED
 
        if (patchCommand.length() == 2) {
975 1 1. computeForwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → NO_COVERAGE
 
            return computeSingleForwardAppliedLength(sourceLength, patchCommand.charAt(0), patchCommand.charAt(1));
976 
        }
977 1 1. computeForwardAppliedLength : negated conditional → KILLED
 
        if (sourceLength == 0) {
978 1 1. computeForwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED
 
            return computeForwardEmptyAppliedLength(patchCommand);
979 
        }
980
981 
        int currentLength = sourceLength;
982 
        int position = 0;
983 2 1. computeForwardAppliedLength : changed conditional boundary → KILLED
2. computeForwardAppliedLength : negated conditional → KILLED
 
        for (int patchIndex = 0, patchLength = patchCommand.length(); patchIndex < patchLength; patchIndex += 2) {
984 
            final char opcode = patchCommand.charAt(patchIndex);
985 1 1. computeForwardAppliedLength : Replaced integer addition with subtraction → KILLED
 
            final char argument = patchCommand.charAt(patchIndex + 1);
986
987 
            switch (opcode) {
988 
                case SKIP_OPCODE:
989 
                    final int skipCount = decodeEncodedCount(argument);
990 2 1. computeForwardAppliedLength : changed conditional boundary → SURVIVED
2. computeForwardAppliedLength : negated conditional → KILLED
 
                    if (skipCount < 1) {
991 1 1. computeForwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → NO_COVERAGE
 
                        return sourceLength;
992 
                    }
993 2 1. computeForwardAppliedLength : Replaced integer subtraction with addition → KILLED
2. computeForwardAppliedLength : Replaced integer addition with subtraction → KILLED
 
                    position = position + skipCount - 1;
994 
                    break;
995
996 
                case REPLACE_OPCODE:
997 4 1. computeForwardAppliedLength : changed conditional boundary → SURVIVED
2. computeForwardAppliedLength : changed conditional boundary → SURVIVED
3. computeForwardAppliedLength : negated conditional → KILLED
4. computeForwardAppliedLength : negated conditional → KILLED
 
                    if (position < 0 || position >= currentLength) {
998 1 1. computeForwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED
 
                        return sourceLength;
999 
                    }
1000 
                    break;
1001
1002 
                case DELETE_OPCODE:
1003 
                    final int deleteCount = decodeEncodedCount(argument);
1004 7 1. computeForwardAppliedLength : changed conditional boundary → SURVIVED
2. computeForwardAppliedLength : Replaced integer addition with subtraction → SURVIVED
3. computeForwardAppliedLength : changed conditional boundary → SURVIVED
4. computeForwardAppliedLength : changed conditional boundary → SURVIVED
5. computeForwardAppliedLength : negated conditional → KILLED
6. computeForwardAppliedLength : negated conditional → KILLED
7. computeForwardAppliedLength : negated conditional → KILLED
 
                    if (deleteCount < 1 || position < 0 || position + deleteCount > currentLength) {
1005 1 1. computeForwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED
 
                        return sourceLength;
1006 
                    }
1007 1 1. computeForwardAppliedLength : Replaced integer subtraction with addition → KILLED
 
                    currentLength -= deleteCount;
1008 1 1. computeForwardAppliedLength : Changed increment from -1 to 1 → KILLED
 
                    position--;
1009 
                    break;
1010
1011 
                case INSERT_OPCODE:
1012 4 1. computeForwardAppliedLength : changed conditional boundary → SURVIVED
2. computeForwardAppliedLength : changed conditional boundary → SURVIVED
3. computeForwardAppliedLength : negated conditional → SURVIVED
4. computeForwardAppliedLength : negated conditional → KILLED
 
                    if (position < 0 || position > currentLength) {
1013 1 1. computeForwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED
 
                        return sourceLength;
1014 
                    }
1015 1 1. computeForwardAppliedLength : Changed increment from 1 to -1 → NO_COVERAGE
 
                    currentLength++;
1016 
                    break;
1017
1018 
                case NOOP_OPCODE:
1019 1 1. computeForwardAppliedLength : negated conditional → KILLED
 
                    if (argument != NOOP_ARGUMENT) {
1020 
                        throw new IllegalArgumentException(MSG_NOOP + argument);
1021 
                    }
1022 1 1. computeForwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED
 
                    return sourceLength;
1023
1024 
                default:
1025 
                    throw new IllegalArgumentException(MSG_OPCODE + opcode);
1026 
            }
1027
1028 1 1. computeForwardAppliedLength : Changed increment from 1 to -1 → KILLED
 
            position++;
1029 
        }
1030 1 1. computeForwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED
 
        return currentLength;
1031 
    }
1032
1033 
    /**
1034 
     * Computes a single backward instruction output length.
1035 
     *
1036 
     * @param sourceLength source length
1037 
     * @param opcode       opcode
1038 
     * @param argument     argument
1039 
     * @return produced length
1040 
     */
1041 
    private static int computeSingleBackwardAppliedLength(final int sourceLength, final char opcode,
1042 
            final char argument) {
1043 
        final int encodedValue;
1044 
        switch (opcode) {
1045 
            case DELETE_OPCODE:
1046 
                encodedValue = decodeEncodedCount(argument);
1047 6 1. computeSingleBackwardAppliedLength : changed conditional boundary → SURVIVED
2. computeSingleBackwardAppliedLength : changed conditional boundary → SURVIVED
3. computeSingleBackwardAppliedLength : negated conditional → KILLED
4. computeSingleBackwardAppliedLength : negated conditional → KILLED
5. computeSingleBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeSingleBackwardAppliedLength → KILLED
6. computeSingleBackwardAppliedLength : Replaced integer subtraction with addition → KILLED
 
                return encodedValue < 1 || encodedValue > sourceLength ? sourceLength : sourceLength - encodedValue;
1048 
            case INSERT_OPCODE:
1049 2 1. computeSingleBackwardAppliedLength : Replaced integer addition with subtraction → KILLED
2. computeSingleBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeSingleBackwardAppliedLength → KILLED
 
                return sourceLength + 1;
1050 
            case REPLACE_OPCODE:
1051 
            case SKIP_OPCODE:
1052 1 1. computeSingleBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeSingleBackwardAppliedLength → KILLED
 
                return sourceLength;
1053 
            case NOOP_OPCODE:
1054 1 1. computeSingleBackwardAppliedLength : negated conditional → SURVIVED
 
                if (argument != NOOP_ARGUMENT) {
1055 
                    throw new IllegalArgumentException(MSG_NOOP + argument);
1056 
                }
1057 1 1. computeSingleBackwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeSingleBackwardAppliedLength → NO_COVERAGE
 
                return sourceLength;
1058 
            default:
1059 
                throw new IllegalArgumentException(MSG_OPCODE + opcode);
1060 
        }
1061 
    }
1062
1063 
    /**
1064 
     * Computes a single forward instruction output length.
1065 
     *
1066 
     * @param sourceLength source length
1067 
     * @param opcode       opcode
1068 
     * @param argument     argument
1069 
     * @return produced length
1070 
     */
1071 
    private static int computeSingleForwardAppliedLength(final int sourceLength, final char opcode,
1072 
            final char argument) {
1073 1 1. computeSingleForwardAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeSingleForwardAppliedLength → NO_COVERAGE
 
        return computeSingleBackwardAppliedLength(sourceLength, opcode, argument);
1074 
    }
1075
1076 
    /**
1077 
     * Computes output length for an empty source in backward traversal.
1078 
     *
1079 
     * @param patchCommand patch command
1080 
     * @return produced length
1081 
     */
1082 
    private static int computeBackwardEmptyAppliedLength(final String patchCommand) {
1083 
        int currentLength = 0;
1084 2 1. computeBackwardEmptyAppliedLength : negated conditional → KILLED
2. computeBackwardEmptyAppliedLength : changed conditional boundary → KILLED
 
        for (int patchIndex = 0, patchLength = patchCommand.length(); patchIndex < patchLength; patchIndex += 2) {
1085 
            final char opcode = patchCommand.charAt(patchIndex);
1086 1 1. computeBackwardEmptyAppliedLength : Replaced integer addition with subtraction → KILLED
 
            final char argument = patchCommand.charAt(patchIndex + 1);
1087 
            switch (opcode) {
1088 
                case INSERT_OPCODE:
1089 1 1. computeBackwardEmptyAppliedLength : Changed increment from 1 to -1 → KILLED
 
                    currentLength++;
1090 
                    break;
1091 
                case SKIP_OPCODE:
1092 
                case REPLACE_OPCODE:
1093 
                case DELETE_OPCODE:
1094 
                    return 0;
1095 
                case NOOP_OPCODE:
1096 1 1. computeBackwardEmptyAppliedLength : negated conditional → KILLED
 
                    if (argument != NOOP_ARGUMENT) {
1097 
                        throw new IllegalArgumentException(MSG_NOOP + argument);
1098 
                    }
1099 
                    return 0;
1100 
                default:
1101 
                    throw new IllegalArgumentException(MSG_OPCODE + opcode);
1102 
            }
1103 
        }
1104 1 1. computeBackwardEmptyAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardEmptyAppliedLength → KILLED
 
        return currentLength;
1105 
    }
1106
1107 
    /**
1108 
     * Computes output length for an empty source in forward traversal.
1109 
     *
1110 
     * @param patchCommand patch command
1111 
     * @return produced length
1112 
     */
1113 
    private static int computeForwardEmptyAppliedLength(final String patchCommand) {
1114 1 1. computeForwardEmptyAppliedLength : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardEmptyAppliedLength → KILLED
 
        return computeBackwardEmptyAppliedLength(patchCommand);
1115 
    }
1116
1117 
    /**
1118 
     * Applies an already-sized patch into caller output.
1119 
     *
1120 
     * @param source             source text
1121 
     * @param sourceOffset       source offset
1122 
     * @param sourceLength       source length
1123 
     * @param patchCommand       patch command
1124 
     * @param traversalDirection traversal direction
1125 
     * @param output             output storage
1126 
     * @param outputOffset       output offset
1127 
     * @param producedLength     already-validated produced length
1128 
     */
1129 
    private static void applyToOutput(final CharSequence source, final int sourceOffset, final int sourceLength,
1130 
            final String patchCommand, final WordTraversalDirection traversalDirection, final char[] output,
1131 
            final int outputOffset, final int producedLength) {
1132 1 1. applyToOutput : negated conditional → KILLED
 
        if (isPreservedSource(sourceLength, producedLength, patchCommand, traversalDirection)) {
1133 1 1. applyToOutput : removed call to org/egothor/stemmer/PatchCommandEncoder::copySource → KILLED
 
            copySource(source, sourceOffset, sourceLength, output, outputOffset);
1134 
            return;
1135 
        }
1136
1137 2 1. applyToOutput : changed conditional boundary → SURVIVED
2. applyToOutput : negated conditional → KILLED
 
        if (sourceLength > 0) {
1138 1 1. applyToOutput : removed call to org/egothor/stemmer/PatchCommandEncoder::copySource → KILLED
 
            copySource(source, sourceOffset, sourceLength, output, outputOffset);
1139 
        }
1140
1141 1 1. applyToOutput : negated conditional → KILLED
 
        if (traversalDirection == WordTraversalDirection.BACKWARD) {
1142 1 1. applyToOutput : removed call to org/egothor/stemmer/PatchCommandEncoder::applyBackwardToOutput → KILLED
 
            applyBackwardToOutput(sourceLength, patchCommand, output, outputOffset);
1143 
        } else {
1144 1 1. applyToOutput : removed call to org/egothor/stemmer/PatchCommandEncoder::applyForwardToOutput → KILLED
 
            applyForwardToOutput(sourceLength, patchCommand, output, outputOffset);
1145 
        }
1146 
    }
1147
1148 
    /**
1149 
     * Applies an already-sized patch into caller output.
1150 
     *
1151 
     * @param source             source storage
1152 
     * @param sourceOffset       source offset
1153 
     * @param sourceLength       source length
1154 
     * @param patchCommand       patch command
1155 
     * @param traversalDirection traversal direction
1156 
     * @param output             output storage
1157 
     * @param outputOffset       output offset
1158 
     * @param producedLength     already-validated produced length
1159 
     */
1160 
    private static void applyToOutput(final char[] source, final int sourceOffset, final int sourceLength,
1161 
            final String patchCommand, final WordTraversalDirection traversalDirection, final char[] output,
1162 
            final int outputOffset, final int producedLength) {
1163 1 1. applyToOutput : negated conditional → SURVIVED
 
        if (isPreservedSource(sourceLength, producedLength, patchCommand, traversalDirection)) {
1164 1 1. applyToOutput : removed call to java/lang/System::arraycopy → NO_COVERAGE
 
            System.arraycopy(source, sourceOffset, output, outputOffset, sourceLength);
1165 
            return;
1166 
        }
1167
1168 2 1. applyToOutput : changed conditional boundary → SURVIVED
2. applyToOutput : negated conditional → KILLED
 
        if (sourceLength > 0) {
1169 1 1. applyToOutput : removed call to java/lang/System::arraycopy → KILLED
 
            System.arraycopy(source, sourceOffset, output, outputOffset, sourceLength);
1170 
        }
1171
1172 1 1. applyToOutput : negated conditional → KILLED
 
        if (traversalDirection == WordTraversalDirection.BACKWARD) {
1173 1 1. applyToOutput : removed call to org/egothor/stemmer/PatchCommandEncoder::applyBackwardToOutput → SURVIVED
 
            applyBackwardToOutput(sourceLength, patchCommand, output, outputOffset);
1174 
        } else {
1175 1 1. applyToOutput : removed call to org/egothor/stemmer/PatchCommandEncoder::applyForwardToOutput → NO_COVERAGE
 
            applyForwardToOutput(sourceLength, patchCommand, output, outputOffset);
1176 
        }
1177 
    }
1178
1179 
    /**
1180 
     * Determines whether the output is exactly the original source.
1181 
     *
1182 
     * @param sourceLength       source length
1183 
     * @param producedLength     produced length
1184 
     * @param patchCommand       patch command
1185 
     * @param traversalDirection traversal direction
1186 
     * @return {@code true} if copying the source is sufficient
1187 
     */
1188 
    private static boolean isPreservedSource(final int sourceLength, final int producedLength,
1189 
            final String patchCommand, final WordTraversalDirection traversalDirection) {
1190 2 1. isPreservedSource : negated conditional → KILLED
2. isPreservedSource : replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isPreservedSource → KILLED
 
        return producedLength == sourceLength
1191 1 1. isPreservedSource : negated conditional → KILLED
 
                && isKnownPreserveOnlyPatch(sourceLength, patchCommand, traversalDirection);
1192 
    }
1193
1194 
    /**
1195 
     * Returns whether equal length also means no mutation is needed.
1196 
     *
1197 
     * @param sourceLength       source length
1198 
     * @param patchCommand       patch command
1199 
     * @param traversalDirection traversal direction
1200 
     * @return {@code true} when the command preserves source content
1201 
     */
1202 
    private static boolean isKnownPreserveOnlyPatch(final int sourceLength, final String patchCommand,
1203 
            final WordTraversalDirection traversalDirection) {
1204 3 1. isKnownPreserveOnlyPatch : negated conditional → KILLED
2. isKnownPreserveOnlyPatch : negated conditional → KILLED
3. isKnownPreserveOnlyPatch : negated conditional → KILLED
 
        if (patchCommand == null || patchCommand.isEmpty() || NOOP_PATCH.equals(patchCommand)
1205 2 1. isKnownPreserveOnlyPatch : negated conditional → KILLED
2. isKnownPreserveOnlyPatch : Replaced bitwise AND with OR → KILLED
 
                || (patchCommand.length() & 1) != 0) {
1206 1 1. isKnownPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → KILLED
 
            return true;
1207 
        }
1208 1 1. isKnownPreserveOnlyPatch : negated conditional → KILLED
 
        if (patchCommand.length() == 2) {
1209 2 1. isKnownPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → KILLED
2. isKnownPreserveOnlyPatch : replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → KILLED
 
            return isSingleInstructionPreserveOnly(sourceLength, patchCommand.charAt(0), patchCommand.charAt(1));
1210 
        }
1211 1 1. isKnownPreserveOnlyPatch : negated conditional → KILLED
 
        if (sourceLength == 0) {
1212 2 1. isKnownPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → SURVIVED
2. isKnownPreserveOnlyPatch : replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → SURVIVED
 
            return hasEmptySourcePreserveOnlyPatch(patchCommand);
1213 
        }
1214 3 1. isKnownPreserveOnlyPatch : negated conditional → SURVIVED
2. isKnownPreserveOnlyPatch : replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → KILLED
3. isKnownPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → KILLED
 
        return traversalDirection == WordTraversalDirection.BACKWARD
1215 
                ? hasBackwardPreserveOnlyPatch(sourceLength, patchCommand)
1216 
                : hasForwardPreserveOnlyPatch(sourceLength, patchCommand);
1217 
    }
1218
1219 
    /**
1220 
     * Tests whether a single instruction preserves the source content.
1221 
     *
1222 
     * @param sourceLength source length
1223 
     * @param opcode       opcode
1224 
     * @param argument     argument
1225 
     * @return {@code true} when no mutation should be applied
1226 
     */
1227 
    private static boolean isSingleInstructionPreserveOnly(final int sourceLength, final char opcode,
1228 
            final char argument) {
1229 
        switch (opcode) {
1230 
            case DELETE_OPCODE:
1231 
                final int encodedValue = decodeEncodedCount(argument);
1232 5 1. isSingleInstructionPreserveOnly : replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isSingleInstructionPreserveOnly → SURVIVED
2. isSingleInstructionPreserveOnly : changed conditional boundary → SURVIVED
3. isSingleInstructionPreserveOnly : changed conditional boundary → SURVIVED
4. isSingleInstructionPreserveOnly : negated conditional → KILLED
5. isSingleInstructionPreserveOnly : negated conditional → KILLED
 
                return encodedValue < 1 || encodedValue > sourceLength;
1233 
            case INSERT_OPCODE:
1234 1 1. isSingleInstructionPreserveOnly : replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isSingleInstructionPreserveOnly → NO_COVERAGE
 
                return false;
1235 
            case REPLACE_OPCODE:
1236 2 1. isSingleInstructionPreserveOnly : negated conditional → KILLED
2. isSingleInstructionPreserveOnly : replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isSingleInstructionPreserveOnly → KILLED
 
                return sourceLength == 0;
1237 
            case SKIP_OPCODE:
1238 1 1. isSingleInstructionPreserveOnly : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isSingleInstructionPreserveOnly → SURVIVED
 
                return true;
1239 
            case NOOP_OPCODE:
1240 1 1. isSingleInstructionPreserveOnly : negated conditional → NO_COVERAGE
 
                if (argument != NOOP_ARGUMENT) {
1241 
                    throw new IllegalArgumentException(MSG_NOOP + argument);
1242 
                }
1243 1 1. isSingleInstructionPreserveOnly : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isSingleInstructionPreserveOnly → NO_COVERAGE
 
                return true;
1244 
            default:
1245 
                throw new IllegalArgumentException(MSG_OPCODE + opcode);
1246 
        }
1247 
    }
1248
1249 
    /**
1250 
     * Tests whether an empty-source patch preserves the source.
1251 
     *
1252 
     * @param patchCommand patch command
1253 
     * @return {@code true} when no mutation should be applied
1254 
     */
1255 
    private static boolean hasEmptySourcePreserveOnlyPatch(final String patchCommand) {
1256 2 1. hasEmptySourcePreserveOnlyPatch : changed conditional boundary → SURVIVED
2. hasEmptySourcePreserveOnlyPatch : negated conditional → SURVIVED
 
        for (int patchIndex = 0, patchLength = patchCommand.length(); patchIndex < patchLength; patchIndex += 2) {
1257 
            final char opcode = patchCommand.charAt(patchIndex);
1258 1 1. hasEmptySourcePreserveOnlyPatch : Replaced integer addition with subtraction → KILLED
 
            final char argument = patchCommand.charAt(patchIndex + 1);
1259 
            switch (opcode) {
1260 
                case INSERT_OPCODE:
1261 
                    break;
1262 
                case SKIP_OPCODE:
1263 
                case REPLACE_OPCODE:
1264 
                case DELETE_OPCODE:
1265 1 1. hasEmptySourcePreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasEmptySourcePreserveOnlyPatch → SURVIVED
 
                    return true;
1266 
                case NOOP_OPCODE:
1267 1 1. hasEmptySourcePreserveOnlyPatch : negated conditional → KILLED
 
                    if (argument != NOOP_ARGUMENT) {
1268 
                        throw new IllegalArgumentException(MSG_NOOP + argument);
1269 
                    }
1270 1 1. hasEmptySourcePreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasEmptySourcePreserveOnlyPatch → SURVIVED
 
                    return true;
1271 
                default:
1272 
                    throw new IllegalArgumentException(MSG_OPCODE + opcode);
1273 
            }
1274 
        }
1275 1 1. hasEmptySourcePreserveOnlyPatch : replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::hasEmptySourcePreserveOnlyPatch → NO_COVERAGE
 
        return false;
1276 
    }
1277
1278 
    /**
1279 
     * Tests whether a backward patch preserves the source because it is malformed
1280 
     * or a NOOP.
1281 
     *
1282 
     * @param sourceLength source length
1283 
     * @param patchCommand patch command
1284 
     * @return {@code true} when no mutation should be applied
1285 
     */
1286 
    private static boolean hasBackwardPreserveOnlyPatch(final int sourceLength, final String patchCommand) {
1287 
        int currentLength = sourceLength;
1288 1 1. hasBackwardPreserveOnlyPatch : Replaced integer subtraction with addition → SURVIVED
 
        int position = sourceLength - 1;
1289 2 1. hasBackwardPreserveOnlyPatch : changed conditional boundary → KILLED
2. hasBackwardPreserveOnlyPatch : negated conditional → KILLED
 
        for (int patchIndex = 0, patchLength = patchCommand.length(); patchIndex < patchLength; patchIndex += 2) {
1290 
            final char opcode = patchCommand.charAt(patchIndex);
1291 1 1. hasBackwardPreserveOnlyPatch : Replaced integer addition with subtraction → KILLED
 
            final char argument = patchCommand.charAt(patchIndex + 1);
1292 
            switch (opcode) {
1293 
                case SKIP_OPCODE:
1294 
                    final int skipCount = decodeEncodedCount(argument);
1295 2 1. hasBackwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
2. hasBackwardPreserveOnlyPatch : negated conditional → KILLED
 
                    if (skipCount < 1) {
1296 1 1. hasBackwardPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → NO_COVERAGE
 
                        return true;
1297 
                    }
1298 2 1. hasBackwardPreserveOnlyPatch : Replaced integer addition with subtraction → KILLED
2. hasBackwardPreserveOnlyPatch : Replaced integer subtraction with addition → KILLED
 
                    position = position - skipCount + 1;
1299 
                    break;
1300 
                case REPLACE_OPCODE:
1301 4 1. hasBackwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
2. hasBackwardPreserveOnlyPatch : changed conditional boundary → KILLED
3. hasBackwardPreserveOnlyPatch : negated conditional → KILLED
4. hasBackwardPreserveOnlyPatch : negated conditional → KILLED
 
                    if (position < 0 || position >= currentLength) {
1302 1 1. hasBackwardPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → NO_COVERAGE
 
                        return true;
1303 
                    }
1304 
                    break;
1305 
                case DELETE_OPCODE:
1306 
                    final int deleteCount = decodeEncodedCount(argument);
1307 2 1. hasBackwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
2. hasBackwardPreserveOnlyPatch : negated conditional → SURVIVED
 
                    if (deleteCount < 1) {
1308 1 1. hasBackwardPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → NO_COVERAGE
 
                        return true;
1309 
                    }
1310 1 1. hasBackwardPreserveOnlyPatch : Replaced integer addition with subtraction → SURVIVED
 
                    final int deleteEndExclusive = position + 1;
1311 2 1. hasBackwardPreserveOnlyPatch : Replaced integer subtraction with addition → SURVIVED
2. hasBackwardPreserveOnlyPatch : Replaced integer subtraction with addition → SURVIVED
 
                    position -= deleteCount - 1;
1312 6 1. hasBackwardPreserveOnlyPatch : negated conditional → NO_COVERAGE
2. hasBackwardPreserveOnlyPatch : negated conditional → NO_COVERAGE
3. hasBackwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
4. hasBackwardPreserveOnlyPatch : changed conditional boundary → NO_COVERAGE
5. hasBackwardPreserveOnlyPatch : changed conditional boundary → NO_COVERAGE
6. hasBackwardPreserveOnlyPatch : negated conditional → KILLED
 
                    if (position < 0 || deleteEndExclusive > currentLength || position > deleteEndExclusive) {
1313 1 1. hasBackwardPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → KILLED
 
                        return true;
1314 
                    }
1315 2 1. hasBackwardPreserveOnlyPatch : Replaced integer subtraction with addition → NO_COVERAGE
2. hasBackwardPreserveOnlyPatch : Replaced integer subtraction with addition → NO_COVERAGE
 
                    currentLength -= deleteEndExclusive - position;
1316 
                    break;
1317 
                case INSERT_OPCODE:
1318 4 1. hasBackwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
2. hasBackwardPreserveOnlyPatch : negated conditional → SURVIVED
3. hasBackwardPreserveOnlyPatch : negated conditional → SURVIVED
4. hasBackwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
 
                    if (position < -1 || position >= currentLength) {
1319 1 1. hasBackwardPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → NO_COVERAGE
 
                        return true;
1320 
                    }
1321 1 1. hasBackwardPreserveOnlyPatch : Changed increment from 1 to -1 → SURVIVED
 
                    currentLength++;
1322 1 1. hasBackwardPreserveOnlyPatch : Changed increment from 1 to -1 → SURVIVED
 
                    position++;
1323 
                    break;
1324 
                case NOOP_OPCODE:
1325 1 1. hasBackwardPreserveOnlyPatch : negated conditional → NO_COVERAGE
 
                    if (argument != NOOP_ARGUMENT) {
1326 
                        throw new IllegalArgumentException(MSG_NOOP + argument);
1327 
                    }
1328 1 1. hasBackwardPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → NO_COVERAGE
 
                    return true;
1329 
                default:
1330 
                    throw new IllegalArgumentException(MSG_OPCODE + opcode);
1331 
            }
1332 1 1. hasBackwardPreserveOnlyPatch : Changed increment from -1 to 1 → SURVIVED
 
            position--;
1333 
        }
1334 1 1. hasBackwardPreserveOnlyPatch : replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → KILLED
 
        return false;
1335 
    }
1336
1337 
    /**
1338 
     * Tests whether a forward patch preserves the source because it is malformed or
1339 
     * a NOOP.
1340 
     *
1341 
     * @param sourceLength source length
1342 
     * @param patchCommand patch command
1343 
     * @return {@code true} when no mutation should be applied
1344 
     */
1345 
    private static boolean hasForwardPreserveOnlyPatch(final int sourceLength, final String patchCommand) {
1346 
        int currentLength = sourceLength;
1347 
        int position = 0;
1348 2 1. hasForwardPreserveOnlyPatch : changed conditional boundary → KILLED
2. hasForwardPreserveOnlyPatch : negated conditional → KILLED
 
        for (int patchIndex = 0, patchLength = patchCommand.length(); patchIndex < patchLength; patchIndex += 2) {
1349 
            final char opcode = patchCommand.charAt(patchIndex);
1350 1 1. hasForwardPreserveOnlyPatch : Replaced integer addition with subtraction → KILLED
 
            final char argument = patchCommand.charAt(patchIndex + 1);
1351 
            switch (opcode) {
1352 
                case SKIP_OPCODE:
1353 
                    final int skipCount = decodeEncodedCount(argument);
1354 2 1. hasForwardPreserveOnlyPatch : changed conditional boundary → KILLED
2. hasForwardPreserveOnlyPatch : negated conditional → KILLED
 
                    if (skipCount < 1) {
1355 1 1. hasForwardPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → NO_COVERAGE
 
                        return true;
1356 
                    }
1357 2 1. hasForwardPreserveOnlyPatch : Replaced integer subtraction with addition → SURVIVED
2. hasForwardPreserveOnlyPatch : Replaced integer addition with subtraction → KILLED
 
                    position = position + skipCount - 1;
1358 
                    break;
1359 
                case REPLACE_OPCODE:
1360 4 1. hasForwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
2. hasForwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
3. hasForwardPreserveOnlyPatch : negated conditional → KILLED
4. hasForwardPreserveOnlyPatch : negated conditional → KILLED
 
                    if (position < 0 || position >= currentLength) {
1361 1 1. hasForwardPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → SURVIVED
 
                        return true;
1362 
                    }
1363 
                    break;
1364 
                case DELETE_OPCODE:
1365 
                    final int deleteCount = decodeEncodedCount(argument);
1366 7 1. hasForwardPreserveOnlyPatch : Replaced integer addition with subtraction → SURVIVED
2. hasForwardPreserveOnlyPatch : negated conditional → SURVIVED
3. hasForwardPreserveOnlyPatch : negated conditional → SURVIVED
4. hasForwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
5. hasForwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
6. hasForwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
7. hasForwardPreserveOnlyPatch : negated conditional → SURVIVED
 
                    if (deleteCount < 1 || position < 0 || position + deleteCount > currentLength) {
1367 1 1. hasForwardPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → KILLED
 
                        return true;
1368 
                    }
1369 1 1. hasForwardPreserveOnlyPatch : Replaced integer subtraction with addition → NO_COVERAGE
 
                    currentLength -= deleteCount;
1370 1 1. hasForwardPreserveOnlyPatch : Changed increment from -1 to 1 → NO_COVERAGE
 
                    position--;
1371 
                    break;
1372 
                case INSERT_OPCODE:
1373 4 1. hasForwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
2. hasForwardPreserveOnlyPatch : changed conditional boundary → SURVIVED
3. hasForwardPreserveOnlyPatch : negated conditional → SURVIVED
4. hasForwardPreserveOnlyPatch : negated conditional → KILLED
 
                    if (position < 0 || position > currentLength) {
1374 1 1. hasForwardPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → KILLED
 
                        return true;
1375 
                    }
1376 1 1. hasForwardPreserveOnlyPatch : Changed increment from 1 to -1 → NO_COVERAGE
 
                    currentLength++;
1377 
                    break;
1378 
                case NOOP_OPCODE:
1379 1 1. hasForwardPreserveOnlyPatch : negated conditional → KILLED
 
                    if (argument != NOOP_ARGUMENT) {
1380 
                        throw new IllegalArgumentException(MSG_NOOP + argument);
1381 
                    }
1382 1 1. hasForwardPreserveOnlyPatch : replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → SURVIVED
 
                    return true;
1383 
                default:
1384 
                    throw new IllegalArgumentException(MSG_OPCODE + opcode);
1385 
            }
1386 1 1. hasForwardPreserveOnlyPatch : Changed increment from 1 to -1 → KILLED
 
            position++;
1387 
        }
1388 1 1. hasForwardPreserveOnlyPatch : replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → KILLED
 
        return false;
1389 
    }
1390
1391 
    /**
1392 
     * Copies source characters from a sequence.
1393 
     *
1394 
     * @param source       source text
1395 
     * @param sourceOffset source offset
1396 
     * @param sourceLength source length
1397 
     * @param output       output storage
1398 
     * @param outputOffset output offset
1399 
     */
1400 
    private static void copySource(final CharSequence source, final int sourceOffset, final int sourceLength,
1401 
            final char[] output, final int outputOffset) {
1402 2 1. copySource : changed conditional boundary → KILLED
2. copySource : negated conditional → KILLED
 
        for (int index = 0; index < sourceLength; index++) {
1403 2 1. copySource : Replaced integer addition with subtraction → KILLED
2. copySource : Replaced integer addition with subtraction → KILLED
 
            output[outputOffset + index] = source.charAt(sourceOffset + index);
1404 
        }
1405 
    }
1406
1407 
    /**
1408 
     * Applies a backward patch after validation.
1409 
     *
1410 
     * @param sourceLength source length
1411 
     * @param patchCommand patch command
1412 
     * @param output       output storage initialized with source
1413 
     * @param outputOffset output offset
1414 
     */
1415 
    private static void applyBackwardToOutput(final int sourceLength, final String patchCommand, final char[] output,
1416 
            final int outputOffset) {
1417 1 1. applyBackwardToOutput : negated conditional → KILLED
 
        if (sourceLength == 0) {
1418 1 1. applyBackwardToOutput : removed call to org/egothor/stemmer/PatchCommandEncoder::applyBackwardEmptyToOutput → KILLED
 
            applyBackwardEmptyToOutput(patchCommand, output, outputOffset);
1419 
            return;
1420 
        }
1421
1422 
        int currentLength = sourceLength;
1423 1 1. applyBackwardToOutput : Replaced integer subtraction with addition → KILLED
 
        int position = sourceLength - 1;
1424 2 1. applyBackwardToOutput : negated conditional → KILLED
2. applyBackwardToOutput : changed conditional boundary → KILLED
 
        for (int patchIndex = 0, patchLength = patchCommand.length(); patchIndex < patchLength; patchIndex += 2) {
1425 
            final char opcode = patchCommand.charAt(patchIndex);
1426 1 1. applyBackwardToOutput : Replaced integer addition with subtraction → KILLED
 
            final char argument = patchCommand.charAt(patchIndex + 1);
1427
1428 
            switch (opcode) {
1429 
                case SKIP_OPCODE:
1430 2 1. applyBackwardToOutput : Replaced integer subtraction with addition → KILLED
2. applyBackwardToOutput : Replaced integer addition with subtraction → KILLED
 
                    position = position - decodeEncodedCount(argument) + 1;
1431 
                    break;
1432
1433 
                case REPLACE_OPCODE:
1434 1 1. applyBackwardToOutput : Replaced integer addition with subtraction → KILLED
 
                    output[outputOffset + position] = argument;
1435 
                    break;
1436
1437 
                case DELETE_OPCODE:
1438 1 1. applyBackwardToOutput : Replaced integer addition with subtraction → SURVIVED
 
                    final int deleteEndExclusive = position + 1;
1439 2 1. applyBackwardToOutput : Replaced integer subtraction with addition → KILLED
2. applyBackwardToOutput : Replaced integer subtraction with addition → KILLED
 
                    position -= decodeEncodedCount(argument) - 1;
1440 4 1. applyBackwardToOutput : removed call to java/lang/System::arraycopy → SURVIVED
2. applyBackwardToOutput : Replaced integer addition with subtraction → KILLED
3. applyBackwardToOutput : Replaced integer addition with subtraction → KILLED
4. applyBackwardToOutput : Replaced integer subtraction with addition → KILLED
 
                    System.arraycopy(output, outputOffset + deleteEndExclusive, output, outputOffset + position,
1441 
                            currentLength - deleteEndExclusive);
1442 2 1. applyBackwardToOutput : Replaced integer subtraction with addition → SURVIVED
2. applyBackwardToOutput : Replaced integer subtraction with addition → KILLED
 
                    currentLength -= deleteEndExclusive - position;
1443 
                    break;
1444
1445 
                case INSERT_OPCODE:
1446 1 1. applyBackwardToOutput : Replaced integer addition with subtraction → KILLED
 
                    final int insertIndex = position + 1;
1447 5 1. applyBackwardToOutput : removed call to java/lang/System::arraycopy → SURVIVED
2. applyBackwardToOutput : Replaced integer addition with subtraction → SURVIVED
3. applyBackwardToOutput : Replaced integer addition with subtraction → SURVIVED
4. applyBackwardToOutput : Replaced integer subtraction with addition → SURVIVED
5. applyBackwardToOutput : Replaced integer addition with subtraction → KILLED
 
                    System.arraycopy(output, outputOffset + insertIndex, output, outputOffset + insertIndex + 1,
1448 
                            currentLength - insertIndex);
1449 1 1. applyBackwardToOutput : Replaced integer addition with subtraction → KILLED
 
                    output[outputOffset + insertIndex] = argument;
1450 1 1. applyBackwardToOutput : Changed increment from 1 to -1 → SURVIVED
 
                    currentLength++;
1451 1 1. applyBackwardToOutput : Changed increment from 1 to -1 → SURVIVED
 
                    position++;
1452 
                    break;
1453
1454 
                case NOOP_OPCODE:
1455 
                    return;
1456
1457 
                default:
1458 
                    throw new AssertionError("Patch command was not validated.");
1459 
            }
1460
1461 1 1. applyBackwardToOutput : Changed increment from -1 to 1 → KILLED
 
            position--;
1462 
        }
1463 
    }
1464
1465 
    /**
1466 
     * Applies a forward patch after validation.
1467 
     *
1468 
     * @param sourceLength source length
1469 
     * @param patchCommand patch command
1470 
     * @param output       output storage initialized with source
1471 
     * @param outputOffset output offset
1472 
     */
1473 
    private static void applyForwardToOutput(final int sourceLength, final String patchCommand, final char[] output,
1474 
            final int outputOffset) {
1475 1 1. applyForwardToOutput : negated conditional → KILLED
 
        if (sourceLength == 0) {
1476 1 1. applyForwardToOutput : removed call to org/egothor/stemmer/PatchCommandEncoder::applyForwardEmptyToOutput → KILLED
 
            applyForwardEmptyToOutput(patchCommand, output, outputOffset);
1477 
            return;
1478 
        }
1479
1480 
        int currentLength = sourceLength;
1481 
        int position = 0;
1482 2 1. applyForwardToOutput : negated conditional → KILLED
2. applyForwardToOutput : changed conditional boundary → KILLED
 
        for (int patchIndex = 0, patchLength = patchCommand.length(); patchIndex < patchLength; patchIndex += 2) {
1483 
            final char opcode = patchCommand.charAt(patchIndex);
1484 1 1. applyForwardToOutput : Replaced integer addition with subtraction → KILLED
 
            final char argument = patchCommand.charAt(patchIndex + 1);
1485
1486 
            switch (opcode) {
1487 
                case SKIP_OPCODE:
1488 2 1. applyForwardToOutput : Replaced integer addition with subtraction → KILLED
2. applyForwardToOutput : Replaced integer subtraction with addition → KILLED
 
                    position = position + decodeEncodedCount(argument) - 1;
1489 
                    break;
1490
1491 
                case REPLACE_OPCODE:
1492 1 1. applyForwardToOutput : Replaced integer addition with subtraction → KILLED
 
                    output[outputOffset + position] = argument;
1493 
                    break;
1494
1495 
                case DELETE_OPCODE:
1496 
                    final int deleteCount = decodeEncodedCount(argument);
1497 6 1. applyForwardToOutput : Replaced integer addition with subtraction → SURVIVED
2. applyForwardToOutput : removed call to java/lang/System::arraycopy → SURVIVED
3. applyForwardToOutput : Replaced integer subtraction with addition → SURVIVED
4. applyForwardToOutput : Replaced integer subtraction with addition → SURVIVED
5. applyForwardToOutput : Replaced integer addition with subtraction → KILLED
6. applyForwardToOutput : Replaced integer addition with subtraction → KILLED
 
                    System.arraycopy(output, outputOffset + position + deleteCount, output, outputOffset + position,
1498 
                            currentLength - position - deleteCount);
1499 1 1. applyForwardToOutput : Replaced integer subtraction with addition → SURVIVED
 
                    currentLength -= deleteCount;
1500 1 1. applyForwardToOutput : Changed increment from -1 to 1 → KILLED
 
                    position--;
1501 
                    break;
1502
1503 
                case INSERT_OPCODE:
1504 5 1. applyForwardToOutput : Replaced integer addition with subtraction → NO_COVERAGE
2. applyForwardToOutput : Replaced integer addition with subtraction → NO_COVERAGE
3. applyForwardToOutput : Replaced integer addition with subtraction → NO_COVERAGE
4. applyForwardToOutput : Replaced integer subtraction with addition → NO_COVERAGE
5. applyForwardToOutput : removed call to java/lang/System::arraycopy → NO_COVERAGE
 
                    System.arraycopy(output, outputOffset + position, output, outputOffset + position + 1,
1505 
                            currentLength - position);
1506 1 1. applyForwardToOutput : Replaced integer addition with subtraction → NO_COVERAGE
 
                    output[outputOffset + position] = argument;
1507 1 1. applyForwardToOutput : Changed increment from 1 to -1 → NO_COVERAGE
 
                    currentLength++;
1508 
                    break;
1509
1510 
                case NOOP_OPCODE:
1511 
                    return;
1512
1513 
                default:
1514 
                    throw new AssertionError("Patch command was not validated.");
1515 
            }
1516
1517 1 1. applyForwardToOutput : Changed increment from 1 to -1 → KILLED
 
            position++;
1518 
        }
1519 
    }
1520
1521 
    /**
1522 
     * Applies an empty-source backward patch after validation.
1523 
     *
1524 
     * @param patchCommand patch command
1525 
     * @param output       output storage
1526 
     * @param outputOffset output offset
1527 
     */
1528 
    private static void applyBackwardEmptyToOutput(final String patchCommand, final char[] output,
1529 
            final int outputOffset) {
1530 
        int currentLength = 0;
1531 2 1. applyBackwardEmptyToOutput : negated conditional → KILLED
2. applyBackwardEmptyToOutput : changed conditional boundary → KILLED
 
        for (int patchIndex = 0, patchLength = patchCommand.length(); patchIndex < patchLength; patchIndex += 2) {
1532 1 1. applyBackwardEmptyToOutput : Replaced integer addition with subtraction → KILLED
 
            final char argument = patchCommand.charAt(patchIndex + 1);
1533 2 1. applyBackwardEmptyToOutput : Replaced integer addition with subtraction → KILLED
2. applyBackwardEmptyToOutput : removed call to java/lang/System::arraycopy → KILLED
 
            System.arraycopy(output, outputOffset, output, outputOffset + 1, currentLength);
1534 
            output[outputOffset] = argument;
1535 1 1. applyBackwardEmptyToOutput : Changed increment from 1 to -1 → KILLED
 
            currentLength++;
1536 
        }
1537 
    }
1538
1539 
    /**
1540 
     * Applies an empty-source forward patch after validation.
1541 
     *
1542 
     * @param patchCommand patch command
1543 
     * @param output       output storage
1544 
     * @param outputOffset output offset
1545 
     */
1546 
    private static void applyForwardEmptyToOutput(final String patchCommand, final char[] output,
1547 
            final int outputOffset) {
1548 
        int currentLength = 0;
1549 2 1. applyForwardEmptyToOutput : changed conditional boundary → KILLED
2. applyForwardEmptyToOutput : negated conditional → KILLED
 
        for (int patchIndex = 0, patchLength = patchCommand.length(); patchIndex < patchLength; patchIndex += 2) {
1550 2 1. applyForwardEmptyToOutput : Replaced integer addition with subtraction → KILLED
2. applyForwardEmptyToOutput : Replaced integer addition with subtraction → KILLED
 
            output[outputOffset + currentLength] = patchCommand.charAt(patchIndex + 1);
1551 1 1. applyForwardEmptyToOutput : Changed increment from 1 to -1 → KILLED
 
            currentLength++;
1552 
        }
1553 
    }
1554
1555 
    /**
1556 
     * Validates that source and output slices do not overlap when backed by the
1557 
     * same array.
1558 
     *
1559 
     * @param source       source storage
1560 
     * @param sourceOffset source offset
1561 
     * @param sourceLength source length
1562 
     * @param output       output storage
1563 
     * @param outputOffset output offset
1564 
     * @param outputLength output length
1565 
     */
1566 
    private static void validateNonOverlappingRanges(final char[] source, final int sourceOffset,
1567 
            final int sourceLength, final char[] output, final int outputOffset, final int outputLength) {
1568 3 1. validateNonOverlappingRanges : negated conditional → KILLED
2. validateNonOverlappingRanges : negated conditional → KILLED
3. validateNonOverlappingRanges : negated conditional → KILLED
 
        if (!source.equals(output) || sourceLength == 0 || outputLength == 0) {
1569 
            return;
1570 
        }
1571 1 1. validateNonOverlappingRanges : Replaced integer addition with subtraction → KILLED
 
        final int sourceEnd = sourceOffset + sourceLength;
1572 1 1. validateNonOverlappingRanges : Replaced integer addition with subtraction → KILLED
 
        final int outputEnd = outputOffset + outputLength;
1573 4 1. validateNonOverlappingRanges : changed conditional boundary → SURVIVED
2. validateNonOverlappingRanges : changed conditional boundary → SURVIVED
3. validateNonOverlappingRanges : negated conditional → KILLED
4. validateNonOverlappingRanges : negated conditional → KILLED
 
        if (sourceOffset < outputEnd && outputOffset < sourceEnd) {
1574 
            throw new IllegalArgumentException("source and output ranges must not overlap.");
1575 
        }
1576 
    }
1577
1578 
    /**
1579 
     * Decodes a compact count argument used by skip and delete instructions.
1580 
     *
1581 
     * @param argument serialized count argument
1582 
     * @return decoded positive count, or {@code -1} when the argument is malformed
1583 
     */
1584 
    private static int decodeEncodedCount(final char argument) {
1585 2 1. decodeEncodedCount : changed conditional boundary → KILLED
2. decodeEncodedCount : negated conditional → KILLED
 
        if (argument < 'a') {
1586 1 1. decodeEncodedCount : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::decodeEncodedCount → SURVIVED
 
            return -1;
1587 
        }
1588 3 1. decodeEncodedCount : Replaced integer subtraction with addition → KILLED
2. decodeEncodedCount : replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::decodeEncodedCount → KILLED
3. decodeEncodedCount : Replaced integer addition with subtraction → KILLED
 
        return argument - 'a' + 1;
1589 
    }
1590
1591 
    /**
1592 
     * Ensures that internal matrices are large enough for the requested input
1593 
     * dimensions.
1594 
     *
1595 
     * @param requiredSourceCapacity required source dimension
1596 
     * @param requiredTargetCapacity required target dimension
1597 
     */
1598 
    private void ensureCapacity(final int requiredSourceCapacity, final int requiredTargetCapacity) {
1599 4 1. ensureCapacity : changed conditional boundary → SURVIVED
2. ensureCapacity : changed conditional boundary → SURVIVED
3. ensureCapacity : negated conditional → TIMED_OUT
4. ensureCapacity : negated conditional → TIMED_OUT
 
        if (requiredSourceCapacity <= this.sourceCapacity && requiredTargetCapacity <= this.targetCapacity) {
1600 
            return;
1601 
        }
1602
1603 1 1. ensureCapacity : Replaced integer addition with subtraction → KILLED
 
        this.sourceCapacity = Math.max(this.sourceCapacity, requiredSourceCapacity) + CAPACITY_MARGIN;
1604 1 1. ensureCapacity : Replaced integer addition with subtraction → KILLED
 
        this.targetCapacity = Math.max(this.targetCapacity, requiredTargetCapacity) + CAPACITY_MARGIN;
1605
1606 
        this.costMatrix = new int[this.sourceCapacity][this.targetCapacity];
1607 
        this.traceMatrix = new Trace[this.sourceCapacity][this.targetCapacity];
1608 
    }
1609
1610 
    /**
1611 
     * Initializes the first row and first column of the dynamic-programming
1612 
     * matrices.
1613 
     *
1614 
     * @param sourceLength length of the source word
1615 
     * @param targetLength length of the target word
1616 
     */
1617 
    private void initializeBoundaryConditionsBackward(final int sourceLength, final int targetLength) {
1618 
        this.costMatrix[0][0] = 0;
1619 
        this.traceMatrix[0][0] = Trace.MATCH;
1620
1621 2 1. initializeBoundaryConditionsBackward : changed conditional boundary → KILLED
2. initializeBoundaryConditionsBackward : negated conditional → KILLED
 
        for (int sourceIndex = 1; sourceIndex <= sourceLength; sourceIndex++) {
1622 1 1. initializeBoundaryConditionsBackward : Replaced integer multiplication with division → SURVIVED
 
            this.costMatrix[sourceIndex][0] = sourceIndex * this.deleteCost;
1623 
            this.traceMatrix[sourceIndex][0] = Trace.DELETE;
1624 
        }
1625
1626 2 1. initializeBoundaryConditionsBackward : negated conditional → KILLED
2. initializeBoundaryConditionsBackward : changed conditional boundary → KILLED
 
        for (int targetIndex = 1; targetIndex <= targetLength; targetIndex++) {
1627 1 1. initializeBoundaryConditionsBackward : Replaced integer multiplication with division → SURVIVED
 
            this.costMatrix[0][targetIndex] = targetIndex * this.insertCost;
1628 
            this.traceMatrix[0][targetIndex] = Trace.INSERT;
1629 
        }
1630 
    }
1631
1632 
    /**
1633 
     * Initializes boundary conditions for forward dynamic-programming traversal.
1634 
     *
1635 
     * @param sourceLength length of the source word
1636 
     * @param targetLength length of the target word
1637 
     */
1638 
    private void initializeBoundaryConditionsForward(final int sourceLength, final int targetLength) {
1639 
        this.costMatrix[sourceLength][targetLength] = 0;
1640 
        this.traceMatrix[sourceLength][targetLength] = Trace.MATCH;
1641
1642 3 1. initializeBoundaryConditionsForward : Replaced integer subtraction with addition → SURVIVED
2. initializeBoundaryConditionsForward : changed conditional boundary → KILLED
3. initializeBoundaryConditionsForward : negated conditional → KILLED
 
        for (int sourceIndex = sourceLength - 1; sourceIndex >= 0; sourceIndex--) {
1643 2 1. initializeBoundaryConditionsForward : Replaced integer addition with subtraction → SURVIVED
2. initializeBoundaryConditionsForward : Replaced integer addition with subtraction → KILLED
 
            this.costMatrix[sourceIndex][targetLength] = this.costMatrix[sourceIndex + 1][targetLength]
1644 
                    + this.deleteCost;
1645 
            this.traceMatrix[sourceIndex][targetLength] = Trace.DELETE;
1646 
        }
1647
1648 3 1. initializeBoundaryConditionsForward : Replaced integer subtraction with addition → SURVIVED
2. initializeBoundaryConditionsForward : negated conditional → KILLED
3. initializeBoundaryConditionsForward : changed conditional boundary → KILLED
 
        for (int targetIndex = targetLength - 1; targetIndex >= 0; targetIndex--) {
1649 2 1. initializeBoundaryConditionsForward : Replaced integer addition with subtraction → SURVIVED
2. initializeBoundaryConditionsForward : Replaced integer addition with subtraction → KILLED
 
            this.costMatrix[sourceLength][targetIndex] = this.costMatrix[sourceLength][targetIndex + 1]
1650 
                    + this.insertCost;
1651 
            this.traceMatrix[sourceLength][targetIndex] = Trace.INSERT;
1652 
        }
1653 
    }
1654
1655 
    /**
1656 
     * Fills dynamic-programming matrices for the supplied source and target
1657 
     * character sequences.
1658 
     *
1659 
     * @param sourceCharacters source characters
1660 
     * @param targetCharacters target characters
1661 
     * @param sourceLength     source length
1662 
     * @param targetLength     target length
1663 
     * @param direction        traversal direction used to compare characters
1664 
     */
1665 
    private void fillMatrices(final char[] sourceCharacters, final char[] targetCharacters, final int sourceLength,
1666 
            final int targetLength, final WordTraversalDirection direction) {
1667 
        final int sourceStart;
1668 
        final int sourceEndExclusive;
1669 
        final int sourceStep;
1670 
        final int targetStart;
1671 
        final int targetEndExclusive;
1672 
        final int targetStep;
1673 
        final int sourceCharacterOffset;
1674 
        final int targetCharacterOffset;
1675 
        final int sourceNeighborDelta;
1676 
        final int targetNeighborDelta;
1677
1678 1 1. fillMatrices : negated conditional → KILLED
 
        if (direction == WordTraversalDirection.BACKWARD) {
1679 
            sourceStart = 1;
1680 1 1. fillMatrices : Replaced integer addition with subtraction → KILLED
 
            sourceEndExclusive = sourceLength + 1;
1681 
            sourceStep = 1;
1682 
            targetStart = 1;
1683 1 1. fillMatrices : Replaced integer addition with subtraction → KILLED
 
            targetEndExclusive = targetLength + 1;
1684 
            targetStep = 1;
1685 
            sourceCharacterOffset = -1;
1686 
            targetCharacterOffset = -1;
1687 
            sourceNeighborDelta = -1;
1688 
            targetNeighborDelta = -1;
1689 
        } else {
1690 1 1. fillMatrices : Replaced integer subtraction with addition → KILLED
 
            sourceStart = sourceLength - 1;
1691 
            sourceEndExclusive = -1;
1692 
            sourceStep = -1;
1693 1 1. fillMatrices : Replaced integer subtraction with addition → KILLED
 
            targetStart = targetLength - 1;
1694 
            targetEndExclusive = -1;
1695 
            targetStep = -1;
1696 
            sourceCharacterOffset = 0;
1697 
            targetCharacterOffset = 0;
1698 
            sourceNeighborDelta = 1;
1699 
            targetNeighborDelta = 1;
1700 
        }
1701
1702 2 1. fillMatrices : Replaced integer addition with subtraction → KILLED
2. fillMatrices : negated conditional → KILLED
 
        for (int sourceIndex = sourceStart; sourceIndex != sourceEndExclusive; sourceIndex += sourceStep) {
1703 1 1. fillMatrices : Replaced integer addition with subtraction → KILLED
 
            final char sourceCharacter = sourceCharacters[sourceIndex + sourceCharacterOffset];
1704 1 1. fillMatrices : Replaced integer addition with subtraction → KILLED
 
            final int sourceNeighbor = sourceIndex + sourceNeighborDelta;
1705
1706 2 1. fillMatrices : negated conditional → KILLED
2. fillMatrices : Replaced integer addition with subtraction → KILLED
 
            for (int targetIndex = targetStart; targetIndex != targetEndExclusive; targetIndex += targetStep) {
1707 1 1. fillMatrices : Replaced integer addition with subtraction → KILLED
 
                final char targetCharacter = targetCharacters[targetIndex + targetCharacterOffset];
1708 1 1. fillMatrices : Replaced integer addition with subtraction → KILLED
 
                final int targetNeighbor = targetIndex + targetNeighborDelta;
1709
1710 1 1. fillMatrices : Replaced integer addition with subtraction → KILLED
 
                final int deleteCandidate = this.costMatrix[sourceNeighbor][targetIndex] + this.deleteCost;
1711 1 1. fillMatrices : Replaced integer addition with subtraction → KILLED
 
                final int insertCandidate = this.costMatrix[sourceIndex][targetNeighbor] + this.insertCost;
1712 1 1. fillMatrices : Replaced integer addition with subtraction → KILLED
 
                final int replaceCandidate = this.costMatrix[sourceNeighbor][targetNeighbor] + this.replaceCost;
1713 
                final int matchCandidate = this.costMatrix[sourceNeighbor][targetNeighbor]
1714 2 1. fillMatrices : negated conditional → KILLED
2. fillMatrices : Replaced integer addition with subtraction → KILLED
 
                        + (sourceCharacter == targetCharacter ? this.matchCost : MISMATCH_PENALTY);
1715
1716 
                int bestCost = matchCandidate;
1717 
                Trace bestTrace = Trace.MATCH;
1718
1719 2 1. fillMatrices : changed conditional boundary → SURVIVED
2. fillMatrices : negated conditional → KILLED
 
                if (deleteCandidate <= bestCost) {
1720 
                    bestCost = deleteCandidate;
1721 
                    bestTrace = Trace.DELETE;
1722 
                }
1723 2 1. fillMatrices : changed conditional boundary → SURVIVED
2. fillMatrices : negated conditional → KILLED
 
                if (insertCandidate < bestCost) {
1724 
                    bestCost = insertCandidate;
1725 
                    bestTrace = Trace.INSERT;
1726 
                }
1727 2 1. fillMatrices : changed conditional boundary → SURVIVED
2. fillMatrices : negated conditional → KILLED
 
                if (replaceCandidate < bestCost) {
1728 
                    bestCost = replaceCandidate;
1729 
                    bestTrace = Trace.REPLACE;
1730 
                }
1731
1732 
                this.costMatrix[sourceIndex][targetIndex] = bestCost;
1733 
                this.traceMatrix[sourceIndex][targetIndex] = bestTrace;
1734 
            }
1735 
        }
1736 
    }
1737
1738 
    /**
1739 
     * Reconstructs the compact patch command by traversing the trace matrix from
1740 
     * the final cell back to the origin.
1741 
     *
1742 
     * @param targetCharacters target characters
1743 
     * @param sourceLength     source length
1744 
     * @param targetLength     target length
1745 
     * @return compact patch command
1746 
     */
1747 
    private String buildPatchCommandBackward(final char[] targetCharacters, final int sourceLength,
1748 
            final int targetLength) {
1749 1 1. buildPatchCommandBackward : Replaced integer addition with subtraction → KILLED
 
        final StringBuilder patchBuilder = new StringBuilder(sourceLength + targetLength);
1750
1751 
        char pendingDeletes = COUNT_SENTINEL;
1752 
        char pendingSkips = COUNT_SENTINEL;
1753
1754 
        int sourceIndex = sourceLength;
1755 
        int targetIndex = targetLength;
1756
1757 2 1. buildPatchCommandBackward : negated conditional → KILLED
2. buildPatchCommandBackward : negated conditional → KILLED
 
        while (sourceIndex != 0 || targetIndex != 0) {
1758 
            final Trace trace = this.traceMatrix[sourceIndex][targetIndex];
1759
1760 
            switch (trace) {
1761 
                case DELETE:
1762 1 1. buildPatchCommandBackward : negated conditional → KILLED
 
                    if (pendingSkips != COUNT_SENTINEL) {
1763 1 1. buildPatchCommandBackward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
                        appendInstruction(patchBuilder, SKIP_OPCODE, pendingSkips);
1764 
                        pendingSkips = COUNT_SENTINEL;
1765 
                    }
1766 1 1. buildPatchCommandBackward : Replaced integer addition with subtraction → KILLED
 
                    pendingDeletes++;
1767 1 1. buildPatchCommandBackward : Changed increment from -1 to 1 → KILLED
 
                    sourceIndex--;
1768 
                    break;
1769
1770 
                case INSERT:
1771 1 1. buildPatchCommandBackward : negated conditional → KILLED
 
                    if (pendingDeletes != COUNT_SENTINEL) {
1772 1 1. buildPatchCommandBackward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → NO_COVERAGE
 
                        appendInstruction(patchBuilder, DELETE_OPCODE, pendingDeletes);
1773 
                        pendingDeletes = COUNT_SENTINEL;
1774 
                    }
1775 1 1. buildPatchCommandBackward : negated conditional → KILLED
 
                    if (pendingSkips != COUNT_SENTINEL) {
1776 1 1. buildPatchCommandBackward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
                        appendInstruction(patchBuilder, SKIP_OPCODE, pendingSkips);
1777 
                        pendingSkips = COUNT_SENTINEL;
1778 
                    }
1779 1 1. buildPatchCommandBackward : Changed increment from -1 to 1 → KILLED
 
                    targetIndex--;
1780 1 1. buildPatchCommandBackward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
                    appendInstruction(patchBuilder, INSERT_OPCODE, targetCharacters[targetIndex]);
1781 
                    break;
1782
1783 
                case REPLACE:
1784 1 1. buildPatchCommandBackward : negated conditional → KILLED
 
                    if (pendingDeletes != COUNT_SENTINEL) {
1785 1 1. buildPatchCommandBackward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
                        appendInstruction(patchBuilder, DELETE_OPCODE, pendingDeletes);
1786 
                        pendingDeletes = COUNT_SENTINEL;
1787 
                    }
1788 1 1. buildPatchCommandBackward : negated conditional → KILLED
 
                    if (pendingSkips != COUNT_SENTINEL) {
1789 1 1. buildPatchCommandBackward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
                        appendInstruction(patchBuilder, SKIP_OPCODE, pendingSkips);
1790 
                        pendingSkips = COUNT_SENTINEL;
1791 
                    }
1792 1 1. buildPatchCommandBackward : Changed increment from -1 to 1 → KILLED
 
                    targetIndex--;
1793 1 1. buildPatchCommandBackward : Changed increment from -1 to 1 → KILLED
 
                    sourceIndex--;
1794 1 1. buildPatchCommandBackward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
                    appendInstruction(patchBuilder, REPLACE_OPCODE, targetCharacters[targetIndex]);
1795 
                    break;
1796
1797 
                case MATCH:
1798 1 1. buildPatchCommandBackward : negated conditional → KILLED
 
                    if (pendingDeletes != COUNT_SENTINEL) {
1799 1 1. buildPatchCommandBackward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
                        appendInstruction(patchBuilder, DELETE_OPCODE, pendingDeletes);
1800 
                        pendingDeletes = COUNT_SENTINEL;
1801 
                    }
1802 1 1. buildPatchCommandBackward : Replaced integer addition with subtraction → KILLED
 
                    pendingSkips++;
1803 1 1. buildPatchCommandBackward : Changed increment from -1 to 1 → KILLED
 
                    sourceIndex--;
1804 1 1. buildPatchCommandBackward : Changed increment from -1 to 1 → KILLED
 
                    targetIndex--;
1805 
                    break;
1806 
            }
1807 
        }
1808
1809 1 1. buildPatchCommandBackward : negated conditional → KILLED
 
        if (pendingDeletes != COUNT_SENTINEL) {
1810 1 1. buildPatchCommandBackward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
            appendInstruction(patchBuilder, DELETE_OPCODE, pendingDeletes);
1811 
        }
1812
1813 1 1. buildPatchCommandBackward : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::buildPatchCommandBackward → KILLED
 
        return patchBuilder.toString();
1814 
    }
1815
1816 
    /**
1817 
     * Reconstructs compact patch command for forward traversal.
1818 
     *
1819 
     * @param targetCharacters target characters
1820 
     * @param sourceLength     source length
1821 
     * @param targetLength     target length
1822 
     * @return compact patch command
1823 
     */
1824 
    private String buildPatchCommandForward(final char[] targetCharacters, final int sourceLength,
1825 
            final int targetLength) {
1826 1 1. buildPatchCommandForward : Replaced integer addition with subtraction → KILLED
 
        final StringBuilder patchBuilder = new StringBuilder(sourceLength + targetLength);
1827
1828 
        char pendingDeletes = COUNT_SENTINEL;
1829 
        char pendingSkips = COUNT_SENTINEL;
1830
1831 
        int sourceIndex = 0;
1832 
        int targetIndex = 0;
1833
1834 2 1. buildPatchCommandForward : negated conditional → KILLED
2. buildPatchCommandForward : negated conditional → KILLED
 
        while (sourceIndex != sourceLength || targetIndex != targetLength) {
1835 
            final Trace trace = this.traceMatrix[sourceIndex][targetIndex];
1836
1837 
            switch (trace) {
1838 
                case DELETE:
1839 1 1. buildPatchCommandForward : negated conditional → KILLED
 
                    if (pendingSkips != COUNT_SENTINEL) {
1840 1 1. buildPatchCommandForward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
                        appendInstruction(patchBuilder, SKIP_OPCODE, pendingSkips);
1841 
                        pendingSkips = COUNT_SENTINEL;
1842 
                    }
1843 1 1. buildPatchCommandForward : Replaced integer addition with subtraction → KILLED
 
                    pendingDeletes++;
1844 1 1. buildPatchCommandForward : Changed increment from 1 to -1 → KILLED
 
                    sourceIndex++;
1845 
                    break;
1846
1847 
                case INSERT:
1848 1 1. buildPatchCommandForward : negated conditional → SURVIVED
 
                    if (pendingDeletes != COUNT_SENTINEL) {
1849 1 1. buildPatchCommandForward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → NO_COVERAGE
 
                        appendInstruction(patchBuilder, DELETE_OPCODE, pendingDeletes);
1850 
                        pendingDeletes = COUNT_SENTINEL;
1851 
                    }
1852 1 1. buildPatchCommandForward : negated conditional → SURVIVED
 
                    if (pendingSkips != COUNT_SENTINEL) {
1853 1 1. buildPatchCommandForward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → NO_COVERAGE
 
                        appendInstruction(patchBuilder, SKIP_OPCODE, pendingSkips);
1854 
                        pendingSkips = COUNT_SENTINEL;
1855 
                    }
1856 1 1. buildPatchCommandForward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → SURVIVED
 
                    appendInstruction(patchBuilder, INSERT_OPCODE, targetCharacters[targetIndex]);
1857 1 1. buildPatchCommandForward : Changed increment from 1 to -1 → KILLED
 
                    targetIndex++;
1858 
                    break;
1859
1860 
                case REPLACE:
1861 1 1. buildPatchCommandForward : negated conditional → SURVIVED
 
                    if (pendingDeletes != COUNT_SENTINEL) {
1862 1 1. buildPatchCommandForward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
                        appendInstruction(patchBuilder, DELETE_OPCODE, pendingDeletes);
1863 
                        pendingDeletes = COUNT_SENTINEL;
1864 
                    }
1865 1 1. buildPatchCommandForward : negated conditional → KILLED
 
                    if (pendingSkips != COUNT_SENTINEL) {
1866 1 1. buildPatchCommandForward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → NO_COVERAGE
 
                        appendInstruction(patchBuilder, SKIP_OPCODE, pendingSkips);
1867 
                        pendingSkips = COUNT_SENTINEL;
1868 
                    }
1869 1 1. buildPatchCommandForward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
                    appendInstruction(patchBuilder, REPLACE_OPCODE, targetCharacters[targetIndex]);
1870 1 1. buildPatchCommandForward : Changed increment from 1 to -1 → KILLED
 
                    sourceIndex++;
1871 1 1. buildPatchCommandForward : Changed increment from 1 to -1 → KILLED
 
                    targetIndex++;
1872 
                    break;
1873
1874 
                case MATCH:
1875 1 1. buildPatchCommandForward : negated conditional → KILLED
 
                    if (pendingDeletes != COUNT_SENTINEL) {
1876 1 1. buildPatchCommandForward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
                        appendInstruction(patchBuilder, DELETE_OPCODE, pendingDeletes);
1877 
                        pendingDeletes = COUNT_SENTINEL;
1878 
                    }
1879 1 1. buildPatchCommandForward : Replaced integer addition with subtraction → KILLED
 
                    pendingSkips++;
1880 1 1. buildPatchCommandForward : Changed increment from 1 to -1 → KILLED
 
                    sourceIndex++;
1881 1 1. buildPatchCommandForward : Changed increment from 1 to -1 → KILLED
 
                    targetIndex++;
1882 
                    break;
1883 
            }
1884 
        }
1885
1886 1 1. buildPatchCommandForward : negated conditional → KILLED
 
        if (pendingDeletes != COUNT_SENTINEL) {
1887 1 1. buildPatchCommandForward : removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED
 
            appendInstruction(patchBuilder, DELETE_OPCODE, pendingDeletes);
1888 
        }
1889
1890 1 1. buildPatchCommandForward : replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::buildPatchCommandForward → KILLED
 
        return patchBuilder.toString();
1891 
    }
1892
1893 
    /**
1894 
     * Appends one serialized instruction to the patch command builder.
1895 
     *
1896 
     * @param patchBuilder patch command builder
1897 
     * @param opcode       single-character instruction opcode
1898 
     * @param argument     encoded instruction argument
1899 
     */
1900 
    private static void appendInstruction(final StringBuilder patchBuilder, final char opcode, final char argument) {
1901 
        patchBuilder.append(opcode).append(argument);
1902 
    }
1903
1904 
    /**
1905 
     * Fluent builder for creating direction-specialized {@link PatchCommandEncoder}
1906 
     * instances.
1907 
     */
1908 
    public static final class Builder {
1909 
        private WordTraversalDirection traversalDirection = WordTraversalDirection.BACKWARD;
1910 
        private int insertCost = 1;
1911 
        private int deleteCost = 1;
1912 
        private int replaceCost = 1;
1913 
        private int matchCost; // = 0
1914
1915 
        /**
1916 
         * Creates a builder initialized with the default Egothor-compatible cost model
1917 
         * and backward traversal.
1918 
         */
1919 
        public Builder() {
1920 
            // Default values are assigned in field initializers.
1921 
        }
1922
1923 
        /**
1924 
         * Sets traversal direction used by the created encoder.
1925 
         *
1926 
         * @param value traversal direction
1927 
         * @return this builder
1928 
         */
1929 
        public Builder traversalDirection(final WordTraversalDirection value) {
1930 
            this.traversalDirection = Objects.requireNonNull(value, "traversalDirection");
1931 1 1. traversalDirection : replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::traversalDirection → KILLED
 
            return this;
1932 
        }
1933
1934 
        /**
1935 
         * Sets cost of an insert operation.
1936 
         *
1937 
         * @param value cost of the operation
1938 
         * @return this builder
1939 
         */
1940 
        public Builder insertCost(final int value) {
1941 
            this.insertCost = value;
1942 1 1. insertCost : replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::insertCost → KILLED
 
            return this;
1943 
        }
1944
1945 
        /**
1946 
         * Sets cost of a delete operation.
1947 
         *
1948 
         * @param value cost of the operation
1949 
         * @return this builder
1950 
         */
1951 
        public Builder deleteCost(final int value) {
1952 
            this.deleteCost = value;
1953 1 1. deleteCost : replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::deleteCost → KILLED
 
            return this;
1954 
        }
1955
1956 
        /**
1957 
         * Sets cost of a replace operation.
1958 
         *
1959 
         * @param value cost of the operation
1960 
         * @return this builder
1961 
         */
1962 
        public Builder replaceCost(final int value) {
1963 
            this.replaceCost = value;
1964 1 1. replaceCost : replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::replaceCost → KILLED
 
            return this;
1965 
        }
1966
1967 
        /**
1968 
         * Sets cost of a match operation.
1969 
         *
1970 
         * @param value cost of the operation
1971 
         * @return this builder
1972 
         */
1973 
        public Builder matchCost(final int value) {
1974 
            this.matchCost = value;
1975 1 1. matchCost : replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::matchCost → KILLED
 
            return this;
1976 
        }
1977
1978 
        /**
1979 
         * Builds a direction-specialized encoder instance.
1980 
         *
1981 
         * @return configured encoder
1982 
         */
1983 
        public PatchCommandEncoder build() {
1984 1 1. build : replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::build → KILLED
 
            return new PatchCommandEncoder(this);
1985 
        }
1986 
    }
1987 
}

Mutations

218

1.1
Location : <init>
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldReturnNullWhenTargetIsNull()] negated conditional → KILLED

2.2
Location : <init>
Killed by : none changed conditional boundary → SURVIVED Covering tests

222

1.1
Location : <init>
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldReturnNullWhenTargetIsNull()] negated conditional → KILLED

2.2
Location : <init>
Killed by : none changed conditional boundary → SURVIVED Covering tests

226

1.1
Location : <init>
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldReturnNullWhenTargetIsNull()] negated conditional → KILLED

2.2
Location : <init>
Killed by : none changed conditional boundary → SURVIVED Covering tests

230

1.1
Location : <init>
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldReturnNullWhenTargetIsNull()] negated conditional → KILLED

2.2
Location : <init>
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldReturnNullWhenTargetIsNull()] changed conditional boundary → KILLED

238

1.1
Location : <init>
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

251

1.1
Location : builder
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldReturnNullWhenTargetIsNull()] replaced return value with null for org/egothor/stemmer/PatchCommandEncoder::builder → KILLED

264

1.1
Location : encode
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldReturnNullWhenSourceIsNull()] negated conditional → KILLED

2.2
Location : encode
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldReturnNullWhenTargetIsNull()] negated conditional → KILLED

265

1.1
Location : encode
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldReturnNullWhenSourceIsNull()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encode → KILLED

267

1.1
Location : encode
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldReturnCanonicalNoopPatchForEqualWords()] negated conditional → KILLED

268

1.1
Location : encode
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldReturnCanonicalNoopPatchForEqualWords()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encode → KILLED

271

1.1
Location : encode
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[test-template:shouldReconstructTargetForRoundTripPairs(int, java.lang.String, java.lang.String)]/[test-template-invocation:#8] negated conditional → KILLED

272

1.1
Location : encode
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encode → KILLED

274

1.1
Location : encode
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encode → KILLED

299

1.1
Location : applyWithConfiguredDirection
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

300

1.1
Location : applyWithConfiguredDirection
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyWithConfiguredDirection → NO_COVERAGE

302

1.1
Location : applyWithConfiguredDirection
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

303

1.1
Location : applyWithConfiguredDirection
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyWithConfiguredDirection → NO_COVERAGE

305

1.1
Location : applyWithConfiguredDirection
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyWithConfiguredDirection → KILLED

318

1.1
Location : compile
Killed by : org.egothor.stemmer.CompiledPatchCommandTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.CompiledPatchCommandTest]/[test-template:shouldReportInsufficientOutputCapacity(org.egothor.stemmer.WordTraversalDirection, java.lang.String, java.lang.String)]/[test-template-invocation:#1] replaced return value with null for org/egothor/stemmer/PatchCommandEncoder::compile → KILLED

337

1.1
Location : apply
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReturnSourceWhenPatchIsEmpty()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::apply → KILLED

363

1.1
Location : apply
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReturnSourceWhenPatchIsEmpty()] negated conditional → KILLED

364

1.1
Location : apply
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReturnNullWhenSourceIsNull()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::apply → KILLED

366

1.1
Location : apply
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] negated conditional → KILLED

367

1.1
Location : apply
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReturnSourceWhenPatchIsEmpty()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::apply → KILLED

369

1.1
Location : apply
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::apply → KILLED

386

1.1
Location : compile
Killed by : none replaced return value with null for org/egothor/stemmer/PatchCommandEncoder::compile → NO_COVERAGE

426

1.1
Location : applyTo
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReportInsufficientCapacityWithoutWritingOutput()] negated conditional → KILLED

2.2
Location : applyTo
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#4] changed conditional boundary → KILLED

427

1.1
Location : applyTo
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReportInsufficientCapacityWithoutWritingOutput()] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::applyTo → KILLED

429

1.1
Location : applyTo
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#10] removed call to org/egothor/stemmer/PatchCommandEncoder::applyToOutput → KILLED

430

1.1
Location : applyTo
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#10] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::applyTo → KILLED

464

1.1
Location : applyTo
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldRejectOverlappingSourceAndOutputRanges()] removed call to org/egothor/stemmer/PatchCommandEncoder::validateNonOverlappingRanges → KILLED

467

1.1
Location : applyTo
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToCharArraySourceSlice()] negated conditional → KILLED

2.2
Location : applyTo
Killed by : none changed conditional boundary → SURVIVED Covering tests

468

1.1
Location : applyTo
Killed by : none replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::applyTo → NO_COVERAGE

470

1.1
Location : applyTo
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToCharArraySourceSlice()] removed call to org/egothor/stemmer/PatchCommandEncoder::applyToOutput → KILLED

472

1.1
Location : applyTo
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToCharArraySourceSlice()] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::applyTo → KILLED

486

1.1
Location : encodeBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] removed call to java/util/concurrent/locks/ReentrantLock::lock → KILLED

488

1.1
Location : encodeBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] removed call to org/egothor/stemmer/PatchCommandEncoder::ensureCapacity → KILLED

2.2
Location : encodeBackward
Killed by : org.egothor.stemmer.FuzzStemmerAndTrieCompilationTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.FuzzStemmerAndTrieCompilationTest]/[method:generatedStemmerTriesShouldSurviveBinaryPersistence()] Replaced integer addition with subtraction → KILLED

3.3
Location : encodeBackward
Killed by : org.egothor.stemmer.FuzzStemmerAndTrieCompilationTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.FuzzStemmerAndTrieCompilationTest]/[method:generatedStemmerTriesShouldSurviveBinaryPersistence()] Replaced integer addition with subtraction → KILLED

489

1.1
Location : encodeBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] removed call to org/egothor/stemmer/PatchCommandEncoder::initializeBoundaryConditionsBackward → KILLED

494

1.1
Location : encodeBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] removed call to org/egothor/stemmer/PatchCommandEncoder::fillMatrices → KILLED

497

1.1
Location : encodeBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encodeBackward → KILLED

499

1.1
Location : encodeBackward
Killed by : none removed call to java/util/concurrent/locks/ReentrantLock::unlock → SURVIVED Covering tests

514

1.1
Location : encodeForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] removed call to java/util/concurrent/locks/ReentrantLock::lock → KILLED

516

1.1
Location : encodeForward
Killed by : none Replaced integer addition with subtraction → SURVIVED Covering tests

2.2
Location : encodeForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] removed call to org/egothor/stemmer/PatchCommandEncoder::ensureCapacity → KILLED

3.3
Location : encodeForward
Killed by : none Replaced integer addition with subtraction → SURVIVED Covering tests

517

1.1
Location : encodeForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] removed call to org/egothor/stemmer/PatchCommandEncoder::initializeBoundaryConditionsForward → KILLED

522

1.1
Location : encodeForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] removed call to org/egothor/stemmer/PatchCommandEncoder::fillMatrices → KILLED

525

1.1
Location : encodeForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encodeForward → KILLED

527

1.1
Location : encodeForward
Killed by : none removed call to java/util/concurrent/locks/ReentrantLock::unlock → SURVIVED Covering tests

540

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReturnSourceWhenPatchIsNull()] negated conditional → KILLED

541

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReturnSourceWhenPatchIsNull()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED

544

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] negated conditional → KILLED

2.2
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] Replaced bitwise AND with OR → KILLED

3.3
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReturnSourceWhenPatchIsEmpty()] negated conditional → KILLED

545

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReturnSourceWhenPatchIsEmpty()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED

547

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

548

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#10] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED

551

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

552

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED

557

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer subtraction with addition → KILLED

560

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] changed conditional boundary → KILLED

2.2
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

562

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer addition with subtraction → KILLED

567

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#5] changed conditional boundary → KILLED

2.2
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

568

1.1
Location : applyBackwardNonNull
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → NO_COVERAGE

570

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] Replaced integer addition with subtraction → KILLED

2.2
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] Replaced integer subtraction with addition → KILLED

574

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] removed call to java/lang/StringBuilder::setCharAt → KILLED

579

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#5] changed conditional boundary → KILLED

2.2
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

580

1.1
Location : applyBackwardNonNull
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → NO_COVERAGE

582

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer addition with subtraction → KILLED

583

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer subtraction with addition → KILLED

2.2
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer subtraction with addition → KILLED

588

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer addition with subtraction → KILLED

589

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[test-template:shouldReconstructTargetForRoundTripPairs(int, java.lang.String, java.lang.String)]/[test-template-invocation:#19] Changed increment from 1 to -1 → KILLED

593

1.1
Location : applyBackwardNonNull
Killed by : none negated conditional → NO_COVERAGE

596

1.1
Location : applyBackwardNonNull
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → NO_COVERAGE

602

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Changed increment from -1 to 1 → KILLED

605

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldReturnOriginalSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#7] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED

608

1.1
Location : applyBackwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED

619

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] negated conditional → KILLED

620

1.1
Location : applyForwardNonNull
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → NO_COVERAGE

623

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] negated conditional → KILLED

2.2
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] Replaced bitwise AND with OR → KILLED

3.3
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] negated conditional → KILLED

624

1.1
Location : applyForwardNonNull
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → NO_COVERAGE

626

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

627

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → KILLED

630

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

631

1.1
Location : applyForwardNonNull
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → NO_COVERAGE

639

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

2.2
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] changed conditional boundary → KILLED

641

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Replaced integer addition with subtraction → KILLED

646

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

2.2
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ConstructionTests]/[method:shouldBuildDirectionSpecializedEncoderViaBuilder()] changed conditional boundary → KILLED

647

1.1
Location : applyForwardNonNull
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → NO_COVERAGE

649

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Replaced integer addition with subtraction → KILLED

2.2
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Replaced integer subtraction with addition → KILLED

653

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReconstructTargetWithForwardTraversalEncoderAndStaticApply()] removed call to java/lang/StringBuilder::setCharAt → KILLED

658

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

2.2
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ConstructionTests]/[method:shouldBuildDirectionSpecializedEncoderViaBuilder()] changed conditional boundary → KILLED

659

1.1
Location : applyForwardNonNull
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → NO_COVERAGE

661

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Replaced integer addition with subtraction → KILLED

662

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ConstructionTests]/[method:shouldBuildDirectionSpecializedEncoderViaBuilder()] Changed increment from -1 to 1 → KILLED

670

1.1
Location : applyForwardNonNull
Killed by : none negated conditional → NO_COVERAGE

673

1.1
Location : applyForwardNonNull
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → NO_COVERAGE

679

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Changed increment from 1 to -1 → KILLED

682

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.CompiledPatchCommandTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.CompiledPatchCommandTest]/[test-template:shouldMatchInterpretedCompoundPatchApplication(org.egothor.stemmer.WordTraversalDirection, java.lang.String, java.lang.String)]/[test-template-invocation:#5] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → KILLED

685

1.1
Location : applyForwardNonNull
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → KILLED

703

1.1
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldRemainCorrectWhenReusedAcrossDifferentInputSizes()] changed conditional boundary → KILLED

2.2
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldReturnOriginalSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#13] negated conditional → KILLED

3.3
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldReturnOriginalSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#8] negated conditional → KILLED

4.4
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[test-template:shouldReconstructTargetForRoundTripPairs(int, java.lang.String, java.lang.String)]/[test-template-invocation:#6] changed conditional boundary → KILLED

704

1.1
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldReturnOriginalSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#11] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED

706

1.1
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] Replaced integer subtraction with addition → KILLED

2.2
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED

709

1.1
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#8] Replaced integer addition with subtraction → KILLED

710

1.1
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] removed call to java/lang/String::getChars → KILLED

712

1.1
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#8] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED

715

1.1
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] negated conditional → KILLED

716

1.1
Location : applySingleBackwardInstruction
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → SURVIVED Covering tests

719

1.1
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] Replaced integer subtraction with addition → KILLED

720

1.1
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED

723

1.1
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldReturnOriginalSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#12] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED

726

1.1
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReturnSourceWhenPatchIsCanonicalNoop()] negated conditional → KILLED

729

1.1
Location : applySingleBackwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReturnSourceWhenPatchIsCanonicalNoop()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED

751

1.1
Location : applySingleForwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] negated conditional → KILLED

2.2
Location : applySingleForwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] negated conditional → KILLED

3.3
Location : applySingleForwardInstruction
Killed by : org.egothor.stemmer.CompiledPatchCommandTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.CompiledPatchCommandTest]/[test-template:shouldMatchInterpretedPatchApplication(org.egothor.stemmer.WordTraversalDirection, java.lang.String, java.lang.String)]/[test-template-invocation:#13] changed conditional boundary → KILLED

4.4
Location : applySingleForwardInstruction
Killed by : none changed conditional boundary → SURVIVED Covering tests

752

1.1
Location : applySingleForwardInstruction
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → NO_COVERAGE

754

1.1
Location : applySingleForwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → KILLED

757

1.1
Location : applySingleForwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] Replaced integer addition with subtraction → KILLED

759

1.1
Location : applySingleForwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] removed call to java/lang/String::getChars → KILLED

760

1.1
Location : applySingleForwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → KILLED

763

1.1
Location : applySingleForwardInstruction
Killed by : org.egothor.stemmer.CompiledPatchCommandTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.CompiledPatchCommandTest]/[test-template:shouldMatchInterpretedPatchApplication(org.egothor.stemmer.WordTraversalDirection, java.lang.String, java.lang.String)]/[test-template-invocation:#12] negated conditional → KILLED

764

1.1
Location : applySingleForwardInstruction
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → NO_COVERAGE

768

1.1
Location : applySingleForwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → KILLED

771

1.1
Location : applySingleForwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → KILLED

774

1.1
Location : applySingleForwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] negated conditional → KILLED

777

1.1
Location : applySingleForwardInstruction
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyForwardSingleInstructionsExplicitly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleForwardInstruction → KILLED

799

1.1
Location : applyBackwardToEmptySource
Killed by : none Replaced Shift Right with Shift Left → SURVIVED Covering tests

801

1.1
Location : applyBackwardToEmptySource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] changed conditional boundary → KILLED

2.2
Location : applyBackwardToEmptySource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] negated conditional → KILLED

803

1.1
Location : applyBackwardToEmptySource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] Replaced integer addition with subtraction → KILLED

816

1.1
Location : applyBackwardToEmptySource
Killed by : none negated conditional → NO_COVERAGE

829

1.1
Location : applyBackwardToEmptySource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardToEmptySource → KILLED

840

1.1
Location : applyForwardToEmptySource
Killed by : none Replaced Shift Right with Shift Left → SURVIVED Covering tests

842

1.1
Location : applyForwardToEmptySource
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : applyForwardToEmptySource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldThrowForUnsupportedNoopArgumentOnForwardEmptySource()] negated conditional → KILLED

844

1.1
Location : applyForwardToEmptySource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldThrowForUnsupportedNoopArgumentOnForwardEmptySource()] Replaced integer addition with subtraction → KILLED

857

1.1
Location : applyForwardToEmptySource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldThrowForUnsupportedNoopArgumentOnForwardEmptySource()] negated conditional → KILLED

870

1.1
Location : applyForwardToEmptySource
Killed by : none replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardToEmptySource → NO_COVERAGE

884

1.1
Location : computeAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReportInsufficientCapacityWithoutWritingOutput()] negated conditional → KILLED

2.2
Location : computeAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReportInsufficientCapacityWithoutWritingOutput()] negated conditional → KILLED

3.3
Location : computeAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReportInsufficientCapacityWithoutWritingOutput()] negated conditional → KILLED

885

1.1
Location : computeAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReportInsufficientCapacityWithoutWritingOutput()] Replaced bitwise AND with OR → KILLED

2.2
Location : computeAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReportInsufficientCapacityWithoutWritingOutput()] negated conditional → KILLED

886

1.1
Location : computeAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#10] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeAppliedLength → KILLED

888

1.1
Location : computeAppliedLength
Killed by : none negated conditional → SURVIVED Covering tests

889

1.1
Location : computeAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReportInsufficientCapacityWithoutWritingOutput()] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeAppliedLength → KILLED

891

1.1
Location : computeAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeAppliedLength → KILLED

902

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] negated conditional → KILLED

903

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReportInsufficientCapacityWithoutWritingOutput()] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → KILLED

905

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

906

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → KILLED

910

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer subtraction with addition → KILLED

911

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

2.2
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] changed conditional boundary → KILLED

913

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer addition with subtraction → KILLED

918

1.1
Location : computeBackwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : computeBackwardAppliedLength
Killed by : none negated conditional → SURVIVED Covering tests

919

1.1
Location : computeBackwardAppliedLength
Killed by : none replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → NO_COVERAGE

921

1.1
Location : computeBackwardAppliedLength
Killed by : none Replaced integer subtraction with addition → SURVIVED Covering tests

2.2
Location : computeBackwardAppliedLength
Killed by : none Replaced integer addition with subtraction → SURVIVED Covering tests

925

1.1
Location : computeBackwardAppliedLength
Killed by : none negated conditional → SURVIVED Covering tests

2.2
Location : computeBackwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

3.3
Location : computeBackwardAppliedLength
Killed by : none negated conditional → SURVIVED Covering tests

4.4
Location : computeBackwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

926

1.1
Location : computeBackwardAppliedLength
Killed by : none replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → NO_COVERAGE

932

1.1
Location : computeBackwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

933

1.1
Location : computeBackwardAppliedLength
Killed by : none replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → NO_COVERAGE

935

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer addition with subtraction → KILLED

936

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer subtraction with addition → KILLED

2.2
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer subtraction with addition → KILLED

937

1.1
Location : computeBackwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

3.3
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] changed conditional boundary → KILLED

4.4
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

5.5
Location : computeBackwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

6.6
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

938

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#7] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → KILLED

940

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer subtraction with addition → KILLED

2.2
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer subtraction with addition → KILLED

944

1.1
Location : computeBackwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

3.3
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

4.4
Location : computeBackwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

945

1.1
Location : computeBackwardAppliedLength
Killed by : none replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → NO_COVERAGE

947

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Changed increment from 1 to -1 → KILLED

948

1.1
Location : computeBackwardAppliedLength
Killed by : none Changed increment from 1 to -1 → SURVIVED Covering tests

952

1.1
Location : computeBackwardAppliedLength
Killed by : none negated conditional → NO_COVERAGE

955

1.1
Location : computeBackwardAppliedLength
Killed by : none replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → NO_COVERAGE

961

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Changed increment from -1 to 1 → KILLED

963

1.1
Location : computeBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → KILLED

974

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#1] negated conditional → KILLED

975

1.1
Location : computeForwardAppliedLength
Killed by : none replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → NO_COVERAGE

977

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] negated conditional → KILLED

978

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#1] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED

983

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] changed conditional boundary → KILLED

2.2
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] negated conditional → KILLED

985

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] Replaced integer addition with subtraction → KILLED

990

1.1
Location : computeForwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] negated conditional → KILLED

991

1.1
Location : computeForwardAppliedLength
Killed by : none replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → NO_COVERAGE

993

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] Replaced integer subtraction with addition → KILLED

2.2
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] Replaced integer addition with subtraction → KILLED

997

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] negated conditional → KILLED

2.2
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] negated conditional → KILLED

3.3
Location : computeForwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

4.4
Location : computeForwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

998

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED

1004

1.1
Location : computeForwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] negated conditional → KILLED

3.3
Location : computeForwardAppliedLength
Killed by : none Replaced integer addition with subtraction → SURVIVED Covering tests

4.4
Location : computeForwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

5.5
Location : computeForwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

6.6
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] negated conditional → KILLED

7.7
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] negated conditional → KILLED

1005

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED

1007

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] Replaced integer subtraction with addition → KILLED

1008

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] Changed increment from -1 to 1 → KILLED

1012

1.1
Location : computeForwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : computeForwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

3.3
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

4.4
Location : computeForwardAppliedLength
Killed by : none negated conditional → SURVIVED Covering tests

1013

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED

1015

1.1
Location : computeForwardAppliedLength
Killed by : none Changed increment from 1 to -1 → NO_COVERAGE

1019

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] negated conditional → KILLED

1022

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED

1028

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] Changed increment from 1 to -1 → KILLED

1030

1.1
Location : computeForwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED

1047

1.1
Location : computeSingleBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#11] negated conditional → KILLED

2.2
Location : computeSingleBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#8] negated conditional → KILLED

3.3
Location : computeSingleBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#11] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeSingleBackwardAppliedLength → KILLED

4.4
Location : computeSingleBackwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

5.5
Location : computeSingleBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] Replaced integer subtraction with addition → KILLED

6.6
Location : computeSingleBackwardAppliedLength
Killed by : none changed conditional boundary → SURVIVED Covering tests

1049

1.1
Location : computeSingleBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReportInsufficientCapacityWithoutWritingOutput()] Replaced integer addition with subtraction → KILLED

2.2
Location : computeSingleBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReportInsufficientCapacityWithoutWritingOutput()] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeSingleBackwardAppliedLength → KILLED

1052

1.1
Location : computeSingleBackwardAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#6] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeSingleBackwardAppliedLength → KILLED

1054

1.1
Location : computeSingleBackwardAppliedLength
Killed by : none negated conditional → SURVIVED Covering tests

1057

1.1
Location : computeSingleBackwardAppliedLength
Killed by : none replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeSingleBackwardAppliedLength → NO_COVERAGE

1073

1.1
Location : computeSingleForwardAppliedLength
Killed by : none replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeSingleForwardAppliedLength → NO_COVERAGE

1084

1.1
Location : computeBackwardEmptyAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] negated conditional → KILLED

2.2
Location : computeBackwardEmptyAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] changed conditional boundary → KILLED

1086

1.1
Location : computeBackwardEmptyAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] Replaced integer addition with subtraction → KILLED

1089

1.1
Location : computeBackwardEmptyAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] Changed increment from 1 to -1 → KILLED

1096

1.1
Location : computeBackwardEmptyAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

1104

1.1
Location : computeBackwardEmptyAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardEmptyAppliedLength → KILLED

1114

1.1
Location : computeForwardEmptyAppliedLength
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#1] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardEmptyAppliedLength → KILLED

1132

1.1
Location : applyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

1133

1.1
Location : applyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#10] removed call to org/egothor/stemmer/PatchCommandEncoder::copySource → KILLED

1137

1.1
Location : applyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] negated conditional → KILLED

2.2
Location : applyToOutput
Killed by : none changed conditional boundary → SURVIVED Covering tests

1138

1.1
Location : applyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] removed call to org/egothor/stemmer/PatchCommandEncoder::copySource → KILLED

1141

1.1
Location : applyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] negated conditional → KILLED

1142

1.1
Location : applyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#8] removed call to org/egothor/stemmer/PatchCommandEncoder::applyBackwardToOutput → KILLED

1144

1.1
Location : applyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#1] removed call to org/egothor/stemmer/PatchCommandEncoder::applyForwardToOutput → KILLED

1163

1.1
Location : applyToOutput
Killed by : none negated conditional → SURVIVED Covering tests

1164

1.1
Location : applyToOutput
Killed by : none removed call to java/lang/System::arraycopy → NO_COVERAGE

1168

1.1
Location : applyToOutput
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : applyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToCharArraySourceSlice()] negated conditional → KILLED

1169

1.1
Location : applyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToCharArraySourceSlice()] removed call to java/lang/System::arraycopy → KILLED

1172

1.1
Location : applyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToCharArraySourceSlice()] negated conditional → KILLED

1173

1.1
Location : applyToOutput
Killed by : none removed call to org/egothor/stemmer/PatchCommandEncoder::applyBackwardToOutput → SURVIVED Covering tests

1175

1.1
Location : applyToOutput
Killed by : none removed call to org/egothor/stemmer/PatchCommandEncoder::applyForwardToOutput → NO_COVERAGE

1190

1.1
Location : isPreservedSource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

2.2
Location : isPreservedSource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#8] replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isPreservedSource → KILLED

1191

1.1
Location : isPreservedSource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

1204

1.1
Location : isKnownPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

2.2
Location : isKnownPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToPreserveSourceForEmptyCompatibilityPatches()] negated conditional → KILLED

3.3
Location : isKnownPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

1205

1.1
Location : isKnownPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

2.2
Location : isKnownPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] Replaced bitwise AND with OR → KILLED

1206

1.1
Location : isKnownPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#5] replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → KILLED

1208

1.1
Location : isKnownPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

1209

1.1
Location : isKnownPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#11] replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → KILLED

2.2
Location : isKnownPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → KILLED

1211

1.1
Location : isKnownPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

1212

1.1
Location : isKnownPreserveOnlyPatch
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → SURVIVED Covering tests

2.2
Location : isKnownPreserveOnlyPatch
Killed by : none replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → SURVIVED Covering tests

1214

1.1
Location : isKnownPreserveOnlyPatch
Killed by : none negated conditional → SURVIVED Covering tests

2.2
Location : isKnownPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → KILLED

3.3
Location : isKnownPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → KILLED

1232

1.1
Location : isSingleInstructionPreserveOnly
Killed by : none replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isSingleInstructionPreserveOnly → SURVIVED Covering tests

2.2
Location : isSingleInstructionPreserveOnly
Killed by : none changed conditional boundary → SURVIVED Covering tests

3.3
Location : isSingleInstructionPreserveOnly
Killed by : none changed conditional boundary → SURVIVED Covering tests

4.4
Location : isSingleInstructionPreserveOnly
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#11] negated conditional → KILLED

5.5
Location : isSingleInstructionPreserveOnly
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#1] negated conditional → KILLED

1234

1.1
Location : isSingleInstructionPreserveOnly
Killed by : none replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isSingleInstructionPreserveOnly → NO_COVERAGE

1236

1.1
Location : isSingleInstructionPreserveOnly
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] negated conditional → KILLED

2.2
Location : isSingleInstructionPreserveOnly
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::isSingleInstructionPreserveOnly → KILLED

1238

1.1
Location : isSingleInstructionPreserveOnly
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isSingleInstructionPreserveOnly → SURVIVED Covering tests

1240

1.1
Location : isSingleInstructionPreserveOnly
Killed by : none negated conditional → NO_COVERAGE

1243

1.1
Location : isSingleInstructionPreserveOnly
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isSingleInstructionPreserveOnly → NO_COVERAGE

1256

1.1
Location : hasEmptySourcePreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : hasEmptySourcePreserveOnlyPatch
Killed by : none negated conditional → SURVIVED Covering tests

1258

1.1
Location : hasEmptySourcePreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#4] Replaced integer addition with subtraction → KILLED

1265

1.1
Location : hasEmptySourcePreserveOnlyPatch
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasEmptySourcePreserveOnlyPatch → SURVIVED Covering tests

1267

1.1
Location : hasEmptySourcePreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

1270

1.1
Location : hasEmptySourcePreserveOnlyPatch
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasEmptySourcePreserveOnlyPatch → SURVIVED Covering tests

1275

1.1
Location : hasEmptySourcePreserveOnlyPatch
Killed by : none replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::hasEmptySourcePreserveOnlyPatch → NO_COVERAGE

1288

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none Replaced integer subtraction with addition → SURVIVED Covering tests

1289

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] changed conditional boundary → KILLED

2.2
Location : hasBackwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

1291

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer addition with subtraction → KILLED

1295

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

2.2
Location : hasBackwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

1296

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → NO_COVERAGE

1298

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] Replaced integer addition with subtraction → KILLED

2.2
Location : hasBackwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] Replaced integer subtraction with addition → KILLED

1301

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] changed conditional boundary → KILLED

2.2
Location : hasBackwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

3.3
Location : hasBackwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

4.4
Location : hasBackwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

1302

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → NO_COVERAGE

1307

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : hasBackwardPreserveOnlyPatch
Killed by : none negated conditional → SURVIVED Covering tests

1308

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → NO_COVERAGE

1310

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none Replaced integer addition with subtraction → SURVIVED Covering tests

1311

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none Replaced integer subtraction with addition → SURVIVED Covering tests

2.2
Location : hasBackwardPreserveOnlyPatch
Killed by : none Replaced integer subtraction with addition → SURVIVED Covering tests

1312

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

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

3.3
Location : hasBackwardPreserveOnlyPatch
Killed by : none negated conditional → NO_COVERAGE

4.4
Location : hasBackwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

5.5
Location : hasBackwardPreserveOnlyPatch
Killed by : none changed conditional boundary → NO_COVERAGE

6.6
Location : hasBackwardPreserveOnlyPatch
Killed by : none changed conditional boundary → NO_COVERAGE

1313

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#7] replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → KILLED

1315

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none Replaced integer subtraction with addition → NO_COVERAGE

2.2
Location : hasBackwardPreserveOnlyPatch
Killed by : none Replaced integer subtraction with addition → NO_COVERAGE

1318

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : hasBackwardPreserveOnlyPatch
Killed by : none negated conditional → SURVIVED Covering tests

3.3
Location : hasBackwardPreserveOnlyPatch
Killed by : none negated conditional → SURVIVED Covering tests

4.4
Location : hasBackwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

1319

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → NO_COVERAGE

1321

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none Changed increment from 1 to -1 → SURVIVED Covering tests

1322

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none Changed increment from 1 to -1 → SURVIVED Covering tests

1325

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none negated conditional → NO_COVERAGE

1328

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → NO_COVERAGE

1332

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : none Changed increment from -1 to 1 → SURVIVED Covering tests

1334

1.1
Location : hasBackwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::hasBackwardPreserveOnlyPatch → KILLED

1348

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] changed conditional boundary → KILLED

2.2
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] negated conditional → KILLED

1350

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] Replaced integer addition with subtraction → KILLED

1354

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] changed conditional boundary → KILLED

2.2
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] negated conditional → KILLED

1355

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → NO_COVERAGE

1357

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : none Replaced integer subtraction with addition → SURVIVED Covering tests

2.2
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] Replaced integer addition with subtraction → KILLED

1360

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] negated conditional → KILLED

2.2
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] negated conditional → KILLED

3.3
Location : hasForwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

4.4
Location : hasForwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

1361

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → SURVIVED Covering tests

1366

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : none Replaced integer addition with subtraction → SURVIVED Covering tests

2.2
Location : hasForwardPreserveOnlyPatch
Killed by : none negated conditional → SURVIVED Covering tests

3.3
Location : hasForwardPreserveOnlyPatch
Killed by : none negated conditional → SURVIVED Covering tests

4.4
Location : hasForwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

5.5
Location : hasForwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

6.6
Location : hasForwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

7.7
Location : hasForwardPreserveOnlyPatch
Killed by : none negated conditional → SURVIVED Covering tests

1367

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → KILLED

1369

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : none Replaced integer subtraction with addition → NO_COVERAGE

1370

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : none Changed increment from -1 to 1 → NO_COVERAGE

1373

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] negated conditional → KILLED

2.2
Location : hasForwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

3.3
Location : hasForwardPreserveOnlyPatch
Killed by : none changed conditional boundary → SURVIVED Covering tests

4.4
Location : hasForwardPreserveOnlyPatch
Killed by : none negated conditional → SURVIVED Covering tests

1374

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → KILLED

1376

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : none Changed increment from 1 to -1 → NO_COVERAGE

1379

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] negated conditional → KILLED

1382

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : none replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → SURVIVED Covering tests

1386

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] Changed increment from 1 to -1 → KILLED

1388

1.1
Location : hasForwardPreserveOnlyPatch
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → KILLED

1402

1.1
Location : copySource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#10] changed conditional boundary → KILLED

2.2
Location : copySource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#10] negated conditional → KILLED

1403

1.1
Location : copySource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#10] Replaced integer addition with subtraction → KILLED

2.2
Location : copySource
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#10] Replaced integer addition with subtraction → KILLED

1417

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] negated conditional → KILLED

1418

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#8] removed call to org/egothor/stemmer/PatchCommandEncoder::applyBackwardEmptyToOutput → KILLED

1423

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] Replaced integer subtraction with addition → KILLED

1424

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] negated conditional → KILLED

2.2
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] changed conditional boundary → KILLED

1426

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] Replaced integer addition with subtraction → KILLED

1430

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] Replaced integer subtraction with addition → KILLED

2.2
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#4] Replaced integer addition with subtraction → KILLED

1434

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#3] Replaced integer addition with subtraction → KILLED

1438

1.1
Location : applyBackwardToOutput
Killed by : none Replaced integer addition with subtraction → SURVIVED Covering tests

1439

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer subtraction with addition → KILLED

2.2
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer subtraction with addition → KILLED

1440

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#5] Replaced integer addition with subtraction → KILLED

2.2
Location : applyBackwardToOutput
Killed by : none removed call to java/lang/System::arraycopy → SURVIVED Covering tests

3.3
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToCharArraySourceSlice()] Replaced integer addition with subtraction → KILLED

4.4
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToCharArraySourceSlice()] Replaced integer subtraction with addition → KILLED

1442

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer subtraction with addition → KILLED

2.2
Location : applyBackwardToOutput
Killed by : none Replaced integer subtraction with addition → SURVIVED Covering tests

1446

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] Replaced integer addition with subtraction → KILLED

1447

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer addition with subtraction → KILLED

2.2
Location : applyBackwardToOutput
Killed by : none removed call to java/lang/System::arraycopy → SURVIVED Covering tests

3.3
Location : applyBackwardToOutput
Killed by : none Replaced integer addition with subtraction → SURVIVED Covering tests

4.4
Location : applyBackwardToOutput
Killed by : none Replaced integer addition with subtraction → SURVIVED Covering tests

5.5
Location : applyBackwardToOutput
Killed by : none Replaced integer subtraction with addition → SURVIVED Covering tests

1449

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#2] Replaced integer addition with subtraction → KILLED

1450

1.1
Location : applyBackwardToOutput
Killed by : none Changed increment from 1 to -1 → SURVIVED Covering tests

1451

1.1
Location : applyBackwardToOutput
Killed by : none Changed increment from 1 to -1 → SURVIVED Covering tests

1461

1.1
Location : applyBackwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Changed increment from -1 to 1 → KILLED

1475

1.1
Location : applyForwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] negated conditional → KILLED

1476

1.1
Location : applyForwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#1] removed call to org/egothor/stemmer/PatchCommandEncoder::applyForwardEmptyToOutput → KILLED

1482

1.1
Location : applyForwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] negated conditional → KILLED

2.2
Location : applyForwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] changed conditional boundary → KILLED

1484

1.1
Location : applyForwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] Replaced integer addition with subtraction → KILLED

1488

1.1
Location : applyForwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] Replaced integer addition with subtraction → KILLED

2.2
Location : applyForwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] Replaced integer subtraction with addition → KILLED

1492

1.1
Location : applyForwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] Replaced integer addition with subtraction → KILLED

1497

1.1
Location : applyForwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] Replaced integer addition with subtraction → KILLED

2.2
Location : applyForwardToOutput
Killed by : none Replaced integer addition with subtraction → SURVIVED Covering tests

3.3
Location : applyForwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] Replaced integer addition with subtraction → KILLED

4.4
Location : applyForwardToOutput
Killed by : none removed call to java/lang/System::arraycopy → SURVIVED Covering tests

5.5
Location : applyForwardToOutput
Killed by : none Replaced integer subtraction with addition → SURVIVED Covering tests

6.6
Location : applyForwardToOutput
Killed by : none Replaced integer subtraction with addition → SURVIVED Covering tests

1499

1.1
Location : applyForwardToOutput
Killed by : none Replaced integer subtraction with addition → SURVIVED Covering tests

1500

1.1
Location : applyForwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] Changed increment from -1 to 1 → KILLED

1504

1.1
Location : applyForwardToOutput
Killed by : none Replaced integer addition with subtraction → NO_COVERAGE

2.2
Location : applyForwardToOutput
Killed by : none Replaced integer addition with subtraction → NO_COVERAGE

3.3
Location : applyForwardToOutput
Killed by : none Replaced integer addition with subtraction → NO_COVERAGE

4.4
Location : applyForwardToOutput
Killed by : none Replaced integer subtraction with addition → NO_COVERAGE

5.5
Location : applyForwardToOutput
Killed by : none removed call to java/lang/System::arraycopy → NO_COVERAGE

1506

1.1
Location : applyForwardToOutput
Killed by : none Replaced integer addition with subtraction → NO_COVERAGE

1507

1.1
Location : applyForwardToOutput
Killed by : none Changed increment from 1 to -1 → NO_COVERAGE

1517

1.1
Location : applyForwardToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardPreserveAndMutationBranches(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#1] Changed increment from 1 to -1 → KILLED

1531

1.1
Location : applyBackwardEmptyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#8] negated conditional → KILLED

2.2
Location : applyBackwardEmptyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#8] changed conditional boundary → KILLED

1532

1.1
Location : applyBackwardEmptyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#8] Replaced integer addition with subtraction → KILLED

1533

1.1
Location : applyBackwardEmptyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] Replaced integer addition with subtraction → KILLED

2.2
Location : applyBackwardEmptyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] removed call to java/lang/System::arraycopy → KILLED

1535

1.1
Location : applyBackwardEmptyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToBufferLikeApplyForBackwardCommands(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#9] Changed increment from 1 to -1 → KILLED

1549

1.1
Location : applyForwardEmptyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#1] changed conditional boundary → KILLED

2.2
Location : applyForwardEmptyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#1] negated conditional → KILLED

1550

1.1
Location : applyForwardEmptyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#1] Replaced integer addition with subtraction → KILLED

2.2
Location : applyForwardEmptyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#1] Replaced integer addition with subtraction → KILLED

1551

1.1
Location : applyForwardEmptyToOutput
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyToForwardEmptySourceCases(int, java.lang.String, java.lang.String)]/[test-template-invocation:#1] Changed increment from 1 to -1 → KILLED

1568

1.1
Location : validateNonOverlappingRanges
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldRejectOverlappingSourceAndOutputRanges()] negated conditional → KILLED

2.2
Location : validateNonOverlappingRanges
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldRejectOverlappingSourceAndOutputRanges()] negated conditional → KILLED

3.3
Location : validateNonOverlappingRanges
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldRejectOverlappingSourceAndOutputRanges()] negated conditional → KILLED

1571

1.1
Location : validateNonOverlappingRanges
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldRejectOverlappingSourceAndOutputRanges()] Replaced integer addition with subtraction → KILLED

1572

1.1
Location : validateNonOverlappingRanges
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldRejectOverlappingSourceAndOutputRanges()] Replaced integer addition with subtraction → KILLED

1573

1.1
Location : validateNonOverlappingRanges
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : validateNonOverlappingRanges
Killed by : none changed conditional boundary → SURVIVED Covering tests

3.3
Location : validateNonOverlappingRanges
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldRejectOverlappingSourceAndOutputRanges()] negated conditional → KILLED

4.4
Location : validateNonOverlappingRanges
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldRejectOverlappingSourceAndOutputRanges()] negated conditional → KILLED

1585

1.1
Location : decodeEncodedCount
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#5] changed conditional boundary → KILLED

2.2
Location : decodeEncodedCount
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] negated conditional → KILLED

1586

1.1
Location : decodeEncodedCount
Killed by : none replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::decodeEncodedCount → SURVIVED Covering tests

1588

1.1
Location : decodeEncodedCount
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer subtraction with addition → KILLED

2.2
Location : decodeEncodedCount
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::decodeEncodedCount → KILLED

3.3
Location : decodeEncodedCount
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[test-template:shouldApplyExplicitPatchCommandsCorrectly(int, java.lang.String, java.lang.String, java.lang.String)]/[test-template-invocation:#7] Replaced integer addition with subtraction → KILLED

1599

1.1
Location : ensureCapacity
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : ensureCapacity
Killed by : none negated conditional → TIMED_OUT

3.3
Location : ensureCapacity
Killed by : none changed conditional boundary → SURVIVED Covering tests

4.4
Location : ensureCapacity
Killed by : none negated conditional → TIMED_OUT

1603

1.1
Location : ensureCapacity
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] Replaced integer addition with subtraction → KILLED

1604

1.1
Location : ensureCapacity
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] Replaced integer addition with subtraction → KILLED

1621

1.1
Location : initializeBoundaryConditionsBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] changed conditional boundary → KILLED

2.2
Location : initializeBoundaryConditionsBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] negated conditional → KILLED

1622

1.1
Location : initializeBoundaryConditionsBackward
Killed by : none Replaced integer multiplication with division → SURVIVED Covering tests

1626

1.1
Location : initializeBoundaryConditionsBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] negated conditional → KILLED

2.2
Location : initializeBoundaryConditionsBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] changed conditional boundary → KILLED

1627

1.1
Location : initializeBoundaryConditionsBackward
Killed by : none Replaced integer multiplication with division → SURVIVED Covering tests

1642

1.1
Location : initializeBoundaryConditionsForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ConstructionTests]/[method:shouldBuildDirectionSpecializedEncoderViaBuilder()] changed conditional boundary → KILLED

2.2
Location : initializeBoundaryConditionsForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

3.3
Location : initializeBoundaryConditionsForward
Killed by : none Replaced integer subtraction with addition → SURVIVED Covering tests

1643

1.1
Location : initializeBoundaryConditionsForward
Killed by : none Replaced integer addition with subtraction → SURVIVED Covering tests

2.2
Location : initializeBoundaryConditionsForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Replaced integer addition with subtraction → KILLED

1648

1.1
Location : initializeBoundaryConditionsForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReconstructTargetWithForwardTraversalEncoderAndStaticApply()] negated conditional → KILLED

2.2
Location : initializeBoundaryConditionsForward
Killed by : org.egothor.stemmer.CompiledPatchCommandTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.CompiledPatchCommandTest]/[test-template:shouldReportInsufficientOutputCapacity(org.egothor.stemmer.WordTraversalDirection, java.lang.String, java.lang.String)]/[test-template-invocation:#12] changed conditional boundary → KILLED

3.3
Location : initializeBoundaryConditionsForward
Killed by : none Replaced integer subtraction with addition → SURVIVED Covering tests

1649

1.1
Location : initializeBoundaryConditionsForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Replaced integer addition with subtraction → KILLED

2.2
Location : initializeBoundaryConditionsForward
Killed by : none Replaced integer addition with subtraction → SURVIVED Covering tests

1678

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] negated conditional → KILLED

1680

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] Replaced integer addition with subtraction → KILLED

1683

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] Replaced integer addition with subtraction → KILLED

1690

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Replaced integer subtraction with addition → KILLED

1693

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Replaced integer subtraction with addition → KILLED

1702

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] Replaced integer addition with subtraction → KILLED

2.2
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] negated conditional → KILLED

1703

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] Replaced integer addition with subtraction → KILLED

1704

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Replaced integer addition with subtraction → KILLED

1706

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] negated conditional → KILLED

2.2
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] Replaced integer addition with subtraction → KILLED

1707

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] Replaced integer addition with subtraction → KILLED

1708

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Replaced integer addition with subtraction → KILLED

1710

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldNotEmitTrailingSkipInstructionsIntoPatchCommand()] Replaced integer addition with subtraction → KILLED

1711

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldNotEmitTrailingSkipInstructionsIntoPatchCommand()] Replaced integer addition with subtraction → KILLED

1712

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldNotEmitTrailingSkipInstructionsIntoPatchCommand()] Replaced integer addition with subtraction → KILLED

1714

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] negated conditional → KILLED

2.2
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] Replaced integer addition with subtraction → KILLED

1719

1.1
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldNotEmitTrailingSkipInstructionsIntoPatchCommand()] negated conditional → KILLED

2.2
Location : fillMatrices
Killed by : none changed conditional boundary → SURVIVED Covering tests

1723

1.1
Location : fillMatrices
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldNotEmitTrailingSkipInstructionsIntoPatchCommand()] negated conditional → KILLED

1727

1.1
Location : fillMatrices
Killed by : none changed conditional boundary → SURVIVED Covering tests

2.2
Location : fillMatrices
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldNotEmitTrailingSkipInstructionsIntoPatchCommand()] negated conditional → KILLED

1749

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] Replaced integer addition with subtraction → KILLED

1757

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] negated conditional → KILLED

2.2
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] negated conditional → KILLED

1762

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[test-template:shouldReconstructTargetForRoundTripPairs(int, java.lang.String, java.lang.String)]/[test-template-invocation:#8] negated conditional → KILLED

1763

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[test-template:shouldPreserveCorrectnessUnderMirroredInputOrientation(int, java.lang.String, java.lang.String)]/[test-template-invocation:#13] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1766

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[test-template:shouldReconstructTargetForRoundTripPairs(int, java.lang.String, java.lang.String)]/[test-template-invocation:#8] Replaced integer addition with subtraction → KILLED

1767

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[test-template:shouldReconstructTargetForRoundTripPairs(int, java.lang.String, java.lang.String)]/[test-template-invocation:#8] Changed increment from -1 to 1 → KILLED

1771

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[test-template:shouldPreserveCorrectnessUnderMirroredInputOrientation(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] negated conditional → KILLED

1772

1.1
Location : buildPatchCommandBackward
Killed by : none removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → NO_COVERAGE

1775

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[test-template:shouldPreserveCorrectnessUnderMirroredInputOrientation(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] negated conditional → KILLED

1776

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[test-template:shouldPreserveCorrectnessUnderMirroredInputOrientation(int, java.lang.String, java.lang.String)]/[test-template-invocation:#14] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1779

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[test-template:shouldPreserveCorrectnessUnderMirroredInputOrientation(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] Changed increment from -1 to 1 → KILLED

1780

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[test-template:shouldPreserveCorrectnessUnderMirroredInputOrientation(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1784

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] negated conditional → KILLED

1785

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandlePluralToSingularTransformation()] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1788

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] negated conditional → KILLED

1789

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[test-template:shouldReconstructTargetForRoundTripPairs(int, java.lang.String, java.lang.String)]/[test-template-invocation:#11] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1792

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] Changed increment from -1 to 1 → KILLED

1793

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] Changed increment from -1 to 1 → KILLED

1794

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1798

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[test-template:shouldReconstructTargetForRoundTripPairs(int, java.lang.String, java.lang.String)]/[test-template-invocation:#5] negated conditional → KILLED

1799

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[test-template:shouldReconstructTargetForRoundTripPairs(int, java.lang.String, java.lang.String)]/[test-template-invocation:#8] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1802

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[test-template:shouldReconstructTargetForRoundTripPairs(int, java.lang.String, java.lang.String)]/[test-template-invocation:#11] Replaced integer addition with subtraction → KILLED

1803

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[test-template:shouldReconstructTargetForRoundTripPairs(int, java.lang.String, java.lang.String)]/[test-template-invocation:#8] Changed increment from -1 to 1 → KILLED

1804

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[test-template:shouldReconstructTargetForRoundTripPairs(int, java.lang.String, java.lang.String)]/[test-template-invocation:#8] Changed increment from -1 to 1 → KILLED

1809

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] negated conditional → KILLED

1810

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[test-template:shouldPreserveCorrectnessUnderMirroredInputOrientation(int, java.lang.String, java.lang.String)]/[test-template-invocation:#13] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1813

1.1
Location : buildPatchCommandBackward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ReversedWordProcessingTests]/[test-template:shouldReconstructReversedTargetsFromReversedSources(int, java.lang.String, java.lang.String)]/[test-template-invocation:#15] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::buildPatchCommandBackward → KILLED

1826

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.CompiledPatchCommandTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.CompiledPatchCommandTest]/[test-template:shouldReportInsufficientOutputCapacity(org.egothor.stemmer.WordTraversalDirection, java.lang.String, java.lang.String)]/[test-template-invocation:#14] Replaced integer addition with subtraction → KILLED

1834

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

2.2
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

1839

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

1840

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1843

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Replaced integer addition with subtraction → KILLED

1844

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Changed increment from 1 to -1 → KILLED

1848

1.1
Location : buildPatchCommandForward
Killed by : none negated conditional → SURVIVED Covering tests

1849

1.1
Location : buildPatchCommandForward
Killed by : none removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → NO_COVERAGE

1852

1.1
Location : buildPatchCommandForward
Killed by : none negated conditional → SURVIVED Covering tests

1853

1.1
Location : buildPatchCommandForward
Killed by : none removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → NO_COVERAGE

1856

1.1
Location : buildPatchCommandForward
Killed by : none removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → SURVIVED Covering tests

1857

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.CompiledPatchCommandTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.CompiledPatchCommandTest]/[test-template:shouldReportInsufficientOutputCapacity(org.egothor.stemmer.WordTraversalDirection, java.lang.String, java.lang.String)]/[test-template-invocation:#14] Changed increment from 1 to -1 → KILLED

1861

1.1
Location : buildPatchCommandForward
Killed by : none negated conditional → SURVIVED Covering tests

1862

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReconstructTargetWithForwardTraversalEncoderAndStaticApply()] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1865

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReconstructTargetWithForwardTraversalEncoderAndStaticApply()] negated conditional → KILLED

1866

1.1
Location : buildPatchCommandForward
Killed by : none removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → NO_COVERAGE

1869

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReconstructTargetWithForwardTraversalEncoderAndStaticApply()] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1870

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyToWithForwardTraversalDirection()] Changed increment from 1 to -1 → KILLED

1871

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldReconstructTargetWithForwardTraversalEncoderAndStaticApply()] Changed increment from 1 to -1 → KILLED

1875

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

1876

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ConstructionTests]/[method:shouldBuildDirectionSpecializedEncoderViaBuilder()] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1879

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Replaced integer addition with subtraction → KILLED

1880

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Changed increment from 1 to -1 → KILLED

1881

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] Changed increment from 1 to -1 → KILLED

1886

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] negated conditional → KILLED

1887

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1890

1.1
Location : buildPatchCommandForward
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ApplyTests]/[method:shouldApplyPatchViaInstanceLevelDirectionSpecializedFastPath()] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::buildPatchCommandForward → KILLED

1931

1.1
Location : traversalDirection
Killed by : org.egothor.stemmer.CompiledPatchCommandTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.CompiledPatchCommandTest]/[test-template:shouldReportInsufficientOutputCapacity(org.egothor.stemmer.WordTraversalDirection, java.lang.String, java.lang.String)]/[test-template-invocation:#1] replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::traversalDirection → KILLED

1942

1.1
Location : insertCost
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ConstructionTests]/[method:shouldRejectNegativeInsertCost()] replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::insertCost → KILLED

1953

1.1
Location : deleteCost
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ConstructionTests]/[method:shouldRejectNegativeInsertCost()] replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::deleteCost → KILLED

1964

1.1
Location : replaceCost
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ConstructionTests]/[method:shouldRejectNegativeInsertCost()] replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::replaceCost → KILLED

1975

1.1
Location : matchCost
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:ConstructionTests]/[method:shouldRejectNegativeInsertCost()] replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::matchCost → KILLED

1984

1.1
Location : build
Killed by : org.egothor.stemmer.PatchCommandEncoderTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.PatchCommandEncoderTest]/[nested-class:EncodeTests]/[method:shouldReturnNullWhenTargetIsNull()] replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::build → KILLED

Active mutators

Tests examined


Report generated by PIT 1.22.1