Mutation Operators — Cross-Framework Reference¶

A comprehensive catalog of mutation operators across the mutation testing ecosystem. Compiled as a reference for irradiate's operator coverage and future development.

irradiate (current)¶

27 operator categories, ~160+ distinct mutations. Python-specific, operates on tree-sitter CST.

Operators implemented¶

Skip rules¶

• Decorated functions (any decorator) — skipped entirely (trampoline incompatibility)
• Enum subclass methods (Enum, IntEnum, StrEnum, Flag, IntFlag) — EnumMeta metaclass conflicts
• Functions containing nonlocal — trampoline extraction breaks scope chains
• __getattribute__, __setattr__, __new__
• len(), isinstance() calls (arg_removal skipped — trivially killed, noisy)
• Generator expression / comprehension arguments (arg_removal skipped — invalid syntax)
• Triple-quoted strings (docstrings) — string_mutation and string_emptying skipped
• Strings containing their own delimiter character
• # pragma: no mutate lines

Python Ecosystem¶

mutmut¶

The reference implementation irradiate descends from. Uses LibCST for parsing.

Operators largely overlap with irradiate. Notable additions beyond irradiate's current set: - String literal case mutations: "FooBar"→"foobar", "foobar"→"FOOBAR" - Dict keyword argument mutation: dict(a=1)→dict(aXX=1) - break→return, continue→break keyword swaps - split↔rsplit (conditional on maxsplit arg)

cosmic-ray¶

Parso-based. Takes a combinatorial approach — generates all pairwise permutations.

mutpy¶

Python ast-based. Follows classical academic mutation operator naming (AOR, ROR, etc.). Has the richest OOP-specific operators.

JVM Ecosystem¶

PIT (pitest) — Java¶

The most widely-used Java mutation tester. Operates on bytecode. Operators grouped into tiers: OLD_DEFAULTS, DEFAULTS, STRONGER, ALL. Commercial extension Arcmutate adds EXTENDED/EXTREME.

DEFAULTS group (recommended production set):

ALL/Experimental (additional):

Arcmutate EXTENDED (commercial):

Stream/builder-specific: REMOVE_DISTINCT, REMOVE_FILTER, REMOVE_LIMIT, REMOVE_SKIP, REMOVE_SORTED, REMOVE_PREDICATE_NEGATION/AND/OR, CHAINED_CALLS removal, SWAP_PARAMS, SWAP_ALL_MATCH, varargs removal, reactive map swaps (concatMap↔flatMap↔switchMap).

Major — Java¶

Compiler plugin (source-level). 9 operator categories following classical naming.

Stryker4s — Scala¶

AST-level, Scala-specific.

Unique features: - 18 Scala method expression swaps: filter↔filterNot, exists↔forall, take↔drop, takeRight↔dropRight, takeWhile↔dropWhile, isEmpty↔nonEmpty, indexOf↔lastIndexOf, max↔min, maxBy↔minBy - Regex mutation via weapon-regex library (20+ patterns: anchor removal, class negation, quantifier removal, lookaround inversion, Unicode property swap) - Conditional replacement: if(cond)→if(true)/if(false), while(cond)→while(false)

JavaScript/TypeScript Ecosystem¶

Stryker Mutator — JS/TS¶

The most comprehensive JS/TS mutation tester.

C#/.NET Ecosystem¶

Stryker.NET¶

Shares the Stryker operator taxonomy with JS/TS-specific additions.

Notable unique operators: - LINQ method swaps (35 pairs): All↔Any, First↔Last, Skip↔Take, OrderBy↔OrderByDescending, Union↔Intersect, Concat↔Except, Min↔Max, Count↔Sum, etc. - Math method swaps (23): trig function cross-swaps (Sin↔Cos↔Tan and hyperbolic variants), Floor↔Ceiling, Exp↔Log - String methods (16): StartsWith↔EndsWith, ToLower↔ToUpper, TrimStart↔TrimEnd, PadLeft↔PadRight, IndexOf↔LastIndexOf, Trim→"", Substring→"" - Initialization emptying: arrays, lists, dictionaries, objects→empty - Removal mutators: method call removal, return removal, break/continue/goto/throw removal, yield removal - Checked statement removal: checked(expr)→expr - Null-coalescing: a ?? b→b ?? a, a, b - Regex: 37 operators (most comprehensive regex mutation of any tool)

Rust Ecosystem¶

cargo-mutants¶

Operates on Rust source. Unique approach: function body replacement is the primary strategy.

C/C++ Ecosystem¶

Mull (LLVM-based)¶

Operates on LLVM IR. 44 operators.

Standard set: arithmetic (6), arithmetic assignment (5), comparison (6), boundary (4), bitwise (6), bitwise assignment (5), increment/decrement (4), logical (2), constant assignment (2), function call removal/replacement (2).

PHP Ecosystem¶

Infection¶

The most operator-rich framework overall. 200+ distinct mutation operators.

Unique operators not found elsewhere: - Function unwrapping (49): strip a function call, return its first argument (array_filter($a, $f)→$a, strtolower($s)→$s, etc.) - Return value mutations (11): return $this→return null, return func()→func(); return null, return $arr→return array_slice($arr, 0, 1, true) - Type cast removal (6): (int)$v→$v, (string)$v→$v, etc. - Loop mutations (6): foreach($x as ...)→foreach([] as ...), while($c)→while(false), do{} while($c)→do{} while(false) - Exception mutations (3): remove throw, remove finally, unwrap try/finally - Visibility reduction: public→protected, protected→private - Catch block dissection: remove individual exception types from catch (A|B $e) - Ternary branch swap: $x ? $a : $b→$x ? $b : $a - Null-safe removal: $obj?->method()→$obj->method() - Spread mutations: [...$arr]→$arr, [...$arr, 2]→[[...$arr][0], 2] - Rounding family (6): round↔floor↔ceil (all pairwise) - BCMath/MBString: replace arbitrary-precision and multibyte functions with standard equivalents

Cross-Ecosystem Comparison Matrix¶

Operators that exist in 3+ ecosystems are considered "universal". Operators unique to 1-2 tools are noted.

Opportunities for irradiate¶

Operators implemented by multiple frameworks that irradiate does not yet have, ranked by likely value for Python.

Implemented (March 2026)¶

The following gaps from the original audit have been closed:

• ~~Condition negation~~ — condition_negation operator: if cond:→if not (cond):, while, assert, ternary
• ~~Condition→true/false~~ — condition_replacement operator: if cond:→if True:/if False:, while, elif
• ~~Statement deletion~~ — statement_deletion operator: assign→pass, return→return None, expr→pass, raise→pass
• ~~break↔continue~~ — keyword_swap operator
• ~~Exception handler mutation~~ — exception_type operator: broaden to except Exception:
• ~~Zero-iteration loop~~ — loop_mutation operator: for x in items:→for x in []:, while cond:→while False:
• ~~Return value replacement~~ — return_value operator: return x→return None
• ~~Ternary branch swap~~ — ternary_swap operator: a if cond else b→b if cond else a
• ~~String emptying~~ — string_emptying operator: "foo"→""
• ~~Unary +↔-~~ — unary_swap operator
• ~~Slice index removal~~ — slice_index_removal operator: x[1:3]→x[:3]/x[1:], three-part slices

Remaining opportunities¶

1. Decorator removal — Remove @decorator individually (cosmic-ray, mutpy). Blocked: trampoline architecture skips decorated functions entirely. Requires architectural changes to support.
2. Constant replacement (42→0, 0→1, c→-c) — More aggressive than current n+1. May produce many equivalent mutants.
3. self.x→x — mutpy only. Tests that self is correctly used. Narrow.
4. super() manipulation — mutpy only. Tests inheritance chains. Narrow.
5. Regex mutation — Applicable but complex. Would need a regex parser.

Not applicable to Python¶

• Visibility reduction — No access modifiers.
• Type cast removal — No explicit casts.
• Optional chaining — No ?. operator.
• ++/-- swap — No increment operators.