Test.Syd.MutationMode.Common

Per-suite outcome of running a single mutation child.

Per-outcome-kind counts produced by tallyGroups. Each OutcomeTimedOut bumps both tallyKilled and tallyTimedOut because a timed-out mutation is treated as killed for scoring; tallyTimedOut carries the separate count for visibility.

Wrap a per-suite runner so that any synchronous exception escaping it is treated as SuiteKilled. A mutation that makes the child process unrunnable (e.g. BlockedIndefinitelyOnMVar / image: loop propagating from waitExitCode, an IOException from log-file IO, a parse failure on the child's output) is conceptually indistinguishable from a mutation that makes the child crash — both mean the test detected the mutation.

SomeAsyncException is re-thrown so Ctrl-C and other cancellations still propagate out of the runner.

Retry an IO action that produces a tagged failure reason.

retryingIO retriesLeft onRetry action runs action; on Left it calls onRetry with the reason and the number of retries remaining, then runs action again with a decremented counter. When retriesLeft reaches zero, the final Left is returned unchanged (so the caller can decide how to surface the failure).

A retriesLeft of 0 means "no retries, one attempt". A retriesLeft of 3 means "up to 4 total attempts".

The action itself decides what counts as a transient failure: returning Right bypasses retry, returning Left triggers it.

Synchronous exceptions thrown by action are not caught here — they are not, in the coverage-child use case, the kind of failure we want to retry through. Use handle inside action if you need to convert exceptions to Left.

A mutation result that should trip within-group fail-fast: the test suite did not detect the mutation (survivor) or no test reaches the mutation site (uncovered). Timeouts count as killed, so they do not trip; MutationSkipped is itself a consequence of a prior failure and does not trip again.

The MutationId of the mutation that produced a failing result, used as the cause on SkippedMutation entries for subsequent group members.

Run one mutation group: walk records sequentially, calling the supplied run for each record, and once one record's result is isMutationFailure record every remaining record as MutationSkipped instead of running it.

Returns the results in source order. When globalFailFast is True and a non-skipped result is a failure, MutationFailFast is thrown after the group's results have been written to the accumulator so a partial report can still be assembled by the caller.

Thrown inside a mapConcurrently worker to abort the mutation run when fail-fast is on and a surviving or uncovered mutation is observed. The sibling workers are cancelled by mapConcurrently on the first exception.

Thrown inside a coverage mapConcurrently worker to abort the run when a coverage child reports that its baseline test failed (exit code 2) and fail-fast is on. Distinct from MutationFailFast because the cause is different — the suite was already red before any mutation ran, so the mutation scores would be meaningless.

Render the per-mutation progress line emitted as each mutation is tested. index/total are this mutation's 1-based position in the run and the total mutation count, shown as a coloured [X/Y] counter. The verbose flag controls detail: in concise mode (the default) this is the single locating line [X/Y] Testing mutation <operator> at <file>:<line>:<cols>, so a long run shows steady progress — including how far along it is — without flooding the log; in verbose/debug mode the full source diff of the mutation follows — the same block the report prints for a survivor.

Render a unified-diff hunk with intra-line colouring. Used by both renderMutationRecord and the runtime mutation report.

startLine is the 1-based source line of the first srcLines entry; the @@@ -a,b +c,d @@ header is computed from there and the lengths of context, source, and mutated lines.

Per-survivor mitigation guidance, appended under a surviving mutation in the report: the exact disable annotation for this mutation (using its operator and, when known, its enclosing binding) and any mitigation hint the operator attached (e.g. an equivalent-mutant suppression).

Progress event for the coverage phase.

Why the coverage phase was skipped.

Difference of two getMonotonicTimeNSec readings expressed in microseconds. The monotonic clock is not affected by NTP slew or step, so timing comparisons here are robust against system-clock changes that getCurrentTime would have observed.