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)¶

38 operator categories (27 tree-sitter + 11 regex), ~160+ distinct mutations. Python-specific, operates on tree-sitter CST.

Operators implemented¶

Skip rules¶

• Enum subclass methods (Enum, IntEnum, StrEnum, Flag, IntFlag) — EnumMeta metaclass conflicts
• Functions containing nonlocal — skipped for trampoline path (source-patch path handles these)
• Descriptor-decorated functions (@property, @classmethod, @staticmethod) — mutated via trampoline
• Other decorated functions (@lru_cache, @app.route, custom decorators) — mutated via source-patching
• __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.