# Differential against mutmut, per mutant Generated by `scripts/differential.py`. Do not edit by hand: a later run rewrites it, and the page is checked for drift against the generated output. Two tools, joined on what the mutation *is* — `(module, original line, mutated line)` — rather than on any identifier, because they share none. mutmut is never authoritative here; a disagreement is a question with four permitted answers, and every one of them has been given. **15 projects compared.** Ten generated projects plus the five pinned M4 libraries (more-itertools, boltons, humanize, sqlparse, tomli), each at its recorded tag, in its own virtualenv, over the same bounded module sample the defect hunt used. mutmut runs pytest in-process, so each target's virtualenv carries mutmut and that project's own dependencies; moonbuggy runs against the same interpreter and the same dependencies. Stated exclusions and harness notes: - **tomli**: mutmut-only deselect: its in-process trampoline adds stack frames, so tomli's own recursion-limit tests fail under it before any mutation; they are not evidence either way | project | moonbuggy mutants | mutmut mutants | shared | agree | disagree | ambiguous | |---|---:|---:|---:|---:|---:|---:| | fixture | 29 | 44 | 16 | 15 | 2 | 2 | | gen-deep | 128 | 144 | 48 | 0 | 52 | 32 | | gen-dense | 32 | 36 | 12 | 0 | 16 | 8 | | gen-flat | 96 | 108 | 60 | 12 | 48 | 0 | | gen-slow | 48 | 54 | 18 | 18 | 4 | 12 | | gen-sparse | 160 | 90 | 30 | 0 | 40 | 40 | | gen-tall | 96 | 108 | 36 | 0 | 38 | 24 | | gen-tiny | 16 | 18 | 6 | 0 | 8 | 4 | | gen-uncovered | 144 | 27 | 9 | 0 | 15 | 36 | | gen-wide | 192 | 216 | 72 | 0 | 88 | 48 | | boltons | 666 | 1549 | 215 | 149 | 80 | 30 | | humanize | 204 | 434 | 101 | 65 | 41 | 10 | | more-itertools | 381 | 1038 | 198 | 136 | 69 | 27 | | sqlparse | 236 | 55 | 11 | 7 | 6 | 7 | | tomli | 333 | 1184 | 91 | 42 | 66 | 75 | **Agreement on shared mutants: 444/923 (48.1%).** ## Disagreements by category | category | count | |---|---:| | genuine semantic difference | 297 | | mutmut false kill (verified) | 2 | | not actually the same mutant | 94 | | vocabulary difference | 180 | ## Every disagreement - **fixture · inventory.py** — `return 0` → `return 1` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **fixture · loops.py** — `total = 0` → `total = 1` - moonbuggy `['KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 2 times in loops.py, so the join is ambiguous and no pairing can be asserted - **gen-deep · mod_0.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 4 == 0:` → `if i % 4 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 4 == 0:` → `if i % 4 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 4 == 0:` → `if i % 5 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 5 == 0:` → `if i % 5 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 5 == 0:` → `if i % 5 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 5 == 0:` → `if i % 6 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 6 == 0:` → `if i % 6 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 6 == 0:` → `if i % 6 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 6 == 0:` → `if i % 7 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 7 == 0:` → `if i % 7 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 7 == 0:` → `if i % 7 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 7 == 0:` → `if i % 8 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 8 == 0:` → `if i % 8 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 8 == 0:` → `if i % 8 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 8 == 0:` → `if i % 9 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 9 == 0:` → `if i % 10 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 9 == 0:` → `if i % 9 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `if i % 9 == 0:` → `if i % 9 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_0.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 8 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-deep · mod_0.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 8 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-deep · mod_1.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 4 == 0:` → `if i % 4 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 4 == 0:` → `if i % 4 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 4 == 0:` → `if i % 5 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 5 == 0:` → `if i % 5 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 5 == 0:` → `if i % 5 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 5 == 0:` → `if i % 6 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 6 == 0:` → `if i % 6 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 6 == 0:` → `if i % 6 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 6 == 0:` → `if i % 7 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 7 == 0:` → `if i % 7 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 7 == 0:` → `if i % 7 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 7 == 0:` → `if i % 8 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 8 == 0:` → `if i % 8 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 8 == 0:` → `if i % 8 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 8 == 0:` → `if i % 9 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 9 == 0:` → `if i % 10 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 9 == 0:` → `if i % 9 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `if i % 9 == 0:` → `if i % 9 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-deep · mod_1.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 8 times in mod_1.py, so the join is ambiguous and no pairing can be asserted - **gen-deep · mod_1.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 8 times in mod_1.py, so the join is ambiguous and no pairing can be asserted - **gen-dense · mod_0.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-dense · mod_0.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-dense · mod_0.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-dense · mod_0.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-dense · mod_0.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-dense · mod_0.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-dense · mod_0.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 2 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-dense · mod_0.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 2 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-dense · mod_1.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-dense · mod_1.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-dense · mod_1.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-dense · mod_1.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-dense · mod_1.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-dense · mod_1.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-dense · mod_1.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 2 times in mod_1.py, so the join is ambiguous and no pairing can be asserted - **gen-dense · mod_1.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 2 times in mod_1.py, so the join is ambiguous and no pairing can be asserted - **gen-flat · mod_0.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_0.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_0.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_0.py** — `total += i` → `total -= i` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_1.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_1.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_1.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_1.py** — `total += i` → `total -= i` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_10.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_10.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_10.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_10.py** — `total += i` → `total -= i` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_11.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_11.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_11.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_11.py** — `total += i` → `total -= i` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_2.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_2.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_2.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_2.py** — `total += i` → `total -= i` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_3.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_3.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_3.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_3.py** — `total += i` → `total -= i` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_4.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_4.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_4.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_4.py** — `total += i` → `total -= i` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_5.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_5.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_5.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_5.py** — `total += i` → `total -= i` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_6.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_6.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_6.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_6.py** — `total += i` → `total -= i` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_7.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_7.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_7.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_7.py** — `total += i` → `total -= i` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_8.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_8.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_8.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_8.py** — `total += i` → `total -= i` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_9.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_9.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_9.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-flat · mod_9.py** — `total += i` → `total -= i` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-slow · mod_0.py** — `total += i` → `total -= i` - moonbuggy `['KILLED', 'KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 3 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-slow · mod_0.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 3 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-slow · mod_1.py** — `total += i` → `total -= i` - moonbuggy `['KILLED', 'KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 3 times in mod_1.py, so the join is ambiguous and no pairing can be asserted - **gen-slow · mod_1.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 3 times in mod_1.py, so the join is ambiguous and no pairing can be asserted - **gen-sparse · mod_0.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_0.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_0.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_0.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_0.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_0.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_0.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 4 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-sparse · mod_0.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 4 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-sparse · mod_1.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_1.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_1.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_1.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_1.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_1.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_1.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 4 times in mod_1.py, so the join is ambiguous and no pairing can be asserted - **gen-sparse · mod_1.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 4 times in mod_1.py, so the join is ambiguous and no pairing can be asserted - **gen-sparse · mod_2.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_2.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_2.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_2.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_2.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_2.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_2.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 4 times in mod_2.py, so the join is ambiguous and no pairing can be asserted - **gen-sparse · mod_2.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 4 times in mod_2.py, so the join is ambiguous and no pairing can be asserted - **gen-sparse · mod_3.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_3.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_3.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_3.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_3.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_3.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_3.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 4 times in mod_3.py, so the join is ambiguous and no pairing can be asserted - **gen-sparse · mod_3.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 4 times in mod_3.py, so the join is ambiguous and no pairing can be asserted - **gen-sparse · mod_4.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_4.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_4.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_4.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_4.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_4.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-sparse · mod_4.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 4 times in mod_4.py, so the join is ambiguous and no pairing can be asserted - **gen-sparse · mod_4.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 4 times in mod_4.py, so the join is ambiguous and no pairing can be asserted - **gen-tall · mod_0.py** — `if i % 10 == 0:` → `if i % 10 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 10 == 0:` → `if i % 10 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 10 == 0:` → `if i % 11 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 11 == 0:` → `if i % 11 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 11 == 0:` → `if i % 11 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 11 == 0:` → `if i % 12 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 12 == 0:` → `if i % 12 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 12 == 0:` → `if i % 12 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 12 == 0:` → `if i % 13 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 13 == 0:` → `if i % 13 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 13 == 0:` → `if i % 13 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 13 == 0:` → `if i % 14 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 4 == 0:` → `if i % 4 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 4 == 0:` → `if i % 4 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 4 == 0:` → `if i % 5 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 5 == 0:` → `if i % 5 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 5 == 0:` → `if i % 5 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 5 == 0:` → `if i % 6 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 6 == 0:` → `if i % 6 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 6 == 0:` → `if i % 6 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 6 == 0:` → `if i % 7 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 7 == 0:` → `if i % 7 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 7 == 0:` → `if i % 7 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 7 == 0:` → `if i % 8 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 8 == 0:` → `if i % 8 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 8 == 0:` → `if i % 8 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 8 == 0:` → `if i % 9 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 9 == 0:` → `if i % 10 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 9 == 0:` → `if i % 9 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `if i % 9 == 0:` → `if i % 9 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tall · mod_0.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 12 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-tall · mod_0.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 12 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-tiny · mod_0.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tiny · mod_0.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tiny · mod_0.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tiny · mod_0.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tiny · mod_0.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tiny · mod_0.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-tiny · mod_0.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 2 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-tiny · mod_0.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 2 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-uncovered · mod_0.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-uncovered · mod_0.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-uncovered · mod_0.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-uncovered · mod_0.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 6 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-uncovered · mod_0.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 6 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-uncovered · mod_1.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-uncovered · mod_1.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-uncovered · mod_1.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-uncovered · mod_1.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 6 times in mod_1.py, so the join is ambiguous and no pairing can be asserted - **gen-uncovered · mod_1.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 6 times in mod_1.py, so the join is ambiguous and no pairing can be asserted - **gen-uncovered · mod_2.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-uncovered · mod_2.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-uncovered · mod_2.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-uncovered · mod_2.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 6 times in mod_2.py, so the join is ambiguous and no pairing can be asserted - **gen-uncovered · mod_2.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 6 times in mod_2.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_0.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_0.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_0.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_0.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_0.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_0.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_0.py** — `if i % 4 == 0:` → `if i % 4 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_0.py** — `if i % 4 == 0:` → `if i % 4 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_0.py** — `if i % 4 == 0:` → `if i % 5 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_0.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 3 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_0.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 3 times in mod_0.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_1.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_1.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_1.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_1.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_1.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_1.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_1.py** — `if i % 4 == 0:` → `if i % 4 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_1.py** — `if i % 4 == 0:` → `if i % 4 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_1.py** — `if i % 4 == 0:` → `if i % 5 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_1.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 3 times in mod_1.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_1.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 3 times in mod_1.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_2.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_2.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_2.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_2.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_2.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_2.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_2.py** — `if i % 4 == 0:` → `if i % 4 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_2.py** — `if i % 4 == 0:` → `if i % 4 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_2.py** — `if i % 4 == 0:` → `if i % 5 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_2.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 3 times in mod_2.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_2.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 3 times in mod_2.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_3.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_3.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_3.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_3.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_3.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_3.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_3.py** — `if i % 4 == 0:` → `if i % 4 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_3.py** — `if i % 4 == 0:` → `if i % 4 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_3.py** — `if i % 4 == 0:` → `if i % 5 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_3.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 3 times in mod_3.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_3.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 3 times in mod_3.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_4.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_4.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_4.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_4.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_4.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_4.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_4.py** — `if i % 4 == 0:` → `if i % 4 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_4.py** — `if i % 4 == 0:` → `if i % 4 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_4.py** — `if i % 4 == 0:` → `if i % 5 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_4.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 3 times in mod_4.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_4.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 3 times in mod_4.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_5.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_5.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_5.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_5.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_5.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_5.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_5.py** — `if i % 4 == 0:` → `if i % 4 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_5.py** — `if i % 4 == 0:` → `if i % 4 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_5.py** — `if i % 4 == 0:` → `if i % 5 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_5.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 3 times in mod_5.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_5.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 3 times in mod_5.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_6.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_6.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_6.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_6.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_6.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_6.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_6.py** — `if i % 4 == 0:` → `if i % 4 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_6.py** — `if i % 4 == 0:` → `if i % 4 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_6.py** — `if i % 4 == 0:` → `if i % 5 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_6.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 3 times in mod_6.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_6.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 3 times in mod_6.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_7.py** — `if i % 2 == 0:` → `if i % 2 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_7.py** — `if i % 2 == 0:` → `if i % 2 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_7.py** — `if i % 2 == 0:` → `if i % 3 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_7.py** — `if i % 3 == 0:` → `if i % 3 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_7.py** — `if i % 3 == 0:` → `if i % 3 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_7.py** — `if i % 3 == 0:` → `if i % 4 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_7.py** — `if i % 4 == 0:` → `if i % 4 != 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_7.py** — `if i % 4 == 0:` → `if i % 4 == 1:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_7.py** — `if i % 4 == 0:` → `if i % 5 == 0:` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **gen-wide · mod_7.py** — `total += i` → `total -= i` - moonbuggy `['NO_COVERAGE', 'NO_COVERAGE', 'NO_COVERAGE']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total += i` -> `total -= i` occurs 3 times in mod_7.py, so the join is ambiguous and no pairing can be asserted - **gen-wide · mod_7.py** — `total = 0` → `total = 1` - moonbuggy `['SURVIVED', 'SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `total = 0` -> `total = 1` occurs 3 times in mod_7.py, so the join is ambiguous and no pairing can be asserted - **boltons · iterutils.py** — `cur_chunk[lc:] = [fill_val] * (size - lc)` → `cur_chunk[lc:] = [fill_val] / (size - lc)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `def sep_func(x): return False` → `def sep_func(x): return True` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **boltons · iterutils.py** — `def value_transform(x): return f(x[1])` → `def value_transform(x): return f(x[2])` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `elif cache and id_value in registry:` → `elif cache or id_value in registry:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `elif visited_item is True:` → `elif visited_item is False:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `for i in range(1, count):` → `for i in range(2, count):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if count != 'repeat' and count < 0:` → `if count != 'repeat' or count < 0:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if count != 'repeat' and count < 0:` → `if count == 'repeat' and count < 0:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if count == 'repeat':` → `if count != 'repeat':` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if i == strip_value:` → `if i != strip_value:` - moonbuggy `['KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `if i == strip_value:` -> `if i != strip_value:` occurs 2 times in iterutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · iterutils.py** — `if isinstance(item, Iterable) and not isinstance(item, (str, bytes)):` → `if isinstance(item, Iterable) or not isinstance(item, (str, bytes)):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if key is not None and not callable(key):` → `if key is not None or not callable(key):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if key_filter is None or key_filter(key_of_val):` → `if key_filter is None and key_filter(key_of_val):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if len(key) != len(src):` → `if len(key) == len(src):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if maxsplit is not None and split_count >= maxsplit:` → `if maxsplit is not None or split_count >= maxsplit:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if new_items is not False:` → `if new_items is not True:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if not (-1.0 <= jitter <= 1.0):` → `if not (-1.0 <= jitter < 1.0):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if start < 0.0:` → `if start <= 0.0:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if stop < start:` → `if stop <= start:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if stop == 0.0:` → `if stop != 0.0:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if value < 0 or (strictly_positive and value == 0):` → `if value < 0 or (strictly_positive and value != 0):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if value < 0 or (strictly_positive and value == 0):` → `if value < 0 or (strictly_positive or value == 0):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if value < 0 or (strictly_positive and value == 0):` → `if value < 1 or (strictly_positive and value == 0):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if value < 0 or (strictly_positive and value == 0):` → `if value <= 0 or (strictly_positive and value == 0):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `if visited_item is False:` → `if visited_item is True:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `key = key or (lambda x: x)` → `key = key and (lambda x: x)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `key_funcs = [_make_key_func(key)] + [_make_key_func(k) for k in keys]` → `key_funcs = [_make_key_func(key)] - [_make_key_func(k) for k in keys]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `last = last or []` → `last = last and []` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `new_items_stack[-1][1].append(visited_item)` → `new_items_stack[-1][2].append(visited_item)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `new_items_stack[-1][1].append(visited_item)` → `new_items_stack[-2][1].append(visited_item)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `overlap_size, 'overlap_size', strictly_positive=False)` → `overlap_size, 'overlap_size', strictly_positive=True)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `parts = [[] for _ in range(len(key_funcs) + 1)]` → `parts = [[] for _ in range(len(key_funcs) + 2)]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `parts = [[] for _ in range(len(key_funcs) + 1)]` → `parts = [[] for _ in range(len(key_funcs) - 1)]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `path += (key,)` → `path -= (key,)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `raise ValueError('expected a positive integer ' + name)` → `raise ValueError('expected a positive integer ' - name)` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **boltons · iterutils.py** — `ret = [None] * count` → `ret = [None] / count` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `ret = [redundant_groups[k][1] for k in redundant_order]` → `ret = [redundant_groups[k][2] for k in redundant_order]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `ret[0] = start` → `ret[1] = start` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `ret[i] = ret[i - 1] + step` → `ret[i] = ret[i + 1] + step` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `ret[i] = ret[i - 1] + step` → `ret[i] = ret[i - 2] + step` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `return True` → `return False` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `return first + other + last` → `return first + other - last` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `return first + other + last` → `return first - other + last` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `return lambda x, k=k: getattr(x, k, False)` → `return lambda x, k=k: getattr(x, k, True)` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **boltons · iterutils.py** — `return ones[0] if len(ones) == 1 else default` → `return ones[1] if len(ones) == 1 else default` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · iterutils.py** — `return value, False` → `return value, True` - moonbuggy `['KILLED_BY_ERROR', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `return value, False` -> `return value, True` occurs 2 times in iterutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · iterutils.py** — `start, stop = 0.0, stop * 1.0` → `start, stop = 0.0, stop / 1.0` - moonbuggy `['NO_COVERAGE', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `start, stop = 0.0, stop * 1.0` -> `start, stop = 0.0, stop / 1.0` occurs 2 times in iterutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · iterutils.py** — `stop, start = start * 1.0, stop * 1.0` → `stop, start = start * 1.0, stop / 1.0` - moonbuggy `['SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `stop, start = start * 1.0, stop * 1.0` -> `stop, start = start * 1.0, stop / 1.0` occurs 2 times in iterutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · iterutils.py** — `stop, start = start * 1.0, stop * 1.0` → `stop, start = start / 1.0, stop * 1.0` - moonbuggy `['SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `stop, start = start * 1.0, stop * 1.0` -> `stop, start = start / 1.0, stop * 1.0` occurs 2 times in iterutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · iterutils.py** — `visited_item = True` → `visited_item = False` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · mathutils.py** — `if i == len(options):` → `if i != len(options):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `delimiter = delimiter and delimiter.strip() + ' '` → `delimiter = delimiter and delimiter.strip() - ' '` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `delta = x - contig_range[0]` → `delta = x - contig_range[1]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `elif delta > 1:` → `elif delta > 2:` - moonbuggy `['KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `elif delta > 1:` -> `elif delta > 2:` occurs 2 times in strutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · strutils.py** — `elif delta > 1:` → `elif delta >= 1:` - moonbuggy `['SURVIVED', 'SURVIVED']`, mutmut `['SURVIVED', 'SURVIVED']` - **not actually the same mutant**: the change `elif delta > 1:` -> `elif delta >= 1:` occurs 2 times in strutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · strutils.py** — `elif len(contig_range) > 1:` → `elif len(contig_range) > 2:` - moonbuggy `['KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `elif len(contig_range) > 1:` -> `elif len(contig_range) > 2:` occurs 2 times in strutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · strutils.py** — `elif len(contig_range) > 1:` → `elif len(contig_range) >= 1:` - moonbuggy `['KILLED', 'SURVIVED']`, mutmut `['KILLED', 'SURVIVED']` - **not actually the same mutant**: the change `elif len(contig_range) > 1:` -> `elif len(contig_range) >= 1:` occurs 2 times in strutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · strutils.py** — `ext = _ORDINAL_MAP.get(numstr[-1], 'th')` → `ext = _ORDINAL_MAP.get(numstr[-2], 'th')` - moonbuggy `['KILLED', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `ext = _ORDINAL_MAP.get(numstr[-1], 'th')` -> `ext = _ORDINAL_MAP.get(numstr[-2], 'th')` occurs 2 times in strutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · strutils.py** — `if delta == 1:` → `if delta != 1:` - moonbuggy `['KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `if delta == 1:` -> `if delta != 1:` occurs 2 times in strutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · strutils.py** — `if delta == 1:` → `if delta == 2:` - moonbuggy `['KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `if delta == 1:` -> `if delta == 2:` occurs 2 times in strutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · strutils.py** — `if numstr and numstr[-1] in string.digits:` → `if numstr and numstr[-2] in string.digits:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `if target_type and target_type != type(cleaned):` → `if target_type or target_type != type(cleaned):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `indented_lines = [(margin + line if key(line) else line)` → `indented_lines = [(margin - line if key(line) else line)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `output_str = (delim+' ').join(output)` → `output_str = (delim - ' ').join(output)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `plural = word + 's'` → `plural = word - 's'` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `plural = word if word.endswith('es') else word + 'es'` → `plural = word if word.endswith('es') else word - 'es'` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `plural = word[:-1] + 'ies'` → `plural = word[:-1] - 'ies'` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `result.append('\\' * len(bs_buf)*2)` → `result.append('\\' * len(bs_buf) / 2)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `result.append('\\' * len(bs_buf)*2)` → `result.append('\\' / len(bs_buf)*2)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `return False` → `return True` - moonbuggy `['KILLED', 'NO_COVERAGE', 'KILLED', 'KILLED']`, mutmut `['KILLED', 'SURVIVED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `return False` -> `return True` occurs 4 times in strutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · strutils.py** — `return True` → `return False` - moonbuggy `['KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `return True` -> `return False` occurs 2 times in strutils.py, so the join is ambiguous and no pairing can be asserted - **boltons · strutils.py** — `return f'{items[0]} {conjunction} {items[1]}'` → `return f'{items[0]} {conjunction} {items[2]}'` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `return items[0]` → `return items[1]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `return numstr + ext` → `return numstr - ext` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `return zlib.decompress(bytestring, 16 + zlib.MAX_WBITS)` → `return zlib.decompress(bytestring, 16 - zlib.MAX_WBITS)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `return zlib.decompress(bytestring, 16 + zlib.MAX_WBITS)` → `return zlib.decompress(bytestring, 17 + zlib.MAX_WBITS)` - moonbuggy `SURVIVED`, mutmut `KILLED` - **mutmut false kill (verified)**: mutmut records KILLED (child exit 1) for x_gunzip_bytes__mutmut_1, but the mutant applied to the real source leaves the full 445-test suite green (verified by direct experiment) and gunzip_bytes behaves identically under it: 17 + MAX_WBITS equals (16 + MAX_WBITS) | 1, and 16 only ever receives gzip bytes, which both window settings accept. moonbuggy's SURVIVED is the verdict the suite supports - **boltons · strutils.py** — `singular = word[:-1] # or just return word?` → `singular = word[:-2] # or just return word?` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **boltons · strutils.py** — `singular = word[:-3] + 'y'` → `singular = word[:-3] - 'y'` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `start, end = match.start(1), match.end(1)` → `start, end = match.start(1), match.end(2)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **boltons · strutils.py** — `start, end = match.start(1), match.end(1)` → `start, end = match.start(2), match.end(1)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **humanize · number.py** — `digits = int(max(0, precision - exponent % 3 - 1))` → `digits = int(max(0, precision + exponent % 3 - 1))` - moonbuggy `['SUSPICIOUS', 'SURVIVED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `digits = int(max(0, precision - exponent % 3 - 1))` -> `digits = int(max(0, precision + exponent % 3 - 1))` occurs 2 times in number.py, so the join is ambiguous and no pairing can be asserted - **humanize · number.py** — `digits = int(max(0, precision - exponent % 3 - 1))` → `digits = int(max(0, precision - exponent % 3 + 1))` - moonbuggy `['SUSPICIOUS', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `digits = int(max(0, precision - exponent % 3 - 1))` -> `digits = int(max(0, precision - exponent % 3 + 1))` occurs 2 times in number.py, so the join is ambiguous and no pairing can be asserted - **humanize · number.py** — `digits = int(max(0, precision - exponent % 3 - 1))` → `digits = int(max(0, precision - exponent % 3 - 2))` - moonbuggy `['SUSPICIOUS', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `digits = int(max(0, precision - exponent % 3 - 1))` -> `digits = int(max(0, precision - exponent % 3 - 2))` occurs 2 times in number.py, so the join is ambiguous and no pairing can be asserted - **humanize · number.py** — `digits = int(max(0, precision - exponent % 3 - 1))` → `digits = int(max(0, precision - exponent % 4 - 1))` - moonbuggy `['SUSPICIOUS', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `digits = int(max(0, precision - exponent % 3 - 1))` -> `digits = int(max(0, precision - exponent % 4 - 1))` occurs 2 times in number.py, so the join is ambiguous and no pairing can be asserted - **humanize · number.py** — `digits = int(max(0, precision - exponent % 3 - 1))` → `digits = int(max(1, precision - exponent % 3 - 1))` - moonbuggy `['SUSPICIOUS', 'SURVIVED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `digits = int(max(0, precision - exponent % 3 - 1))` -> `digits = int(max(1, precision - exponent % 3 - 1))` occurs 2 times in number.py, so the join is ambiguous and no pairing can be asserted - **humanize · number.py** — `elif ceil is not None and value > ceil:` → `elif ceil is not None or value > ceil:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **humanize · number.py** — `elif exponent < 0:` → `elif exponent < 1:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `elif exponent < 0:` → `elif exponent <= 0:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `exponent = int(math.floor(math.log10(abs(value)))) if value != 0 else 0` → `exponent = int(math.floor(math.log10(abs(value)))) if value != 0 else 1` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `exponent = int(math.floor(math.log10(abs(value)))) if value != 0 else 0` → `exponent = int(math.floor(math.log10(abs(value)))) if value != 1 else 0` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `exponent = int(math.floor(math.log10(abs(value)))) if value != 0 else 0` → `exponent = int(math.floor(math.log10(abs(value)))) if value == 0 else 0` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if exponent < 30 and round(abs(value), digits) >= 1000:` → `if exponent < 30 and round(abs(value), digits) > 1000:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if exponent < 30 and round(abs(value), digits) >= 1000:` → `if exponent < 30 and round(abs(value), digits) >= 1001:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if exponent < 30 and round(abs(value), digits) >= 1000:` → `if exponent < 30 or round(abs(value), digits) >= 1000:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if exponent < 30 and round(abs(value), digits) >= 1000:` → `if exponent < 31 and round(abs(value), digits) >= 1000:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if exponent < 30 and round(abs(value), digits) >= 1000:` → `if exponent <= 30 and round(abs(value), digits) >= 1000:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if exponent >= 33 or exponent < -30:` → `if exponent > 33 or exponent < -30:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if exponent >= 33 or exponent < -30:` → `if exponent >= 33 and exponent < -30:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if exponent >= 33 or exponent < -30:` → `if exponent >= 33 or exponent < -31:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if exponent >= 33 or exponent < -30:` → `if exponent >= 33 or exponent <= -30:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if exponent >= 33 or exponent < -30:` → `if exponent >= 34 or exponent < -30:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if exponent >= 3:` → `if exponent > 3:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if exponent >= 3:` → `if exponent >= 4:` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if floor is not None and value < floor:` → `if floor is not None or value < floor:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **humanize · number.py** — `if not (unit or ordinal_) or unit in ("°", "′", "″"):` → `if not (unit and ordinal_) or unit in ("°", "′", "″"):` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `if not 0 <= value < 10:` → `if not 0 <= value < 11:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **humanize · number.py** — `if not 0 <= value < 10:` → `if not 0 <= value <= 10:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **humanize · number.py** — `new_bucket = exponent // 3 * 3` → `new_bucket = exponent / 3 * 3` - moonbuggy `SURVIVED`, mutmut `KILLED` - **mutmut false kill (verified)**: mutmut records KILLED (child exit 1) for all 123 x_metric__mutmut_* floor-division mutants, but each one activated through mutmut's own trampoline (MUTANT_UNDER_TEST set, mutants/ tree first on sys.path) leaves the full 783-test suite green -- verified for every one of the 123. A 22,210-case input sweep finds no output the mutant changes (the enclosing branch only runs at exponent multiples of 3, where floor and true division agree), so no test can kill it. mutmut's per-function test selection runs a test subset whose recorded exit 1 is stale. moonbuggy's SURVIVED is the verdict the suite supports - **humanize · number.py** — `old_bucket = exponent // 3 * 3` → `old_bucket = exponent / 3 * 3` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `old_bucket = exponent // 3 * 3` → `old_bucket = exponent // 3 * 4` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `old_bucket = exponent // 3 * 3` → `old_bucket = exponent // 3 / 3` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `old_bucket = exponent // 3 * 3` → `old_bucket = exponent // 4 * 3` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `ordinal_ = "kMGTPEZYRQ"[exponent // 3 - 1]` → `ordinal_ = "kMGTPEZYRQ"[exponent / 3 - 1]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **humanize · number.py** — `result = result.translate(str.maketrans(",.", thousands_sep + decimal_sep))` → `result = result.translate(str.maketrans(",.", thousands_sep - decimal_sep))` - moonbuggy `NO_COVERAGE`, mutmut `SURVIVED` - **genuine semantic difference**: no test covers this line at all. moonbuggy reports NO_COVERAGE because an untested line is a finding -- a different finding from `tested but not checked`, but a finding. mutmut has no tests to run for the function and reports the run it could not make rather than the gap it found. Both are defensible; they are answers to different questions - **humanize · number.py** — `return scientific(value, precision - 1) + unit` → `return scientific(value, precision + 1) + unit` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `return scientific(value, precision - 1) + unit` → `return scientific(value, precision - 1) - unit` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `return scientific(value, precision - 1) + unit` → `return scientific(value, precision - 2) + unit` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `return token + format(value)` → `return token - format(value)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **humanize · number.py** — `return token + format.format(value)` → `return token - format.format(value)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **humanize · number.py** — `value /= 10**old_bucket` → `value /= 10 * old_bucket` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **humanize · number.py** — `value /= 10**old_bucket` → `value /= 11**old_bucket` - moonbuggy `SUSPICIOUS`, mutmut `KILLED` - **genuine semantic difference**: moonbuggy declines a confident status where mutmut gives one; see M1.4.3 -- a flaky covering test makes both KILLED and SURVIVED unsupportable - **more-itertools · recipes.py** — `c, n = c * (n - r) // n, n - 1` → `c, n = c * (n + r) // n, n - 1` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `c, n = c * (n - r) // n, n - 1` → `c, n = c / (n - r) // n, n - 1` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `c, n, r = c * r // n, n - 1, r - 1` → `c, n, r = c * r // n, n + 1, r - 1` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `c, n, r = c * r // n, n - 1, r - 1` → `c, n, r = c * r // n, n - 1, r + 1` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `c, n, r = c * r // n, n - 1, r - 1` → `c, n, r = c / r // n, n - 1, r - 1` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `data = bytearray((0, 1)) * (n // 2)` → `data = bytearray((0, 1)) * (n / 2)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `data = bytearray((0, 1)) * (n // 2)` → `data = bytearray((0, 1)) / (n // 2)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `data = bytearray((0, 1)) * (n // 2)` → `data = bytearray((1, 1)) * (n // 2)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `data[p * p : n : p + p] = bytes(len(range(p * p, n, p + p)))` → `data[p * p : n : p - p] = bytes(len(range(p * p, n, p + p)))` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `data[p * p : n : p + p] = bytes(len(range(p * p, n, p + p)))` → `data[p / p : n : p + p] = bytes(len(range(p * p, n, p + p)))` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `elif n == 1:` → `elif n != 1:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `elif n == 1:` → `elif n == 2:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `elif n == 2:` → `elif n == 3:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `elif n > 2:` → `elif n > 3:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `for p in iter_index(data, 1, start, stop=isqrt(n) + 1):` → `for p in iter_index(data, 2, start, stop=isqrt(n) + 1):` - moonbuggy `TIMEOUT`, mutmut `KILLED` - **genuine semantic difference**: mutmut derives its own timeout from a baseline run rather than taking ours, so which mutants time out need not match - **more-itertools · recipes.py** — `if index < 0:` → `if index < 1:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if index < 0:` → `if index <= 0:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if len(seq) == 0:` → `if len(seq) != 0:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if len(seq) == 0:` → `if len(seq) == 1:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if maxlen <= 0:` → `if maxlen < 0:` - moonbuggy `['KILLED', 'KILLED_BY_ERROR', 'KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `if maxlen <= 0:` -> `if maxlen < 0:` occurs 4 times in recipes.py, so the join is ambiguous and no pairing can be asserted - **more-itertools · recipes.py** — `if maxlen <= 0:` → `if maxlen <= 1:` - moonbuggy `['KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `if maxlen <= 0:` -> `if maxlen <= 1:` occurs 4 times in recipes.py, so the join is ambiguous and no pairing can be asserted - **more-itertools · recipes.py** — `if n < 1:` → `if n < 2:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if n < 1:` → `if n <= 1:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if not 0 <= index < c:` → `if not 0 < index < c:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if not 0 <= index < c:` → `if not 0 <= index <= c:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if not 0 <= index < c:` → `if not 1 <= index < c:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if sds and sds[0][0] == index - maxlen:` → `if sds and sds[0][0] == index + maxlen:` - moonbuggy `KILLED`, mutmut `TIMEOUT` - **genuine semantic difference**: mutmut derives its own timeout from a baseline run rather than taking ours, so which mutants time out need not match - **more-itertools · recipes.py** — `if sds and sds[0][0] == index - maxlen:` → `if sds and sds[0][1] == index - maxlen:` - moonbuggy `KILLED`, mutmut `TIMEOUT` - **genuine semantic difference**: mutmut derives its own timeout from a baseline run rather than taking ours, so which mutants time out need not match - **more-itertools · recipes.py** — `if sds and sds[0][0] == index - maxlen:` → `if sds and sds[1][0] == index - maxlen:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if sds and sds[0][0] == index - maxlen:` → `if sds or sds[0][0] == index - maxlen:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if sis and sis[0][0] == index - maxlen:` → `if sis and sis[1][0] == index - maxlen:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if sis and sis[0][0] == index - maxlen:` → `if sis or sis[0][0] == index - maxlen:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if strict and len(batch) != n:` → `if strict and len(batch) == n:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `if strict and len(batch) != n:` → `if strict or len(batch) != n:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `index += c` → `index -= c` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `index -= c` → `index += c` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `iterators = [iter(iterable)] * n` → `iterators = [iter(iterable)] / n` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `m = n // 2` → `m = n / 2` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `n //= prime` → `n /= prime` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `pools = tuple(map(tuple, iterables)) * repeat` → `pools = tuple(map(tuple, iterables)) / repeat` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `result.append(pool[-1 - n])` → `result.append(pool[-2 - n])` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `return False` → `return True` - moonbuggy `['KILLED', 'KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `return False` -> `return True` occurs 3 times in recipes.py, so the join is ambiguous and no pairing can be asserted - **more-itertools · recipes.py** — `return True` → `return False` - moonbuggy `['KILLED', 'KILLED', 'KILLED_BY_ERROR', 'TIMEOUT', 'TIMEOUT']`, mutmut `['KILLED', 'KILLED', 'KILLED', 'TIMEOUT', 'TIMEOUT']` - **not actually the same mutant**: the change `return True` -> `return False` occurs 5 times in recipes.py, so the join is ambiguous and no pairing can be asserted - **more-itertools · recipes.py** — `return map(next, map(itemgetter(1), groupby(iterable, key)))` → `return map(next, map(itemgetter(2), groupby(iterable, key)))` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `start = p * p` → `start = p / p` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `t0, t1, t2, t3 = tee(iterable, 4)` → `t0, t1, t2, t3 = tee(iterable, 5)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `t1, t2, t3 = tee(iterable, 3)` → `t1, t2, t3 = tee(iterable, 4)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `todo += (fact, n // fact)` → `todo += (fact, n / fact)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `todo += (fact, n // fact)` → `todo -= (fact, n // fact)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `while True:` → `while False:` - moonbuggy `['KILLED', 'KILLED', 'KILLED', 'KILLED_BY_ERROR', 'NO_COVERAGE', 'KILLED', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `while True:` -> `while False:` occurs 7 times in recipes.py, so the join is ambiguous and no pairing can be asserted - **more-itertools · recipes.py** — `while sds and not sds[-1][1] > value: # Remove non-decreasing values` → `while sds and not sds[-1][2] > value: # Remove non-decreasing values` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `while sds and not sds[-1][1] > value: # Remove non-decreasing values` → `while sds and not sds[-2][1] > value: # Remove non-decreasing values` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `while sds and not sds[-1][1] > value: # Remove non-decreasing values` → `while sds or not sds[-1][1] > value: # Remove non-decreasing values` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `while sis and not sis[-1][1] < value: # Remove non-increasing values` → `while sis and not sis[-1][2] < value: # Remove non-increasing values` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `while sis and not sis[-1][1] < value: # Remove non-increasing values` → `while sis and not sis[-2][1] < value: # Remove non-increasing values` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `while sis and not sis[-1][1] < value: # Remove non-increasing values` → `while sis or not sis[-1][1] < value: # Remove non-increasing values` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `window = deque([0], maxlen=n) * n` → `window = deque([0], maxlen=n) / n` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `x = (x * x + b) % n` → `x = (x / x + b) % n` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `y = (y * y + b) % n` → `y = (y * y - b) % n` - moonbuggy `['TIMEOUT', 'TIMEOUT']`, mutmut `['TIMEOUT', 'TIMEOUT']` - **not actually the same mutant**: the change `y = (y * y + b) % n` -> `y = (y * y - b) % n` occurs 2 times in recipes.py, so the join is ambiguous and no pairing can be asserted - **more-itertools · recipes.py** — `y = (y * y + b) % n` → `y = (y / y + b) % n` - moonbuggy `['KILLED_BY_ERROR', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `y = (y * y + b) % n` -> `y = (y / y + b) % n` occurs 2 times in recipes.py, so the join is ambiguous and no pairing can be asserted - **more-itertools · recipes.py** — `yield (hi[0] - lo[0]) / 2` → `yield (hi[0] - lo[1]) / 2` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `yield (hi[0] - lo[0]) / 2` → `yield (hi[1] - lo[0]) / 2` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `yield -lo[0]` → `yield -lo[1]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `yield from iter_index(data, 1, start, p * p)` → `yield from iter_index(data, 1, start, p / p)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `yield ordered[m] if n & 1 else (ordered[m - 1] + ordered[m]) / 2` → `yield ordered[m] if n & 1 else (ordered[m + 1] + ordered[m]) / 2` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `yield sds[0][1] # Window maximum at position 0` → `yield sds[0][2] # Window maximum at position 0` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `yield sds[0][1] # Window maximum at position 0` → `yield sds[1][1] # Window maximum at position 0` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `yield sis[0][1] # Window minimum at position 0` → `yield sis[0][2] # Window minimum at position 0` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **more-itertools · recipes.py** — `yield sis[0][1] # Window minimum at position 0` → `yield sis[1][1] # Window minimum at position 0` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **sqlparse · utils.py** — `if i and isinstance(token, i):` → `if i or isinstance(token, i):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **sqlparse · utils.py** — `if val[0] in ('"', "'", '`') and val[0] == val[-1]:` → `if val[1] in ('"', "'", '`') and val[0] == val[-1]:` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **sqlparse · utils.py** — `outputlines[-1] += line` → `outputlines[-1] -= line` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **sqlparse · utils.py** — `outputlines[-1] += line` → `outputlines[-2] += line` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **sqlparse · utils.py** — `return False` → `return True` - moonbuggy `['KILLED_BY_ERROR', 'TIMEOUT']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `return False` -> `return True` occurs 2 times in utils.py, so the join is ambiguous and no pairing can be asserted - **sqlparse · utils.py** — `return True` → `return False` - moonbuggy `['KILLED', 'KILLED', 'KILLED', 'NO_COVERAGE', 'KILLED']`, mutmut `['KILLED', 'KILLED', 'KILLED', 'SURVIVED', 'KILLED']` - **not actually the same mutant**: the change `return True` -> `return False` occurs 5 times in utils.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `abs_key_parent = header + key_parent` → `abs_key_parent = header - key_parent` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `c = src[pos : pos + 1]` → `c = src[pos : pos + 2]` - moonbuggy `['KILLED_BY_ERROR', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `c = src[pos : pos + 1]` -> `c = src[pos : pos + 2]` occurs 2 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `c = src[pos : pos + 1]` → `c = src[pos : pos - 1]` - moonbuggy `['KILLED_BY_ERROR', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `c = src[pos : pos + 1]` -> `c = src[pos : pos - 1]` occurs 2 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `escape_id = src[pos : pos + 2]` → `escape_id = src[pos : pos + 3]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `escape_id = src[pos : pos + 2]` → `escape_id = src[pos : pos - 2]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `first_four = src[pos : pos + 4]` → `first_four = src[pos : pos + 5]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `first_four = src[pos : pos + 4]` → `first_four = src[pos : pos - 4]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `first_three = src[pos : pos + 3]` → `first_three = src[pos : pos + 4]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `first_three = src[pos : pos + 3]` → `first_three = src[pos : pos - 3]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `hex_str = src[pos : pos + hex_len]` → `hex_str = src[pos : pos - hex_len]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `if char == "'":` → `if char != "'":` - moonbuggy `['KILLED_BY_ERROR', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `if char == "'":` -> `if char != "'":` occurs 2 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `if char == '"':` → `if char != '"':` - moonbuggy `['KILLED_BY_ERROR', 'KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `if char == '"':` -> `if char != '"':` occurs 3 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `if len(hex_str) != hex_len or not HEXDIGIT_CHARS.issuperset(hex_str):` → `if len(hex_str) == hex_len or not HEXDIGIT_CHARS.issuperset(hex_str):` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `key += (key_part,)` → `key -= (key_part,)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `key_parent, key_stem = key[:-1], key[-1]` → `key_parent, key_stem = key[:-1], key[-2]` - moonbuggy `['KILLED_BY_ERROR', 'KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `key_parent, key_stem = key[:-1], key[-1]` -> `key_parent, key_stem = key[:-1], key[-2]` occurs 3 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `key_parent, key_stem = key[:-1], key[-1]` → `key_parent, key_stem = key[:-2], key[-1]` - moonbuggy `['KILLED', 'KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `key_parent, key_stem = key[:-1], key[-1]` -> `key_parent, key_stem = key[:-2], key[-1]` occurs 3 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `out.flags.set(header + key, Flags.FROZEN, recursive=True)` → `out.flags.set(header - key, Flags.FROZEN, recursive=True)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)` → `out.flags.set(key, Flags.EXPLICIT_NEST, recursive=True)` - moonbuggy `['KILLED_BY_ERROR', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)` -> `out.flags.set(key, Flags.EXPLICIT_NEST, recursive=True)` occurs 2 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `pos += 1` → `pos += 2` - moonbuggy `['KILLED', 'KILLED', 'KILLED', 'KILLED_BY_ERROR', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'SURVIVED', 'KILLED', 'KILLED', 'KILLED', 'SURVIVED', 'KILLED']`, mutmut `['KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'SURVIVED', 'KILLED', 'KILLED', 'KILLED', 'SURVIVED', 'KILLED']` - **not actually the same mutant**: the change `pos += 1` -> `pos += 2` occurs 17 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `pos += 1` → `pos -= 1` - moonbuggy `['KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'TIMEOUT', 'SURVIVED', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'TIMEOUT', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'SURVIVED', 'KILLED', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'TIMEOUT', 'TIMEOUT']`, mutmut `['KILLED', 'KILLED', 'KILLED', 'SURVIVED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'TIMEOUT', 'KILLED', 'KILLED', 'SURVIVED', 'KILLED', 'KILLED', 'KILLED', 'TIMEOUT', 'TIMEOUT']` - **not actually the same mutant**: the change `pos += 1` -> `pos -= 1` occurs 17 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `pos += 1 # Skip "["` → `pos -= 1 # Skip "["` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `pos += 2 # Skip "[["` → `pos -= 2 # Skip "[["` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `pos = end_pos + 3` → `pos = end_pos - 3` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `relative_path_cont_keys = (header + key[:i] for i in range(1, len(key)))` → `relative_path_cont_keys = (header - key[:i] for i in range(1, len(key)))` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `result += parsed_escape` → `result -= parsed_escape` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `result += src[start_pos:pos]` → `result -= src[start_pos:pos]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)` → `return (0 < codepoint <= 55295) or (57344 <= codepoint <= 1114111)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)` → `return (0 <= codepoint < 55295) or (57344 <= codepoint <= 1114111)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)` → `return (0 <= codepoint <= 55295) or (57344 < codepoint <= 1114111)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)` → `return (0 <= codepoint <= 55295) or (57344 <= codepoint < 1114111)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)` → `return (0 <= codepoint <= 55295) or (57345 <= codepoint <= 1114111)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)` → `return (1 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return parse_basic_str_escape(src, pos, multiline=True)` → `return parse_basic_str_escape(src, pos, multiline=False)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return parse_hex_char(src, pos, 2)` → `return parse_hex_char(src, pos, 3)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return parse_hex_char(src, pos, 8)` → `return parse_hex_char(src, pos, 9)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return parse_multiline_str(src, pos, literal=False)` → `return parse_multiline_str(src, pos, literal=True)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return parse_multiline_str(src, pos, literal=True)` → `return parse_multiline_str(src, pos, literal=False)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 1, array` → `return pos + 2, array` - moonbuggy `['KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `return pos + 1, array` -> `return pos + 2, array` occurs 3 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `return pos + 1, array` → `return pos - 1, array` - moonbuggy `['KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `return pos + 1, array` -> `return pos - 1, array` occurs 3 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `return pos + 1, key` → `return pos + 2, key` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 1, key` → `return pos - 1, key` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 1, nested_dict.dict` → `return pos + 2, nested_dict.dict` - moonbuggy `['KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `return pos + 1, nested_dict.dict` -> `return pos + 2, nested_dict.dict` occurs 3 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `return pos + 1, nested_dict.dict` → `return pos - 1, nested_dict.dict` - moonbuggy `['KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `return pos + 1, nested_dict.dict` -> `return pos - 1, nested_dict.dict` occurs 3 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _parser.py** — `return pos + 1, result + src[start_pos:pos]` → `return pos + 1, result - src[start_pos:pos]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 1, result + src[start_pos:pos]` → `return pos - 1, result + src[start_pos:pos]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 1, src[start_pos:pos] # Skip ending apostrophe` → `return pos - 1, src[start_pos:pos] # Skip ending apostrophe` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 2, key` → `return pos + 3, key` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 2, key` → `return pos - 2, key` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 3, parse_float(first_three)` → `return pos + 4, parse_float(first_three)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 3, parse_float(first_three)` → `return pos - 3, parse_float(first_three)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 3, result + src[start_pos:pos]` → `return pos + 3, result - src[start_pos:pos]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 3, result + src[start_pos:pos]` → `return pos - 3, result + src[start_pos:pos]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 4, True` → `return pos - 4, True` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 4, parse_float(first_four)` → `return pos + 5, parse_float(first_four)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 4, parse_float(first_four)` → `return pos - 4, parse_float(first_four)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos + 5, False` → `return pos - 5, False` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos, result + (delim * 2)` → `return pos, result + (delim / 2)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `return pos, result + delim` → `return pos, result - delim` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `second_char: str | None = src[pos + 1]` → `second_char: str | None = src[pos + 2]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `second_char: str | None = src[pos + 1]` → `second_char: str | None = src[pos - 1]` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `src, pos + 1, "\n", error_on=ILLEGAL_COMMENT_CHARS, error_on_eof=False` → `src, pos + 1, "\n", error_on=ILLEGAL_COMMENT_CHARS, error_on_eof=True` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _parser.py** — `while True:` → `while False:` - moonbuggy `['KILLED', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED', 'KILLED']` - **not actually the same mutant**: the change `while True:` -> `while False:` occurs 6 times in _parser.py, so the join is ambiguous and no pairing can be asserted - **tomli · _re.py** — `micros = int(micros_str.ljust(6, "0")) if micros_str else 0` → `micros = int(micros_str.ljust(6, "0")) if micros_str else 1` - moonbuggy `['KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `micros = int(micros_str.ljust(6, "0")) if micros_str else 0` -> `micros = int(micros_str.ljust(6, "0")) if micros_str else 1` occurs 2 times in _re.py, so the join is ambiguous and no pairing can be asserted - **tomli · _re.py** — `micros = int(micros_str.ljust(6, "0")) if micros_str else 0` → `micros = int(micros_str.ljust(7, "0")) if micros_str else 0` - moonbuggy `['KILLED_BY_ERROR', 'KILLED_BY_ERROR']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `micros = int(micros_str.ljust(6, "0")) if micros_str else 0` -> `micros = int(micros_str.ljust(7, "0")) if micros_str else 0` occurs 2 times in _re.py, so the join is ambiguous and no pairing can be asserted - **tomli · _re.py** — `return int(match.group(), 0)` → `return int(match.group(), 1)` - moonbuggy `KILLED_BY_ERROR`, mutmut `KILLED` - **vocabulary difference**: both tools killed the mutant. moonbuggy additionally reports whether the kill was a failed assertion or a test erroring out; mutmut reads only pytest's exit code and has one word for both - **tomli · _re.py** — `sec = int(sec_str) if sec_str else 0` → `sec = int(sec_str) if sec_str else 1` - moonbuggy `['KILLED', 'KILLED']`, mutmut `['KILLED', 'KILLED']` - **not actually the same mutant**: the change `sec = int(sec_str) if sec_str else 0` -> `sec = int(sec_str) if sec_str else 1` occurs 2 times in _re.py, so the join is ambiguous and no pairing can be asserted