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