@mutineerjs/mutineer 0.2.3 → 0.3.2

package/README.md

@@ -26,25 +26,31 @@ Mutations are applied using Babel AST analysis, so operators inside strings and
 
 ## Supported Mutations (WIP)
 
-| Category   | Mutator         | Transformation     |
-| ---------- | --------------- | ------------------ |
-| Equality   | `flipStrictEQ`  | `===` → `!==` |
-|            | `flipStrictNEQ` | `!==` → `===` |
-|            | `flipEQ`        | `==` → `!=`   |
-|            | `flipNEQ`       | `!=` → `==`   |
-| Boundary   | `relaxLE`       | `<=` &rarr; `<`    |
-|            | `relaxGE`       | `>=` &rarr; `>`    |
-|            | `tightenLT`     | `<` &rarr; `<=`    |
-|            | `tightenGT`     | `>` &rarr; `>=`    |
-| Logical    | `andToOr`       | `&&` &rarr; `\|\|` |
-|            | `orToAnd`       | `\|\|` &rarr; `&&` |
-|            | `nullishToOr`   | `??` &rarr; `\|\|` |
-| Arithmetic | `addToSub`      | `+` &rarr; `-`     |
-|            | `subToAdd`      | `-` &rarr; `+`     |
-|            | `mulToDiv`      | `*` &rarr; `/`     |
-|            | `divToMul`      | `/` &rarr; `*`     |
-|            | `modToMul`      | `%` &rarr; `*`     |
-|            | `powerToMul`    | `**` &rarr; `*`    |
+| Category     | Mutator             | Transformation                       |
+| ------------ | ------------------- | ------------------------------------ |
+| Equality     | `flipStrictEQ`      | `===` &rarr; `!==`                   |
+|              | `flipStrictNEQ`     | `!==` &rarr; `===`                   |
+|              | `flipEQ`            | `==` &rarr; `!=`                     |
+|              | `flipNEQ`           | `!=` &rarr; `==`                     |
+| Boundary     | `relaxLE`           | `<=` &rarr; `<`                      |
+|              | `relaxGE`           | `>=` &rarr; `>`                      |
+|              | `tightenLT`         | `<` &rarr; `<=`                      |
+|              | `tightenGT`         | `>` &rarr; `>=`                      |
+| Logical      | `andToOr`           | `&&` &rarr; `\|\|`                   |
+|              | `orToAnd`           | `\|\|` &rarr; `&&`                   |
+|              | `nullishToOr`       | `??` &rarr; `\|\|`                   |
+| Arithmetic   | `addToSub`          | `+` &rarr; `-`                       |
+|              | `subToAdd`          | `-` &rarr; `+`                       |
+|              | `mulToDiv`          | `*` &rarr; `/`                       |
+|              | `divToMul`          | `/` &rarr; `*`                       |
+|              | `modToMul`          | `%` &rarr; `*`                       |
+|              | `powerToMul`        | `**` &rarr; `*`                      |
+| Return value | `returnToNull`      | `return x` &rarr; `return null`      |
+|              | `returnToUndefined` | `return x` &rarr; `return undefined` |
+|              | `returnFlipBool`    | `return true` &harr; `return false`  |
+|              | `returnZero`        | `return n` &rarr; `return 0`         |
+|              | `returnEmptyStr`    | `return s` &rarr; `return ''`        |
+|              | `returnEmptyArr`    | `return [...]` &rarr; `return []`    |
 
 ## Installation
 
@@ -56,11 +62,11 @@ npm i @mutineerjs/mutineer
 
 ### Commands
 
-| Command          | Description                                          |
-| ---------------- | ---------------------------------------------------- |
-| `mutineer init`  | Create a `mutineer.config.ts` with minimal defaults  |
-| `mutineer run`   | Run mutation testing                                 |
-| `mutineer clean` | Remove leftover `__mutineer__` temp directories      |
+| Command          | Description                                         |
+| ---------------- | --------------------------------------------------- |
+| `mutineer init`  | Create a `mutineer.config.ts` with minimal defaults |
+| `mutineer run`   | Run mutation testing                                |
+| `mutineer clean` | Remove leftover `__mutineer__` temp directories     |
 
 ### Quick Start
 
@@ -93,7 +99,7 @@ npm run mutineer
 | ------------------------ | ------------------------------------------ | ------------- |
 | `--runner <type>`        | Test runner: `vitest` or `jest`            | `vitest`      |
 | `--config`, `-c`         | Path to config file                        | auto-detected |
-| `--concurrency <n>`      | Parallel workers (1-4)                     | CPUs - 1      |
+| `--concurrency <n>`      | Parallel workers (min 1)                   | CPUs - 1      |
 | `--changed`              | Only mutate files changed vs base branch   | --            |
 | `--changed-with-deps`    | Include dependents of changed files        | --            |
 | `--only-covered-lines`   | Skip mutations on uncovered lines          | --            |
@@ -140,23 +146,23 @@ export default defineMutineerConfig({
 
 ### Config Options
 
-| Option              | Type                               | Description                                      |
-| ------------------- | ---------------------------------- | ------------------------------------------------ |
-| `source`            | `string \| string[]`               | Glob patterns for source files to mutate         |
-| `targets`           | `MutateTarget[]`                   | Explicit list of files to mutate                 |
-| `runner`            | `'vitest' \| 'jest'`               | Test runner to use                               |
-| `vitestConfig`      | `string`                           | Path to vitest config                            |
-| `jestConfig`        | `string`                           | Path to jest config                              |
-| `include`           | `string[]`                         | Only run these mutators                          |
-| `exclude`           | `string[]`                         | Skip these mutators                              |
-| `excludePaths`      | `string[]`                         | Glob patterns for paths to skip                  |
-| `maxMutantsPerFile` | `number`                           | Cap mutations per file                           |
-| `minKillPercent`    | `number`                           | Fail if kill rate is below this                  |
-| `onlyCoveredLines`  | `boolean`                          | Only mutate lines covered by tests               |
-| `perTestCoverage`   | `boolean`                          | Use per-test coverage to select tests            |
-| `baseRef`           | `string`                           | Git ref for `--changed` (default: `origin/main`) |
-| `testPatterns`      | `string[]`                         | Globs for test file discovery                    |
-| `extensions`        | `string[]`                         | File extensions to consider                      |
+| Option              | Type                 | Description                                      |
+| ------------------- | -------------------- | ------------------------------------------------ |
+| `source`            | `string \| string[]` | Glob patterns for source files to mutate         |
+| `targets`           | `MutateTarget[]`     | Explicit list of files to mutate                 |
+| `runner`            | `'vitest' \| 'jest'` | Test runner to use                               |
+| `vitestConfig`      | `string`             | Path to vitest config                            |
+| `jestConfig`        | `string`             | Path to jest config                              |
+| `include`           | `string[]`           | Only run these mutators                          |
+| `exclude`           | `string[]`           | Skip these mutators                              |
+| `excludePaths`      | `string[]`           | Glob patterns for paths to skip                  |
+| `maxMutantsPerFile` | `number`             | Cap mutations per file                           |
+| `minKillPercent`    | `number`             | Fail if kill rate is below this                  |
+| `onlyCoveredLines`  | `boolean`            | Only mutate lines covered by tests               |
+| `perTestCoverage`   | `boolean`            | Use per-test coverage to select tests            |
+| `baseRef`           | `string`             | Git ref for `--changed` (default: `origin/main`) |
+| `testPatterns`      | `string[]`           | Globs for test file discovery                    |
+| `extensions`        | `string[]`           | File extensions to consider                      |
 
 ## File Support
 

package/dist/core/__tests__/module.spec.js

@@ -1,6 +1,69 @@
 import { describe, it, expect } from 'vitest';
-describe('Module', () => {
-    it('should pass a basic test', () => {
-        expect(true).toBe(true);
+import { mutateModuleSource } from '../module.js';
+describe('mutateModuleSource', () => {
+    it('returns empty array for code with no mutable patterns', () => {
+        const result = mutateModuleSource('const x = 1');
+        expect(result).toEqual([]);
+    });
+    it('generates mutations for equality operators', () => {
+        const code = 'if (a === b) {}';
+        const result = mutateModuleSource(code);
+        expect(result.length).toBeGreaterThan(0);
+        expect(result.some((v) => v.name === 'flipStrictEQ')).toBe(true);
+    });
+    it('generates mutations for logical operators', () => {
+        const code = 'const x = a && b';
+        const result = mutateModuleSource(code);
+        expect(result.some((v) => v.name === 'andToOr')).toBe(true);
+    });
+    it('generates mutations for arithmetic operators', () => {
+        const code = 'const x = a + b';
+        const result = mutateModuleSource(code);
+        expect(result.some((v) => v.name === 'addToSub')).toBe(true);
+    });
+    it('deduplicates identical mutations', () => {
+        const code = 'if (a === b) {}';
+        const result = mutateModuleSource(code);
+        const codes = result.map((v) => v.code);
+        expect(new Set(codes).size).toBe(codes.length);
+    });
+    it('respects include filter', () => {
+        const code = 'if (a === b && c || d) {}';
+        const result = mutateModuleSource(code, ['andToOr']);
+        expect(result.every((v) => v.name === 'andToOr')).toBe(true);
+    });
+    it('respects exclude filter', () => {
+        const code = 'if (a === b && c || d) {}';
+        const result = mutateModuleSource(code, undefined, ['flipStrictEQ']);
+        expect(result.every((v) => v.name !== 'flipStrictEQ')).toBe(true);
+    });
+    it('respects max limit', () => {
+        const code = 'if (a === b && c || d) {}';
+        const all = mutateModuleSource(code);
+        expect(all.length).toBeGreaterThan(1);
+        const limited = mutateModuleSource(code, undefined, undefined, 1);
+        expect(limited).toHaveLength(1);
+    });
+    it('throws when max is 0', () => {
+        expect(() => mutateModuleSource('code', undefined, undefined, 0)).toThrow('max must be a positive number');
+    });
+    it('throws when max is negative', () => {
+        expect(() => mutateModuleSource('code', undefined, undefined, -1)).toThrow('max must be a positive number');
+    });
+    it('includes line and col in variants', () => {
+        const code = 'const x = a + b';
+        const result = mutateModuleSource(code);
+        for (const v of result) {
+            expect(typeof v.line).toBe('number');
+            expect(typeof v.col).toBe('number');
+        }
+    });
+    it('produces valid mutated code strings', () => {
+        const code = 'const x = a <= b';
+        const result = mutateModuleSource(code);
+        for (const v of result) {
+            expect(typeof v.code).toBe('string');
+            expect(v.code).not.toBe(code);
+        }
     });
 });

package/dist/core/__tests__/sfc.spec.js

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi } from 'vitest';
+import { mutateVueSfcScriptSetup } from '../sfc.js';
+// Mock @vue/compiler-sfc
+vi.mock('@vue/compiler-sfc', () => ({
+    parse: (code, _opts) => {
+        // Simple mock that extracts content between <script setup> tags
+        const startTag = '<script setup>';
+        const endTag = '</script>';
+        const startIdx = code.indexOf(startTag);
+        if (startIdx === -1) {
+            return { descriptor: { scriptSetup: null } };
+        }
+        const contentStart = startIdx + startTag.length;
+        const contentEnd = code.indexOf(endTag, contentStart);
+        return {
+            descriptor: {
+                scriptSetup: {
+                    loc: {
+                        start: { offset: contentStart },
+                        end: { offset: contentEnd },
+                    },
+                },
+            },
+        };
+    },
+}));
+describe('mutateVueSfcScriptSetup', () => {
+    it('returns empty array when there is no script setup block', async () => {
+        const code = '<template><div>hello</div></template>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code);
+        expect(result).toEqual([]);
+    });
+    it('throws when max is 0', async () => {
+        await expect(mutateVueSfcScriptSetup('test.vue', '<script setup></script>', [], [], 0)).rejects.toThrow('max must be a positive number, got: 0');
+    });
+    it('throws when max is negative', async () => {
+        await expect(mutateVueSfcScriptSetup('test.vue', '<script setup></script>', [], [], -1)).rejects.toThrow('max must be a positive number, got: -1');
+    });
+    it('generates mutations for script setup content', async () => {
+        const code = '<script setup>\nconst x = a && b\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code);
+        // Should find at least the andToOr mutation
+        expect(result.length).toBeGreaterThan(0);
+        // Every result should have the full SFC code (containing template tags)
+        for (const v of result) {
+            expect(v.code).toContain('<script setup>');
+            expect(v.code).toContain('</script>');
+        }
+    });
+    it('deduplicates identical mutations', async () => {
+        const code = '<script setup>\nconst x = a && b\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code);
+        const outputs = result.map((v) => v.code);
+        const unique = new Set(outputs);
+        expect(outputs.length).toBe(unique.size);
+    });
+    it('respects max limit', async () => {
+        const code = '<script setup>\nconst x = a && b\nconst y = c || d\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code, undefined, undefined, 1);
+        expect(result.length).toBeLessThanOrEqual(1);
+    });
+    it('filters mutators with include', async () => {
+        const code = '<script setup>\nconst x = a && b\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code, ['andToOr']);
+        for (const v of result) {
+            expect(v.name).toBe('andToOr');
+        }
+    });
+    it('filters mutators with exclude', async () => {
+        const code = '<script setup>\nconst x = a && b\n</script>';
+        const result = await mutateVueSfcScriptSetup('test.vue', code, undefined, ['andToOr']);
+        for (const v of result) {
+            expect(v.name).not.toBe('andToOr');
+        }
+    });
+});

package/dist/core/__tests__/variant-utils.spec.js

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest';
+import { generateMutationVariants, getFilteredRegistry } from '../variant-utils.js';
+function makeMutator(name, mutations) {
+    return {
+        name,
+        description: name,
+        apply: () => mutations,
+    };
+}
+describe('generateMutationVariants', () => {
+    it('returns empty array for empty registry', () => {
+        expect(generateMutationVariants([], 'const x = 1')).toEqual([]);
+    });
+    it('generates variants from a single mutator', () => {
+        const mutator = makeMutator('flip', [
+            { code: 'const x = 2', line: 1, col: 0 },
+        ]);
+        const result = generateMutationVariants([mutator], 'const x = 1');
+        expect(result).toEqual([
+            { name: 'flip', code: 'const x = 2', line: 1, col: 0 },
+        ]);
+    });
+    it('generates variants from multiple mutators', () => {
+        const m1 = makeMutator('a', [{ code: 'code_a', line: 1, col: 0 }]);
+        const m2 = makeMutator('b', [{ code: 'code_b', line: 2, col: 5 }]);
+        const result = generateMutationVariants([m1, m2], 'original');
+        expect(result).toHaveLength(2);
+        expect(result[0].name).toBe('a');
+        expect(result[1].name).toBe('b');
+    });
+    it('deduplicates identical mutation outputs', () => {
+        const m1 = makeMutator('a', [{ code: 'same', line: 1, col: 0 }]);
+        const m2 = makeMutator('b', [{ code: 'same', line: 2, col: 0 }]);
+        const result = generateMutationVariants([m1, m2], 'original');
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe('a');
+    });
+    it('throws when max is 0', () => {
+        expect(() => generateMutationVariants([], 'code', { max: 0 })).toThrow('max must be a positive number, got: 0');
+    });
+    it('throws when max is negative', () => {
+        expect(() => generateMutationVariants([], 'code', { max: -5 })).toThrow('max must be a positive number, got: -5');
+    });
+    it('respects max limit', () => {
+        const mutator = makeMutator('m', [
+            { code: 'v1', line: 1, col: 0 },
+            { code: 'v2', line: 2, col: 0 },
+            { code: 'v3', line: 3, col: 0 },
+        ]);
+        const result = generateMutationVariants([mutator], 'code', { max: 2 });
+        expect(result).toHaveLength(2);
+    });
+    it('stops iterating mutators once max is reached via inner return', () => {
+        const m1 = makeMutator('a', [
+            { code: 'v1', line: 1, col: 0 },
+            { code: 'v2', line: 2, col: 0 },
+        ]);
+        const m2 = makeMutator('b', [{ code: 'v3', line: 3, col: 0 }]);
+        const result = generateMutationVariants([m1, m2], 'code', { max: 2 });
+        expect(result).toHaveLength(2);
+        expect(result.every((v) => v.name === 'a')).toBe(true);
+    });
+    // NOTE: The outer loop `break` (variant-utils.ts line 42) is dead code.
+    // The inner loop always `return`s immediately when max is reached after adding
+    // a new unique variant, so the outer loop check can never fire.
+    // Same applies to sfc.ts line 43.
+    it('works with undefined max', () => {
+        const mutator = makeMutator('m', [
+            { code: 'v1', line: 1, col: 0 },
+            { code: 'v2', line: 2, col: 0 },
+        ]);
+        const result = generateMutationVariants([mutator], 'code', {});
+        expect(result).toHaveLength(2);
+    });
+});
+describe('getFilteredRegistry', () => {
+    it('returns the full registry when no filters', () => {
+        const result = getFilteredRegistry();
+        expect(result.length).toBeGreaterThan(0);
+        expect(result[0]).toHaveProperty('name');
+        expect(result[0]).toHaveProperty('apply');
+    });
+    it('filters by include', () => {
+        const result = getFilteredRegistry(['flipEQ', 'andToOr']);
+        expect(result.map((r) => r.name)).toEqual(['andToOr', 'flipEQ']);
+    });
+    it('filters by exclude', () => {
+        const all = getFilteredRegistry();
+        const result = getFilteredRegistry(undefined, ['flipEQ']);
+        expect(result.length).toBe(all.length - 1);
+        expect(result.find((r) => r.name === 'flipEQ')).toBeUndefined();
+    });
+});

package/dist/mutators/__tests__/operator.spec.js

@@ -0,0 +1,169 @@
+import { describe, it, expect } from 'vitest';
+import { relaxLE, relaxGE, tightenLT, tightenGT, andToOr, orToAnd, nullishToOr, flipEQ, flipNEQ, flipStrictEQ, flipStrictNEQ, addToSub, subToAdd, mulToDiv, divToMul, modToMul, powerToMul, } from '../operator.js';
+// ---------------------------------------------------------------------------
+// Shared behaviour (tested once; all mutators use the same factory)
+// ---------------------------------------------------------------------------
+describe('operator mutator shared behaviour', () => {
+    it('produces one mutation per matching operator occurrence', () => {
+        const src = `const ok = a && b && c`;
+        const results = andToOr.apply(src);
+        expect(results).toHaveLength(2);
+    });
+    it('reports the correct 1-based line number', () => {
+        const src = `const x = 1\nconst ok = a && b`;
+        const [result] = andToOr.apply(src);
+        expect(result.line).toBe(2);
+    });
+    it('reports the correct visual column', () => {
+        const src = `const ok = a && b`;
+        //                        ^ col 14 ('a' is at col 12, ' ' 13, '&' 14)
+        const [result] = andToOr.apply(src);
+        expect(result.col).toBe(14);
+    });
+    it('does not mutate operators inside string literals (AST-safe)', () => {
+        const src = `const s = 'a && b'`;
+        const results = andToOr.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('does not mutate operators inside comments (AST-safe)', () => {
+        const src = `// a && b\nconst x = 1`;
+        const results = andToOr.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('returns no results when the operator is absent', () => {
+        const src = `const x = a || b`;
+        const results = andToOr.apply(src);
+        expect(results).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// Boundary mutators
+// ---------------------------------------------------------------------------
+describe('relaxLE', () => {
+    it("replaces '<=' with '<'", () => {
+        const src = `if (x <= 10) {}`;
+        const [result] = relaxLE.apply(src);
+        expect(result.code).toBe(`if (x < 10) {}`);
+    });
+});
+describe('relaxGE', () => {
+    it("replaces '>=' with '>'", () => {
+        const src = `if (x >= 0) {}`;
+        const [result] = relaxGE.apply(src);
+        expect(result.code).toBe(`if (x > 0) {}`);
+    });
+});
+describe('tightenLT', () => {
+    it("replaces '<' with '<='", () => {
+        const src = `if (x < 10) {}`;
+        const [result] = tightenLT.apply(src);
+        expect(result.code).toBe(`if (x <= 10) {}`);
+    });
+});
+describe('tightenGT', () => {
+    it("replaces '>' with '>='", () => {
+        const src = `if (x > 0) {}`;
+        const [result] = tightenGT.apply(src);
+        expect(result.code).toBe(`if (x >= 0) {}`);
+    });
+});
+// ---------------------------------------------------------------------------
+// Logical mutators
+// ---------------------------------------------------------------------------
+describe('andToOr', () => {
+    it("replaces '&&' with '||'", () => {
+        const src = `const ok = a && b`;
+        const [result] = andToOr.apply(src);
+        expect(result.code).toBe(`const ok = a || b`);
+    });
+});
+describe('orToAnd', () => {
+    it("replaces '||' with '&&'", () => {
+        const src = `const ok = a || b`;
+        const [result] = orToAnd.apply(src);
+        expect(result.code).toBe(`const ok = a && b`);
+    });
+});
+describe('nullishToOr', () => {
+    it("replaces '??' with '||'", () => {
+        const src = `const v = x ?? defaultValue`;
+        const [result] = nullishToOr.apply(src);
+        expect(result.code).toBe(`const v = x || defaultValue`);
+    });
+});
+// ---------------------------------------------------------------------------
+// Equality mutators
+// ---------------------------------------------------------------------------
+describe('flipEQ', () => {
+    it("replaces '==' with '!='", () => {
+        const src = `if (a == b) {}`;
+        const [result] = flipEQ.apply(src);
+        expect(result.code).toBe(`if (a != b) {}`);
+    });
+});
+describe('flipNEQ', () => {
+    it("replaces '!=' with '=='", () => {
+        const src = `if (a != b) {}`;
+        const [result] = flipNEQ.apply(src);
+        expect(result.code).toBe(`if (a == b) {}`);
+    });
+});
+describe('flipStrictEQ', () => {
+    it("replaces '===' with '!=='", () => {
+        const src = `if (a === b) {}`;
+        const [result] = flipStrictEQ.apply(src);
+        expect(result.code).toBe(`if (a !== b) {}`);
+    });
+});
+describe('flipStrictNEQ', () => {
+    it("replaces '!==' with '==='", () => {
+        const src = `if (a !== b) {}`;
+        const [result] = flipStrictNEQ.apply(src);
+        expect(result.code).toBe(`if (a === b) {}`);
+    });
+});
+// ---------------------------------------------------------------------------
+// Arithmetic mutators
+// ---------------------------------------------------------------------------
+describe('addToSub', () => {
+    it("replaces '+' with '-'", () => {
+        const src = `const n = a + b`;
+        const [result] = addToSub.apply(src);
+        expect(result.code).toBe(`const n = a - b`);
+    });
+});
+describe('subToAdd', () => {
+    it("replaces '-' with '+'", () => {
+        const src = `const n = a - b`;
+        const [result] = subToAdd.apply(src);
+        expect(result.code).toBe(`const n = a + b`);
+    });
+});
+describe('mulToDiv', () => {
+    it("replaces '*' with '/'", () => {
+        const src = `const n = a * b`;
+        const [result] = mulToDiv.apply(src);
+        expect(result.code).toBe(`const n = a / b`);
+    });
+});
+describe('divToMul', () => {
+    it("replaces '/' with '*'", () => {
+        const src = `const n = a / b`;
+        const [result] = divToMul.apply(src);
+        expect(result.code).toBe(`const n = a * b`);
+    });
+});
+describe('modToMul', () => {
+    it("replaces '%' with '*'", () => {
+        const src = `const n = a % b`;
+        const [result] = modToMul.apply(src);
+        expect(result.code).toBe(`const n = a * b`);
+    });
+});
+describe('powerToMul', () => {
+    it("replaces '**' with '*'", () => {
+        const src = `const n = a ** b`;
+        const [result] = powerToMul.apply(src);
+        expect(result.code).toBe(`const n = a * b`);
+    });
+});

package/dist/mutators/__tests__/registry.spec.js

@@ -18,6 +18,12 @@ const ALL_NAMES = [
     'divToMul',
     'modToMul',
     'powerToMul',
+    'returnToNull',
+    'returnToUndefined',
+    'returnFlipBool',
+    'returnZero',
+    'returnEmptyStr',
+    'returnEmptyArr',
 ];
 describe('mutator registry', () => {
     it('returns all mutators by default in declared order', () => {