Convert an augmented assignment (x += v) to a plain assignment (x = v), dropping the accumulation, verifying that the update operator is tested.

# before
total += amount

# after
total = amount

Replace break with return, exiting the enclosing function instead of just the loop, verifying that the loop's exit path is tested.

# before
for item in items:
    if item.done:
        break

# after
for item in items:
    if item.done:
        return

Negate a comparison expression by wrapping it with not (...), verifying that the direction of every comparison is tested.

# before
if x > 0:
    process(x)

# after
if not (x > 0):
    process(x)

Remove a function or class definition entirely (only when others remain in the same body), surfacing unreferenced definitions.

# before
def helper():
    return 42

def main():
    return helper()

# after
def main():
    return helper()

Force the test of an if/while/assert/ternary to always be True or always False, verifying that both branches are meaningfully exercised.

# before
if is_valid(x):
    save(x)

# after
if True:
    save(x)

Replace expressions that have well-known failure modes with a raise of the exception they can produce. This targets error-handling paths that pass on the happy path but silently break when the environment misbehaves.

The contracts are intentionally narrow — stdlib only, no inference:

Mutations are skipped when the expression is already inside a try/except that handles the relevant exception, and never injected inside except blocks.

# before
value = data[key]

# after
raise KeyError(key)

Use --without-exception-injection to skip all InjectException mutations when error-handling paths are intentionally untested or produce too much noise.

Replace the right-hand side of a plain assignment with None, verifying that the assigned value is not silently ignored.

# before
result = compute()

# after
result = None

Replace each positional call argument with None, and drop one argument at a time from multi-argument calls, verifying that every argument is actually used.

# before
result = process(data, config)

# after
result = process(None, config)

Swap in ↔ not in in membership tests, verifying that the expected membership relationship is directly tested.

# before
if key in cache:
    return cache[key]

# after
if key not in cache:
    return cache[key]

Strip context managers from a with statement one at a time, keeping the body, verifying that each manager's effect is tested.

# before
with lock:
    update_shared_state()

# after
update_shared_state()

Remove leading default argument values one at a time, making parameters required, verifying that callers always supply them explicitly.

# before
def connect(host, port=8080, timeout=30):
    ...

# after
def connect(host, port, timeout=30):
    ...

Replace the specific exception type in an except clause with the generic Exception, verifying that the handler is tested for the right error kind.

# before
try:
    connect()
except ConnectionError:
    retry()

# after
try:
    connect()
except Exception:
    retry()

Replace each interpolated expression in an f-string with an empty string, verifying that callers check the formatted content rather than just the surrounding template.

# before
msg = f"expected {actual}, got {result}"

# after
msg = f"expected , got {result}"

Remove a global or nonlocal declaration entirely, causing assignments to bind a local variable instead, verifying that the scoping is exercised by tests.

# before
def increment():
    global counter
    counter += 1

# after
def increment():
    counter += 1

Swap is ↔ is not in identity comparisons, verifying that the expected identity relationship is directly tested.

# before
if obj is None:
    init()

# after
if obj is not None:
    init()

Wrap a for-loop's iterable in reversed(), verifying that iteration order assumptions are tested.

# before
for item in queue:
    process(item)

# after
for item in reversed(queue):
    process(item)

Rotate flow keywords (break/continue/pass), swap boolean constants (True/False/None), and flip boolean operators (and/or).

# before
while True:
    if done:
        break

# after
while True:
    if done:
        continue

Replace the body of a lambda with None (or 0 when the body is already None), verifying that the lambda's computation is actually used.

# before
transform = lambda x: x * 2

# after
transform = lambda x: None

Remove one case branch at a time from a match statement (Python 3.10+ only), verifying that each branch is exercised by the test suite.

# before
match command:
    case "quit":
        quit()
    case "go":
        go()

# after
match command:
    case "go":
        go()

Replace an integer or float literal with a random value in the same bit-range, verifying that the exact numeric value is tested.

# before
TIMEOUT = 30

# after
TIMEOUT = 17

Replace an arithmetic, bitwise, shift, or comparison operator with another in the same group, verifying the exact operator matters.

# before
result = a + b

# after
result = a - b

Replace a return value with a type-appropriate default (None, 0, False, or ""), verifying that callers check what the function returns.

# before
def get_count():
    return len(items)

# after
def get_count():
    return 0

Drop the lower or upper bound of a slice (a[i:j] → a[:j] or a[i:]) and negate the step (a[::2] → a[::-2]), verifying that slice boundary conditions and direction are tested.

# before
chunk = data[start:end]

# after
chunk = data[:end]

Prepend a fixed prefix to a string or bytes literal, verifying that callers check the actual content.

# before
label = "hello"

# after
label = "mutated string hello"

Swap directionally symmetric string methods (lower↔upper, lstrip↔rstrip, find↔rfind, ljust↔rjust, removeprefix↔removesuffix, partition↔rpartition, split↔rsplit), verifying that the direction matters.

# before
name = text.lower()

# after
name = text.upper()

Replace the value of a yield expression with None, verifying that the yielded value is actually used by callers.

# before
def generate():
    yield compute()

# after
def generate():
    yield None

Wrap a bare (non-comparison) condition with not, inserting the logical inverse of the test, verifying that the truthiness of the value actually matters.

# before
if user.is_active:
    allow()

# after
if not user.is_active:
    allow()

Remove one decorator at a time from a decorated function or class, verifying that each decorator's effect is covered by tests.

# before
@login_required
def dashboard(request):
    return render(request)

# after
def dashboard(request):
    return render(request)

Strip a unary operator (not, -, ~) and leave only the operand, verifying that the operator's effect is covered by tests.

# before
if not flag:
    skip()

# after
if flag:
    skip()

Replace a covered statement with pass, verifying that no statement is inert dead code.

# before
x = compute()
validate(x)

# after
x = compute()
pass

Swap each pair of positional call arguments, verifying that argument order is tested.

# before
result = process(source, dest)

# after
result = process(dest, source)

Replace a for-loop's iterable with an empty list, forcing the body to never execute, verifying that callers handle empty-collection cases.

# before
for item in items:
    process(item)

# after
for item in []:
    process(item)