Give every status a filter, and the log something to filter it with (fixes #460) - #486

The last of #439's redesign PRs. A1 gave the report a summary header, A2 gave
the tree Xcode's outline, A3a gave each view its own surface and reserved a
slot in each toolbar. This fills the slots.

The expected-failure bucket (#460)

The model has named .expectedFailure since #443, and A1's tally has counted
it in a bucket of its own since the header landed. The filter row was the last
reading of a run that still had it in no bucket at all: five functions,
each naming the four row classes it shows or hides, and an expected failure
carries none of them.

Measured on this branch's build of the shipped code, that meant:

• "Passed" left one on screen. A reader asking for the tests that passed
  was shown one that did not.
• "All" could not put it back, because "All" only ever set
  display: block on those same four classes.
• A suite of nothing but expected failures vanished. The group pass reads
  a row as visible only when its display is block; an unfiltered row's
  never is. So the suite disappeared from the tree the moment the reader
  touched any filter, "All" included.

The decision, and why nothing in the header moves

Expected-failure rows leave unknown entirely — and they left it before this
PR. Status.expectedFailure has had its own case, its own cssClass, its
own glyph (#459) and its own Tally bucket (A1) for some time; the ring, the
legend, the picker's spoken tally and donut-center's total are all already
computed from that bucket. So the coordination A1's summary math needed here
was not to move a count. It was to make the toolbar agree with counts that
were already right.

Evidence that nothing moved: every A1 assertion passes unedited —
RunSummaryTests.testExpectedFailuresAreCountedRatherThanDropped,
testRingArcsTileTheWholeCircle,
DifferentialSummaryHeaderTests.testSummaryHeaderNumbersAgreeAcrossBackends,
and CoreTests.testSummaryHeaderAccountsForExpectedFailures. The header
assertions that did change (testLegendCountsEveryStatusTheFixtureProduces,
the duration total, the picker's spoken tally) changed because the synthetic
fixture gained a sixth test — a parameterized case, for the executions work
below — not because any bucket moved. Each edit is one number.

CoreTests has carried the disagreement as a comment since A1 — "the two
readings disagree until A3 rebuilds the filters" — and now asserts the
partition instead.

The pills are the legend, made operable

Both are rendered from the run's Tally: same buckets, same order, same
drop-the-empty-ones rule. A leading "All", then one pill per outcome the run
produced.

Xcode's own toolbar reads All Tests (21) on the same bundle, and its Log view
names the same bucket in words: "14 tests total, 9 passed, 1 skipped, 2
expected failures".

Dropping the empty ones is the legend's rule, applied to the control that acts
on what the legend states — a permanent "Mixed (0)" in a report that never
retried a test is noise, and three pills reading (0) were three controls that
could only ever empty the pane. It is also what closes the class of defect
rather than the instance: a pill exists because the run produced that
outcome, so unknown — which had exactly the same gap as expectedFailure and
no issue filed against it — is filtered now for the same reason. Status
became the single mapping between an outcome and the report's vocabulary for
it, and moved into Status.swift to say so: cssClass is the row class the
stylesheet paints and the data-filter a pill carries, so adding a case adds
a glyph, a legend row, a pill and a filter with no list anywhere to keep in
step.

Three more filters that did not finish

Each is the same defect in a different place, each found while building the
first one, each gated:

• A suite goes when its last visible row does. The pass this replaces
  bailed out on any group holding a sub-group, so the legacy backend's two
  wrapper levels — "Selected tests" and <target>.xctest, which hold only
  other groups — survived every filter. Two selected rows sat under three empty
  headings. Deciding deepest-first covers both cases with one rule. The digest
  jump now clears the whole ancestor chain rather than the nearest suite, since
  a wrapper can be hidden now and could not be before.
• A filtered-out test takes its screenshot with it. .screenshot-tail is
  emitted between rows rather than inside one (A2), so it sat outside
  everything the filters touched: a hidden test left a 200px picture in the
  tree with no row to belong to.
• A childless suite is a row. Run.allTests counts one as a leaf — the
  shape a crashed target leaves behind, which TruncationFaultTests is built
  from — so the pills count it, and it has to be filterable by them or the
  toolbar's own arithmetic is wrong.

Tests and runs

Xcode states 21 tests and 23 runs on TestResults.xcresult. Ours knew only
tests. The difference is parameterizedAddition(value:), which ran once per
argument set.

Neither field already in the port could carry the second number. Both readers
deliberately collapse argument executions into one iteration — that is what
makes the two backends agree on the rows (migration answer 8) — and only the
modern format names the argument values at all. But the count is in both
bundles: legacy has one sibling metadata entry per execution, modern one
Arguments child. Legacy was throwing it away in mergingArgumentExecutions,
at the one point where it still knew.

So ParsedTestCase gains executionCount, and this converges the readers
rather than reading anything new:

DifferentialTests.testExecutionCountsAgreeAcrossBackends holds them
converged — per test identifier, not just per run, so a disagreement names what
disagrees — with a non-vacuity check, because equality is free if nothing in
any fixture ever ran twice.

Corroborated from a source neither reader's test-tree parse touches: filtering
the run log to Run test case (logs-filtered-1440-light.png) lists
-------- Run test case parameterizedAddition(value:) -------- three
times. The simulator really did run it three times; 23 is not an artefact of
how one backend counts.

The toolbar reads 23 executions, not "23 runs": this report already
spends the word "run" on a destination, which A3a's picker labels Run 1,
Run 2. It is aria-live, because the filters change it — Failed gives
6 executions, exactly as Xcode's second dropdown relabels to Failed Runs (6). Each row that accounts for a difference says so with the option-A
mockup's own tag, 3 arguments; only the count is stated, never the values,
which one backend cannot see. A repeated test gets no tag — its iterations are
rows already.

No per-run rows in the tree. Counts and filter semantics only; drawing a
row per argument set is a bigger feature and not this one.

A Filter field, in both views

Xcode puts one at the trailing end of both toolbars. So does this, in the slot
A3a reserved — the mockup has no toolbar at all, so Xcode is the source here.
On Tests it is a name-substring filter that composes with the pills:
"Failed" and "one" together mean the failing tests whose names contain "one",
which is what a reader who set both is asking for. It matches the row and
every suite above it, because a filter over a tree that only reads its leaves
is one a reader finds out about the hard way — typing the name of a suite they
can see would empty the pane. The status filter stays a leaf question: a
suite's own status is folded from its children, so filtering on it would put
rows of every outcome under a heading claiming one.

On Logs it filters the log's lines, and the count reads 23 of 83 lines.

The log moves into the page, and that is what makes a log filter possible

It was an <iframe src> pointing at a file:// sibling or a data: URI — a
foreign origin either way. Two things followed, both of which the report
shipped:

• Nothing in the page could act on it. No control the parent holds can
  filter, search or scroll across an origin boundary, which is why A3a's Logs
  toolbar carried an inert All Messages label where a control belongs. There
  was no better label to write; the delivery mechanism was the problem.
• It could not see the token layer. In dark mode the Logs view rendered as
  a white slab with black text — the same class of defect as the base64
  status PNGs C-refresh part 2/2 — structure: responsive collapse, SVG icons, all six status glyphs, type-derived attachment labels (refs #439) #459 replaced with masks, and for the same reason.
  logs-1440-dark.png in A3a's evidence is that slab; the file of the same
  name here is the same view themed.

A single <pre> rather than an element per line: a filter that rebuilds one
text node is a string join, where a six-figure log would otherwise be a
six-figure DOM. tabindex="0" for the reason the tests list has one — axe's
scrollable-region-focusable.

The .log export is untouched: it is the artifact #480 fixed and
DifferentialLogTests compares, and it stays the signal logFailedToResolve
reads. Only linking mode pays anything for this — one extra read of the same
bytes, since it also writes the file. Inline mode gets smaller: escaped text
costs less than the same bytes base64'd into a URI.

Substitution order, closed rather than ordered

Run fills its two templates from two ordered lists instead of one dictionary.
HTML.html reduces over a dictionary, so it fills placeholders in hash order,
and fills the ones an earlier replacement inserted as readily as the ones the
template author wrote — the hazard the A3a review found in the picker. Two
per-view templates make it closable rather than merely ordered: each list
holds only what its own template needs, so a test named [[LOG_TEXT]] is not
filled late but unfillable, and a log line reading [[TEST_SUMMARIES]]
likewise. Both directions pinned in PlaceholderOrderTests.

Keyboard and accessibility

• The pills stay a roving radiogroup; the two Filter fields are ordinary
  type="search" inputs, so Tab still steps past a toolbar in three presses
  and Escape clears a field with nothing here re-implementing either.
• The axe gate runs in six states now, up from four. The two new ones are
  the pages the filters produce — a tree narrowed to one bucket and one name,
  with rows and suites carrying display: none and a live count rewritten by
  script, and a log narrowed to one line. Each asserts its own precondition, in
  A2's pattern: the filtered tree must have both visible and hidden rows, and
  the filtered log must be shorter than the whole one, or the state is not the
  state and axe would pass it trivially.
• The contrast walk now covers both views. It reads the live cascade, and
  the two views are mutually exclusive, so one pass could only ever see one of
  them — which cost nothing while the log was a foreign document and would have
  left its colours, its count and its field unmeasured now that it is not.

Contrast

Tightest is the field's border at 3.24:1 against a 3.0:1 floor — the same
--color-border-control pairing A3a sized for the picker's summary. No new
token. The 3 arguments tag reuses .row-note, the chip a retried row's
outcome breakdown already wore, so it introduces no pairing either.

375px

The toolbar has the most to fit and the least room: six pills, a count and a
field. The pills wrap, the field gives way first (max-width, min-width: 0),
and the gate asserts its own precondition — the pills must actually have
wrapped, or it is measuring a row that fitted on one line and proving nothing.
Then: the field may not overhang the toolbar, must stay wide enough to type in,
and nothing may push the page sideways, since body is overflow: hidden and
anything past the right edge is unreachable rather than merely unscrolled.

Screenshots

1440 and 375, light and dark, in orca-artifacts/a3b-filters/: the Tests view,
the Expected-failures filter chosen, the name filter applied, the Logs view,
and the log filtered — twenty files, rendered from TestResults.xcresult so
the numbers in them are the 21/23 Xcode states for the same bundle.

Deviations

• The mockup has no toolbar, so the filter field's shape and placement come
  from Xcode's test report rather than from option A. What the mockup does have
  is the 3 arguments row tag, which is here verbatim.
• The pills are a row, not two dropdowns. Xcode has All Tests (21) ▾ and
  All Runs (23) ▾; ours states the same two numbers side by side without
  making the reader open a menu to see the split. A dropdown that has to be
  opened to be read is a worse trade at 375px than a row that wraps.
• No Test Scheme Action or All Tags filters. Neither is in the port:
  the action is not modelled, and Swift Testing tags are not carried by either
  reader.
• The log gets a text filter, not a section jump. Both are honest now that
  Give the Logs tab back its log on the default reader (fixes #480) #482 made the exported log identical across backends — its
  -------- title -------- headers would index cleanly. The text filter is the
  one Xcode puts in this corner, it is the one that answers "where is the
  failure", and it subsumes the jump for a document this shape.

Verification

• swift test — 193 tests, 0 failures, 3 skipped (the two env-gated capture
  tests and the standing JUnit drift skip from CoreTests.testRetryFunctionalityJunit expectations drift with Xcode version #378), on both legs
  (default/auto and XCHR_RESULT_READER=modern).
• DifferentialTests green on both legs; the allow-list is untouched.
• visual — 48 Playwright tests, 0 failures.
• Masked duration shapes untouched — (N.NNs) in the tree and
  <span class="summary-duration">(10.50s)</span> in the header, both still
  asserted against KnownLossMasker.
• swiftformat --lint clean; no new SwiftLint warnings (diffed against a
  baseline run on main, which is why Status moved to its own file and two
  real-fixture tests moved out of CoreTests — both files were at their length
  limits).

A note on the fixtures

TestResults.xcresult on this machine was a stale 16-test bundle from before
the sample app gained testExpectedFailure, knownIssue and
parameterizedAddition — the exact partial-bundle condition #478's gate
exists to catch, and it rejected it. Regenerated with prepareTestResults.sh;
scripts/verify_fixtures.sh now reports 21/1/4/1. Everything above is measured
against the regenerated set.

Fixes #460. Refs #439.

🤖 Generated with Claude Code

Summary by CodeRabbit

• New Features
  • Added combined status and name filtering for tests and logs, with per-run filter state.
  • Added searchable inline logs with monospace formatting, line counts, and accessible focus styling.
  • Added execution counts for repeated and parameterized tests, including toolbar totals.
  • Added expected-failure and unknown status filters.
• Bug Fixes
  • Improved visibility for nested suites, empty groups, screenshots, and digest navigation.
  • Preserved log content in inline and linked rendering modes.