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

Mutations

216

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

220

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

224

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

228

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

236

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

249

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

262

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

263

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

265

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

266

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

269

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

270

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:#14] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encode → KILLED

272

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

297

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

298

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

300

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

301

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

303

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

316

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

335

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

361

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

362

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

364

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

365

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

367

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:#4] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::apply → KILLED

384

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

424

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:#3] changed conditional boundary → KILLED

425

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

427

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

428

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

462

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

465

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

466

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

468

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

470

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

484

1.1
Location : encodeBackward
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:#14] removed call to java/util/concurrent/locks/ReentrantLock::lock → KILLED

486

1.1
Location : encodeBackward
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:#14] 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

487

1.1
Location : encodeBackward
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:#14] removed call to org/egothor/stemmer/PatchCommandEncoder::initializeBoundaryConditionsBackward → KILLED

492

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

495

1.1
Location : encodeBackward
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:#14] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::encodeBackward → KILLED

497

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

512

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

514

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

515

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

520

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

523

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

525

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

538

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

539

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

542

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

543

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:#3] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyBackwardNonNull → KILLED

545

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

546

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

549

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

550

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

555

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

558

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

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] Replaced integer addition with subtraction → KILLED

565

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

566

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

568

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

572

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

577

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

578

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

580

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

581

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

586

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

587

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

591

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

594

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

600

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

603

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

606

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

617

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

618

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

621

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

622

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

624

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

625

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:#4] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applyForwardNonNull → KILLED

628

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

629

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

637

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

639

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

644

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

645

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

647

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

651

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

656

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

657

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

659

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

660

1.1
Location : applyForwardNonNull
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

668

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

671

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

677

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

680

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

683

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

701

1.1
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:#14] 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:#11] 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:#14] changed conditional boundary → KILLED

702

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

704

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

707

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

708

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

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:#8] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::applySingleBackwardInstruction → KILLED

713

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

714

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

717

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

718

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

721

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

724

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

727

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

749

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

750

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

752

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

755

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

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] removed call to java/lang/String::getChars → KILLED

758

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

761

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

762

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

766

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

769

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

772

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

775

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

797

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

799

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

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] Replaced integer addition with subtraction → KILLED

814

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

827

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

838

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

840

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

842

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

855

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

868

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

882

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

883

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

884

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

886

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

887

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

889

1.1
Location : computeAppliedLength
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::computeAppliedLength → KILLED

900

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

901

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

903

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

904

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

908

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

909

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

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] Replaced integer addition with subtraction → KILLED

916

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

917

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

919

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

923

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

924

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

930

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

931

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

933

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

934

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

935

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

936

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

938

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

942

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

943

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

945

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

946

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

950

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

953

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

959

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

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] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeBackwardAppliedLength → KILLED

972

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

973

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

975

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

976

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

981

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

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:#5] Replaced integer addition with subtraction → KILLED

988

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

989

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

991

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

995

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

996

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

1002

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

1003

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

1005

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

1006

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

1010

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

1011

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

1013

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

1017

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

1020

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

1026

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

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:#1] replaced int return with 0 for org/egothor/stemmer/PatchCommandEncoder::computeForwardAppliedLength → KILLED

1045

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

1047

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

1050

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

1052

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

1055

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

1071

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

1082

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

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] Replaced integer addition with subtraction → KILLED

1087

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

1094

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

1102

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

1112

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

1130

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:#3] negated conditional → KILLED

1131

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

1135

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

1136

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

1139

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

1140

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

1142

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

1161

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

1162

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

1166

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

1167

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

1170

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

1171

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

1173

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

1188

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:#3] 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

1189

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:#3] negated conditional → KILLED

1202

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:#3] 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:#3] negated conditional → KILLED

1203

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:#3] 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:#3] Replaced bitwise AND with OR → 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:shouldApplyToPreserveSourceForMalformedOrIndexInvalidPatchCommands(int, java.lang.String, java.lang.String)]/[test-template-invocation:#5] replaced boolean return with false for org/egothor/stemmer/PatchCommandEncoder::isKnownPreserveOnlyPatch → 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:#7] negated conditional → KILLED

1207

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

1209

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

1210

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

1212

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

1230

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

1232

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

1234

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

1236

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

1238

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

1241

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

1254

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

1256

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

1263

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

1265

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

1268

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

1273

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

1286

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

1287

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

1289

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

1293

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

1294

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

1296

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

1299

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

1300

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

1305

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

1306

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

1308

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

1309

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

1310

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

1311

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

1313

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

1316

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

1317

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

1319

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

1320

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

1323

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

1326

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

1330

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

1332

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

1346

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

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:#5] Replaced integer addition with subtraction → KILLED

1352

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

1353

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

1355

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

1358

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

1359

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

1364

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

1365

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

1367

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

1368

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

1371

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

1372

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

1374

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

1377

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

1380

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

1384

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

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:#1] replaced boolean return with true for org/egothor/stemmer/PatchCommandEncoder::hasForwardPreserveOnlyPatch → KILLED

1400

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

1401

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

1415

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

1416

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

1421

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

1422

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

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] Replaced integer addition with subtraction → KILLED

1428

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

1432

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

1436

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

1437

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

1438

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

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:#7] Replaced integer subtraction with addition → KILLED

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

1444

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

1445

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

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:#2] Replaced integer addition with subtraction → KILLED

1448

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

1449

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

1459

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

1473

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

1474

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

1480

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

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] Replaced integer addition with subtraction → KILLED

1486

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

1490

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

1495

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

1497

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

1498

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

1502

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

1504

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

1505

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

1515

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

1529

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

1530

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

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:#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

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] Changed increment from 1 to -1 → KILLED

1547

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

1548

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

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 increment from 1 to -1 → KILLED

1566

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

1569

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

1570

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

1571

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

1583

1.1
Location : decodeEncodedCount
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:#14] 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

1584

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

1586

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

1597

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

1601

1.1
Location : ensureCapacity
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:#14] Replaced integer addition with subtraction → KILLED

1602

1.1
Location : ensureCapacity
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:#14] Replaced integer addition with subtraction → KILLED

1619

1.1
Location : initializeBoundaryConditionsBackward
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:#14] changed conditional boundary → KILLED

2.2
Location : initializeBoundaryConditionsBackward
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:#14] negated conditional → KILLED

1620

1.1
Location : initializeBoundaryConditionsBackward
Killed by : org.egothor.stemmer.benchmark.generalization.EditCostSensitivityApplicationTest.[engine:junit-jupiter]/[class:org.egothor.stemmer.benchmark.generalization.EditCostSensitivityApplicationTest]/[method:scaledOperationCostsShouldBeEquivalent()] Replaced integer multiplication with division → KILLED

1624

1.1
Location : initializeBoundaryConditionsBackward
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:#14] 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

1625

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

1640

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

1641

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

1646

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

1647

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

1676

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

1678

1.1
Location : fillMatrices
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:#14] Replaced integer addition with subtraction → KILLED

1681

1.1
Location : fillMatrices
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:#14] Replaced integer addition with subtraction → KILLED

1688

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

1691

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

1700

1.1
Location : fillMatrices
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:#14] 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

1701

1.1
Location : fillMatrices
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:#14] Replaced integer addition with subtraction → KILLED

1702

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

1704

1.1
Location : fillMatrices
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:#14] 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

1705

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

1706

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

1708

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

1709

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

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:StemmingScenarioTests]/[method:shouldHandleSingleCharacterReplacement()] negated conditional → KILLED

1712

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

1718

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

1722

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

1726

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

1748

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

1756

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:#14] negated conditional → KILLED

2.2
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:#14] negated conditional → KILLED

1761

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:#14] negated conditional → KILLED

1762

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

1765

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:#14] Replaced integer addition with subtraction → 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:#14] Changed increment from -1 to 1 → KILLED

1770

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

1771

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

1774

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

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:#14] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1778

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

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] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1783

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

1784

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

1787

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

1788

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

1791

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

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()] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1797

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

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:#8] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1801

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

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:#8] Changed increment from -1 to 1 → 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

1808

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:#14] negated conditional → KILLED

1809

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:#14] removed call to org/egothor/stemmer/PatchCommandEncoder::appendInstruction → KILLED

1812

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:#14] replaced return value with "" for org/egothor/stemmer/PatchCommandEncoder::buildPatchCommandBackward → KILLED

1825

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

1833

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

1838

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

1839

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

1842

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

1843

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

1847

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

1848

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

1851

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

1852

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

1855

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

1856

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

1860

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

1861

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

1864

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

1865

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

1868

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

1869

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

1870

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

1874

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

1875

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

1878

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

1879

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

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

1885

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

1886

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

1889

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

1930

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:#2] replaced return value with null for org/egothor/stemmer/PatchCommandEncoder$Builder::traversalDirection → KILLED

1941

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

1952

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

1963

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

1974

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

1983

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