Coverable lines across every file.

Covered lines across every file.

One entry per non-test source file the bundle mapped back to.

Overall percentage covered.

Lines the source map attributes to executable positions in the bundle.

Lines executed at least once.

Path relative to the project root, with forward slashes.

coveredLines / coverableLines, as a percentage rounded to two decimals.

The engine the tests ran in.

Coverage artifact formats beyond the terminal summary.

File extensions treated as test files.

The active test-name filter, when one was set.

Absolute path of the build output directory — where the bundle and artifacts landed.

The port actually bound, which may differ from the one requested.

Absolute path of the directory holding package.json.

Absolute paths of the test files this group bundled and ran together.

Position in the run's group list, and the group-<index> suffix on output.

Absolute path of this group's build output directory.

console.* calls and uncaught errors from the page — warnings and errors unless debug.

How many page-log entries were dropped to stay under the cap. 0 in every ordinary run.

Outcome totals.

Line coverage, or null when coverage was not requested.

Wall-clock duration of the test phase, in milliseconds.

What the CLI would have exited with: 0 when ok, 1 otherwise.

Absolute paths of the test files with at least one failure, attributed via source maps.

The subset of tests that failed — the list you almost always want first.

Absolute paths of the test files this run executed — the ones scoped to, in a filtered watch rerun, rather than everything being watched.

Epoch ms when it ended.

How the files were split across concurrent groups — one entry per group, never empty. groups.length is the concurrency the run actually used; 1 for watch and single-file runs.

The JUnit XML document, when junit was requested. Written to disk as well.

qunitx's own diagnostics for this run, in emission order.

true when every test passed and nothing else went wrong.

What the run resolved to — see ResolvedRun.

Epoch ms when the test phase began.

How the run finished: whether it got through everything it selected, and if not, what stopped it. Distinct from RunResult.ok, which is the verdict — a completed run can be entirely red, and an aborted one can have no failures at all.

Every finished test, in the order the browser reported them.

The test's assertions. QUnit trims these for passing tests, so this is populated for failures and empty otherwise — a passing test's assertion count is not reported.

How long the test took, in milliseconds.

Source file this test was declared in, relative to the project root, or null.

"Module > Sub: test name" — the string filter matches against.

The QUnit module path it was declared under; empty for a top-level test.

The test's own name, without its modules.

QUnit's outcome for this test.