Skip to content

Commit 006c4ca

Browse files
test: nightly parser fuzz lane — parser input fails as typed AppErrors, never hangs (#1414) (#1438)
* test: nightly parser fuzz lane with typed-AppError invariant (#1414) Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * test(fuzz): run envelope, artifact promotion, and harness self-check tests (#1414) Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * test(fuzz): shared scheduled-lane envelope on every terminal path, watchdog after ready (#1414) Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * test(fuzz): envelope for malformed options; add scheduled-lane health consumer (#1414, #1430) Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * fix(lanes): actions:read scope, terminal error envelope, first-due grace (#1414, #1430) Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * fix(lanes): anchor first-run grace to schedule registration, use exec helper in tests (#1414, #1430) Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * fix(lanes): portable POSIX pickaxe pattern for schedule registration (#1414, #1430) Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * refactor(fuzz): fast-check generators over the shared hazard list, drop the bundled lane-health work (#1414) - Strip scripts/scheduled-lane/* and scheduled-lane-health.yml: that watcher is #1430's own deliverable and collides with PR #1439's implementation of the same lane. What this lane owes (a per-run envelope) moves into scripts/fuzz/envelope.ts. - Rebase onto #1437 and rebuild the generator layer on fast-check: cases come from arbitraries sharing SELECTOR_VALUE_HAZARDS with the property suite, and counterexamples are shrunk, so a failure names a minimal input plus fast-check's seed/path instead of a 20k-char random string. - Route harness.test.ts into the serialized subprocess-stub project. - Drop the AGENT_DEVICE_FUZZ_STARTUP_DELAY_MS test seam: the ready handshake is now proven by a case budget far below real worker startup. Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * test(fuzz): replay the regression corpus through the worker watchdog (#1414) A promoted hang case used to wedge the unit job until the CI timeout, because corpus replay called checkCase in-process. It now goes through the same worker-backed watchdog the nightly lane uses, so such a case fails against a 5s per-case budget; the file moves to the serialized subprocess-stub project with the rest of the worker-driven fuzz tests. Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * test(fuzz): let the watchdog outlive vitest's default case timeout (#1414) A wedged parser was surfacing as a bare 'Test timed out in 5000ms' instead of the named hang: failure that says which input wedged, because the file's vitest timeout was shorter than the watchdog budget times the number of replayed cases. Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> * test(fuzz): complete drift provenance in the lane envelope (#1414) configHash now covers every input that decides what a seed generates (generate.ts and the shared property arbitraries, not just the arbitraries/targets/invariant), and tool records fast-check's installed version. A generation-loop edit or a fast-check upgrade previously changed the case set while the envelope looked unchanged. A test recomputes the hash with each input omitted so a future omission fails. Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> --------- Co-authored-by: Michał Pierzchała <[email protected]> Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
1 parent e545544 commit 006c4ca

26 files changed

Lines changed: 1806 additions & 7 deletions

‎.github/workflows/replays-nightly.yml‎

Lines changed: 75 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,14 @@ on:
44
schedule:
55
- cron: '0 3 * * *'
66
workflow_dispatch:
7+
inputs:
8+
fuzz-iterations:
9+
description: 'Parser fuzz cases per target'
10+
required: false
11+
default: '50000'
12+
fuzz-seed:
13+
description: 'Parser fuzz PRNG seed (defaults to the run number)'
14+
required: false
715

816
permissions:
917
contents: read
@@ -13,6 +21,73 @@ concurrency:
1321
cancel-in-progress: true
1422

1523
jobs:
24+
# Parser fuzz lane (#1414): hostile input into parseArgs, selector parsing, .ad replay
25+
# scripts, batch --steps JSON, and the Maestro compat parser. One invariant — every
26+
# rejection is a typed AppError with a non-empty hint, and no case hangs. Device-free, so
27+
# it rides this nightly rather than owning a workflow; the seed varies per run so the lane
28+
# keeps exploring, and anything it catches is appended to the checked-in corpus that the
29+
# unit lane replays (scripts/fuzz/corpus/regressions.json).
30+
nightly-parser-fuzz:
31+
name: Parser Fuzz Lane
32+
runs-on: ubuntu-latest
33+
timeout-minutes: 20
34+
steps:
35+
- name: Checkout
36+
uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
37+
38+
- name: Setup toolchain
39+
uses: ./.github/actions/setup-node-pnpm
40+
41+
# A lane whose classifier or watchdog regressed would pass forever. This runs the
42+
# broken-on-purpose targets first and fails unless each violation is caught.
43+
- name: Self-check the harness
44+
run: pnpm fuzz:parsers --self-check --artifact-dir .tmp/fuzz/self-check
45+
46+
# Runs even when the self-check fails, so the lane always produces a fuzz envelope too
47+
# (a step that never runs writes no envelope, and monitoring cannot tell that apart from
48+
# a lane that went dark). The job still fails because both steps report their status.
49+
- name: Fuzz parsers
50+
if: always()
51+
env:
52+
FUZZ_ITERATIONS: ${{ github.event.inputs.fuzz-iterations || '50000' }}
53+
FUZZ_SEED: ${{ github.event.inputs.fuzz-seed || github.run_number }}
54+
run: |
55+
pnpm fuzz:parsers \
56+
--iterations "$FUZZ_ITERATIONS" \
57+
--seed "$FUZZ_SEED" \
58+
--artifact-dir .tmp/fuzz/run
59+
60+
# Uploaded on pass as well as failure: each subdirectory of .tmp/fuzz holds a
61+
# run-envelope.json on #1430's shared lane contract (scripts/lib/lane-envelope.ts) —
62+
# commit/ref/run provenance, tool + config hash, seed, result — which is what freshness
63+
# monitoring reads.
64+
- name: Upload run envelopes and failing cases
65+
if: always()
66+
uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
67+
with:
68+
name: parser-fuzz-run-${{ github.run_id }}-${{ github.run_attempt }}
69+
path: .tmp/fuzz
70+
if-no-files-found: warn
71+
72+
# Never fails the job on its own: a missing envelope is reported as such rather than
73+
# masking the real failure with a `cat` error.
74+
- name: Summarize
75+
if: always()
76+
run: |
77+
{
78+
echo '### Parser fuzz lane'
79+
found=0
80+
for envelope in .tmp/fuzz/*/run-envelope.json; do
81+
[ -f "$envelope" ] || continue
82+
found=1
83+
echo "#### $envelope"
84+
echo '```json'
85+
cat "$envelope"
86+
echo '```'
87+
done
88+
[ "$found" = 1 ] || echo 'No run envelope was produced — the lane failed before it could run.'
89+
} >> "$GITHUB_STEP_SUMMARY"
90+
1691
nightly-android:
1792
name: Android Replay Suite
1893
runs-on: ubuntu-latest

‎docs/agents/testing.md‎

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -179,6 +179,48 @@ pnpm mutation:baseline # full sweep, then record it (reviewed c
179179
written on every exit path, including a crash before any mutant runs: an absent envelope would be
180180
indistinguishable from a lane that never ran.
181181

182+
## Parser fuzz lane
183+
184+
`pnpm fuzz:parsers` feeds generated hostile input to `parseArgs`, selector parsing,
185+
`parseReplayScriptDetailed`, `batch --steps` JSON, and the Maestro compat parser, and enforces one
186+
invariant: every rejection is a typed `AppError` whose normalized `hint` is non-empty, and no case
187+
hangs (a worker-thread watchdog attributes a stall to the exact input).
188+
189+
```sh
190+
pnpm fuzz:parsers # all targets, 2,000 cases each, seed 1
191+
pnpm fuzz:parsers --target selector --iterations 50000 --seed 7
192+
pnpm fuzz:parsers --input-file .tmp/fuzz/<case>.json # repro a saved case
193+
pnpm fuzz:parsers --input-file .tmp/fuzz/<case>.json --append-corpus # …and pin it
194+
pnpm fuzz:parsers --self-check # require the harness to still fail
195+
```
196+
197+
The generating run is nightly (`Parser Fuzz Lane` in `.github/workflows/replays-nightly.yml`, seeded
198+
by the run number). Every terminal path — pass, fail, `--self-check`, or a crash in the harness
199+
itself — writes `<artifact-dir>/run-envelope.json` on the shared lane contract
200+
(`scripts/lib/lane-envelope.ts`, #1430), with the lane's own facts under `data`: mode, per-target
201+
cases/failures/durations, failures, repro commands, and `stage` (`error` marks a run that could not
202+
complete itself, since the shared `result` is only `pass`/`fail`). `configHash` hashes the modules
203+
that decide a case set, so "the same seed means different inputs now" is distinguishable from "the
204+
parsers changed". The self-check and fuzz steps write to separate artifact subdirectories and both
205+
run unconditionally; the step summary prints each envelope it finds and never fails on a missing
206+
file.
207+
208+
Cases come from fast-check arbitraries (`scripts/fuzz/arbitraries.ts`) built on the hazard vocabulary
209+
shared with `src/__tests__/test-utils/property-arbitraries.ts`, so a hazard added for the property
210+
suite reaches the fuzz lane too — and a counterexample is reported **shrunk**, with fast-check's seed
211+
and replay path printed alongside the saved artifact.
212+
213+
A nightly discovery reaches the unit lane by promotion, not hand-editing: the printed
214+
`promote:` command re-runs the downloaded artifact and appends it to
215+
`scripts/fuzz/corpus/regressions.json`, which `scripts/fuzz/corpus-replay.test.ts` replays on every
216+
PR — through the same worker watchdog, so a promoted hang case fails against its per-case budget
217+
instead of wedging the unit job. `scripts/fuzz/harness.test.ts` covers the harness itself — an
218+
untyped throw, an empty hint, and a wedged worker must each be reported, startup time is never charged against the per-case budget, and
219+
every mode writes an envelope — using the broken-on-purpose targets in
220+
`scripts/fuzz/self-check-targets.ts` (also what `--self-check` runs in CI), so a regressed classifier
221+
or watchdog cannot pass silently. Adding a parser to the lane means adding a target to
222+
`scripts/fuzz/targets.ts` — nothing else.
223+
182224
## Live web smoke
183225

184226
The live web platform smoke runs the public built CLI against a local fixture page through the managed web backend:

‎package.json‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -114,8 +114,9 @@
114114
"mutation:affected": "node --experimental-strip-types scripts/mutation/run.ts --affected",
115115
"mutation:test": "node --experimental-strip-types --test scripts/mutation/*.test.ts",
116116
"lint": "oxlint . --deny-warnings",
117-
"format": "node ./node_modules/oxfmt/bin/oxfmt --write src test skills scripts/mutation scripts/lib scripts/help-conformance-bench.mjs scripts/help-conformance-case-checks.mjs scripts/help-conformance-command-validator.ts scripts/help-conformance-expectations.mjs scripts/help-conformance-plan-validator.mjs scripts/help-conformance-runner-output.mjs scripts/help-conformance-summary.mjs scripts/help-conformance-cases.mjs scripts/help-conformance-sample-outputs.mjs scripts/__tests__/help-conformance-bench.test.ts scripts/__tests__/help-conformance-sample-outputs.test.ts scripts/__tests__/help-conformance-topic-coverage.test.ts package.json tsconfig.json tsconfig.lib.json tsdown.config.ts vitest.config.ts vitest.mutation.config.ts .github/actions/setup-node-pnpm/action.yml .oxlintrc.json .oxfmtrc.json '!test/skillgym/.skillgym-results/**'",
118-
"format:check": "node ./node_modules/oxfmt/bin/oxfmt --check src test skills scripts/mutation scripts/lib scripts/help-conformance-bench.mjs scripts/help-conformance-case-checks.mjs scripts/help-conformance-command-validator.ts scripts/help-conformance-expectations.mjs scripts/help-conformance-plan-validator.mjs scripts/help-conformance-runner-output.mjs scripts/help-conformance-summary.mjs scripts/help-conformance-cases.mjs scripts/help-conformance-sample-outputs.mjs scripts/__tests__/help-conformance-bench.test.ts scripts/__tests__/help-conformance-sample-outputs.test.ts scripts/__tests__/help-conformance-topic-coverage.test.ts package.json tsconfig.json tsconfig.lib.json tsdown.config.ts vitest.config.ts vitest.mutation.config.ts .github/actions/setup-node-pnpm/action.yml .oxlintrc.json .oxfmtrc.json '!test/skillgym/.skillgym-results/**'",
117+
"format": "node ./node_modules/oxfmt/bin/oxfmt --write src test skills scripts/fuzz scripts/mutation scripts/lib scripts/help-conformance-bench.mjs scripts/help-conformance-case-checks.mjs scripts/help-conformance-command-validator.ts scripts/help-conformance-expectations.mjs scripts/help-conformance-plan-validator.mjs scripts/help-conformance-runner-output.mjs scripts/help-conformance-summary.mjs scripts/help-conformance-cases.mjs scripts/help-conformance-sample-outputs.mjs scripts/__tests__/help-conformance-bench.test.ts scripts/__tests__/help-conformance-sample-outputs.test.ts scripts/__tests__/help-conformance-topic-coverage.test.ts package.json tsconfig.json tsconfig.lib.json tsdown.config.ts vitest.config.ts vitest.mutation.config.ts .github/actions/setup-node-pnpm/action.yml .oxlintrc.json .oxfmtrc.json '!test/skillgym/.skillgym-results/**'",
118+
"format:check": "node ./node_modules/oxfmt/bin/oxfmt --check src test skills scripts/fuzz scripts/mutation scripts/lib scripts/help-conformance-bench.mjs scripts/help-conformance-case-checks.mjs scripts/help-conformance-command-validator.ts scripts/help-conformance-expectations.mjs scripts/help-conformance-plan-validator.mjs scripts/help-conformance-runner-output.mjs scripts/help-conformance-summary.mjs scripts/help-conformance-cases.mjs scripts/help-conformance-sample-outputs.mjs scripts/__tests__/help-conformance-bench.test.ts scripts/__tests__/help-conformance-sample-outputs.test.ts scripts/__tests__/help-conformance-topic-coverage.test.ts package.json tsconfig.json tsconfig.lib.json tsdown.config.ts vitest.config.ts vitest.mutation.config.ts .github/actions/setup-node-pnpm/action.yml .oxlintrc.json .oxfmtrc.json '!test/skillgym/.skillgym-results/**'",
119+
"fuzz:parsers": "node --experimental-strip-types scripts/fuzz/run.ts",
119120
"fallow": "fallow audit --base origin/main",
120121
"fallow:all": "fallow --summary",
121122
"fallow:baseline": "(fallow dead-code --save-baseline fallow-baselines/dead-code.json --summary || true) && (fallow health --save-baseline fallow-baselines/health.json --summary || true)",

‎scripts/fuzz/arbitraries.ts‎

Lines changed: 114 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,114 @@
1+
// Case generators for the parser fuzz lane (#1414).
2+
//
3+
// fast-check rather than a bespoke PRNG, for two reasons the lane depends on: a reported
4+
// counterexample is the SHRUNK input (a hand-rolled mutator reports the 20k-character random one),
5+
// and the hazard vocabulary is the one #1437's property suite already curates — a hazard added
6+
// there for a round-trip property reaches the fuzzer without being retyped here.
7+
//
8+
// Cases stay near the grammar's edge on purpose: a well-formed base with hostile chunks spliced in
9+
// reaches deep parser branches that uniformly random noise never gets past the first token of.
10+
11+
import fc from 'fast-check';
12+
import {
13+
replayScriptArb,
14+
SELECTOR_VALUE_HAZARDS,
15+
selectorChainArb,
16+
} from '../../src/__tests__/test-utils/property-arbitraries.ts';
17+
import type { FuzzTarget, FuzzTargetName } from './target-types.ts';
18+
19+
/**
20+
* Hazards a valid-input property cannot use — they exist to be *rejected*: structural JSON/YAML
21+
* punctuation, delimiter lookalikes, prototype-pollution keys, numeric edges, bidi/zero-width
22+
* controls. The shared list above carries the ones valid inputs must also survive.
23+
*/
24+
const REJECTION_HAZARDS = [
25+
'`',
26+
'==',
27+
'&&',
28+
'--',
29+
'---',
30+
'#',
31+
':',
32+
',',
33+
'{',
34+
'}',
35+
'[',
36+
']',
37+
'(',
38+
')',
39+
'${',
40+
'${}',
41+
'@',
42+
'~=',
43+
'*',
44+
'\r\n',
45+
'\u0000',
46+
'\u200b',
47+
'\u202e',
48+
'\ufeff',
49+
'-0',
50+
'NaN',
51+
'Infinity',
52+
'1e999',
53+
'9007199254740993',
54+
'null',
55+
'undefined',
56+
'__proto__',
57+
'constructor',
58+
] as const;
59+
60+
const hazardArb: fc.Arbitrary<string> = fc.constantFrom(
61+
...SELECTOR_VALUE_HAZARDS,
62+
...REJECTION_HAZARDS,
63+
);
64+
65+
/** A base string with 1–4 hazards spliced in at shrinkable positions. */
66+
function corrupted(base: fc.Arbitrary<string>): fc.Arbitrary<string> {
67+
return fc
68+
.tuple(
69+
base,
70+
fc.array(fc.tuple(hazardArb, fc.nat({ max: 4096 })), { minLength: 1, maxLength: 4 }),
71+
)
72+
.map(([text, edits]) =>
73+
edits.reduce((current, [chunk, at]) => {
74+
const index = at % (current.length + 1);
75+
return current.slice(0, index) + chunk + current.slice(index);
76+
}, text),
77+
);
78+
}
79+
80+
/** A long run of one hazard — regex-backtracking and quadratic-scan bait. */
81+
const repeatedHazardArb: fc.Arbitrary<string> = fc
82+
.tuple(hazardArb, fc.integer({ min: 50, max: 400 }))
83+
.map(([chunk, times]) => chunk.repeat(times));
84+
85+
/** Input that is not trying to look like the grammar at all. */
86+
const noiseArb: fc.Arbitrary<string> = fc.oneof(
87+
fc.string({ maxLength: 40 }),
88+
fc.string({ unit: 'binary', maxLength: 40 }),
89+
fc.array(hazardArb, { maxLength: 8 }).map((parts) => parts.join('')),
90+
repeatedHazardArb,
91+
);
92+
93+
/**
94+
* Bases borrowed from the property suite, which generates *valid* inputs: corrupting a
95+
* grammar-correct script or selector chain is how the fuzzer reaches branches past the first
96+
* rejection. Targets without one generate from their own seed list.
97+
*/
98+
const STRUCTURED_BASES: Partial<Record<FuzzTargetName, fc.Arbitrary<string>>> = {
99+
selector: selectorChainArb.map((chain) => chain.expression),
100+
'replay-script': replayScriptArb,
101+
'batch-steps': fc.json({ maxDepth: 3 }),
102+
};
103+
104+
/** The case distribution for one target: mostly near-miss, some valid, some pure noise. */
105+
export function arbitraryForTarget(target: FuzzTarget): fc.Arbitrary<string> {
106+
const seeded = fc.constantFrom(...target.seeds);
107+
const structured = STRUCTURED_BASES[target.name];
108+
const base = structured === undefined ? seeded : fc.oneof(seeded, structured);
109+
return fc.oneof(
110+
{ weight: 6, arbitrary: corrupted(base) },
111+
{ weight: 2, arbitrary: base },
112+
{ weight: 2, arbitrary: noiseArb },
113+
);
114+
}

‎scripts/fuzz/corpus-replay.test.ts‎

Lines changed: 83 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,83 @@
1+
// Unit-lane replay of the parser fuzz regression corpus (#1414).
2+
//
3+
// The nightly lane finds cases; this replays every case it ever found so a regression fails in
4+
// seconds on a PR instead of a night later. Cases go through the same worker-backed watchdog the
5+
// nightly lane uses: a promoted hang case must fail this test against its per-case budget, not
6+
// wedge the unit job until the CI timeout.
7+
8+
import fc from 'fast-check';
9+
import { describe, expect, it } from 'vitest';
10+
import { arbitraryForTarget } from './arbitraries.ts';
11+
import { readCorpus } from './corpus.ts';
12+
import { runCases } from './execute.ts';
13+
import { describeFailure } from './invariant.ts';
14+
import { getFuzzTarget } from './registry.ts';
15+
import { FUZZ_TARGETS } from './targets.ts';
16+
17+
/**
18+
* Generous enough that a loaded CI runner never reports a healthy parser as hung, small enough
19+
* that a genuinely wedged case fails the file in seconds.
20+
*/
21+
const CASE_TIMEOUT_MS = 5_000;
22+
23+
/**
24+
* Vitest must outlast the watchdog for every case a test replays, or a wedged parser is reported as
25+
* a bare `Test timed out` instead of the named `hang:` failure that says which input wedged.
26+
*/
27+
const timeoutFor = (cases: number) => cases * CASE_TIMEOUT_MS + 10_000;
28+
29+
describe('parser fuzz regression corpus', () => {
30+
const corpus = readCorpus();
31+
32+
it('is non-empty and free of duplicates', () => {
33+
expect(corpus.length).toBeGreaterThan(0);
34+
const keys = corpus.map((entry) => `${entry.target}\u0000${entry.input}`);
35+
expect(new Set(keys).size).toBe(keys.length);
36+
});
37+
38+
it('names only real parser targets and explains every entry', () => {
39+
const parserTargets = new Set<string>(FUZZ_TARGETS.map((target) => target.name));
40+
for (const entry of corpus) {
41+
expect(parserTargets).toContain(entry.target);
42+
expect(entry.note.trim()).not.toBe('');
43+
}
44+
});
45+
46+
// One worker per target rather than per case: startup is the only real cost here, and the
47+
// watchdog budget is per case either way.
48+
it.each(FUZZ_TARGETS.map((target) => [target.name, target] as const))(
49+
'%s corpus cases and seeds hold the invariant, under the watchdog',
50+
async (name, target) => {
51+
const cases = [
52+
...target.seeds,
53+
...corpus.filter((entry) => entry.target === name).map((entry) => entry.input),
54+
];
55+
const failures = await runCases(target, cases, CASE_TIMEOUT_MS);
56+
expect(failures.map(describeFailure)).toEqual([]);
57+
},
58+
timeoutFor(corpus.length + Math.max(...FUZZ_TARGETS.map((t) => t.seeds.length))),
59+
);
60+
});
61+
62+
describe('fuzz case generation', () => {
63+
const target = getFuzzTarget('selector');
64+
65+
it('is deterministic for a seed, so a reported counterexample replays', () => {
66+
const sample = (seed: number) => fc.sample(arbitraryForTarget(target), { numRuns: 32, seed });
67+
expect(sample(7)).toEqual(sample(7));
68+
expect(sample(7)).not.toEqual(sample(8));
69+
});
70+
71+
const GENERATED_CASES = 64;
72+
73+
it(
74+
'generates strings the target can be fed directly',
75+
async () => {
76+
const inputs = fc.sample(arbitraryForTarget(target), { numRuns: GENERATED_CASES, seed: 1 });
77+
expect(inputs.every((input) => typeof input === 'string')).toBe(true);
78+
const failures = await runCases(target, inputs, CASE_TIMEOUT_MS);
79+
expect(failures.map(describeFailure)).toEqual([]);
80+
},
81+
timeoutFor(GENERATED_CASES),
82+
);
83+
});

0 commit comments

Comments
 (0)