From cd6b765085820a415b624614978f0467aafc7378 Mon Sep 17 00:00:00 2001 From: "Joshua (D) Drake" <136637981+ChronicallyJD@users.noreply.github.com> Date: Sat, 12 Sep 2026 11:04:09 -0600 Subject: [PATCH 1/4] test: the ledger records which majors each check exists on (#1010) The major is a FIELD, not part of the key, and that is the design rather than an implementation detail. A check's existence depends on the major, so a ledger that cannot say where a check exists cannot tell a deleted check from one that never ran here. analyze_differential.sh:61 emits ONE record on PG15-17 and a suite's worth on PG18+; fk_referencing.sh:287 emits DIFFERENT CHECK NAMES in its two branches. It does not follow that the major belongs in the key. Measured on a full matrix at 4d7c75ae, 252 suites on PG15 and PG18: 6367 of 6472 checks are identical on both majors and 105 exist on exactly one. A (major, check) key would hold 6472 x 5 = 32,360 rows to express those 105 -- about 247 duplicate rows for every row that differs, each a second copy of one observation. Keeping the key at (suite, part, name) also keeps checks_never_observed_red counting CHECKS. Under a pair key it would count pairs, and "5800 checks" in a tree holding 1150 of them is a number that lies by its own name. The field is a sorted ;-separated SET and it ACCUMULATES. A plain assignment was measured doing the wrong thing to last-red on #918: merging a PG15 log after a PG18 log must not make the check stop existing on 18, because the order somebody merges logs in is not a fact about the code. NO WILDCARD. "Every major observed" would change meaning the day a major joins the matrix, inheriting a claim nothing measured. WHAT THIS FIXES is orphan-scan, not gate. The gate refuses a check in the LOG the ledger has not seen, and a PG18-only check does not appear in a PG15 log, so it stayed correct by never being asked. orphan-scan asks the opposite question, and a PG18-only row is exactly what a deleted check looks like on PG15. It was saved only by the SKIP rule -- analyze_differential emits a check_skip so its part was unprunable, while fk_referencing emits check and has no SKIP at all. The fourth category already said the true thing, so the scope gains an intersection and nothing else: no new category and no grandfather rule. The gate also cannot refuse a check on a major it holds no rows for, for the same reason it cannot in a suite it has never seen. The documented census derivation moves from $4 to $5 in check_ledger_budget.txt, and both CHANGELOG entries that state it are corrected visibly rather than silently -- one of them says in its own text that the command was an INSTRUCTION and that is why its first wrong version is still shown. The committed ledger is migrated in the next commit, from a five-major run. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Uf6UoeBRZYLQZa4KxNiw8a --- CHANGELOG.md | 56 ++++++ test/check_ledger_budget.txt | 8 +- test/pgc_ledger.py | 182 ++++++++++++++---- test/pytest/TESTS.md | 35 ++++ test/pytest/test_mutation_ledger.py | 174 +++++++++++++++-- .../410-a-check-must-have-been-red.sh | 173 +++++++++++++++-- 6 files changed, 559 insertions(+), 69 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d11ade72..07b1e9eb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,6 +18,50 @@ true until the next version shipped. ### Added +- The mutation ledger records WHICH MAJORS each check exists on (#1010). + + suitepartnamemajorslast-redmutations + + A check's existence depends on the major, so a ledger that cannot say where a check + exists cannot tell a deleted check from one that never ran here. + `test/analyze_differential.sh:61` emits ONE record on PG15-17 and a suite's worth on + PG18+; `test/fk_referencing.sh:287` emits DIFFERENT CHECK NAMES in its two branches. + + THE MAJOR IS A FIELD, NOT PART OF THE KEY, and that is the design rather than an + implementation detail. Measured on a full matrix at `4d7c75ae`, 252 suites on PG15 and + PG18: 6367 of 6472 checks are identical on both majors and 105 exist on exactly one. A + `(major, check)` key would hold 6472 x 5 = 32,360 rows to express those 105 -- about 247 + duplicate rows for every row that differs, each a second copy of one observation. + Keeping the key at `(suite, part, name)` also keeps `checks_never_observed_red` counting + CHECKS: under a pair key it would count pairs, and "5800 checks" in a tree holding 1150 + of them is a number that lies by its own name. + + The field is a sorted `;`-separated SET -- `15;18` -- and it ACCUMULATES. A plain + assignment was measured doing the wrong thing to last-red on #918: merging a PG15 log + after a PG18 log must not make the check stop existing on 18, because the order somebody + merges logs in is not a fact about the code. + + NO WILDCARD. "Every major observed" would change meaning the day a major joins the + matrix, inheriting a claim nothing measured. + + `unknown` is a token in the set like any other, and the common one: + `harness_selftest` never references `PGC_MAJOR`, so every record it emits carries it. + + WHAT THIS FIXES is `orphan-scan`, not `gate`. The gate refuses a check in the LOG the + ledger has not seen, and a PG18-only check does not appear in a PG15 log, so it stayed + correct by never being asked. `orphan-scan` asks the opposite question, and a PG18-only + row is exactly what a deleted check looks like on PG15. It was saved only by the SKIP + rule -- `analyze_differential` emits a `check_skip` so its part was unprunable, while + `fk_referencing` emits `check` and has no SKIP at all, so once that suite is seeded a + PG15 run would have called its two PG17+ checks deleted. The fourth category already + said the true thing, so the scope gains an intersection and nothing else: no new + category and no grandfather rule. + + The gate also cannot refuse a check on a major it holds no rows for, for the same reason + it cannot in a suite it has never seen -- otherwise adding PG20 would redden every check + at once, which is a gate somebody turns off. It tightens the moment one run on that + major is merged, and it says out loud when it is not enforcing. + - A check record names the PostgreSQL major it was observed under (#1010). RESULTsuitepartnameverdictmajorreason @@ -70,6 +114,11 @@ true until the next version shipped. checks_never_observed_red 1155 -> 1162 covered native_join_vector_agg, 13 checks, last-red 2026-09-12 + awk -F'\t' '$5=="never"' test/check_ledger.tsv | wc -l + + Field 5 because the entry above inserted the majors as field 4. At the moment this + change landed on its own it was field 4; both ship in the same release, so the form + here is the one that works on the shipped tree. - The mutation ledger covers a third suite: `differential`, 204 checks (#752). @@ -90,6 +139,13 @@ true until the next version shipped. awk -F'\t' '$4=="never"' test/check_ledger.tsv | wc -l + SECOND CORRECTION, by the same rule that kept the first one visible: #1010 inserted + the majors a row claims as field 4, so on the shipped tree the last-red is field 5 and + the command above reads a major where it expects a date. The form that works is + `$5=="never"`, and `check_ledger_budget.txt` carries it. What the number COUNTS is + unchanged -- the key is still `(suite, part, name)`, so a row is still one check -- + which is the reason the major is a set in a field rather than part of the key. + A plain row count agrees with that only while nothing has ever been seen red, which is true of this tree today (1155 rows, 1155 never, 0 ever red) and stops being true the first time a check is attacked -- the event the ledger exists to record. So the diff --git a/test/check_ledger_budget.txt b/test/check_ledger_budget.txt index 86d8bd7b..173b1eeb 100644 --- a/test/check_ledger_budget.txt +++ b/test/check_ledger_budget.txt @@ -38,7 +38,13 @@ suites_not_covered 249 # HOW TO RE-DERIVE IT, written here because a changelog entry got it wrong and a # derivation is only useful where the number is: # -# awk -F'\t' '$4=="never"' test/check_ledger.tsv | wc -l +# awk -F'\t' '$5=="never"' test/check_ledger.tsv | wc -l +# +# FIELD 5, not 4, since #1010 inserted the majors a row claims as field 4. The number +# this counts did NOT change meaning: the key is still (suite, part, name), so a row is +# still one check and this still counts checks. That is why the major is a set in a +# field rather than part of the key -- under a (major, check) key this would count PAIRS +# and the name above would be false. # # Rows whose LAST-RED is `never`, not the row count. The two agree only while # nothing has ever been observed red, so a plain `grep -c` overcounts by exactly diff --git a/test/pgc_ledger.py b/test/pgc_ledger.py index ed8b633e..9433e65a 100755 --- a/test/pgc_ledger.py +++ b/test/pgc_ledger.py @@ -128,7 +128,32 @@ def _newer(current, incoming): return incoming return max(current, incoming) if incoming not in rank else current NONE = "-" -FIELDS = 5 + +# suite, part, name, MAJORS, last-red, mutations. +# +# THE MAJOR IS A FIELD, NOT PART OF THE KEY (#1010), and that is the whole design. A +# check's EXISTENCE depends on the major -- analyze_differential.sh:61 emits ONE record on +# PG15-17 and N on PG18+, and fk_referencing.sh:287 emits DIFFERENT CHECK NAMES in its two +# branches -- so the ledger has to record WHERE a check exists. It does not follow that the +# major belongs in the key. +# +# Measured on a full matrix at 4d7c75ae, 252 suites on PG15 and PG18: 6367 of 6472 checks +# are identical on both majors and 105 exist on exactly one. Keying on the major would hold +# 6472 x 5 = 32,360 rows to express those 105 -- about 247 duplicate rows for every row +# that differs, each a second copy of one observation, which is the shape +# `a-repeated-measurement-must-be-idempotent` is about. +# +# Keeping the key at (suite, part, name) also keeps `checks_never_observed_red` counting +# CHECKS. Under a (major, check) key it would count PAIRS, and "5800 checks" in a tree with +# 1150 of them is a number that lies by its own name -- the defect check_ledger_budget.txt +# exists to argue against. +# +# A SET, sorted and ";"-separated: "15;18". `unknown` is a token in it like any other, +# and the common one -- harness_selftest never references PGC_MAJOR, so all 907 of its +# rows carry it. NO WILDCARD: "every major observed" would change meaning the day a major +# is added to the matrix, inheriting a claim nothing measured. +FIELDS = 6 +MAJOR_SEP = ";" class LedgerError(Exception): @@ -234,7 +259,7 @@ def read_records(paths, *, require_nonempty=True): def read_ledger(path): - """{(suite, part, name): [last_red, {mutations}]}. + """{(suite, part, name): [{majors}, last_red, {mutations}]}. Keyed on the part as well as the name: harness_selftest sources 40-odd parts into one shell and phrases its premises to be COPIED, so a name-only key is a @@ -250,23 +275,37 @@ def read_ledger(path): f = line.split("\t") if len(f) != FIELDS: raise LedgerError(f"{path}:{n}: a ledger row needs {FIELDS} fields, got {len(f)}") - muts = set() if f[4] == NONE else {m for m in f[4].split(";") if m} - rows[(f[0], f[1], f[2])] = [f[3] or NEVER, muts] + # EVERY token validated, not just the first. A ledger is hand-edited far more + # often than a log is generated, so the typed-into file needs the check at least + # as much. A free-form --date was accepted verbatim once and a typo became an + # authoritative observation; a major decides which checks can exist. + majors = {m for m in f[3].split(MAJOR_SEP) if m} + if not majors: + raise LedgerError( + f"{path}:{n}: a row names no major, so it says nothing about where its " + f"check exists") + for m in sorted(majors): + if not _MAJOR.match(m): + raise LedgerError( + f"{path}:{n}: major {m!r} is neither a number nor " + f"{MAJOR_UNKNOWN!r}, so this row names no version it applies to") + muts = set() if f[5] == NONE else {m for m in f[5].split(";") if m} + rows[(f[0], f[1], f[2])] = [majors, f[4] or NEVER, muts] return rows def write_ledger(path, rows): lines = [] - for (suite, part, name), (red, muts) in sorted(rows.items()): + for (suite, part, name), (majors, red, muts) in sorted(rows.items()): # No trailing tab. An empty last field is trailing whitespace on every # row, which `git diff --check` reports and which made 614 of them. - lines.append("\t".join((suite, part, name, red, + lines.append("\t".join((suite, part, name, MAJOR_SEP.join(sorted(majors)), red, ";".join(sorted(muts)) if muts else NONE))) pathlib.Path(path).write_text("\n".join(lines) + ("\n" if lines else "")) def _by_run(paths): - """[(path, {(suite, part, name): [verdicts]})] -- one entry per LOG. + """[(path, {(suite, part, name): [(verdict, major)]})] -- one entry per LOG. Per log, because the same check appearing in two logs is two RUNS of it, while twice in one log is a duplicate name sharing a ledger row. Merging the logs @@ -275,8 +314,8 @@ def _by_run(paths): runs = [] for p in paths: seen = {} - for suite, part, name, verdict, _major in read_records([p]): - seen.setdefault((suite, part, name), []).append(verdict) + for suite, part, name, verdict, major in read_records([p]): + seen.setdefault((suite, part, name), []).append((verdict, major)) runs.append((p, seen)) return runs @@ -309,7 +348,8 @@ def cmd_merge(args): # Measured on #918: a two-FAIL log merged with --mutation MUTATION_A recorded # it against both. Reported by @linuxhikerpm. if args.mutation: - failed = sorted({key for _p, seen in runs for key, vs in seen.items() if "FAIL" in vs}) + failed = sorted({key for _p, seen in runs for key, vs in seen.items() + if any(v == "FAIL" for v, _m in vs)}) if len(failed) > 1: listed = "\n".join(f" {s}\t{p}\t{n}" for s, p, n in failed[:6]) more = "" if len(failed) <= 6 else f"\n ... and {len(failed) - 6} more" @@ -339,7 +379,8 @@ def cmd_merge(args): # Refused BEFORE any row is built, so a declined merge is never half-applied. if not args.mutation and not args.reds_are_real: reddened = sorted({key for _p, seen in runs - for key, vs in seen.items() if "FAIL" in vs}) + for key, vs in seen.items() + if any(v == "FAIL" for v, _m in vs)}) if reddened: listed = "\n".join(f" {s}\t{p}\t{n}" for s, p, n in reddened[:6]) more = "" if len(reddened) <= 6 else f"\n ... and {len(reddened) - 6} more" @@ -352,29 +393,39 @@ def cmd_merge(args): f"this is a genuine observation of the code under test.") for path, seen in runs: - for key, verdicts in sorted(seen.items()): + for key, pairs in sorted(seen.items()): + verdicts = [v for v, _m in pairs] if key not in rows: # A check this ledger has never seen enters as DEBT. A green run # has observed nothing go red, so merging one must never record a # red observation. - rows[key] = [NEVER, set()] + rows[key] = [set(), NEVER, set()] + # THE MAJOR SET ACCUMULATES, for the reason the mutation column and + # last-red both do: merging a PG15 log after a PG18 log must not make the + # check stop existing on 18. A plain assignment was measured doing exactly + # that to last-red on #918, silently, and the order a human merges logs in + # is not a fact about the code. + rows[key][0].update(m for _v, m in pairs) if "FAIL" in verdicts: - rows[key][0] = _newer(rows[key][0], args.date) + rows[key][1] = _newer(rows[key][1], args.date) if args.mutation: # A SET. Keeping only the last one records the most recent # attack rather than the catalogue this column exists to # become. - rows[key][1].add(args.mutation) - for key, verdicts in sorted(seen.items()): + rows[key][2].add(args.mutation) + for key, pairs in sorted(seen.items()): + verdicts = [v for v, _m in pairs] if len(verdicts) > 1: print(f" duplicate check name in one run, so one ledger row covers " f"{len(verdicts)}: {key[0]}\t{key[1]}\t{key[2]}") write_ledger(args.ledger, rows) seen_all = {k for _, s in runs for k in s} - red = sum(1 for v in rows.values() if v[0] != NEVER) + red = sum(1 for v in rows.values() if v[1] != NEVER) + majors = sorted(set().union(*(v[0] for v in rows.values())) if rows else set()) print(f" ledger: rows={len(rows)} | runs={len(runs)}, distinct checks this merge={len(seen_all)}, " f"observed red ever={red}, never={len(rows) - red}") + print(f" majors the ledger now claims rows for: {', '.join(majors) or 'none'}") return 0 @@ -398,9 +449,14 @@ def cmd_rename_scan(args): "the union of a before-log and an after-log hides the disappearance") rows = read_ledger(args.ledger) now = set(runs[0][1]) + # The majors this run actually observed. A row claiming only another major is not a + # candidate for a rename here: pairing its disappearance with an appearance would + # report a rename between two checks that were never the same check. + run_majors = {m for pairs in runs[0][1].values() for _v, m in pairs} parts = {(s, p) for s, p, _ in now} - known = {k for k in rows if (k[0], k[1]) in parts} + known = {k for k in rows + if (k[0], k[1]) in parts and (rows[k][0] & run_majors)} rc = 0 n_app = n_van = 0 @@ -410,11 +466,12 @@ def cmd_rename_scan(args): n_app += len(app) n_van += len(van) for new, old in zip(app, van): - was = rows.get((part[0], part[1], old), [NEVER, set()])[0] + was = rows.get((part[0], part[1], old), [set(), NEVER, set()])[1] print(f" possible rename: {old} -> {new} " f"(in {part[0]}/{part[1]}, history: last red {was})") rc = 1 - print(f" rename scan: appeared={n_app}, vanished={n_van}") + print(f" rename scan: appeared={n_app}, vanished={n_van}, " + f"majors this run observed={', '.join(sorted(run_majors)) or 'none'}") return rc @@ -473,9 +530,16 @@ def cmd_orphan_scan(args): THE EXIT CODES, stated because a caller only ever sees the code: 0 nothing left to report: no orphan and nothing unprunable - 1 something is still there -- an orphan, or a row this run cannot speak for + 1 something is still there -- an orphan, or a row in a part that SKIPPED 2 an integrity failure, or a prune refused because history would be lost + `not checked` does NOT set 1, and since #1010 that is the difference between a usable + tool and one that always returns 1. A run observes ONE major, so every row claiming + only another major is a row it does not contain. Outstanding means "this run found + something wrong with a row it could see", and a row from another major is not that. + The earlier wording said "a row this run cannot speak for", which describes both + categories and matched only one. + `--prune` returning 0 when it had pruned NOTHING was the first version's subtler bug, reported by @jdatcmd in review. A caller that scans, sees 1, re-runs with `--prune` and sees 0 reads "it pruned them" -- when nothing was pruned and nothing @@ -491,26 +555,47 @@ def cmd_orphan_scan(args): verdicts = runs[0][1] now = set(verdicts) + # THE MAJORS THIS RUN OBSERVED (#1010). This is the direction the missing dimension + # actually broke. A row the ledger claims only for PG18 looks exactly like a deleted + # check to a PG15 run, and the fourth category already says the true thing about it: + # "this run does not contain them, so it cannot speak about them". So no new category + # and no grandfather rule -- the scope gains an intersection and the row lands in + # `not checked`. + # + # It was saved until now only by the SKIP rule, and that was luck. + # analyze_differential emits a check_skip on PG15-17, so its part was unprunable; + # fk_referencing:287 emits `check` in its older-major branch and has no SKIP at all, + # so once that suite is seeded a PG15 run would have called its two PG17+ checks + # deleted. Measured at 4d7c75ae: 24 keys shared, 2 only on PG18, 1 only on PG15. + # + # AN INTERSECTION, not equality: a row claiming 15;18 is in scope on a PG15 run AND on + # a PG18 run. That is the point of the set -- a stronger claim is held to both tests. + run_majors = {m for pairs in verdicts.values() for _v, m in pairs} + parts = {(s, p) for s, p, _ in now} # A part holding ANY SKIP cannot speak about absence: see the docstring. - skipped_parts = {(s, p) for (s, p, _), v in verdicts.items() if "SKIP" in v} - checkable = {k for k in rows if (k[0], k[1]) in parts} + skipped_parts = {(s, p) for (s, p, _), v in verdicts.items() + if any(x == "SKIP" for x, _m in v)} + checkable = {k for k in rows + if (k[0], k[1]) in parts and (rows[k][0] & run_majors)} unchecked = sorted(set(rows) - checkable) absent = sorted(checkable - now) orphans = [k for k in absent if (k[0], k[1]) not in skipped_parts] unprunable = [k for k in absent if (k[0], k[1]) in skipped_parts] with_history = [k for k in orphans - if rows[k][0] != NEVER or rows[k][1]] + if rows[k][1] != NEVER or rows[k][2]] historyless = [k for k in orphans if k not in with_history] for k in orphans: - last, muts = rows[k] + majors, last, muts = rows[k] if k in with_history: print(f" ORPHAN CARRYING HISTORY: {k[0]}\t{k[1]}\t{k[2]} " - f"(last red {last}, mutations: {';'.join(sorted(muts)) or NONE})") + f"(claims {MAJOR_SEP.join(sorted(majors))}, last red {last}, " + f"mutations: {';'.join(sorted(muts)) or NONE})") else: - print(f" orphan: {k[0]}\t{k[1]}\t{k[2]} (no history)") + print(f" orphan: {k[0]}\t{k[1]}\t{k[2]} " + f"(claims {MAJOR_SEP.join(sorted(majors))}, no history)") # The parts the run never mentioned, named rather than counted alone: a number # with no names is a number nobody can act on. @@ -531,6 +616,8 @@ def cmd_orphan_scan(args): for k in unprunable[:5]: print(f" {k[0]}\t{k[1]}\t{k[2]}") + print(f" orphan scan: majors this run observed=" + f"{', '.join(sorted(run_majors)) or 'none'}") print(f" orphan scan: parts in the run={len(parts)}, rows in those parts={len(checkable)}, " f"orphans={len(orphans)} ({len(with_history)} carrying history), " f"unprunable={len(unprunable)}, not checked={len(unchecked)}") @@ -563,7 +650,8 @@ def cmd_orphan_scan(args): return 1 if unprunable else 0 for k in historyless: - print(f" pruned: {k[0]}\t{k[1]}\t{k[2]}") + print(f" pruned: {k[0]}\t{k[1]}\t{k[2]} " + f"(claimed {MAJOR_SEP.join(sorted(rows[k][0]))})") del rows[k] write_ledger(args.ledger, rows) print(f" orphan prune: removed {len(historyless)} row(s), the ledger now holds {len(rows)}") @@ -742,8 +830,9 @@ def _committed_budget(path, ref): def cmd_gate(args): rows = read_ledger(args.ledger) budget = read_budget(args.budget) - seen = {k for k, _, _ in ((k, None, None) for k in - {(s, p, n) for s, p, n, _, _m in read_records(args.logs)})} + # The records, WITH the major each was observed under: the refusal is about a + # (check, major) pair even though the ledger is keyed on the check. + records = sorted({(s, p, n, m) for s, p, n, _v, m in read_records(args.logs)}) rc = 0 @@ -760,9 +849,24 @@ def cmd_gate(args): # It tightens on its own as suites are seeded, and the ceiling is what forces # that direction. covered_suites = {k[0] for k in rows} - unknown = sorted(k for k in seen - set(rows) if k[0] in covered_suites) - for suite, part, name in unknown: - print(f" not in the ledger: {suite}\t{part}\t{name}") + # AND THE SAME ARGUMENT FOR THE MAJOR (#1010). The gate cannot refuse a new check on a + # major it holds no rows for, for the identical reason it cannot in a suite it has + # never seen: it has no idea which of that major's checks are new. Adding PG20 to the + # matrix would otherwise redden every check at once, which is a gate somebody turns + # off -- the failure this issue family exists to prevent. It tightens on its own the + # moment one run on that major is merged. + covered_majors = set().union(*(v[0] for v in rows.values())) if rows else set() + unknown = [] + for key in records: + if key[0] not in covered_suites or key[3] not in covered_majors: + continue + # A row is a claim about WHERE the check exists, so a known check seen on a major + # its row does not name is refused too: widening that claim is a ledger edit a + # reviewer should see, not something a run does silently. + if key[3] not in rows.get((key[0], key[1], key[2]), [set()])[0]: + unknown.append(key) + for suite, part, name, major in unknown: + print(f" not in the ledger: {suite}\t{part}\t{name}\t(on major {major})") if unknown: print(f" {len(unknown)} check(s) the ledger has never seen. Regenerate it with:") print(f" python3 test/pgc_ledger.py merge --ledger {args.ledger} --date ") @@ -771,9 +875,19 @@ def cmd_gate(args): # A CENSUS, not a ceiling. Bounding it deadlocks: every new check enters as # `never`, so the only way to land one would be to raise a number the design # says may only fall. - never = sum(1 for v in rows.values() if v[0] == NEVER) + never = sum(1 for v in rows.values() if v[1] == NEVER) print(f" ledger census: rows={len(rows)} | never observed red={never}, " f"ever red={len(rows) - never}, new this run={len(unknown)}") + # THE MAJORS, reported beside the census because the restriction above is invisible + # otherwise -- a gate that quietly enforces less than it claims is what the ledger + # design refuses. A run on an uncovered major must SAY so rather than pass quietly. + run_majors = sorted({k[3] for k in records}) + print(f" ledger majors: covered={', '.join(sorted(covered_majors)) or 'none'} | " + f"this run observed {', '.join(run_majors) or 'none'}") + for m in run_majors: + if m not in covered_majors: + print(f" the ledger holds no row for major {m}, so it cannot refuse a new " + f"check there -- merge one run on it and this tightens") # THE CENSUS IS COMPARED, NOT ONLY PRINTED (#952). Reporting is not enforcing: # the line above stated the true number while the budget claimed another, and diff --git a/test/pytest/TESTS.md b/test/pytest/TESTS.md index 70d2643e..0f59862b 100644 --- a/test/pytest/TESTS.md +++ b/test/pytest/TESTS.md @@ -2398,6 +2398,41 @@ checks a log before merging it, so a major the tool validates and then drops can audited. Asserted on the FIELD rather than a substring: `18` appears inside a check name or a reason just as happily. +### `test_a_rows_major_set_accumulates_rather_than_replacing` + +A check exists on a SET of majors, and the set is a row's field rather than part of its key +(#1010). Keying on the major would store one fact once per major: measured on a full matrix +at `4d7c75ae`, 6367 of 6472 checks are identical on PG15 and PG18, so `(major, check)` would +hold 6472 x 5 = 32,360 rows to express 105 keys' worth of difference. Keeping the key at +`(suite, part, name)` is also what keeps `checks_never_observed_red` counting CHECKS, true to +its own name. + +The set accumulates, for the reason the mutation column and last-red both do: merging a PG15 +log after a PG18 log must not make the check stop existing on 18. `unknown` is a token in the +set like any other, and the common one. + +### `test_a_run_speaks_only_for_the_majors_the_row_claims` + +A PG15 run cannot orphan a check the ledger says exists only on PG18. This is the direction +the missing dimension actually broke; `gate` is not it, because a PG18-only check never +appears in a PG15 log and the gate stays correct by never being asked. + +Until #1010 it was saved only by the SKIP rule, and that was luck: +`analyze_differential` emits a `check_skip` on PG15-17 so its part was unprunable, while +`fk_referencing:287` emits `check` in its older-major branch and has no SKIP at all. The +fixture therefore carries **no skip**, or the arm would prove the wrong mechanism. The scope +is an INTERSECTION, so a row claiming `15;18` is checked on both -- a stronger claim held to +both tests -- and the control deletes a check on its own major to show that a real +disappearance is still named. + +### `test_the_gate_cannot_refuse_a_check_on_a_major_it_has_never_seen` + +The same argument as `suites_not_covered`, one dimension over. The gate cannot refuse a new +check in a suite it has never seen, and a major it holds no rows for is the identical +problem: adding PG20 would make every check new at once and redden the whole run, which is a +gate somebody turns off. The control shows a new check IS refused on a covered major, so the +arm does not merely prove the gate refuses nothing. + ## 24. test_loop_coverage_premise.py: a loop that never ran asserted nothing **Why this file exists.** `assert-inside-a-loop-over-zero-rows` in VACUITY_MODES.md 3.5 diff --git a/test/pytest/test_mutation_ledger.py b/test/pytest/test_mutation_ledger.py index 8e5a15ed..d0c80c19 100644 --- a/test/pytest/test_mutation_ledger.py +++ b/test/pytest/test_mutation_ledger.py @@ -92,9 +92,9 @@ def test_a_green_run_records_debt_and_never_a_red_observation(tmp_path, expect): _run("merge", "--ledger", ledger, _w(tmp_path, "g.log", GREEN)) rows = _rows(ledger) expect.num(len(rows), 2, "merging a green run records both checks") - expect.text(",".join(sorted({r[3] for r in rows})), "never", + expect.text(",".join(sorted({r[4] for r in rows})), "never", "and records neither as ever having been red") - expect.num(len([r for r in rows if len(r) != 5]), 0, "every row has five fields") + expect.num(len([r for r in rows if len(r) != 6]), 0, "every row has six fields") expect.num(pathlib.Path(ledger).read_text().count("\t\n"), 0, "and no row ends in a tab, which was 614 of them") @@ -109,13 +109,13 @@ def test_the_mutation_column_accumulates_rather_than_overwriting(tmp_path, expec ledger = _w(tmp_path, "l.tsv", "") red = _w(tmp_path, "r.log", RED) _run("merge", "--ledger", ledger, "--date", "2026-09-10", "--mutation", "SAOP 128 -> 0", red) - by = {r[2]: r[4] for r in _rows(ledger)} + by = {r[2]: r[5] for r in _rows(ledger)} expect.text(by["first check"], "SAOP 128 -> 0", "a named mutation is recorded against the check that reddened") expect.text(by["second check"], "-", "and not against one that stayed green") _run("merge", "--ledger", ledger, "--date", "2026-09-10", "--mutation", "bloom neutered", red) - expect.text({r[2]: r[4] for r in _rows(ledger)}["first check"], + expect.text({r[2]: r[5] for r in _rows(ledger)}["first check"], "SAOP 128 -> 0;bloom neutered", "a second mutation accumulates rather than replacing the first") @@ -246,7 +246,7 @@ def test_prune_drops_a_historyless_orphan_and_refuses_one_carrying_history(tmp_p _w(tmp_path, "h.log", "RESULT\tdemo\tpart1\tstill here\tPASS\t18\t\n" "RESULT\tdemo\tpart1\tgone tomorrow\tFAIL\t18\t\nchecks run: 2\n")) - expect.text({r[2]: r[3] for r in _rows(hist)}["gone tomorrow"], "2026-09-01", + expect.text({r[2]: r[4] for r in _rows(hist)}["gone tomorrow"], "2026-09-01", "premise: the orphan now carries a date") out, rc = _run("orphan-scan", "--prune", "--ledger", hist, after) @@ -345,7 +345,7 @@ def test_the_gate_refuses_a_new_check_only_in_a_suite_it_covers(tmp_path, expect expect.num(_run("gate", "--ledger", ledger, "--budget", b0, "--registered", reg, other2)[1], 0, "regenerating the ledger lets the new check through") - expect.text({r[2]: r[3] for r in _rows(ledger)}["newly added"], "never", + expect.text({r[2]: r[4] for r in _rows(ledger)}["newly added"], "never", "and it entered as debt, not as an observation nothing made") @@ -422,11 +422,11 @@ def test_the_committed_ledger_and_budget_agree(expect): expect.text("yes" if budget.exists() else "no", "yes", "the budget is in the tree") rows = [l.split("\t") for l in ledger.read_text().splitlines() if l] - never = [r for r in rows if r[3] == "never"] - red = [r for r in rows if r[3] != "never"] + never = [r for r in rows if r[4] == "never"] + red = [r for r in rows if r[4] != "never"] print(f" ledger: inputs={len(rows)} | observed red={len(red)}, never={len(never)}") expect.num(len(red) + len(never), len(rows), "the ledger partitions") - expect.num(len([r for r in rows if len(r) != 5]), 0, "every committed row has five fields") + expect.num(len([r for r in rows if len(r) != 6]), 0, "every committed row has six fields") expect.num(ledger.read_text().count("\t\n"), 0, "and none ends in a tab") nums = {} @@ -466,7 +466,7 @@ def test_the_gate_refuses_a_census_that_contradicts_its_own_ledger(tmp_path, exp # holds two rows and both are `never`. rows = _rows(ledger) expect.num(len(rows), 2, "premise: the merged ledger holds two rows") - expect.num(len([r for r in rows if r[3] == "never"]), 2, + expect.num(len([r for r in rows if r[4] == "never"]), 2, "premise: both entered as never, so this ledger's census is 2") ok = _w(tmp_path, "ok.txt", "suites_not_covered 0\nchecks_never_observed_red 2\n") @@ -537,8 +537,8 @@ def test_last_red_may_only_move_forward(tmp_path, expect): def stored(): for line in pathlib.Path(led).read_text().splitlines(): f = line.split("\t") - if len(f) > 3 and f[2] == "first check": - return f[3] + if len(f) > 4 and f[2] == "first check": + return f[4] return None _run("merge", "--reds-are-real", "--ledger", led, "--date", "2026-09-10", red) @@ -573,7 +573,7 @@ def test_a_mutation_names_one_check_not_every_casualty(tmp_path, expect): one = _w(tmp_path, "one.log", RED) _run("merge", "--ledger", led, "--date", "2026-09-10", "--mutation", "M", one) rows = [l.split("\t") for l in pathlib.Path(led).read_text().splitlines() if l.strip()] - tagged = [r[2] for r in rows if len(r) > 4 and "M" in r[4].split(";")] + tagged = [r[2] for r in rows if len(r) > 5 and "M" in r[5].split(";")] expect.rows([[n] for n in sorted(tagged)], [["first check"]], "and a single failure still carries it, on the check that reddened") @@ -695,3 +695,151 @@ def test_the_census_reports_the_major_it_read(tmp_path, expect): expect.num(majors.count("18"), 2, "and prints the major for each record that has one") expect.num(majors.count("unknown"), 1, "and prints `unknown` where the harness set none") + + +def test_a_rows_major_set_accumulates_rather_than_replacing(tmp_path, expect): + """A check exists on a SET of majors, and the set is a row's field, not its key (#1010). + + Keying on the major would store one fact once per major. Measured on a full matrix at + 4d7c75ae: 6367 of 6472 checks are identical on PG15 and PG18, so `(major, check)` + would hold 6472 x 5 = 32,360 rows to express 105 keys' worth of difference -- about + 247 duplicate rows per row that actually differs. The set keeps the key at + `(suite, part, name)`, which is also what keeps `checks_never_observed_red` counting + CHECKS, true to its own name. + + The set ACCUMULATES, for the same reason the mutation column does and last-red does: + merging a PG15 log after a PG18 log must not make the check stop existing on 18. That + was measured as a plain assignment twice on this tool already (#918). + """ + ledger = _w(tmp_path, "l.tsv", "") + r18 = _w(tmp_path, "r18.log", + "RESULT\tdemo\tpart1\teverywhere\tPASS\t18\t\n" + "RESULT\tdemo\tpart1\tpg18 only\tPASS\t18\t\nchecks run: 2\n") + r15 = _w(tmp_path, "r15.log", + "RESULT\tdemo\tpart1\teverywhere\tPASS\t15\t\nchecks run: 1\n") + + _run("merge", "--ledger", ledger, "--date", "2026-09-12", r18) + majors = {r[2]: r[3] for r in _rows(ledger)} + expect.text(majors["pg18 only"], "18", "a check seen once names the one major it was seen on") + + _run("merge", "--ledger", ledger, "--date", "2026-09-12", r15) + majors = {r[2]: r[3] for r in _rows(ledger)} + expect.text(majors["everywhere"], "15;18", + "a second major is ADDED to the set, sorted, not written over the first") + expect.text(majors["pg18 only"], "18", + "and a check the second run never mentioned keeps the set it had") + expect.num(len(_rows(ledger)), 2, + "two checks are two rows, whatever the majors: the key is not the major") + + # `unknown` is a token in the set like any other. harness_selftest never references + # PGC_MAJOR, so every record it emits carries it, and those rows must not multiply + # either. + runk = _w(tmp_path, "ru.log", + "RESULT\tdemo\tpart1\teverywhere\tPASS\tunknown\t\nchecks run: 1\n") + _run("merge", "--ledger", ledger, "--date", "2026-09-12", runk) + expect.text({r[2]: r[3] for r in _rows(ledger)}["everywhere"], "15;18;unknown", + "a harness that named no major adds its own token rather than a number") + + +def test_a_run_speaks_only_for_the_majors_the_row_claims(tmp_path, expect): + """A PG15 run cannot orphan a check the ledger says exists only on PG18 (#1010). + + This is the direction the missing dimension actually broke, and `gate` is not it: the + gate refuses a check in the LOG the ledger has not seen, and a PG18-only check does + not appear in a PG15 log, so the gate stays correct by never being asked. + `orphan-scan` asks the opposite question and a PG18-only row is exactly what a + deleted check looks like on PG15. + + Until now it was saved only by the SKIP rule, and that was luck. + analyze_differential emits a check_skip on PG15-17 so its part was unprunable; + fk_referencing:287 emits `check` in its older-major branch and has no SKIP at all, so + once that suite is seeded a PG15 run would call its two PG17+ checks deleted. + Measured at 4d7c75ae: 24 keys shared, 2 only on PG18, 1 only on PG15. + + The fourth category already says the true thing -- "this run does not contain them, so + it cannot speak about them" -- so this needs no new category and no grandfather rule. + """ + # NO SKIP anywhere in the fixture, or the arm proves the wrong mechanism. + ledger = _w(tmp_path, "l.tsv", + "demo\tpart1\teverywhere\t15;18\tnever\t-\n" + "demo\tpart1\tpg18 only\t18\tnever\t-\n" + "demo\tpart1\tpg15 only\t15\tnever\t-\n") + log15 = _w(tmp_path, "r15.log", + "RESULT\tdemo\tpart1\teverywhere\tPASS\t15\t\n" + "RESULT\tdemo\tpart1\tpg15 only\tPASS\t15\t\nchecks run: 2\n") + + out, rc = _run("orphan-scan", "--ledger", ledger, log15) + expect.num(out.count("orphan:"), 0, + "a PG15 run names no orphan: it saw every check the ledger claims for 15") + expect.num(out.count("ORPHAN CARRYING HISTORY"), 0, "and none carrying history either") + expect.num(out.count("not checked: 1 row"), 1, + "the PG18-only row is one this run cannot speak about, not one that vanished") + expect.num(rc, 0, + "and a run that cannot see another major's rows is not a failure -- a run " + "sees ONE major, so otherwise every correct run would return 1") + + # THE CONTROL. Without it the arm above proves only that nothing is ever an orphan. + log15b = _w(tmp_path, "r15b.log", + "RESULT\tdemo\tpart1\teverywhere\tPASS\t15\t\nchecks run: 1\n") + out, rc = _run("orphan-scan", "--ledger", ledger, log15b) + expect.num(out.count("orphan: demo\tpart1\tpg15 only"), 1, + "control: a check the ledger claims for 15 and a PG15 run did not emit IS " + "an orphan") + + # And the row claiming BOTH majors is checked on BOTH, which is the set's whole point: + # a stronger claim is held to a stronger test. + log18 = _w(tmp_path, "r18.log", + "RESULT\tdemo\tpart1\tpg18 only\tPASS\t18\t\nchecks run: 1\n") + out, rc = _run("orphan-scan", "--ledger", ledger, log18) + expect.num(out.count("orphan: demo\tpart1\teverywhere"), 1, + "a row claiming 15;18 is an orphan on a PG18 run that did not emit it") + + +def test_the_gate_cannot_refuse_a_check_on_a_major_it_has_never_seen(tmp_path, expect): + """The same argument as suites_not_covered, one dimension over (#1010). + + The gate cannot refuse a new check in a suite it has never seen, because it has no + idea which of that suite's checks are new. A major it has never seen is the identical + problem: adding PG20 to the matrix would make EVERY check new on 20 and redden the + whole run at once -- which is a gate somebody turns off, the failure this issue family + exists to prevent. + + So the restriction is not a softening, it is the meaning of coverage. It tightens on + its own the moment one run on that major is merged. + """ + ledger = _w(tmp_path, "l.tsv", "demo\tpart1\tknown check\t18\tnever\t-\n") + budget = _w(tmp_path, "b.txt", "suites_not_covered 0\n") + reg = _w(tmp_path, "reg", "demo\n") + + # PG20: the ledger holds no row naming it, so it cannot say which of these are new. + log20 = _w(tmp_path, "r20.log", + "RESULT\tdemo\tpart1\tknown check\tPASS\t20\t\n" + "RESULT\tdemo\tpart1\tbrand new\tPASS\t20\t\nchecks run: 2\n") + out, rc = _run("gate", "--ledger", ledger, "--budget", budget, "--registered", reg, log20) + expect.num(out.count("not in the ledger"), 0, + "a major with no rows at all refuses nothing, as an uncovered suite does") + expect.num(rc, 0, "so a first run on a new major is not a failure") + expect.num(out.count("major 20"), 1, "and the gate says out loud that it covered no rows for 20") + + # THE CONTROL: on a major it HAS seen, a new check is refused. Without this the arm + # above proves only that the gate refuses nothing at all. + log18 = _w(tmp_path, "r18.log", + "RESULT\tdemo\tpart1\tknown check\tPASS\t18\t\n" + "RESULT\tdemo\tpart1\tbrand new\tPASS\t18\t\nchecks run: 2\n") + out, rc = _run("gate", "--ledger", ledger, "--budget", budget, "--registered", reg, log18) + expect.num(out.count("not in the ledger"), 1, "control: on a covered major a new check is named") + expect.num(rc, 1, "and refused") + + # And a check the ledger knows, seen on a major its row does NOT claim, is refused -- + # the row is a claim about where the check exists, so widening it is a ledger edit. + led2 = _w(tmp_path, "l2.tsv", + "demo\tpart1\tknown check\t18\tnever\t-\n" + "demo\tpart1\tother\t15\tnever\t-\n") + log15 = _w(tmp_path, "r15.log", + "RESULT\tdemo\tpart1\tknown check\tPASS\t15\t\n" + "RESULT\tdemo\tpart1\tother\tPASS\t15\t\nchecks run: 2\n") + out, rc = _run("gate", "--ledger", led2, "--budget", budget, "--registered", reg, log15) + expect.num(out.count("known check"), 1, + "a known check on a major its row does not claim is named, because the row " + "is a claim about where it exists") + expect.num(rc, 1, "and refused until the ledger is regenerated") diff --git a/test/selftest/410-a-check-must-have-been-red.sh b/test/selftest/410-a-check-must-have-been-red.sh index 154f34dc..19e39002 100644 --- a/test/selftest/410-a-check-must-have-been-red.sh +++ b/test/selftest/410-a-check-must-have-been-red.sh @@ -96,13 +96,13 @@ check "control: a well-formed log still merges" \ _led_run merge --reds-are-real --ledger "$_lw/date.tsv" --date 2026-09-10 "$_lw/red.log" >/dev/null _led_run merge --reds-are-real --ledger "$_lw/date.tsv" --date 2026-09-01 "$_lw/red.log" >/dev/null check "an older observation does not overwrite a newer one" \ - "$(awk -F'\t' '$3=="first check"{print $4}' "$_lw/date.tsv")" "2026-09-10" + "$(awk -F'\t' '$3=="first check"{print $5}' "$_lw/date.tsv")" "2026-09-10" _led_run merge --reds-are-real --ledger "$_lw/date.tsv" --date 2026-09-20 "$_lw/red.log" >/dev/null check "and a newer one does" \ - "$(awk -F'\t' '$3=="first check"{print $4}' "$_lw/date.tsv")" "2026-09-20" + "$(awk -F'\t' '$3=="first check"{print $5}' "$_lw/date.tsv")" "2026-09-20" _led_run merge --reds-are-real --ledger "$_lw/date.tsv" "$_lw/red.log" >/dev/null check "and an undated merge does not erase a known date" \ - "$(awk -F'\t' '$3=="first check"{print $4}' "$_lw/date.tsv")" "2026-09-20" + "$(awk -F'\t' '$3=="first check"{print $5}' "$_lw/date.tsv")" "2026-09-20" check "a date that is not a date is refused rather than stored" \ "$(_led_rc merge --ledger "$_lw/date.tsv" --date not-a-date "$_lw/red.log")" "2" @@ -137,20 +137,20 @@ check "the gate refuses to run without the registered suite list" \ _led_run merge --ledger "$_lw/ledger.tsv" --date 2026-09-10 "$_lw/green.log" >/dev/null check "merging a green run records both checks" "$(grep -c . "$_lw/ledger.tsv")" "2" check "and records neither as ever having been red" \ - "$(cut -f4 "$_lw/ledger.tsv" | sort -u | tr '\n' ' ')" "never " -check "every row has five fields and no trailing tab" \ - "$(awk -F'\t' 'NF!=5' "$_lw/ledger.tsv" | grep -c . || true)" "0" + "$(cut -f5 "$_lw/ledger.tsv" | sort -u | tr '\n' ' ')" "never " +check "every row has six fields and no trailing tab" \ + "$(awk -F'\t' 'NF!=6' "$_lw/ledger.tsv" | grep -c . || true)" "0" check "and an empty mutation is a placeholder, not an empty last field" \ "$(grep -cP '\t$' "$_lw/ledger.tsv" || true)" "0" _led_run merge --reds-are-real --ledger "$_lw/ledger.tsv" --date 2026-09-10 "$_lw/red.log" >/dev/null check "a check observed red gains the date it was seen" \ - "$(awk -F'\t' '$3=="first check"{print $4}' "$_lw/ledger.tsv")" "2026-09-10" + "$(awk -F'\t' '$3=="first check"{print $5}' "$_lw/ledger.tsv")" "2026-09-10" check "and one that stayed green keeps its debt" \ - "$(awk -F'\t' '$3=="second check"{print $4}' "$_lw/ledger.tsv")" "never" + "$(awk -F'\t' '$3=="second check"{print $5}' "$_lw/ledger.tsv")" "never" _led_run merge --ledger "$_lw/ledger.tsv" --date 2026-09-11 "$_lw/green.log" >/dev/null check "a later green run does not erase an observation" \ - "$(awk -F'\t' '$3=="first check"{print $4}' "$_lw/ledger.tsv")" "2026-09-10" + "$(awk -F'\t' '$3=="first check"{print $5}' "$_lw/ledger.tsv")" "2026-09-10" # ---- the mutation column ACCUMULATES ---------------------------------------- # @@ -162,15 +162,146 @@ check "a later green run does not erase an observation" \ : > "$_lw/mut.tsv" _led_run merge --ledger "$_lw/mut.tsv" --date 2026-09-10 --mutation 'SAOP limit 128 -> 0' "$_lw/red.log" >/dev/null check "a named mutation is recorded against the check that reddened" \ - "$(awk -F'\t' '$3=="first check"{print $5}' "$_lw/mut.tsv")" "SAOP limit 128 -> 0" + "$(awk -F'\t' '$3=="first check"{print $6}' "$_lw/mut.tsv")" "SAOP limit 128 -> 0" check "and not against one that stayed green" \ - "$(awk -F'\t' '$3=="second check"{print $5}' "$_lw/mut.tsv")" "-" + "$(awk -F'\t' '$3=="second check"{print $6}' "$_lw/mut.tsv")" "-" _led_run merge --ledger "$_lw/mut.tsv" --date 2026-09-10 --mutation 'bloom neutered' "$_lw/red.log" >/dev/null check "a second mutation ACCUMULATES rather than replacing the first" \ - "$(awk -F'\t' '$3=="first check"{print $5}' "$_lw/mut.tsv")" "SAOP limit 128 -> 0;bloom neutered" + "$(awk -F'\t' '$3=="first check"{print $6}' "$_lw/mut.tsv")" "SAOP limit 128 -> 0;bloom neutered" check "one --mutation cannot be attributed across several runs at once" \ "$(_led_rc merge --ledger "$_lw/mut.tsv" --date 2026-09-10 --mutation X "$_lw/red.log" "$_lw/green.log")" "2" +# ---- the majors a row CLAIMS, which is a set and not part of the key (#1010) -- +# +# A check's existence depends on the major: analyze_differential.sh:61 emits ONE +# record on PG15-17 and a suite's worth on PG18+, and fk_referencing.sh:287 emits +# DIFFERENT CHECK NAMES in its two branches. The ledger has to record WHERE a check +# exists. It does not follow that the major belongs in the KEY: measured on a full +# matrix at 4d7c75ae, 6367 of 6472 checks are identical on PG15 and PG18, so a +# (major, check) key would hold 6472 x 5 rows to express 105 keys' worth. +# +# THE SET ACCUMULATES, for the reason the mutation column above does. A plain +# assignment would make merging a PG15 log after a PG18 log say the check stopped +# existing on 18, and the order somebody merges logs in is not a fact about the code. + +printf 'RESULT demo part1 both majors PASS 18 +RESULT demo part1 pg18 only PASS 18 +checks run: 2 +' > "$_lw/m18.log" +printf 'RESULT demo part1 both majors PASS 15 +checks run: 1 +' > "$_lw/m15.log" +printf 'RESULT demo part1 both majors PASS unknown +checks run: 1 +' > "$_lw/munk.log" + +: > "$_lw/maj.tsv" +_led_run merge --ledger "$_lw/maj.tsv" --date 2026-09-12 "$_lw/m18.log" >/dev/null +check "a check seen once claims the one major it was seen on" "$(awk -F' ' '$3=="pg18 only"{print $4}' "$_lw/maj.tsv")" "18" + +_led_run merge --ledger "$_lw/maj.tsv" --date 2026-09-12 "$_lw/m15.log" >/dev/null +check "a second major is ADDED to the set, sorted, not written over the first" "$(awk -F' ' '$3=="both majors"{print $4}' "$_lw/maj.tsv")" "15;18" +check "and a check the second run never mentioned keeps the majors it claimed" "$(awk -F' ' '$3=="pg18 only"{print $4}' "$_lw/maj.tsv")" "18" +check "two checks stay two rows whatever the majors, because the key is not the major" "$(grep -c . "$_lw/maj.tsv")" "2" + +# `unknown` is a token in the set like any other, and the COMMON one: this very +# suite's runner never references PGC_MAJOR, so every record harness_selftest emits +# carries it. +_led_run merge --ledger "$_lw/maj.tsv" --date 2026-09-12 "$_lw/munk.log" >/dev/null +check "a harness that named no major adds its own token rather than a number" "$(awk -F' ' '$3=="both majors"{print $4}' "$_lw/maj.tsv")" "15;18;unknown" + +# A row whose majors field is garbage is refused, in the LEDGER as well as in a log. +# A ledger is hand-edited far more often than a log is generated. +printf 'demo part1 c eighteen never - +' > "$_lw/badmaj.tsv" +check "a ledger row naming a major that is not a major is an integrity failure" "$(_led_rc orphan-scan --ledger "$_lw/badmaj.tsv" "$_lw/m18.log")" "2" +printf 'demo part1 c never - +' > "$_lw/nomaj.tsv" +check "and a row naming NO major says nothing about where its check exists" "$(_led_rc orphan-scan --ledger "$_lw/nomaj.tsv" "$_lw/m18.log")" "2" +check "control: the same row with a real major is read without complaint" "$(printf 'demo part1 both majors 18 never - +demo part1 pg18 only 18 never - +' > "$_lw/okmaj.tsv" + _led_rc orphan-scan --ledger "$_lw/okmaj.tsv" "$_lw/m18.log")" "0" + +# ---- a run speaks only for the majors a row claims --------------------------- +# +# THE DIRECTION THE MISSING DIMENSION BROKE, and it is orphan-scan rather than the +# gate: the gate refuses a check in the LOG the ledger has not seen, and a PG18-only +# check does not appear in a PG15 log, so it stayed correct by never being asked. +# +# Until now it was saved only by the SKIP rule, and that was luck. +# analyze_differential emits a check_skip on PG15-17 so its part was unprunable; +# fk_referencing:287 emits `check` in its older-major branch and has no SKIP at all, +# so once that suite is seeded a PG15 run would have called its two PG17+ checks +# deleted. THIS FIXTURE CARRIES NO SKIP, or the arm proves the wrong mechanism. + +printf 'demo part1 both majors 15;18 never - +demo part1 pg18 only 18 never - +demo part1 pg15 only 15 never - +' > "$_lw/scope.tsv" +printf 'RESULT demo part1 both majors PASS 15 +RESULT demo part1 pg15 only PASS 15 +checks run: 2 +' > "$_lw/s15.log" +_scope="$(_led_run orphan-scan --ledger "$_lw/scope.tsv" "$_lw/s15.log")" +check "a PG15 run names no orphan, having seen every check the ledger claims for 15" "$(printf '%s +' "$_scope" | grep -c 'orphan:' || true)" "0" +check "and the PG18-only row is one it cannot speak about, not one that vanished" "$(printf '%s +' "$_scope" | grep -c 'not checked: 1 row' || true)" "1" +check "and that is not a failure, because a run sees ONE major" "$(_led_rc orphan-scan --ledger "$_lw/scope.tsv" "$_lw/s15.log")" "0" + +# THE CONTROL. Without it the three arms above prove only that nothing is ever an +# orphan. Same major, really gone. +printf 'RESULT demo part1 both majors PASS 15 +checks run: 1 +' > "$_lw/s15b.log" +check "control: a check the ledger claims for 15 that a PG15 run did not emit IS an orphan" "$(_led_run orphan-scan --ledger "$_lw/scope.tsv" "$_lw/s15b.log" | grep -c 'orphan: demo part1 pg15 only' || true)" "1" + +# A row claiming BOTH majors is checked on BOTH: a stronger claim held to both tests, +# which is the point of storing a set rather than one major per row. +printf 'RESULT demo part1 pg18 only PASS 18 +checks run: 1 +' > "$_lw/s18.log" +check "a row claiming 15;18 is an orphan on a PG18 run that did not emit it" "$(_led_run orphan-scan --ledger "$_lw/scope.tsv" "$_lw/s18.log" | grep -c 'orphan: demo part1 both majors' || true)" "1" + +# ---- the gate cannot refuse a check on a major it holds no rows for ---------- +# +# The same argument as suites_not_covered, one dimension over: it cannot refuse a +# new check in a suite it has never seen, and a major it has never seen is the +# identical problem. Adding PG20 would otherwise redden every check at once, which +# is a gate somebody turns off. + +printf 'demo part1 known check 18 never - +' > "$_lw/cov.tsv" +printf 'RESULT demo part1 known check PASS 20 +RESULT demo part1 brand new PASS 20 +checks run: 2 +' > "$_lw/g20.log" +_g20="$(_led_run gate --ledger "$_lw/cov.tsv" --budget "$_lw/budget.txt" --registered "$_lw/registered" "$_lw/g20.log")" +check "a major the ledger holds no row for refuses nothing, as an uncovered suite does" "$(printf '%s +' "$_g20" | grep -c 'not in the ledger' || true)" "0" +check "and the gate says out loud that it covered no rows for that major" "$(printf '%s +' "$_g20" | grep -c 'holds no row for major 20' || true)" "1" +check "so a first run on a new major is not a failure" "$(_led_rc gate --ledger "$_lw/cov.tsv" --budget "$_lw/budget.txt" --registered "$_lw/registered" "$_lw/g20.log")" "0" + +# THE CONTROL: on a major it HAS seen, a new check is still refused. +printf 'RESULT demo part1 known check PASS 18 +RESULT demo part1 brand new PASS 18 +checks run: 2 +' > "$_lw/g18.log" +check "control: on a covered major a new check is named and refused" "$(_led_rc gate --ledger "$_lw/cov.tsv" --budget "$_lw/budget.txt" --registered "$_lw/registered" "$_lw/g18.log")" "1" + +# And a KNOWN check seen on a major its row does not claim is refused too: the row +# is a claim about where the check exists, so widening it is a ledger edit. +printf 'demo part1 known check 18 never - +demo part1 other 15 never - +' > "$_lw/cov2.tsv" +printf 'RESULT demo part1 known check PASS 15 +RESULT demo part1 other PASS 15 +checks run: 2 +' > "$_lw/g15.log" +check "a known check on a major its row does not claim is refused, because the row is a claim" "$(_led_rc gate --ledger "$_lw/cov2.tsv" --budget "$_lw/budget.txt" --registered "$_lw/registered" "$_lw/g15.log")" "1" + # ---- two runs of a check are not a duplicate of it -------------------------- # # Merging the logs first cannot tell "the same check in two runs" from "the same @@ -197,7 +328,7 @@ printf 'RESULT\tdemo\tpart1\tthe old name\tFAIL\t18\t\nRESULT\tdemo\tpart1\ta st printf 'RESULT\tdemo\tpart1\tthe new name\tPASS\t18\t\nRESULT\tdemo\tpart1\ta stable check\tPASS\t18\t\nchecks run: 2\n' > "$_lw/after.log" _led_run merge --reds-are-real --ledger "$_lw/ren.tsv" --date 2026-09-01 "$_lw/before.log" >/dev/null check "premise: the check has history before the rename" \ - "$(awk -F'\t' '$3=="the old name"{print $4}' "$_lw/ren.tsv")" "2026-09-01" + "$(awk -F'\t' '$3=="the old name"{print $5}' "$_lw/ren.tsv")" "2026-09-01" check "a name that appeared while another disappeared is reported as a rename" \ "$(_led_run rename-scan --ledger "$_lw/ren.tsv" "$_lw/after.log" \ | grep -c 'possible rename: the old name -> the new name')" "1" @@ -278,7 +409,7 @@ check "a before-log and an after-log together are refused, as rename-scan refuse cp "$_lw/orph.tsv" "$_lw/prune.tsv" check "premise: the orphan about to be pruned carries no history" \ - "$(awk -F'\t' '$3=="gone tomorrow"{print $4}' "$_lw/prune.tsv")" "never" + "$(awk -F'\t' '$3=="gone tomorrow"{print $5}' "$_lw/prune.tsv")" "never" check "--prune removes a historyless orphan and says which" \ "$(_led_run orphan-scan --prune --ledger "$_lw/prune.tsv" "$_lw/o_after.log" \ | grep -c 'pruned: demo part1 gone tomorrow')" "1" @@ -296,7 +427,7 @@ printf 'RESULT\tdemo\tpart1\tstill here\tPASS\t18\t\nRESULT\tdemo\tpart1\tgone t _led_run merge --reds-are-real --mutation "drop the guard" --ledger "$_lw/hist.tsv" \ --date 2026-09-01 "$_lw/h_before.log" >/dev/null check "premise: the orphan now carries a date and a mutation" \ - "$(awk -F'\t' '$3=="gone tomorrow"{print $4"/"$5}' "$_lw/hist.tsv")" "2026-09-01/drop the guard" + "$(awk -F'\t' '$3=="gone tomorrow"{print $5"/"$6}' "$_lw/hist.tsv")" "2026-09-01/drop the guard" check "an orphan carrying history is reported as carrying it" \ "$(_led_run orphan-scan --ledger "$_lw/hist.tsv" "$_lw/o_after.log" \ | grep -c 'ORPHAN CARRYING HISTORY')" "1" @@ -456,7 +587,7 @@ _led_run merge --ledger "$_lw/g.tsv" --date 2026-09-10 "$_lw/new.log" >/dev/null check "regenerating the ledger lets the new check through" \ "$(_led_rc gate --ledger "$_lw/g.tsv" --budget "$_lw/gb.txt" --registered "$_lw/registered" "$_lw/new.log")" "0" check "and it entered as debt, not as an observation nothing made" \ - "$(awk -F'\t' '$3=="brand new"{print $4}' "$_lw/g.tsv")" "never" + "$(awk -F'\t' '$3=="brand new"{print $5}' "$_lw/g.tsv")" "never" # ---- the ceiling is monotone, mechanically ---------------------------------- # @@ -519,14 +650,14 @@ check "and it runs before the build directory is removed, which is the only plac # ---- the committed files agree ---------------------------------------------- _l_total="$(grep -c . "$_ledger" || true)" -_l_red="$(awk -F'\t' '$4!="never"' "$_ledger" | grep -c . || true)" -_l_never="$(awk -F'\t' '$4=="never"' "$_ledger" | grep -c . || true)" +_l_red="$(awk -F'\t' '$5!="never"' "$_ledger" | grep -c . || true)" +_l_never="$(awk -F'\t' '$5=="never"' "$_ledger" | grep -c . || true)" echo " ledger: inputs=$_l_total | observed red=$_l_red, never=$_l_never | sum=$((_l_red + _l_never))" check "the ledger partitions into observed and never" "$((_l_red + _l_never))" "$_l_total" check "premise: the ledger is not empty, so the partition means something" \ "$([ "$_l_total" -gt 0 ] && echo yes || echo no)" "yes" -check "every committed row has five fields" \ - "$(awk -F'\t' 'NF!=5' "$_ledger" | grep -c . || true)" "0" +check "every committed row has six fields" \ + "$(awk -F'\t' 'NF!=6' "$_ledger" | grep -c . || true)" "0" check "and none of them ends in a tab" "$(grep -cP '\t$' "$_ledger" || true)" "0" check "the committed census matches the committed ledger" \ "$(sed -n 's/^checks_never_observed_red //p' "$_budget")" "$_l_never" @@ -551,7 +682,7 @@ _led_run merge --ledger "$_cw/led" --date 2026-09-10 "$_lw/green.log" >/dev/null check "premise: the fixture ledger holds two rows" \ "$(grep -c . "$_cw/led" || true)" "2" check "premise: both are never, so this ledger's census is two" \ - "$(awk -F'\t' '$4=="never"' "$_cw/led" | grep -c . || true)" "2" + "$(awk -F'\t' '$5=="never"' "$_cw/led" | grep -c . || true)" "2" printf 'suites_not_covered 0\nchecks_never_observed_red 2\n' > "$_cw/ok.txt" check "a census that matches the ledger passes" \ From 72610616403c97494bb5eb85a78da4f039251d59 Mon Sep 17 00:00:00 2001 From: "Joshua (D) Drake" <136637981+ChronicallyJD@users.noreply.github.com> Date: Sat, 12 Sep 2026 11:14:29 -0600 Subject: [PATCH 2/4] test: correct why a record carries an unknown major (#1010) I justified the `unknown` token by grepping harness_selftest.sh for PGC_MAJOR, finding none, and concluding its 907 records all carry it. That was written into eight places before one awk over a log already on disk disproved it: grep '^RESULT\t' pg18-harness_selftest.log | awk -F'\t' '{c[$6]++} END {...}' 18: 916 All 916 carry the real major. The suite does not reference PGC_MAJOR, but 10 of its 46 parts call pgc_setup -- which sets it -- and parts are sourced into ONE shell, so the value persists to every later record. Absence from the source was never the question. The truth is 14 OTHER suites: they need no cluster, so they never call pgc_setup, and every record they emit carries `unknown`. Measured on a full pg18 matrix, 544 of 6753 records: audit, concurrency, decode_interrupts, hilbert_curve, objstore_stash_recovery, phase2-6, smoke, unique_conc, update_conc, wal_envelope. None of the three suites the ledger covers today is one, so every migrated row will name real majors; the token matters for the suites coverage reaches next. A consequence only the measurement showed: because the value is set by whichever part runs first, `unknown` versus a number is ORDER-DEPENDENT in any suite that sources parts into one shell. On pg18 all 916 of harness_selftest's records named the major, so the first pgc_setup precedes the first record today. A part added ahead of it would not, and the ledger expecting a number would refuse it. Also corrects orphan-scan's docstring, which named part 340's stand-in skip name as a present-tense blocker to arming it. #994 and #998 removed that: part 340 now calls check_skip under each premise's own name and the stand-in survives only in a comment. Arming is now a decision rather than a dependency, and it is not taken here -- filed as #1015, because "the one blocker I measured is gone" is not the same claim as "no blocker remains". Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Uf6UoeBRZYLQZa4KxNiw8a --- CHANGELOG.md | 14 ++++- test/lib.sh | 14 ++++- test/pgc_ledger.py | 60 ++++++++++++++----- test/pytest/TESTS.md | 5 +- test/pytest/test_mutation_ledger.py | 13 ++-- .../410-a-check-must-have-been-red.sh | 7 ++- 6 files changed, 80 insertions(+), 33 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 07b1e9eb..3d595854 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -85,9 +85,17 @@ true until the next version shipped. decides which checks can exist. `unknown` is the one non-numeric value, and it is lib.sh's own word for a field the - harness did not set (it already uses it for an unset suite and part). It is a real - case rather than a courtesy: `harness_selftest` never references `PGC_MAJOR`, so every - record it emits says `unknown` truthfully -- 907 of the 1155 committed ledger rows. + harness did not set (it already uses it for an unset suite and part). It is a real case + rather than a courtesy: `PGC_MAJOR` is set in `pgc_setup`, and 14 suites need no cluster + so never call it. Measured on a full pg18 matrix, 544 of 6753 records carry it -- + `audit`, `concurrency`, `decode_interrupts`, `hilbert_curve`, `objstore_stash_recovery`, + `phase2`-`phase6`, `smoke`, `unique_conc`, `update_conc`, `wal_envelope`. + + It is ORDER-DEPENDENT in a suite that sources parts into one shell: a record emitted + before the first `pgc_setup` says `unknown` and one after it names the major. + `harness_selftest` is that shape, 10 of its 46 parts call `pgc_setup`, and on pg18 all + 916 of its records named the major -- so the first setup precedes the first record + today, and a part added ahead of it would change that. The ledger itself is unchanged in SHAPE: it still keys on `(suite, part, name)` and discards the major. Keying on it is #1010's second step, and it needs a migration this diff --git a/test/lib.sh b/test/lib.sh index 72b5901e..4606d248 100755 --- a/test/lib.sh +++ b/test/lib.sh @@ -1182,9 +1182,17 @@ pgc_record() { # pgc_record VERDICT NAME DISPLAY [REASON] # is misattributed and nothing in the log can contradict it. # # `unknown` is this function's OWN word for a field the harness did not set, - # already used two lines down for an unset suite and part, and it is a REAL - # case rather than a courtesy: harness_selftest never references PGC_MAJOR, so - # every one of its records says `unknown` truthfully. + # already used two lines down for an unset suite and part, and it is a REAL case + # rather than a courtesy: PGC_MAJOR is set in pgc_setup, and 14 suites need no + # cluster so never call it. Measured on a full pg18 matrix, 544 of 6753 records + # carry it -- audit, concurrency, decode_interrupts, hilbert_curve, + # objstore_stash_recovery, phase2-6, smoke, unique_conc, update_conc, wal_envelope. + # + # It is therefore ORDER-DEPENDENT inside a suite that sources parts into one shell: + # a record emitted before the first pgc_setup in that shell says `unknown` and one + # after it names the major. harness_selftest is that shape -- 10 of its 46 parts + # call pgc_setup -- and on pg18 all 916 of its records named the major, so the + # first setup precedes the first record today. A part added ahead of it would not. printf 'RESULT\t%s\t%s\t%s\t%s\t%s\t%s\n' \ "${PGC_SUITE:-unknown}" \ "${_part:-${PGC_SUITE:-unknown}}" \ diff --git a/test/pgc_ledger.py b/test/pgc_ledger.py index 9433e65a..0322cf12 100755 --- a/test/pgc_ledger.py +++ b/test/pgc_ledger.py @@ -148,10 +148,15 @@ def _newer(current, incoming): # 1150 of them is a number that lies by its own name -- the defect check_ledger_budget.txt # exists to argue against. # -# A SET, sorted and ";"-separated: "15;18". `unknown` is a token in it like any other, -# and the common one -- harness_selftest never references PGC_MAJOR, so all 907 of its -# rows carry it. NO WILDCARD: "every major observed" would change meaning the day a major -# is added to the matrix, inheriting a claim nothing measured. +# A SET, sorted and ";"-separated: "15;18". `unknown` is a token in it like any other, and +# a real case rather than a courtesy: 14 suites need no cluster, so they never call +# pgc_setup -- which is where PGC_MAJOR is set -- and every record they emit carries it. +# Measured on a full pg18 matrix, 544 of 6753 records: audit, concurrency, +# decode_interrupts, hilbert_curve, objstore_stash_recovery, phase2-6, smoke, unique_conc, +# update_conc, wal_envelope. All three suites the ledger covers today DO set it. +# +# NO WILDCARD: "every major observed" would change meaning the day a major is added to the +# matrix, inheriting a claim nothing measured. FIELDS = 6 MAJOR_SEP = ";" @@ -180,10 +185,12 @@ class LedgerError(Exception): # pg19_vacuum_options.sh and native_dml.sh gate on server_version_num and never # mention it -- which is why this is a field and not a convention. # -# `unknown` is lib.sh's OWN word for a field the harness did not set, used there for -# an unset suite and part, and it is a REAL case rather than a courtesy: -# harness_selftest never references PGC_MAJOR anywhere, so its 907 committed rows -# have no major to name even in principle. +# `unknown` is lib.sh's OWN word for a field the harness did not set, used there for an +# unset suite and part, and it is a REAL case rather than a courtesy: PGC_MAJOR is set in +# pgc_setup, and 14 suites need no cluster so never call it. Measured on a full pg18 +# matrix, 544 of 6753 records carry it -- audit, concurrency, decode_interrupts, +# hilbert_curve, objstore_stash_recovery, phase2-6, smoke, unique_conc, update_conc, +# wal_envelope. None of the three suites the ledger covers today is one. MAJOR_UNKNOWN = "unknown" _MAJOR = re.compile(r"^(?:[0-9]+|unknown)$") @@ -264,6 +271,20 @@ def read_ledger(path): Keyed on the part as well as the name: harness_selftest sources 40-odd parts into one shell and phrases its premises to be COPIED, so a name-only key is a key of check NAMES rather than of checks. + + AND NOT ON THE MAJOR, which is the third field's job instead (#1010). A check's + existence depends on the major, so the ledger must record WHERE a check exists; it + does not follow that the major belongs in the key. Measured on a full matrix at + 4d7c75ae, 6367 of 6472 checks are identical on PG15 and PG18, so a (major, check) + key would hold five copies of one observation for 98% of the file. Keeping the key + here is also what keeps `checks_never_observed_red` counting CHECKS rather than + pairs. + + The majors field is a SET and it accumulates in `merge`. `unknown` is a member of + it like any number: PGC_MAJOR is set in pgc_setup, and 14 suites need no cluster so + never call it -- 544 of 6753 records on a full pg18 matrix. None of the three suites + the ledger covers today is one, so every migrated row names real majors; the token + matters for the suites coverage reaches next. """ rows = {} p = pathlib.Path(path) @@ -491,13 +512,22 @@ def cmd_orphan_scan(args): as present would make a single-suite run certify the whole ledger, so they are counted OUT LOUD as `not checked` instead. - WHY THIS REPORTS AND IS NOT WIRED INTO THE GATE. Measured, not assumed: part - 340 records ONE skip under a DIFFERENT name ("the unreadable-source refusal") - when the box has no non-root user to read as, rather than skipping its two - named arms. On such a box two committed rows have no matching record and are - not removed checks, so a gate refusing on absence would redden a correct run. - Arming this needs those branches to record a SKIP under the names they stand - in for -- the same conversion #965 made for the eleven timeout paths. + WHY THIS REPORTS AND IS NOT WIRED INTO THE GATE. The blocker this paragraph used + to name has been REMOVED and the paragraph is kept because the conclusion has not + changed. Part 340 recorded ONE skip under a DIFFERENT name ("the unreadable-source + refusal") when the box had no non-root user to read as, rather than skipping its + two named arms; on such a box two committed rows had no matching record and were + not removed checks, so a gate refusing on absence would have reddened a correct + run. #994 and #998 made the conversion -- part 340 now calls check_skip under each + premise's own name, and the stand-in survives only in a comment explaining what it + used to do. + + So the stated precondition is met, and arming this is now a DECISION rather than a + dependency. It is not taken here, because "the one blocker I measured is gone" is + not the same claim as "no blocker remains", and the second needs its own run across + the parts that skip. Nothing in the tree invokes this subcommand -- not + run_all_versions.sh, not either workflow -- so the direction #1010 fixes in it is + latent today and the fix is a precondition for arming rather than a live repair. A ROW CARRYING HISTORY IS NEVER PRUNED. The catalogue of what has been seen red is the thing this ledger exists to be, and no run can recreate it. Dropping diff --git a/test/pytest/TESTS.md b/test/pytest/TESTS.md index 0f59862b..4a220b78 100644 --- a/test/pytest/TESTS.md +++ b/test/pytest/TESTS.md @@ -2408,8 +2408,9 @@ hold 6472 x 5 = 32,360 rows to express 105 keys' worth of difference. Keeping th its own name. The set accumulates, for the reason the mutation column and last-red both do: merging a PG15 -log after a PG18 log must not make the check stop existing on 18. `unknown` is a token in the -set like any other, and the common one. +log after a PG18 log must not make the check stop existing on 18. `unknown` is a member of the +set like any number: `PGC_MAJOR` is set in `pgc_setup`, and 14 suites need no cluster so never +call it -- 544 of 6753 records on a full pg18 matrix. ### `test_a_run_speaks_only_for_the_majors_the_row_claims` diff --git a/test/pytest/test_mutation_ledger.py b/test/pytest/test_mutation_ledger.py index d0c80c19..ca2aa0b5 100644 --- a/test/pytest/test_mutation_ledger.py +++ b/test/pytest/test_mutation_ledger.py @@ -663,10 +663,10 @@ def test_a_record_that_does_not_name_its_major_is_not_evidence(tmp_path, expect) "--registered", reg, good)[1], 1, "a record naming its major reaches the gate's own verdict") - # `unknown` is the emitter's word for a field the harness never set, and it is a - # REAL case rather than a courtesy: harness_selftest does not reference PGC_MAJOR - # anywhere, so its 907 rows have no major to name even in principle. It must be - # accepted and it must stay distinguishable from a number. + # `unknown` is the emitter's word for a field the harness never set, and it is a REAL + # case rather than a courtesy: PGC_MAJOR is set in pgc_setup, and 14 suites need no + # cluster so never call it -- measured, 544 of 6753 records on a full pg18 matrix. It + # must be accepted and it must stay distinguishable from a number. unk = _w(tmp_path, "unk.log", "RESULT\tdemo\tpart1\tfirst check\tPASS\tunknown\t\nchecks run: 1\n") expect.num(_run("gate", "--ledger", ledger, "--budget", budget, @@ -731,9 +731,8 @@ def test_a_rows_major_set_accumulates_rather_than_replacing(tmp_path, expect): expect.num(len(_rows(ledger)), 2, "two checks are two rows, whatever the majors: the key is not the major") - # `unknown` is a token in the set like any other. harness_selftest never references - # PGC_MAJOR, so every record it emits carries it, and those rows must not multiply - # either. + # `unknown` is a token in the set like any other, and what a suite needing no cluster + # emits: PGC_MAJOR is set in pgc_setup and 14 suites never call it. runk = _w(tmp_path, "ru.log", "RESULT\tdemo\tpart1\teverywhere\tPASS\tunknown\t\nchecks run: 1\n") _run("merge", "--ledger", ledger, "--date", "2026-09-12", runk) diff --git a/test/selftest/410-a-check-must-have-been-red.sh b/test/selftest/410-a-check-must-have-been-red.sh index 19e39002..bd566350 100644 --- a/test/selftest/410-a-check-must-have-been-red.sh +++ b/test/selftest/410-a-check-must-have-been-red.sh @@ -204,9 +204,10 @@ check "a second major is ADDED to the set, sorted, not written over the first" check "and a check the second run never mentioned keeps the majors it claimed" "$(awk -F' ' '$3=="pg18 only"{print $4}' "$_lw/maj.tsv")" "18" check "two checks stay two rows whatever the majors, because the key is not the major" "$(grep -c . "$_lw/maj.tsv")" "2" -# `unknown` is a token in the set like any other, and the COMMON one: this very -# suite's runner never references PGC_MAJOR, so every record harness_selftest emits -# carries it. +# `unknown` is a token in the set like any other, and a real case: PGC_MAJOR is set in +# pgc_setup, and 14 suites need no cluster so never call it -- 544 of 6753 records on a +# full pg18 matrix. This suite is NOT one of them: 10 of its 46 parts call pgc_setup and +# they share one shell, so its records name the major. _led_run merge --ledger "$_lw/maj.tsv" --date 2026-09-12 "$_lw/munk.log" >/dev/null check "a harness that named no major adds its own token rather than a number" "$(awk -F' ' '$3=="both majors"{print $4}' "$_lw/maj.tsv")" "15;18;unknown" From c47570e165e23fa061b952e03ae182bb9d7863df Mon Sep 17 00:00:00 2001 From: "Joshua (D) Drake" <136637981+ChronicallyJD@users.noreply.github.com> Date: Sat, 12 Sep 2026 11:30:15 -0600 Subject: [PATCH 3/4] test: migrate the committed ledger to the major set (#1010) Derived from a five-major matrix on step 1's tree (a0b2c00b), 252 suite logs per major, 6660-6787 records each. Not a merge: the committed ledger is five fields and step 2's read_ledger needs six, and a five-field compatibility path in the tool would leave a branch nobody removes. rows 1166 -> 1166 (carried 1166, added 0) census 1164 -> 1164 (unchanged) ever red 2 -> 2 (both carried, with their dates) fields 5 -> 6 major sets held 1166 x "15;16;17;18;19" Every row claims all five majors, because all three covered suites emit the same checks on every one: harness_selftest 916, differential 204, native_join_runtime_filter 46, identical on 15/16/17/18/19. So the census does not move and the diff is one field added per line. THE MEASURED CASE FOR THE SET. Under a (major, check) key those same 1166 checks would be 5830 rows -- exactly 5x, 4664 of them second copies of one observation. Across the whole tree the logs hold 7795 distinct checks whose major sets would be 31357 rows under a pair key, a 4x multiplier, and the distribution says why a set is the right shape: 5863 15;16;17;18;19 checks identical on every major 545 unknown suites that need no cluster, so never call pgc_setup 285 19 \ 251 18 | 250 per major of these are fuzz, whose names 250 15, 16, 17 each | interpolate a random fixture (#1011) 93 18;19 / 3 15;16;17 2 15;16;17;18 2 17;18;19 1 15;16 COVERAGE IS NOT WIDENED HERE, and the migration refuses to. The logs carry all 252 suites; seeding them would take the ledger to 7795 rows and drop suites_not_covered from 249 to nearly nothing, making several thousand checks gate-enforced in a diff nobody could review. 6629 observed checks outside the three covered suites were deliberately not seeded. The migration also fails closed rather than guessing: a committed row observed on no major refuses the whole run and prints the rows, because absence is not removal and a placeholder major would be a claim nothing measured. On this tree it refused nothing -- all 1166 were observed. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Uf6UoeBRZYLQZa4KxNiw8a --- test/check_ledger_budget.txt | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/test/check_ledger_budget.txt b/test/check_ledger_budget.txt index 173b1eeb..86d8bd7b 100644 --- a/test/check_ledger_budget.txt +++ b/test/check_ledger_budget.txt @@ -38,13 +38,7 @@ suites_not_covered 249 # HOW TO RE-DERIVE IT, written here because a changelog entry got it wrong and a # derivation is only useful where the number is: # -# awk -F'\t' '$5=="never"' test/check_ledger.tsv | wc -l -# -# FIELD 5, not 4, since #1010 inserted the majors a row claims as field 4. The number -# this counts did NOT change meaning: the key is still (suite, part, name), so a row is -# still one check and this still counts checks. That is why the major is a set in a -# field rather than part of the key -- under a (major, check) key this would count PAIRS -# and the name above would be false. +# awk -F'\t' '$4=="never"' test/check_ledger.tsv | wc -l # # Rows whose LAST-RED is `never`, not the row count. The two agree only while # nothing has ever been observed red, so a plain `grep -c` overcounts by exactly From 9389792d3a808843161debfdbbf14d7f728603de Mon Sep 17 00:00:00 2001 From: "Joshua (D) Drake" <136637981+ChronicallyJD@users.noreply.github.com> Date: Sat, 12 Sep 2026 12:10:19 -0600 Subject: [PATCH 4/4] test: two ledger fixtures in part 410 still carried five fields (#1010) Found by running harness_selftest on pg15 rather than by reading: seven arms in the --against prior-budget family went red, all with rc=2, which is the tool's integrity failure. Both fixtures write a ledger to a path that is neither *.tsv nor $_ledger -- "$_dist/led" and "$_rr/led" -- so the sweep that widened every other fixture matched neither, twice. The lesson is the same one the format transform taught earlier in this change and I did not carry far enough: a sweep keyed on a FILENAME PATTERN cannot find a fixture named something else. The sweep that found these counts tab-separated FIELDS in every printf that writes a date or `never`, which is a property of the content rather than of the path. --- CHANGELOG.md | 19 + test/check_ledger.tsv | 2376 +++++++++-------- test/check_ledger_budget.txt | 2 +- .../410-a-check-must-have-been-red.sh | 4 +- 4 files changed, 1219 insertions(+), 1182 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3d595854..aaae43d6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,25 @@ true until the next version shipped. suitepartnamemajorslast-redmutations + rows 1179 -> 1197 (carried 1177, new 20, dropped 2) + checks_never_observed_red 1171 -> 1189 + ever red 8 -> 8 (all carried, with their dates and one mutation) + major sets 1197 x "15;16;17;18;19" + covered differential, harness_selftest, native_join_runtime_filter, + native_join_vector_agg + suites_not_covered 249 (unchanged) + + Every row claims all five majors, because all four covered suites are major-invariant: + 934, 204, 46 and 13 records, identical on 15/16/17/18/19 in a five-major matrix. So the + census moves only by the twenty arms this change adds, and the diff is one field per + line. + + The 20 new rows are part 410's arms about the majors field; the 2 dropped are the rows + whose checks this change RENAMED (`every committed row has five fields` became `six`). + The migration refuses to drop a row carrying history, for the reason `orphan-scan` + refuses it -- the catalogue of what has been seen red is the thing no run can recreate -- + so a drop is only available for a row with nothing to lose, and the name has to be typed. + A check's existence depends on the major, so a ledger that cannot say where a check exists cannot tell a deleted check from one that never ran here. `test/analyze_differential.sh:61` emits ONE record on PG15-17 and a suite's worth on diff --git a/test/check_ledger.tsv b/test/check_ledger.tsv index d1994b4c..de82e5c4 100644 --- a/test/check_ledger.tsv +++ b/test/check_ledger.tsv @@ -1,1179 +1,1197 @@ -differential differential agg avg never - -differential differential agg count never - -differential differential agg minmax never - -differential differential agg sum never - -differential differential allnull chunk isnull never - -differential differential allnull chunk range never - -differential differential allnull chunk scan never - -differential differential allnull column count never - -differential differential allnull column isnull never - -differential differential allnull column minmax never - -differential differential allnull column scan never - -differential differential bloom absent correct never - -differential differential bloom k present never - -differential differential bloom k range never - -differential differential bloom u eq never - -differential differential c_arr count never - -differential differential c_arr eq never - -differential differential c_arr is null never - -differential differential c_arr not null never - -differential differential c_arr project never - -differential differential c_big count never - -differential differential c_big is null never - -differential differential c_big min/max never - -differential differential c_big not null never - -differential differential c_big project never - -differential differential c_big range never - -differential differential c_big sum/avg never - -differential differential c_bool count never - -differential differential c_bool eq never - -differential differential c_bool is null never - -differential differential c_bool not null never - -differential differential c_bool project never - -differential differential c_bytea count never - -differential differential c_bytea is null never - -differential differential c_bytea not null never - -differential differential c_bytea project never - -differential differential c_bytea range never - -differential differential c_char count never - -differential differential c_char is null never - -differential differential c_char min/max never - -differential differential c_char not null never - -differential differential c_char project never - -differential differential c_date count never - -differential differential c_date is null never - -differential differential c_date min/max never - -differential differential c_date not null never - -differential differential c_date project never - -differential differential c_date range never - -differential differential c_f4 count never - -differential differential c_f4 is null never - -differential differential c_f4 min/max never - -differential differential c_f4 not null never - -differential differential c_f4 project never - -differential differential c_f4 sum/avg never - -differential differential c_f8 count never - -differential differential c_f8 is null never - -differential differential c_f8 min/max never - -differential differential c_f8 not null never - -differential differential c_f8 project never - -differential differential c_f8 range never - -differential differential c_f8 sum/avg never - -differential differential c_int count never - -differential differential c_int eq never - -differential differential c_int is null never - -differential differential c_int min/max never - -differential differential c_int not null never - -differential differential c_int project never - -differential differential c_int range never - -differential differential c_int sum/avg never - -differential differential c_iv count never - -differential differential c_iv is null never - -differential differential c_iv min/max never - -differential differential c_iv not null never - -differential differential c_iv project never - -differential differential c_jsonb count never - -differential differential c_jsonb eq never - -differential differential c_jsonb is null never - -differential differential c_jsonb not null never - -differential differential c_jsonb project never - -differential differential c_num count never - -differential differential c_num is null never - -differential differential c_num min/max never - -differential differential c_num not null never - -differential differential c_num project never - -differential differential c_num range never - -differential differential c_num sum/avg never - -differential differential c_small count never - -differential differential c_small is null never - -differential differential c_small min/max never - -differential differential c_small not null never - -differential differential c_small project never - -differential differential c_small sum/avg never - -differential differential c_text count never - -differential differential c_text is null never - -differential differential c_text min/max never - -differential differential c_text not null never - -differential differential c_text project never - -differential differential c_text range never - -differential differential c_ts count never - -differential differential c_ts is null never - -differential differential c_ts min/max never - -differential differential c_ts not null never - -differential differential c_ts project never - -differential differential c_ts range never - -differential differential c_tstz count never - -differential differential c_tstz is null never - -differential differential c_tstz min/max never - -differential differential c_tstz not null never - -differential differential c_tstz project never - -differential differential c_tstz range never - -differential differential c_uuid count never - -differential differential c_uuid eq never - -differential differential c_uuid is null never - -differential differential c_uuid not null never - -differential differential c_uuid project never - -differential differential c_uuid range never - -differential differential c_vc count never - -differential differential c_vc eq never - -differential differential c_vc is null never - -differential differential c_vc min/max never - -differential differential c_vc not null never - -differential differential c_vc project never - -differential differential c_vc range never - -differential differential c_ztext count never - -differential differential c_ztext is null never - -differential differential c_ztext min/max never - -differential differential c_ztext not null never - -differential differential c_ztext project never - -differential differential cg boundary N=100 groups never - -differential differential cg boundary N=100 range never - -differential differential cg boundary N=100 scan never - -differential differential cg boundary N=101 groups never - -differential differential cg boundary N=101 range never - -differential differential cg boundary N=101 scan never - -differential differential cg boundary N=200 groups never - -differential differential cg boundary N=200 range never - -differential differential cg boundary N=200 scan never - -differential differential cg boundary N=201 groups never - -differential differential cg boundary N=201 range never - -differential differential cg boundary N=201 scan never - -differential differential cg boundary N=250 groups never - -differential differential cg boundary N=250 range never - -differential differential cg boundary N=250 scan never - -differential differential cg boundary N=99 groups never - -differential differential cg boundary N=99 range never - -differential differential cg boundary N=99 scan never - -differential differential compound never - -differential differential control: the set oracle is order-blind by design never - -differential differential count meta=off never - -differential differential count meta=on never - -differential differential dict text agg never - -differential differential dict text eq never - -differential differential dict text group never - -differential differential dict whole-row never - -differential differential empty agg never - -differential differential empty count never - -differential differential empty scan never - -differential differential empty-vs-null empties never - -differential differential empty-vs-null nulls never - -differential differential empty-vs-null scan never - -differential differential enc aggregate never - -differential differential enc const scan never - -differential differential enc lowcard eq never - -differential differential enc seq range never - -differential differential enc whole-row never - -differential differential enc+nocompress agg never - -differential differential enc+nocompress scan never - -differential differential i4 float agg never - -differential differential i4 ts minmax never - -differential differential i4 ts range never - -differential differential i4 whole-row never - -differential differential matrix chunk groups>=12 never - -differential differential matrix row count never - -differential differential matrix stripes>=2 never - -differential differential matrix whole-row never - -differential differential order limit head never - -differential differential order limit tail never - -differential differential premise: the ordered oracle agrees with itself never - -differential differential premise: the ordered oracle is order-sensitive never - -differential differential single count never - -differential differential single scan never - -differential differential stripe boundary N=1000 agg never - -differential differential stripe boundary N=1000 scan never - -differential differential stripe boundary N=1000 stripes never - -differential differential stripe boundary N=1001 agg never - -differential differential stripe boundary N=1001 scan never - -differential differential stripe boundary N=1001 stripes never - -differential differential stripe boundary N=2000 agg never - -differential differential stripe boundary N=2000 scan never - -differential differential stripe boundary N=2000 stripes never - -differential differential stripe boundary N=2001 agg never - -differential differential stripe boundary N=2001 scan never - -differential differential stripe boundary N=2001 stripes never - -differential differential textbloom C absent never - -differential differential textbloom C eq never - -differential differential textbloom absent never - -differential differential textbloom collate-mismatch never - -differential differential textbloom present never - -differential differential wide most never - -differential differential wide nomatch never - -differential differential wide point never - -differential differential wide range never - -differential differential wide row proj never - -differential differential wide row scan never - -harness_selftest 030-assertions nothing leaked into the squatter never - -harness_selftest 030-assertions pgc_port_free says the squatter's port is busy never - -harness_selftest 030-assertions squatter survived untouched never - -harness_selftest 030-assertions suite did not settle on the squatter's port never - -harness_selftest 030-assertions suite's cluster is its own never - -harness_selftest 030-assertions suite's own objects are visible to it never - -harness_selftest 040-the-detection-primitive-itself detection distinguishes it from ours never - -harness_selftest 040-the-detection-primitive-itself detection reports a foreign cluster's directory never - -harness_selftest 040-the-detection-primitive-itself guard accepts our own cluster never - -harness_selftest 040-the-detection-primitive-itself guard rejects a foreign cluster never - -harness_selftest 040-the-detection-primitive-itself premise: the runner answered --list-suites, so the two checks below mean something never - -harness_selftest 050-the-list-must-be-read-the a name after the array's closing paren is not read as a registered suite never - -harness_selftest 050-the-list-must-be-read-the and the mistake empties the whole array rather than appending to it never - -harness_selftest 050-the-list-must-be-read-the positive control: and it is a whole list, not one lucky line never - -harness_selftest 050-the-list-must-be-read-the positive control: the real runner's list is read, and contains isolation never - -harness_selftest 050-the-list-must-be-read-the premise: the fixture really does carry the stray name never - -harness_selftest 060-the-list-stays-sorted-which-is premise: C collation puts sort_status before sorted_projection never - -harness_selftest 060-the-list-stays-sorted-which-is the suite list is sorted in C order, so two new suites land in different places never - -harness_selftest 070-and-comm-s-two-inputs-must a file that uses comm pins the collation of every sort feeding it never - -harness_selftest 070-and-comm-s-two-inputs-must and a prefix of a registered name is not treated as registered never - -harness_selftest 070-and-comm-s-two-inputs-must every registered suite has a file never - -harness_selftest 070-and-comm-s-two-inputs-must every suite is registered in run_all_versions.sh never - -harness_selftest 070-and-comm-s-two-inputs-must negative control: and does not find one that is not never - -harness_selftest 070-and-comm-s-two-inputs-must positive control: the membership test finds a name that is registered never - -harness_selftest 070-and-comm-s-two-inputs-must premise: some suite still uses comm, or the check below is vacuous never - -harness_selftest 080-no-suite-pipes-a-captured-string a comment ending in a pipe is not a producer never - -harness_selftest 080-no-suite-pipes-a-captured-string a comment naming a TERMINATED tag still opens no heredoc, so the lines below it are seen never - -harness_selftest 080-no-suite-pipes-a-captured-string a comment naming a heredoc exempts nothing, so the line below it is still seen never - -harness_selftest 080-no-suite-pipes-a-captured-string an opener on a line of CODE with no terminator exempts nothing either never - -harness_selftest 080-no-suite-pipes-a-captured-string an opener with no terminator exempts nothing never - -harness_selftest 080-no-suite-pipes-a-captured-string and a pipeline split BEFORE the pipe, with the operator at column 1 never - -harness_selftest 080-no-suite-pipes-a-captured-string and an indented split is reported twice, at the reader and at the producer never - -harness_selftest 080-no-suite-pipes-a-captured-string and bench/ was in the scan, which is the hole this rule had never - -harness_selftest 080-no-suite-pipes-a-captured-string and does not cover the live one above it never - -harness_selftest 080-no-suite-pipes-a-captured-string and it follows the pipe across blank and comment lines never - -harness_selftest 080-no-suite-pipes-a-captured-string and reports it at the PRODUCER's line, which is the line that has to change never - -harness_selftest 080-no-suite-pipes-a-captured-string and selftest/ was in the scan, which is the hole that reddened #923 never - -harness_selftest 080-no-suite-pipes-a-captured-string and the heredoc exemption covers the one inside the heredoc, not the other never - -harness_selftest 080-no-suite-pipes-a-captured-string and the planted violation in that file is found by the pattern never - -harness_selftest 080-no-suite-pipes-a-captured-string and the scan examined the suites rather than finding nothing to read never - -harness_selftest 080-no-suite-pipes-a-captured-string and the sweep counts it once, because a hit is keyed on file:line never - -harness_selftest 080-no-suite-pipes-a-captured-string control: a real heredoc, opened in code and terminated, still exempts its body never - -harness_selftest 080-no-suite-pipes-a-captured-string control: piping a large string into grep -q reports a match as absent never - -harness_selftest 080-no-suite-pipes-a-captured-string no suite pipes a captured string into an early-exit reader never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: and bash agrees -- with no command to continue, the reader alone will not parse never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: and bash runs that file as one assignment -- no reader, no output, rc 0 never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: and its second line really does hold the reader it must not flag never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: and that body line is the one the pattern would otherwise flag never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: and the exemption covers a minority of them, not the corpus never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: and the line below it is what the pattern would flag never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: and the line really does hold the reader it must not flag never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: and the old echo/printf pattern did NOT catch it never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: and the physical-line pattern alone saw neither of those two never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: and the violation between that comment and its tag is what the pattern would flag never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: and without -H it reports a line number where the key wants a path never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: bash joins a pipeline across blank and comment lines, which is why the joiner must never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: indent that same reader by a tab and the physical-line pattern sees it unaided never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: no backslash continuation is followed by a blank or a comment never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: no line opens a heredoc AND continues, which is what lets the joiner ignore bodies never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: that shape matches in both streams at one line, which is what the key is for never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: the candidate is on a line of code, not a comment never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: the continuation detector found continuations to classify never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: the file the old filename exclusion named holds no reader to exclude never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: the fixture really has two backslash continuations to classify never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: the fixture really has two heredoc openers for the detector to see never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: the heredoc exemption found heredoc lines to exempt never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: the joiner joined continuations, so the sweep is not still line-oriented never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: the opener detector found heredocs to classify never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: the physical stream names the file even when it reads only one of them never - -harness_selftest 080-no-suite-pipes-a-captured-string premise: the sweep read lines to classify never - -harness_selftest 080-no-suite-pipes-a-captured-string the continuing-opener detector finds an opener that ends in a pipe, and one that ends in a backslash never - -harness_selftest 080-no-suite-pipes-a-captured-string the gap detector finds a continuation followed by a comment, and one followed by a blank never - -harness_selftest 080-no-suite-pipes-a-captured-string the join CREATES a hit on a two-line quoted string, the sweep's one false positive never - -harness_selftest 080-no-suite-pipes-a-captured-string the joiner does not mistake a two-line || fallback for a split pipeline never - -harness_selftest 080-no-suite-pipes-a-captured-string the sweep catches a producer that is neither echo nor printf never - -harness_selftest 080-no-suite-pipes-a-captured-string the sweep does not mistake the || operator for a pipe never - -harness_selftest 080-no-suite-pipes-a-captured-string the sweep sees a pipeline split AFTER the pipe, which all six live sites were never - -harness_selftest 080-no-suite-pipes-a-captured-string the sweep's pattern sees both lines of the probe never - -harness_selftest 090-no-suite-hands-every-run-the no suite hands every run the same default port never - -harness_selftest 090-no-suite-hands-every-run-the no test picks a port from inside the ephemeral range never - -harness_selftest 100-the-assertions-that-refuse-an-empty check compares two empty strings and passes, which is why the rest exist never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_num accepts a decimal and a sign never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_num refuses a psql error message never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_num refuses an md5, which is why check_text exists never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_num refuses the word a yes/no check would produce never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_num refuses two empty strings never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_num still compares two real numbers never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_num still fails two unequal numbers never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_ratio fails a ratio outside its bound never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_ratio passes a ratio inside its bound never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_ratio refuses a zero denominator rather than dividing by it never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_ratio refuses a zero numerator, which is inside every bound never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_ratio refuses an empty measurement never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_text compares two md5 hashes, which check_num cannot never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_text refuses one empty side never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_text refuses two empty strings, where plain check passes never - -harness_selftest 100-the-assertions-that-refuse-an-empty check_text still fails two different strings never - -harness_selftest 100-the-assertions-that-refuse-an-empty pgc_require_tools fails on one that does not never - -harness_selftest 100-the-assertions-that-refuse-an-empty pgc_require_tools passes on tools that exist never - -harness_selftest 110-the-harness-must-say-which-binary pgc_setup reports the installed .so never - -harness_selftest 110-the-harness-must-say-which-binary the installed .so is the one this run built never - -harness_selftest 120-a-failing-suite-must-surface-the a failing suite names the first fatal event in its log never - -harness_selftest 120-a-failing-suite-must-surface-the premise: the 40-line tail is filler, not the marker never - -harness_selftest 120-a-failing-suite-must-surface-the premise: the sub-suite failed, so its summary ran never - -harness_selftest 130-the-sanitizer-subset-must-cover-the premise: at least one suite drives the C-level encoding selftest never - -harness_selftest 130-the-sanitizer-subset-must-cover-the premise: run_san.sh's default subset was found and is non-empty never - -harness_selftest 130-the-sanitizer-subset-must-cover-the the sanitizer subset runs every suite that drives the encoding selftest never - -harness_selftest 140-a-cluster-that-will-not-start and still matches a PANIC never - -harness_selftest 140-a-cluster-that-will-not-start and still matches a signal death never - -harness_selftest 140-a-cluster-that-will-not-start and still matches an AddressSanitizer report never - -harness_selftest 140-a-cluster-that-will-not-start but not a routine statement error never - -harness_selftest 140-a-cluster-that-will-not-start nor an ordinary log line never - -harness_selftest 140-a-cluster-that-will-not-start premise: the harness exposes its fatal pattern to be judged never - -harness_selftest 140-a-cluster-that-will-not-start the fatal pattern matches a library that will not load never - -harness_selftest 150-the-verdict-must-not-assert-a a mixed run reports both causes and neither as the whole story never - -harness_selftest 150-the-verdict-must-not-assert-a and is NOT made when our own postmaster died, which is the #537 case never - -harness_selftest 150-the-verdict-must-not-assert-a and so is the attempt count never - -harness_selftest 150-the-verdict-must-not-assert-a and the no-squatter verdict points at the server log never - -harness_selftest 150-the-verdict-must-not-assert-a premise: the verdict is composed somewhere it can be judged never - -harness_selftest 150-the-verdict-must-not-assert-a the ownership claim is made when a squatter held the port every time never - -harness_selftest 150-the-verdict-must-not-assert-a the port is named either way never - -harness_selftest 160-and-the-log-report-must-show and a log with no fatal line still reports rather than staying silent never - -harness_selftest 160-and-the-log-report-must-show premise: the log report is a function that can be fed a fixture never - -harness_selftest 160-and-the-log-report-must-show the report names the symbol that was actually missing never - -harness_selftest 170-and-lib-sh-must-ask-these and asks pgc_start_failure_message for the verdict never - -harness_selftest 170-and-lib-sh-must-ask-these and the old start-failure verdict is not echoed inline anywhere never - -harness_selftest 170-and-lib-sh-must-ask-these and the start path asks pgc_start_fatal_pattern, its deliberately wider one never - -harness_selftest 170-and-lib-sh-must-ask-these premise: lib.sh is readable, or every grep below approves nothing never - -harness_selftest 170-and-lib-sh-must-ask-these premise: the start-failure path still exists to be judged never - -harness_selftest 170-and-lib-sh-must-ask-these the failure path asks pgc_start_log_report for the reason never - -harness_selftest 170-and-lib-sh-must-ask-these the summary path asks pgc_fatal_pattern rather than hardcoding it never - -harness_selftest 180-the-port-walk-must-wrap-not a free port beyond the old 300-probe bound is still found never - -harness_selftest 180-the-port-walk-must-wrap-not a seed at the ceiling wraps past a busy top and still finds a port never - -harness_selftest 180-the-port-walk-must-wrap-not an entirely busy band reports itself full and terminates never - -harness_selftest 180-the-port-walk-must-wrap-not and the port it found is below the busy region, which is where wrapping lands never - -harness_selftest 180-the-port-walk-must-wrap-not premise: and really does allow the bottom never - -harness_selftest 180-the-port-walk-must-wrap-not premise: the auxiliary band has a width to wrap within never - -harness_selftest 180-the-port-walk-must-wrap-not premise: the real prober was restored, or every check after this lies never - -harness_selftest 180-the-port-walk-must-wrap-not premise: the stub frees exactly one port, 500 past the floor never - -harness_selftest 180-the-port-walk-must-wrap-not premise: the stub really does refuse the top of the band never - -harness_selftest 190-an-in-tree-build-must-not an unknown provenance is not reported as a major never - -harness_selftest 190-an-in-tree-build-must-not an unparseable stamp cleans rather than guessing never - -harness_selftest 190-an-in-tree-build-must-not and an empty WANT is refused rather than compared never - -harness_selftest 190-an-in-tree-build-must-not and in the other direction too never - -harness_selftest 190-an-in-tree-build-must-not and it is 3 bytes, not an escaped literal never - -harness_selftest 190-an-in-tree-build-must-not and it says plainly that no major was recorded never - -harness_selftest 190-an-in-tree-build-must-not building a DIFFERENT major needs a clean, which is the #536 case never - -harness_selftest 190-an-in-tree-build-must-not building the same major again needs no clean never - -harness_selftest 190-an-in-tree-build-must-not but a tree with no objects at all needs nothing, stamp or not never - -harness_selftest 190-an-in-tree-build-must-not objects with NO stamp are unknown provenance and must be cleaned never - -harness_selftest 190-an-in-tree-build-must-not premise: the build-stamp decision is exposed to be judged never - -harness_selftest 190-an-in-tree-build-must-not premise: the stamp writer is a function that can be exercised never - -harness_selftest 190-an-in-tree-build-must-not the build path asks pgc_build_needs_clean rather than merely naming it never - -harness_selftest 190-an-in-tree-build-must-not the stamp lib.sh writes is exactly the major never - -harness_selftest 200-additions-go-in-their-own-file premise: the parts directory exists and was sourced never - -harness_selftest 200-additions-go-in-their-own-file the driver holds no checks; they all live in parts never - -harness_selftest 200-additions-go-in-their-own-file the driver sources the parts by glob, not by a list never - -harness_selftest 210-no-suite-assigns-a-bash-special control: reads, longer names, and the deliberate RANDOM/SECONDS seeds are not flagged never - -harness_selftest 210-no-suite-assigns-a-bash-special control: the sweep catches an assignment to a bash special never - -harness_selftest 210-no-suite-assigns-a-bash-special no suite assigns to a bash special variable never - -harness_selftest 220-an-opt-in-upgrade-guard-must CI runs the extension-upgrade guard somewhere (#741) never - -harness_selftest 220-an-opt-in-upgrade-guard-must every PGC_RUN_UPGRADE-gated suite is excluded from the coverage runner (#741) never - -harness_selftest 220-an-opt-in-upgrade-guard-must premise: both not_a_suite definitions were found never - -harness_selftest 220-an-opt-in-upgrade-guard-must premise: not_a_suite says no to an ordinary suite, so its yes means something never - -harness_selftest 220-an-opt-in-upgrade-guard-must premise: run_coverage.sh defines not_a_suite and calls it never - -harness_selftest 220-an-opt-in-upgrade-guard-must premise: the PGC_RUN_UPGRADE block was found and names at least one suite never - -harness_selftest 220-an-opt-in-upgrade-guard-must premise: the population is the real test directory, not an empty glob never - -harness_selftest 220-an-opt-in-upgrade-guard-must premise: there are workflow files to search never - -harness_selftest 220-an-opt-in-upgrade-guard-must the coverage runner's not_a_suite agrees with the selftest's, both ways (#741) never - -harness_selftest 230-a-suite-connecting-by-socket-must every suite that connects by socket path sets unix_socket_directories never - -harness_selftest 230-a-suite-connecting-by-socket-must premise: at least one suite connects by a socket path, so this is not vacuous never - -harness_selftest 230-a-suite-connecting-by-socket-must premise: no TCP suite is counted as a socket user never - -harness_selftest 240-the-nightly-enumeration-must-not every nightly job is named in docs/testing.md (#741) never - -harness_selftest 240-the-nightly-enumeration-must-not premise: at least three nightly jobs were parsed, so the list is real never - -harness_selftest 240-the-nightly-enumeration-must-not premise: the nightly paragraph was located and is not empty never - -harness_selftest 240-the-nightly-enumeration-must-not premise: the nightly workflow and the testing doc are both present never - -harness_selftest 250-the-coverage-runner-must-refuse GCOV_PREFIX is exported before the suites run (#740) never - -harness_selftest 250-the-coverage-runner-must-refuse a file at 100% reads 100.0%, not a small number (#974) never - -harness_selftest 250-the-coverage-runner-must-refuse a row with absent counters never reads as 0.0% (#974) never - -harness_selftest 250-the-coverage-runner-must-refuse an absent counter prints a dash instead (#974) never - -harness_selftest 250-the-coverage-runner-must-refuse and no lcov --list call survives in the runner (#974) never - -harness_selftest 250-the-coverage-runner-must-refuse and the function rate is computed too, not copied (#974) never - -harness_selftest 250-the-coverage-runner-must-refuse premise: both stray-counter probes were located never - -harness_selftest 250-the-coverage-runner-must-refuse premise: both the counter refusal and the lcov capture were located never - -harness_selftest 250-the-coverage-runner-must-refuse premise: stripping comments leaves the runner's code behind never - -harness_selftest 250-the-coverage-runner-must-refuse premise: the containment and the copy were both located never - -harness_selftest 250-the-coverage-runner-must-refuse premise: the coverage runner is present and parses never - -harness_selftest 250-the-coverage-runner-must-refuse premise: the generator produced a row for each of the three files never - -harness_selftest 250-the-coverage-runner-must-refuse premise: the guard's count directory and the capture's were both located never - -harness_selftest 250-the-coverage-runner-must-refuse premise: the redirect, the suite invocation and the copy-back were located never - -harness_selftest 250-the-coverage-runner-must-refuse premise: the table generator is present and parses never - -harness_selftest 250-the-coverage-runner-must-refuse the copy-back refuses a destination outside the tree (#740) never - -harness_selftest 250-the-coverage-runner-must-refuse the counters are returned beside their objects before the refusal (#740) never - -harness_selftest 250-the-coverage-runner-must-refuse the coverage runner computes the table instead of parsing lcov --list (#974) never - -harness_selftest 250-the-coverage-runner-must-refuse the coverage runner refuses zero counters before it calls lcov (#740) never - -harness_selftest 250-the-coverage-runner-must-refuse the least covered file sorts first (#974) never - -harness_selftest 250-the-coverage-runner-must-refuse the rate carries hit/found so a reader can check it (#974) never - -harness_selftest 250-the-coverage-runner-must-refuse the refusal looks in GCOV_PREFIX before the tree-wide walk (#740) never - -harness_selftest 250-the-coverage-runner-must-refuse the zero-counter guard counts the directory lcov captures (#740) never - -harness_selftest 250-the-coverage-runner-must-refuse while the lcov --summary call stays, being correct on both builds (#974) never - -harness_selftest 260-an-ordered-comparison-must-use-the and it is the same suites, not merely the same count never - -harness_selftest 260-an-ordered-comparison-must-use-the every diff_query_ordered site actually names an ORDER BY never - -harness_selftest 260-an-ordered-comparison-must-use-the every suite using the ordered oracle asserts its premise never - -harness_selftest 260-an-ordered-comparison-must-use-the no diff_query site names an ORDER BY it cannot test (use diff_query_ordered) never - -harness_selftest 260-an-ordered-comparison-must-use-the premise: both comparison helpers are present never - -harness_selftest 260-an-ordered-comparison-must-use-the premise: both oracles are present never - -harness_selftest 260-an-ordered-comparison-must-use-the premise: some suite uses the ordered oracle, or the next check is vacuous never - -harness_selftest 260-an-ordered-comparison-must-use-the premise: the tree really contains continued diff_query calls to join never - -harness_selftest 260-an-ordered-comparison-must-use-the sorted_projection's two comparisons are ordered, its subject being order never - -harness_selftest 260-an-ordered-comparison-must-use-the the ordered oracle keeps the empty-result sentinel never - -harness_selftest 260-an-ordered-comparison-must-use-the the ordered oracle keeps the unique query-error sentinel never - -harness_selftest 260-an-ordered-comparison-must-use-the the ordered oracle numbers the rows as they arrive never - -harness_selftest 260-an-ordered-comparison-must-use-the the ordered oracle orders by row_number, so it keeps the query's order never - -harness_selftest 260-an-ordered-comparison-must-use-the the set oracle orders by the rendered row, so it is order-blind never - -harness_selftest 270-a-set-options-call-must-use-values no suite calls set_options with a value it will reject never - -harness_selftest 270-a-set-options-call-must-use-values premise: and does NOT fire when the error is the point, across a continuation never - -harness_selftest 270-a-set-options-call-must-use-values premise: every file containing a set_options call is in the sweep never - -harness_selftest 270-a-set-options-call-must-use-values premise: the detector fires on an out-of-range value that is NOT expect_error never - -harness_selftest 270-a-set-options-call-must-use-values premise: the set_options sweep read a substantial number of calls never - -harness_selftest 280-the-shared-cluster-config-must-not premise: and it is the right block (it sets the port and the preload) never - -harness_selftest 280-the-shared-cluster-config-must-not premise: the cluster-config block was located in lib.sh never - -harness_selftest 280-the-shared-cluster-config-must-not premise: the detector fires on the line that caused #799 never - -harness_selftest 280-the-shared-cluster-config-must-not the per-suite escape hatch PGC_EXTRA_CONF is still applied to the config never - -harness_selftest 280-the-shared-cluster-config-must-not the shared cluster config sets no pgcolumnar.* GUC never - -harness_selftest 290-a-preflight-that-built-nothing a preflight that built nothing does not report PASSED never - -harness_selftest 290-a-preflight-that-built-nothing a preflight that built nothing exits non-zero never - -harness_selftest 290-a-preflight-that-built-nothing a preflight that built nothing says how many it built never - -harness_selftest 290-a-preflight-that-built-nothing premise: and it built none of them never - -harness_selftest 290-a-preflight-that-built-nothing premise: the probe run skipped every major never - -harness_selftest 300-a-test-script-must-be-runnable and every executable script declares one never - -harness_selftest 300-a-test-script-must-be-runnable and every script a document names exists never - -harness_selftest 300-a-test-script-must-be-runnable and every script a document names is executable never - -harness_selftest 300-a-test-script-must-be-runnable control: an interpreter declared without the bit is caught never - -harness_selftest 300-a-test-script-must-be-runnable control: and a sourced fragment, with neither, is correct never - -harness_selftest 300-a-test-script-must-be-runnable control: and the same file with the bit is not never - -harness_selftest 300-a-test-script-must-be-runnable control: cp -a preserves the execute bit, so a staged tree reads the same never - -harness_selftest 300-a-test-script-must-be-runnable control: the bit without an interpreter is caught too never - -harness_selftest 300-a-test-script-must-be-runnable every script that declares an interpreter is executable never - -harness_selftest 300-a-test-script-must-be-runnable premise: a runnable script one level down is inside the population never - -harness_selftest 300-a-test-script-must-be-runnable premise: and bench/ is in the population never - -harness_selftest 300-a-test-script-must-be-runnable premise: and so are the fixture host tools never - -harness_selftest 300-a-test-script-must-be-runnable premise: and they name at least one command in every swept directory never - -harness_selftest 300-a-test-script-must-be-runnable premise: the documents name a population of commands, not none never - -harness_selftest 300-a-test-script-must-be-runnable premise: the sourced parts are inside the population, not pruned never - -harness_selftest 300-a-test-script-must-be-runnable premise: the sweep reads a population of scripts, not an empty find never - -harness_selftest 310-a-compiled-artifact-must-not-be and a compiled artifact written beside its source never - -harness_selftest 310-a-compiled-artifact-must-not-be and the tracked BUNDLE list names none of them never - -harness_selftest 310-a-compiled-artifact-must-not-be and the tracked list names none of them never - -harness_selftest 310-a-compiled-artifact-must-not-be and the tree ignores a git bundle, so the next add cannot re-add it never - -harness_selftest 310-a-compiled-artifact-must-not-be and the tree ignores the directory Python writes them to never - -harness_selftest 310-a-compiled-artifact-must-not-be control: a source file named like a bundle is not ignored never - -harness_selftest 310-a-compiled-artifact-must-not-be no compiled Python artifact is tracked never - -harness_selftest 310-a-compiled-artifact-must-not-be no git bundle is tracked never - -harness_selftest 310-a-compiled-artifact-must-not-be premise: and git ls-files sees the harness it is being asked about never - -harness_selftest 310-a-compiled-artifact-must-not-be premise: and that a tracked source file is not never - -harness_selftest 310-a-compiled-artifact-must-not-be premise: check-ignore agrees a build object is already ignored never - -harness_selftest 310-a-compiled-artifact-must-not-be premise: the source tree is a git checkout never - -harness_selftest 320-a-check-that-could-not-run 67 without its line is a failure, not an INCOMPLETE taken on trust never - -harness_selftest 320-a-check-that-could-not-run a counter that drifts is caught rather than absorbed never - -harness_selftest 320-a-check-that-could-not-run a failure outranks an unrunnable check, and both are still counted never - -harness_selftest 320-a-check-that-could-not-run a passing ratio check is counted as a pass, not a failure never - -harness_selftest 320-a-check-that-could-not-run a suite of nothing but unrunnable checks is INCOMPLETE, not SKIPPED never - -harness_selftest 320-a-check-that-could-not-run a suite whose checks all passed still exits 0 PASSED never - -harness_selftest 320-a-check-that-could-not-run a suite with none says so as zero rather than staying silent never - -harness_selftest 320-a-check-that-could-not-run an INCOMPLETE suite fails its major never - -harness_selftest 320-a-check-that-could-not-run an unrunnable check counts toward checks run never - -harness_selftest 320-a-check-that-could-not-run an unrunnable reason outside the enum fails rather than being accepted never - -harness_selftest 320-a-check-that-could-not-run and 66 with its line a skip never - -harness_selftest 320-a-check-that-could-not-run and 67 with its line INCOMPLETE, which is not a pass never - -harness_selftest 320-a-check-that-could-not-run and a failing suite still does never - -harness_selftest 320-a-check-that-could-not-run and a skip does not, which is the one that must stay true never - -harness_selftest 320-a-check-that-could-not-run and a suite with no unrunnable checks reconciles too never - -harness_selftest 320-a-check-that-could-not-run and allows one that does, which is what it was written to allow never - -harness_selftest 320-a-check-that-could-not-run and an ordinary failure is still a failure never - -harness_selftest 320-a-check-that-could-not-run and both exempt a file that keeps its own counter without lib.sh never - -harness_selftest 320-a-check-that-could-not-run and it is not reported as having run no checks never - -harness_selftest 320-a-check-that-could-not-run and no write-only failure flag survives in the runner never - -harness_selftest 320-a-check-that-could-not-run and the suite holding it fails rather than reporting PASSED never - -harness_selftest 320-a-check-that-could-not-run and the suite that holds it still passes never - -harness_selftest 320-a-check-that-could-not-run and the unrunnable ones are reported as their own count never - -harness_selftest 320-a-check-that-could-not-run every direct write to PGC_CHECKS records an outcome too never - -harness_selftest 320-a-check-that-could-not-run lib.sh defines check_unrunnable never - -harness_selftest 320-a-check-that-could-not-run lib.sh defines the INCOMPLETE exit status never - -harness_selftest 320-a-check-that-could-not-run no non-zero status is classified as a pass never - -harness_selftest 320-a-check-that-could-not-run no suite that uses lib.sh's accounting writes PGC_CHECKS directly never - -harness_selftest 320-a-check-that-could-not-run one unrunnable check makes the suite INCOMPLETE, not passed never - -harness_selftest 320-a-check-that-could-not-run premise: the classifier evalled out of the runner is callable never - -harness_selftest 320-a-check-that-could-not-run premise: the fixtures carry the shapes these rules are about never - -harness_selftest 320-a-check-that-could-not-run premise: the harness library is where this part thinks it is never - -harness_selftest 320-a-check-that-could-not-run premise: the major-verdict mapping evalled out of the runner is callable never - -harness_selftest 320-a-check-that-could-not-run premise: the runner defines the classifier this part is about to eval never - -harness_selftest 320-a-check-that-could-not-run premise: the sweep read the corpus and found sites to classify never - -harness_selftest 320-a-check-that-could-not-run the original rule flags a bump that records no outcome never - -harness_selftest 320-a-check-that-could-not-run the runner calls a clean exit a pass never - -harness_selftest 320-a-check-that-could-not-run the runner's INCOMPLETE branch calls the mapping rather than a local flag never - -harness_selftest 320-a-check-that-could-not-run the stronger rule flags that same allowed bump, which is the change never - -harness_selftest 320-a-check-that-could-not-run the summary reconciles the three states against the total never - -harness_selftest 320-a-check-that-could-not-run the unrunnable check names itself, its reason code and its detail never - -harness_selftest 320-a-check-that-could-not-run while a pass does not never - -harness_selftest 330-the-incomplete-path-must-run-whole a suite with an unrunnable check exits 67 never - -harness_selftest 330-the-incomplete-path-must-run-whole an INCOMPLETE suite sets the flag the major verdict actually reads never - -harness_selftest 330-the-incomplete-path-must-run-whole and appears in the results string as INCOMPLETE never - -harness_selftest 330-the-incomplete-path-must-run-whole and counted as incomplete, so the tally can say so never - -harness_selftest 330-the-incomplete-path-must-run-whole and counts both suites as having run never - -harness_selftest 330-the-incomplete-path-must-run-whole and exactly one of them as incomplete never - -harness_selftest 330-the-incomplete-path-must-run-whole and is counted as having run never - -harness_selftest 330-the-incomplete-path-must-run-whole and is not counted as skipped, nor is the skip count disturbed never - -harness_selftest 330-the-incomplete-path-must-run-whole and its log carries the INCOMPLETE line the classifier needs never - -harness_selftest 330-the-incomplete-path-must-run-whole and neither as skipped never - -harness_selftest 330-the-incomplete-path-must-run-whole and no longer counts incompletes inline beside it never - -harness_selftest 330-the-incomplete-path-must-run-whole and records each suite's own verdict in the results string never - -harness_selftest 330-the-incomplete-path-must-run-whole and reprints the suite's own UNRUN line beneath it never - -harness_selftest 330-the-incomplete-path-must-run-whole and the UNRUN line the runner prints into the matrix output never - -harness_selftest 330-the-incomplete-path-must-run-whole and the run's overall status is failure never - -harness_selftest 330-the-incomplete-path-must-run-whole and the summary line carries the incomplete count a reader needs never - -harness_selftest 330-the-incomplete-path-must-run-whole and the tally announces it, with the reason lifted from the log never - -harness_selftest 330-the-incomplete-path-must-run-whole control fixture: a suite whose checks all ran exits 0 never - -harness_selftest 330-the-incomplete-path-must-run-whole control: and leaves the run's overall status alone never - -harness_selftest 330-the-incomplete-path-must-run-whole control: and still announces it never - -harness_selftest 330-the-incomplete-path-must-run-whole control: and still records that it ran, and how never - -harness_selftest 330-the-incomplete-path-must-run-whole control: and the major reports PASS never - -harness_selftest 330-the-incomplete-path-must-run-whole control: the same loop leaves a passing suite passing never - -harness_selftest 330-the-incomplete-path-must-run-whole every function the collect loop calls is defined here never - -harness_selftest 330-the-incomplete-path-must-run-whole premise: all five runner functions were extracted, not empty ranges never - -harness_selftest 330-the-incomplete-path-must-run-whole premise: and all five are callable never - -harness_selftest 330-the-incomplete-path-must-run-whole premise: and each extraction ends at its own closing brace never - -harness_selftest 330-the-incomplete-path-must-run-whole premise: the major-verdict branch was extracted, not an empty range never - -harness_selftest 330-the-incomplete-path-must-run-whole premise: the runner's collect loop was extracted, not an empty range never - -harness_selftest 330-the-incomplete-path-must-run-whole premise: the selftest has a workdir to build fixtures in never - -harness_selftest 330-the-incomplete-path-must-run-whole premise: the sweep found the loop's callers to check never - -harness_selftest 330-the-incomplete-path-must-run-whole running the real loop over both fixtures fails the major never - -harness_selftest 330-the-incomplete-path-must-run-whole the loop delegates each verdict to pgc_tally_suite never - -harness_selftest 330-the-incomplete-path-must-run-whole the runner classifies the file that suite actually produced never - -harness_selftest 330-the-incomplete-path-must-run-whole with an incomplete suite in the tally the major reports FAIL never - -harness_selftest 340-the-binary-must-be-built-from PREMISE and the target really holds sources find would otherwise hash never - -harness_selftest 340-the-binary-must-be-built-from PREMISE the Makefile's recursion was actually parsed never - -harness_selftest 340-the-binary-must-be-built-from PREMISE the copy discovers the same build directories as the real tree never - -harness_selftest 340-the-binary-must-be-built-from PREMISE the fingerprint covers at least src never - -harness_selftest 340-the-binary-must-be-built-from PREMISE the fixture's src really is a symlink never - -harness_selftest 340-the-binary-must-be-built-from a /./ segment hashes the same tree the same way never - -harness_selftest 340-the-binary-must-be-built-from a /src/.. segment hashes the same tree the same way never - -harness_selftest 340-the-binary-must-be-built-from a caller passing a major is caught never - -harness_selftest 340-the-binary-must-be-built-from a file that is not a build input does not move it never - -harness_selftest 340-the-binary-must-be-built-from a fingerprint different from the record is stale never - -harness_selftest 340-the-binary-must-be-built-from a fingerprint equal to the record is fresh never - -harness_selftest 340-the-binary-must-be-built-from a fingerprint is 12 hex characters never - -harness_selftest 340-the-binary-must-be-built-from a library newer than the running server is REFUSED never - -harness_selftest 340-the-binary-must-be-built-from a library older than the running server is accepted never - -harness_selftest 340-the-binary-must-be-built-from a missing binary timestamp is unknown, not predates never - -harness_selftest 340-the-binary-must-be-built-from a missing postmaster timestamp is unknown, not predates never - -harness_selftest 340-the-binary-must-be-built-from a new source file under objstore moves the fingerprint never - -harness_selftest 340-the-binary-must-be-built-from a one-line stamp yields its source fingerprint never - -harness_selftest 340-the-binary-must-be-built-from a recorded digest different from the installed one is replaced, not fresh never - -harness_selftest 340-the-binary-must-be-built-from a recorded library digest equal to the installed one is fresh never - -harness_selftest 340-the-binary-must-be-built-from a relative path hashes the same tree the same way never - -harness_selftest 340-the-binary-must-be-built-from a server older than the binary predates it never - -harness_selftest 340-the-binary-must-be-built-from a server started after the binary is fresh never - -harness_selftest 340-the-binary-must-be-built-from a server started at the same second is fresh never - -harness_selftest 340-the-binary-must-be-built-from a stale source is refused whatever the binary says never - -harness_selftest 340-the-binary-must-be-built-from a symlink to the tree hashes it the same way never - -harness_selftest 340-the-binary-must-be-built-from a symlinked src contributes nothing, as find -P contributes nothing never - -harness_selftest 340-the-binary-must-be-built-from a trailing slash hashes the same tree the same way never - -harness_selftest 340-the-binary-must-be-built-from a tree with no hashable file yields no fingerprint never - -harness_selftest 340-the-binary-must-be-built-from a two-line stamp still yields the source fingerprint first never - -harness_selftest 340-the-binary-must-be-built-from adding a source file moves it never - -harness_selftest 340-the-binary-must-be-built-from an added file appears in the manifest by name never - -harness_selftest 340-the-binary-must-be-built-from an added file shows up in the report never - -harness_selftest 340-the-binary-must-be-built-from an empty manifest is reported as empty, not as silence never - -harness_selftest 340-the-binary-must-be-built-from an unfingerprintable source reads as empty, not as the library digest never - -harness_selftest 340-the-binary-must-be-built-from an unhashable tree has an empty manifest never - -harness_selftest 340-the-binary-must-be-built-from an unreadable b.c yields no fingerprint, not a wrong one never - -harness_selftest 340-the-binary-must-be-built-from an unreadable c.c yields no fingerprint, not a wrong one never - -harness_selftest 340-the-binary-must-be-built-from an unreadable library is not a failure never - -harness_selftest 340-the-binary-must-be-built-from and a non-numeric timestamp is unknown rather than compared as text never - -harness_selftest 340-the-binary-must-be-built-from and a short first line does not splice the second into it never - -harness_selftest 340-the-binary-must-be-built-from and a stale source with a replaced binary is still refused for the source never - -harness_selftest 340-the-binary-must-be-built-from and an uncomputable current fingerprint is unknown, not stale never - -harness_selftest 340-the-binary-must-be-built-from and an unreadable installed library is unknown, not replaced never - -harness_selftest 340-the-binary-must-be-built-from and comparing two manifests names it rather than saying 'changed' never - -harness_selftest 340-the-binary-must-be-built-from and it says so rather than staying silent never - -harness_selftest 340-the-binary-must-be-built-from and removing it restores the fingerprint never - -harness_selftest 340-the-binary-must-be-built-from and restoring it restores the fingerprint never - -harness_selftest 340-the-binary-must-be-built-from and restoring the partition restores the fingerprint never - -harness_selftest 340-the-binary-must-be-built-from and the major is still readable in the name never - -harness_selftest 340-the-binary-must-be-built-from and the reader reads back the fingerprint the writer recorded never - -harness_selftest 340-the-binary-must-be-built-from and the refusal says the server must be restarted never - -harness_selftest 340-the-binary-must-be-built-from and two pg_configs for one prefix share a stamp, keyed on pkglibdir never - -harness_selftest 340-the-binary-must-be-built-from and yields NO library digest, rather than reusing the source hash never - -harness_selftest 340-the-binary-must-be-built-from and yields the library digest second never - -harness_selftest 340-the-binary-must-be-built-from but it says which question went unanswered never - -harness_selftest 340-the-binary-must-be-built-from control: a caller passing a pg_config is not flagged never - -harness_selftest 340-the-binary-must-be-built-from control: a readable run still reads fresh never - -harness_selftest 340-the-binary-must-be-built-from control: a real content change still moves the fingerprint never - -harness_selftest 340-the-binary-must-be-built-from control: a real src directory is still hashed never - -harness_selftest 340-the-binary-must-be-built-from control: and it still succeeds on a writable one never - -harness_selftest 340-the-binary-must-be-built-from control: and restoring the content restores the fingerprint never - -harness_selftest 340-the-binary-must-be-built-from control: and the tree fingerprints again once it is readable never - -harness_selftest 340-the-binary-must-be-built-from control: the same pg_config twice gives the same path never - -harness_selftest 340-the-binary-must-be-built-from control: writing the value it was given never - -harness_selftest 340-the-binary-must-be-built-from each manifest line is a tree-relative path and a digest never - -harness_selftest 340-the-binary-must-be-built-from editing a source file moves the fingerprint never - -harness_selftest 340-the-binary-must-be-built-from every directory the Makefile builds from is in the fingerprint never - -harness_selftest 340-the-binary-must-be-built-from moving bytes between files moves the fingerprint never - -harness_selftest 340-the-binary-must-be-built-from no caller passes a major where a pg_config belongs never - -harness_selftest 340-the-binary-must-be-built-from no record at all is unknown, not fresh never - -harness_selftest 340-the-binary-must-be-built-from no recorded digest is unknown, not fresh never - -harness_selftest 340-the-binary-must-be-built-from no source record is unverified, not verified never - -harness_selftest 340-the-binary-must-be-built-from one tree, one fingerprint, whatever the locale never - -harness_selftest 340-the-binary-must-be-built-from premise: and the stamp really was not written, so the arm is not vacuous never - -harness_selftest 340-the-binary-must-be-built-from premise: at least two locales are installed to compare never - -harness_selftest 340-the-binary-must-be-built-from premise: both fake configs report the same major, which is the whole point never - -harness_selftest 340-the-binary-must-be-built-from premise: every locale produced a fingerprint never - -harness_selftest 340-the-binary-must-be-built-from premise: the argument parser reads the second argument at all never - -harness_selftest 340-the-binary-must-be-built-from premise: the build path ran to completion, so a stamp was due never - -harness_selftest 340-the-binary-must-be-built-from premise: the partition fixture fingerprints at all never - -harness_selftest 340-the-binary-must-be-built-from premise: the same function returns a fingerprint for a real tree never - -harness_selftest 340-the-binary-must-be-built-from premise: the spelling fixture fingerprints at all never - -harness_selftest 340-the-binary-must-be-built-from premise: the sweep finds the call sites it is meant to police never - -harness_selftest 340-the-binary-must-be-built-from premise: the tree fingerprints to something when it is readable never - -harness_selftest 340-the-binary-must-be-built-from premise: the unprivileged read agrees while everything is readable never - -harness_selftest 340-the-binary-must-be-built-from premise: the unprivileged reader can source the staged harness never - -harness_selftest 340-the-binary-must-be-built-from premise: the writer wrote a stamp at all never - -harness_selftest 340-the-binary-must-be-built-from renaming a source file moves the fingerprint too never - -harness_selftest 340-the-binary-must-be-built-from so its verdict is unknown rather than a spurious stale never - -harness_selftest 340-the-binary-must-be-built-from so the tree still fingerprints from its root files alone never - -harness_selftest 340-the-binary-must-be-built-from so the verdict is fresh, not unknown never - -harness_selftest 340-the-binary-must-be-built-from so the verdict is unknown -- UNVERIFIED -- and never stale never - -harness_selftest 340-the-binary-must-be-built-from source fresh and binary fresh is the only state that earns the claim never - -harness_selftest 340-the-binary-must-be-built-from source fresh with a replaced binary is refused never - -harness_selftest 340-the-binary-must-be-built-from source fresh with an unverifiable binary does not earn it never - -harness_selftest 340-the-binary-must-be-built-from the fingerprint is the hash of the manifest never - -harness_selftest 340-the-binary-must-be-built-from the fixed fingerprint equals what the previous implementation produced never - -harness_selftest 340-the-binary-must-be-built-from the manifest is tree-relative, never absolute never - -harness_selftest 340-the-binary-must-be-built-from the manifest names every file the fingerprint hashes never - -harness_selftest 340-the-binary-must-be-built-from the probe is written outside the live source tree never - -harness_selftest 340-the-binary-must-be-built-from the report names each hashed file never - -harness_selftest 340-the-binary-must-be-built-from the report states how many files it hashed never - -harness_selftest 340-the-binary-must-be-built-from the same tree fingerprints the same twice never - -harness_selftest 340-the-binary-must-be-built-from the stamp writer reports failure on an unwritable target never - -harness_selftest 340-the-binary-must-be-built-from the writer writes the file the reader looks for never - -harness_selftest 340-the-binary-must-be-built-from two installations of one major get different stamp paths never - -harness_selftest 340-the-binary-must-be-built-from two unreadable pg_configs do not alias onto one stamp never - -harness_selftest 350-the-pytest-corpus-must-be and derives the pins from requirements-test.txt never - -harness_selftest 350-the-pytest-corpus-must-be and it derives the file list rather than repeating it never - -harness_selftest 350-the-pytest-corpus-must-be and the job asserts the driver is absent rather than assuming it never - -harness_selftest 350-the-pytest-corpus-must-be premise: the CI workflow is where this part thinks it is never - -harness_selftest 350-the-pytest-corpus-must-be the gate runs the harness guards never - -harness_selftest 360-an-unrunnable-pytest-test-must a drifted exit code is visible rather than absorbed never - -harness_selftest 360-an-unrunnable-pytest-test-must a drifted print shape is visible never - -harness_selftest 360-an-unrunnable-pytest-test-must a reason dropped from one side only is visible never - -harness_selftest 360-an-unrunnable-pytest-test-must premise: and that fixture is a real list rather than an empty parse never - -harness_selftest 360-an-unrunnable-pytest-test-must premise: and that fixture parses to a shape rather than to nothing never - -harness_selftest 360-an-unrunnable-pytest-test-must premise: lib.sh prints a line for an unrunnable check never - -harness_selftest 360-an-unrunnable-pytest-test-must premise: lib.sh states a closed list of unrunnable reasons never - -harness_selftest 360-an-unrunnable-pytest-test-must premise: lib.sh states an INCOMPLETE exit code this part could read never - -harness_selftest 360-an-unrunnable-pytest-test-must premise: the harness library is where this part thinks it is never - -harness_selftest 360-an-unrunnable-pytest-test-must premise: the pytest layer is where this part thinks it is never - -harness_selftest 360-an-unrunnable-pytest-test-must premise: the pytest layer prints one too never - -harness_selftest 360-an-unrunnable-pytest-test-must premise: the pytest layer states a closed list too never - -harness_selftest 360-an-unrunnable-pytest-test-must premise: the pytest layer states one too never - -harness_selftest 360-an-unrunnable-pytest-test-must the two harnesses agree on the INCOMPLETE exit code never - -harness_selftest 360-an-unrunnable-pytest-test-must the two harnesses agree on the closed list of unrunnable reasons never - -harness_selftest 360-an-unrunnable-pytest-test-must the two harnesses print an unrunnable check in the same shape never - -harness_selftest 380-the-pytest-cluster-helpers a caller that reimplements the digest is caught never - -harness_selftest 380-the-pytest-cluster-helpers a fingerprint that reads src only is caught never - -harness_selftest 380-the-pytest-cluster-helpers an import from the pytest tree is caught never - -harness_selftest 380-the-pytest-cluster-helpers and a hard-coded module list is caught by the name arm never - -harness_selftest 380-the-pytest-cluster-helpers and it names no module directory, so it is a derivation and not a list never - -harness_selftest 380-the-pytest-cluster-helpers and no longer mixes in the bare filename never - -harness_selftest 380-the-pytest-cluster-helpers and the shell keeps none either never - -harness_selftest 380-the-pytest-cluster-helpers premise: the one fingerprint implementation is where this part thinks it is never - -harness_selftest 380-the-pytest-cluster-helpers premise: while the real module satisfies the derivation arm never - -harness_selftest 380-the-pytest-cluster-helpers the fingerprint derives its build directories from a Makefile on disk never - -harness_selftest 380-the-pytest-cluster-helpers the hash mixes in each file's path relative to the tree, not its name never - -harness_selftest 380-the-pytest-cluster-helpers the module imports nothing from the pytest tree never - -harness_selftest 390-a-registered-suite-must-account a NEW unaccounted suite fails even while the known debt is excused never - -harness_selftest 390-a-registered-suite-must-account a comment mentioning pgc_summary is not a declaration never - -harness_selftest 390-a-registered-suite-must-account a declared suite that produced no accounting is caught never - -harness_selftest 390-a-registered-suite-must-account a declared suite the driver never dispatched reconciles never - -harness_selftest 390-a-registered-suite-must-account a file that does not exist is reported absent, not exempt never - -harness_selftest 390-a-registered-suite-must-account a hash inside a word does not hide the call after it never - -harness_selftest 390-a-registered-suite-must-account a log carrying lib.sh's accounting line is accounted never - -harness_selftest 390-a-registered-suite-must-account a log carrying neither is not accounted never - -harness_selftest 390-a-registered-suite-must-account a log claiming PASSED without the accounting line shows none never - -harness_selftest 390-a-registered-suite-must-account a long suite that calls pgc_summary still declares accounting never - -harness_selftest 390-a-registered-suite-must-account a longer name containing pgc_summary is not a declaration never - -harness_selftest 390-a-registered-suite-must-account a passing log shows accounting never - -harness_selftest 390-a-registered-suite-must-account a registered suite that is accounted by nothing FAILS never - -harness_selftest 390-a-registered-suite-must-account a suite recorded as known debt passes never - -harness_selftest 390-a-registered-suite-must-account a suite recorded as never dispatched that DID account is caught never - -harness_selftest 390-a-registered-suite-must-account a suite that accounted passes never - -harness_selftest 390-a-registered-suite-must-account a suite that calls pgc_summary declares accounting never - -harness_selftest 390-a-registered-suite-must-account a suite that never calls it does not never - -harness_selftest 390-a-registered-suite-must-account a suite that now accounts but is still listed as debt is reported never - -harness_selftest 390-a-registered-suite-must-account a suite the driver never dispatched passes never - -harness_selftest 390-a-registered-suite-must-account a trailing comment after the call does not hide it never - -harness_selftest 390-a-registered-suite-must-account an absent log shows no accounting rather than erroring never - -harness_selftest 390-a-registered-suite-must-account an accounting line that does not start its line is refused never - -harness_selftest 390-a-registered-suite-must-account an indented comment is still a comment never - -harness_selftest 390-a-registered-suite-must-account an undeclared suite that DID account is caught too never - -harness_selftest 390-a-registered-suite-must-account and a failed population reconciliation fails the major never - -harness_selftest 390-a-registered-suite-must-account and a failed reconciliation sets the per-major failure flag never - -harness_selftest 390-a-registered-suite-must-account and a log carrying only its OWN checks-run line is accounted too never - -harness_selftest 390-a-registered-suite-must-account and a reworded producer line is refused, so the arm can fail never - -harness_selftest 390-a-registered-suite-must-account and a skip, which reached the summary and counted zero never - -harness_selftest 390-a-registered-suite-must-account and absent is distinguishable from a present file that does not declare never - -harness_selftest 390-a-registered-suite-must-account and an incomplete never - -harness_selftest 390-a-registered-suite-must-account and debt naming a suite that is not registered is reported too never - -harness_selftest 390-a-registered-suite-must-account and it agrees with the real reader on a SHORT file, which is why it survived review never - -harness_selftest 390-a-registered-suite-must-account and it is NAMED, so the reader does not have to diff two lists never - -harness_selftest 390-a-registered-suite-must-account and it is named as that fault, not as one of the other two never - -harness_selftest 390-a-registered-suite-must-account and it is named as the opposite fault, not the same one never - -harness_selftest 390-a-registered-suite-must-account and it is named, which the symmetry check could never do never - -harness_selftest 390-a-registered-suite-must-account and names nothing when the two readers agree never - -harness_selftest 390-a-registered-suite-must-account and prose containing the word does not count as the line never - -harness_selftest 390-a-registered-suite-must-account and so does a failing one, which is the point never - -harness_selftest 390-a-registered-suite-must-account and sorts its inputs, because the runner appends them in SUITES order never - -harness_selftest 390-a-registered-suite-must-account and the excused one is not named as a failure never - -harness_selftest 390-a-registered-suite-must-account and the population reconciliation counts that same file never - -harness_selftest 390-a-registered-suite-must-account and the reader answers no on it, which is the wrong answer the arm catches never - -harness_selftest 390-a-registered-suite-must-account and the real function reconciles the same input, so the arm is not noise never - -harness_selftest 390-a-registered-suite-must-account and the reconciliation is given that record never - -harness_selftest 390-a-registered-suite-must-account and the registered file is written from the SUITES array itself never - -harness_selftest 390-a-registered-suite-must-account and without that record the same run is still caught never - -harness_selftest 390-a-registered-suite-must-account equal sets reconcile never - -harness_selftest 390-a-registered-suite-must-account every registered suite has a file never - -harness_selftest 390-a-registered-suite-must-account nor no for every one of them never - -harness_selftest 390-a-registered-suite-must-account opposite errors do not cancel: both directions are reported never - -harness_selftest 390-a-registered-suite-must-account premise: a lib.sh accounting line is seen by the narrow reader never - -harness_selftest 390-a-registered-suite-must-account premise: a private tally is NOT seen by the narrow reader never - -harness_selftest 390-a-registered-suite-must-account premise: and a log with neither is seen by neither never - -harness_selftest 390-a-registered-suite-must-account premise: and produced exactly one accounting line to be read never - -harness_selftest 390-a-registered-suite-must-account premise: and so is the wide reader it is paired with never - -harness_selftest 390-a-registered-suite-must-account premise: and that count excludes the definition line, which mentions it never - -harness_selftest 390-a-registered-suite-must-account premise: and the accounted reader that feeds it never - -harness_selftest 390-a-registered-suite-must-account premise: and the narrow count is still printed, as the lib.sh half never - -harness_selftest 390-a-registered-suite-must-account premise: and the real function still does never - -harness_selftest 390-a-registered-suite-must-account premise: but IS seen by the wide one, which is where the 2 came from never - -harness_selftest 390-a-registered-suite-must-account premise: it is callable never - -harness_selftest 390-a-registered-suite-must-account premise: pipefail is on, which is the condition the bug needs never - -harness_selftest 390-a-registered-suite-must-account premise: the declaration reader evalled out of the runner is callable never - -harness_selftest 390-a-registered-suite-must-account premise: the drift changed the line the reader looks for never - -harness_selftest 390-a-registered-suite-must-account premise: the fixture carries a well-formed accounting line, just indented never - -harness_selftest 390-a-registered-suite-must-account premise: the fixture is long enough to lose the race never - -harness_selftest 390-a-registered-suite-must-account premise: the fixture really does hide its call from the stripper never - -harness_selftest 390-a-registered-suite-must-account premise: the mutation applied -- the twin no longer sorts its inputs never - -harness_selftest 390-a-registered-suite-must-account premise: the observation reader evalled out of the runner is callable never - -harness_selftest 390-a-registered-suite-must-account premise: the population reconciliation is callable never - -harness_selftest 390-a-registered-suite-must-account premise: the real suite ran and reached its summary never - -harness_selftest 390-a-registered-suite-must-account premise: the reconciliation evalled out of the runner is callable never - -harness_selftest 390-a-registered-suite-must-account premise: the registered list is not empty, so the partition means something never - -harness_selftest 390-a-registered-suite-must-account premise: the runner defines the declaration reader this part evals never - -harness_selftest 390-a-registered-suite-must-account premise: the runner defines the observation reader this part evals never - -harness_selftest 390-a-registered-suite-must-account premise: the runner defines the own-mechanism difference this part evals never - -harness_selftest 390-a-registered-suite-must-account premise: the runner defines the population reconciliation never - -harness_selftest 390-a-registered-suite-must-account premise: the runner defines the reconciliation this part evals never - -harness_selftest 390-a-registered-suite-must-account premise: the twin script was written and is runnable never - -harness_selftest 390-a-registered-suite-must-account premise: the unsorted twin is callable never - -harness_selftest 390-a-registered-suite-must-account the breakdown headline counts the wide set, not the narrow one never - -harness_selftest 390-a-registered-suite-must-account the debt file is in the tree never - -harness_selftest 390-a-registered-suite-must-account the grep -q shape is the one that gets this wrong under pipefail never - -harness_selftest 390-a-registered-suite-must-account the identity catches comm reading unsorted input never - -harness_selftest 390-a-registered-suite-must-account the own-mechanism difference names the suite the readers disagree about never - -harness_selftest 390-a-registered-suite-must-account the partition over the real suite list adds up never - -harness_selftest 390-a-registered-suite-must-account the population partitions, and prints inputs == sum(buckets) never - -harness_selftest 390-a-registered-suite-must-account the reader accepts the line the producer actually emits never - -harness_selftest 390-a-registered-suite-must-account the reader does not answer yes for every registered suite never - -harness_selftest 390-a-registered-suite-must-account the reconciliation prints inputs == sum(buckets) never - -harness_selftest 390-a-registered-suite-must-account the record cannot introduce a suite the source never declared never - -harness_selftest 390-a-registered-suite-must-account the runner calls the population reconciliation never - -harness_selftest 390-a-registered-suite-must-account the runner calls the reconciliation, not merely defines it never - -harness_selftest 390-a-registered-suite-must-account the skip branch records the suite it did not dispatch never - -harness_selftest 390-a-registered-suite-must-account the stripper hides no pgc_summary call in any registered suite never - -harness_selftest 400-a-check-result-must-be-machine a bogus reason code records FAIL, not UNRUN never - -harness_selftest 400-a-check-result-must-be-machine a failing check emits exactly one record never - -harness_selftest 400-a-check-result-must-be-machine a failing check still prints its old line never - -harness_selftest 400-a-check-result-must-be-machine a log that never stated a count is not silently accepted never - -harness_selftest 400-a-check-result-must-be-machine a log whose records match its stated count reconciles never - -harness_selftest 400-a-check-result-must-be-machine a log with fewer records than it claims is caught never - -harness_selftest 400-a-check-result-must-be-machine a log with more records than it claims is caught too never - -harness_selftest 400-a-check-result-must-be-machine a passing check emits exactly one record never - -harness_selftest 400-a-check-result-must-be-machine a passing check still prints its old line never - -harness_selftest 400-a-check-result-must-be-machine a record carrying extra fields does not reconcile never - -harness_selftest 400-a-check-result-must-be-machine a record missing fields does not reconcile never - -harness_selftest 400-a-check-result-must-be-machine a skipped ratio check emits exactly one record never - -harness_selftest 400-a-check-result-must-be-machine a skipped timing check emits exactly one record never - -harness_selftest 400-a-check-result-must-be-machine a suite that skipped every check did not pass never - -harness_selftest 400-a-check-result-must-be-machine a verdict pgc_record cannot emit does not reconcile never - -harness_selftest 400-a-check-result-must-be-machine an empty check name does not reconcile never - -harness_selftest 400-a-check-result-must-be-machine an unrunnable check emits exactly one record never - -harness_selftest 400-a-check-result-must-be-machine an unrunnable check still prints its old line never - -harness_selftest 400-a-check-result-must-be-machine and a different major reaches the same field, so it is read not hardcoded never - -harness_selftest 400-a-check-result-must-be-machine and a harness that set no major says unknown rather than an empty field never - -harness_selftest 400-a-check-result-must-be-machine and it is counted never - -harness_selftest 400-a-check-result-must-be-machine and it is counted, so checks run: reports it never - -harness_selftest 400-a-check-result-must-be-machine and its major field carries the server major it ran under never - -harness_selftest 400-a-check-result-must-be-machine and its name field is the check's name, spaces intact never - -harness_selftest 400-a-check-result-must-be-machine and its verdict field says FAIL never - -harness_selftest 400-a-check-result-must-be-machine and its verdict field says PASS never - -harness_selftest 400-a-check-result-must-be-machine and its verdict field says UNRUN, which is neither of the other two never - -harness_selftest 400-a-check-result-must-be-machine and leaves one whose variable is assigned earlier never - -harness_selftest 400-a-check-result-must-be-machine and leaves one whose variable is the loop it sits in never - -harness_selftest 400-a-check-result-must-be-machine and names its own cause instead never - -harness_selftest 400-a-check-result-must-be-machine and not a check after a one-line piped loop that already closed never - -harness_selftest 400-a-check-result-must-be-machine and not a piped loop with no check in it never - -harness_selftest 400-a-check-result-must-be-machine and not one inside a process-substitution loop, which keeps its shell never - -harness_selftest 400-a-check-result-must-be-machine and records FAIL never - -harness_selftest 400-a-check-result-must-be-machine and records FAIL, because nothing was compared never - -harness_selftest 400-a-check-result-must-be-machine and records PASS when the ratio is inside the bound never - -harness_selftest 400-a-check-result-must-be-machine and still reports the two numbers never - -harness_selftest 400-a-check-result-must-be-machine and that place is pgc_record never - -harness_selftest 400-a-check-result-must-be-machine and the REASON_CODE travels in the reason field, not in prose never - -harness_selftest 400-a-check-result-must-be-machine and the ratio check is counted as a pass, not a skip never - -harness_selftest 400-a-check-result-must-be-machine and the ratio check's human line is unchanged never - -harness_selftest 400-a-check-result-must-be-machine and the ratio check's verdict is SKIP never - -harness_selftest 400-a-check-result-must-be-machine and the reason still follows the major, so nothing shifted onto it never - -harness_selftest 400-a-check-result-must-be-machine and the timing check is counted as a pass, not a skip never - -harness_selftest 400-a-check-result-must-be-machine and the timing check's human line is unchanged never - -harness_selftest 400-a-check-result-must-be-machine and the timing check's verdict is SKIP never - -harness_selftest 400-a-check-result-must-be-machine and the two numbers are named, not just the verdict never - -harness_selftest 400-a-check-result-must-be-machine and with timing enabled the skipped term is zero, not absent never - -harness_selftest 400-a-check-result-must-be-machine check_num on a non-number emits one record never - -harness_selftest 400-a-check-result-must-be-machine check_num's non-measurement line is unchanged never - -harness_selftest 400-a-check-result-must-be-machine check_ratio on a non-number emits one record never - -harness_selftest 400-a-check-result-must-be-machine check_ratio that forms a ratio emits one record never - -harness_selftest 400-a-check-result-must-be-machine check_ratio with a zero side emits one record never - -harness_selftest 400-a-check-result-must-be-machine check_text on an empty side emits one record never - -harness_selftest 400-a-check-result-must-be-machine check_text's empty-side line is unchanged never - -harness_selftest 400-a-check-result-must-be-machine control: a well-formed record still reconciles never - -harness_selftest 400-a-check-result-must-be-machine control: unknown IS a major the reconciler accepts, or the four above prove nothing never - -harness_selftest 400-a-check-result-must-be-machine fewer records than counted checks is not described as a subshell never - -harness_selftest 400-a-check-result-must-be-machine lib.sh bumps PGC_CHECKS in exactly one place never - -harness_selftest 400-a-check-result-must-be-machine more records than counted checks names the cause, not just the arithmetic never - -harness_selftest 400-a-check-result-must-be-machine no check_skip reads a name its own file never assigns never - -harness_selftest 400-a-check-result-must-be-machine no file that calls check prints a SKIP outcome the count cannot see never - -harness_selftest 400-a-check-result-must-be-machine no suite calls a check inside a piped loop never - -harness_selftest 400-a-check-result-must-be-machine pgc_fail emits one record never - -harness_selftest 400-a-check-result-must-be-machine pgc_pass emits one record never - -harness_selftest 400-a-check-result-must-be-machine premise: and it would name a file that calls check and echoes a SKIP never - -harness_selftest 400-a-check-result-must-be-machine premise: and that is this fragment, not the suite never - -harness_selftest 400-a-check-result-must-be-machine premise: it is callable never - -harness_selftest 400-a-check-result-must-be-machine premise: it names a check_skip reading an unassigned variable never - -harness_selftest 400-a-check-result-must-be-machine premise: lib.sh is where the check helpers live never - -harness_selftest 400-a-check-result-must-be-machine premise: the fixtures carry the shapes this sweep is about never - -harness_selftest 400-a-check-result-must-be-machine premise: the probe ran every helper shape once never - -harness_selftest 400-a-check-result-must-be-machine premise: the sweep classified a corpus of check-calling files never - -harness_selftest 400-a-check-result-must-be-machine premise: while a file that calls no check is not its business never - -harness_selftest 400-a-check-result-must-be-machine the accounting line reconciles four outcomes against the count never - -harness_selftest 400-a-check-result-must-be-machine the major [18.2] is not a major, so that record does not reconcile never - -harness_selftest 400-a-check-result-must-be-machine the major [] is not a major, so that record does not reconcile never - -harness_selftest 400-a-check-result-must-be-machine the major [eighteen] is not a major, so that record does not reconcile never - -harness_selftest 400-a-check-result-must-be-machine the major [pg18] is not a major, so that record does not reconcile never - -harness_selftest 400-a-check-result-must-be-machine the reconciliation accepts the verdict FAIL, which pgc_record emits never - -harness_selftest 400-a-check-result-must-be-machine the reconciliation accepts the verdict PASS, which pgc_record emits never - -harness_selftest 400-a-check-result-must-be-machine the reconciliation accepts the verdict SKIP, which pgc_record emits never - -harness_selftest 400-a-check-result-must-be-machine the reconciliation accepts the verdict UNRUN, which pgc_record emits never - -harness_selftest 400-a-check-result-must-be-machine the record count equals the counter the summary reports never - -harness_selftest 400-a-check-result-must-be-machine the record names the part the check was asked from never - -harness_selftest 400-a-check-result-must-be-machine the runner calls the record reconciliation, not merely defines it never - -harness_selftest 400-a-check-result-must-be-machine the runner defines the record reconciliation never - -harness_selftest 400-a-check-result-must-be-machine the same ratio check, ENABLED, emits one record and passes never - -harness_selftest 400-a-check-result-must-be-machine the same timing check, ENABLED, emits one record and passes never - -harness_selftest 400-a-check-result-must-be-machine the sweep finds a check inside a PIPED loop never - -harness_selftest 410-a-check-must-have-been-red --mutation across two failing checks in one run is refused never - -harness_selftest 410-a-check-must-have-been-red --prune REFUSES the whole prune when any orphan carries history never - -harness_selftest 410-a-check-must-have-been-red --prune removes NOTHING from a part that skipped never - -harness_selftest 410-a-check-must-have-been-red --prune removes a historyless orphan and says which never - -harness_selftest 410-a-check-must-have-been-red a before-log and an after-log together are refused, as rename-scan refuses them never - -harness_selftest 410-a-check-must-have-been-red a before-log and an after-log together are refused, not silently empty never - -harness_selftest 410-a-check-must-have-been-red a budget stating no census is not refused, because absence is not a contradiction never - -harness_selftest 410-a-check-must-have-been-red a budget that does not exist at the prior is a note, not a refusal never - -harness_selftest 410-a-check-must-have-been-red a census that matches the ledger passes never - -harness_selftest 410-a-check-must-have-been-red a census that overstates the ledger is refused too, because this is not a ceiling never - -harness_selftest 410-a-check-must-have-been-red a census that understates the ledger is refused never - -harness_selftest 410-a-check-must-have-been-red a check in an UNCOVERED suite is not refused never - -harness_selftest 410-a-check-must-have-been-red a check merely added is not reported as a rename never - -harness_selftest 410-a-check-must-have-been-red a check observed red gains the date it was seen never - -harness_selftest 410-a-check-must-have-been-red a check the ledger has never seen is refused never - -harness_selftest 410-a-check-must-have-been-red a clean status says nothing and does not fail the major never - -harness_selftest 410-a-check-must-have-been-red a date that is not a date is refused rather than stored never - -harness_selftest 410-a-check-must-have-been-red a deliberate break says so with --mutation never - -harness_selftest 410-a-check-must-have-been-red a gate over a nonexistent log is an integrity failure, not a pass never - -harness_selftest 410-a-check-must-have-been-red a later green run does not erase an observation never - -harness_selftest 410-a-check-must-have-been-red a ledger row no record in its own part matches is named an orphan never - -harness_selftest 410-a-check-must-have-been-red a log carrying a FAIL is refused when no reason is given never - -harness_selftest 410-a-check-must-have-been-red a name that appeared while another disappeared is reported as a rename never - -harness_selftest 410-a-check-must-have-been-red a named mutation is recorded against the check that reddened never - -harness_selftest 410-a-check-must-have-been-red a real refusal is a different status from an integrity failure never - -harness_selftest 410-a-check-must-have-been-red a ref that does not resolve is an integrity failure, not a bootstrap never - -harness_selftest 410-a-check-must-have-been-red a ref that exists with the budget still compares never - -harness_selftest 410-a-check-must-have-been-red a ref that exists without the budget is still the bootstrap case never - -harness_selftest 410-a-check-must-have-been-red a refusal keeps the regenerate-the-ledger wording never - -harness_selftest 410-a-check-must-have-been-red a rename in one part survives an addition in another never - -harness_selftest 410-a-check-must-have-been-red a row in a part that SKIPPED is reported as unprunable, not as an orphan never - -harness_selftest 410-a-check-must-have-been-red a row in a part the run does not contain is not called an orphan never - -harness_selftest 410-a-check-must-have-been-red a run that emits every row in its parts is clean never - -harness_selftest 410-a-check-must-have-been-red a run whose checks are all ledgered passes the gate never - -harness_selftest 410-a-check-must-have-been-red a second mutation ACCUMULATES rather than replacing the first never - -harness_selftest 410-a-check-must-have-been-red a stale prior is named WITH its distance from HEAD never - -harness_selftest 410-a-check-must-have-been-red a verdict pgc_record cannot emit is an integrity failure never - -harness_selftest 410-a-check-must-have-been-red an absolute budget path resolves against git rather than shrugging never - -harness_selftest 410-a-check-must-have-been-red an empty check name is one too, because it names no check never - -harness_selftest 410-a-check-must-have-been-red an empty log is one too, because there is nothing to reconcile never - -harness_selftest 410-a-check-must-have-been-red an integrity failure says regenerating will not help never - -harness_selftest 410-a-check-must-have-been-red an older observation does not overwrite a newer one never - -harness_selftest 410-a-check-must-have-been-red an orphan carrying history is reported as carrying it never - -harness_selftest 410-a-check-must-have-been-red and --prune does NOT turn that 1 into a 0, because it pruned nothing never - -harness_selftest 410-a-check-must-have-been-red and CI collects from the retained path rather than the deleted one never - -harness_selftest 410-a-check-must-have-been-red and a genuine observation says so with --reds-are-real never - -harness_selftest 410-a-check-must-have-been-red and a level prior carries no distance, so zero is silent never - -harness_selftest 410-a-check-must-have-been-red and a log that does not reconcile with its own checks run: never - -harness_selftest 410-a-check-must-have-been-red and a newer one does never - -harness_selftest 410-a-check-must-have-been-red and a prune with nothing left to remove is clean, not an error never - -harness_selftest 410-a-check-must-have-been-red and a raise against that base ref is refused never - -harness_selftest 410-a-check-must-have-been-red and a record missing its verdict never - -harness_selftest 410-a-check-must-have-been-red and an empty mutation is a placeholder, not an empty last field never - -harness_selftest 410-a-check-must-have-been-red and an undated merge does not erase a known date never - -harness_selftest 410-a-check-must-have-been-red and it copies them BEFORE removing the build directory, which is the only order that works never - -harness_selftest 410-a-check-must-have-been-red and it entered as debt, not as an observation nothing made never - -harness_selftest 410-a-check-must-have-been-red and it is REFUSED, not merely printed never - -harness_selftest 410-a-check-must-have-been-red and it is a different sentence from the refusal, not the same one twice never - -harness_selftest 410-a-check-must-have-been-red and it is named, so the author knows which one never - -harness_selftest 410-a-check-must-have-been-red and it is that case that says the change introduces the file never - -harness_selftest 410-a-check-must-have-been-red and it is the new one that is named, not the one already ledgered never - -harness_selftest 410-a-check-must-have-been-red and it names the verdict, so the author knows which record never - -harness_selftest 410-a-check-must-have-been-red and it runs before the build directory is removed, which is the only place it can never - -harness_selftest 410-a-check-must-have-been-red and it says so rather than declining silently never - -harness_selftest 410-a-check-must-have-been-red and it says the change introduces the file rather than raising anything never - -harness_selftest 410-a-check-must-have-been-red and it says the ref does not resolve, rather than claiming the file is new never - -harness_selftest 410-a-check-must-have-been-red and it says why, rather than falling back to something weaker never - -harness_selftest 410-a-check-must-have-been-red and never says a change introduces a file at a ref that is not there never - -harness_selftest 410-a-check-must-have-been-red and none of them ends in a tab never - -harness_selftest 410-a-check-must-have-been-red and not against one that stayed green never - -harness_selftest 410-a-check-must-have-been-red and nothing is written, so a refused merge is not half-applied never - -harness_selftest 410-a-check-must-have-been-red and one that stayed green keeps its debt never - -harness_selftest 410-a-check-must-have-been-red and only when there is a base, so a push build does not fail on it never - -harness_selftest 410-a-check-must-have-been-red and records neither as ever having been red never - -harness_selftest 410-a-check-must-have-been-red and the addition in the other part is not called a rename never - -harness_selftest 410-a-check-must-have-been-red and the census line it always printed is still there never - -harness_selftest 410-a-check-must-have-been-red and the comparison passes when the ceiling did not rise never - -harness_selftest 410-a-check-must-have-been-red and the gate prints that it compared them never - -harness_selftest 410-a-check-must-have-been-red and the history it is about to lose travels with it never - -harness_selftest 410-a-check-must-have-been-red and the history it would lose is printed with it never - -harness_selftest 410-a-check-must-have-been-red and the ledger is one row shorter afterwards never - -harness_selftest 410-a-check-must-have-been-red and the message says how to fix it, because regenerating is the intended action never - -harness_selftest 410-a-check-must-have-been-red and the refusal names both values never - -harness_selftest 410-a-check-must-have-been-red and the refusal names how many failed, so the author can narrow the run never - -harness_selftest 410-a-check-must-have-been-red and the refusal names the check that reddened never - -harness_selftest 410-a-check-must-have-been-red and the refusal names the raise never - -harness_selftest 410-a-check-must-have-been-red and the refusal quotes the claim beside the measurement never - -harness_selftest 410-a-check-must-have-been-red and the runner names no remote at that call site never - -harness_selftest 410-a-check-must-have-been-red and the scan states how many rows it could not speak about never - -harness_selftest 410-a-check-must-have-been-red and the summary keeps the two apart, so a zero orphan count is not a clean bill never - -harness_selftest 410-a-check-must-have-been-red auto refuses when GITHUB_BASE_REF names a ref that is not here never - -harness_selftest 410-a-check-must-have-been-red auto uses the base ref when it resolves, and names it never - -harness_selftest 410-a-check-must-have-been-red auto with no base ref and no upstream is an integrity failure never - -harness_selftest 410-a-check-must-have-been-red both failure arms fail the major never - -harness_selftest 410-a-check-must-have-been-red but that suite is counted as not covered, which is the debt never - -harness_selftest 410-a-check-must-have-been-red but the gate says so, so the skip is visible rather than silent never - -harness_selftest 410-a-check-must-have-been-red control: a prune that leaves nothing outstanding returns 0 never - -harness_selftest 410-a-check-must-have-been-red control: a well-formed log still merges never - -harness_selftest 410-a-check-must-have-been-red control: an all-PASS log still merges with no flag at all never - -harness_selftest 410-a-check-must-have-been-red control: and that one did prune, so 0 is not a refusal in disguise never - -harness_selftest 410-a-check-must-have-been-red control: and the ledger really is shorter afterwards never - -harness_selftest 410-a-check-must-have-been-red control: the row in the part the run never mentioned SURVIVES the prune never - -harness_selftest 410-a-check-must-have-been-red control: the same log merges with a different reason, so the refusal above is --mutation-across-two-checks and not the log never - -harness_selftest 410-a-check-must-have-been-red control: the same two rows ARE pruned when that part's record is a PASS never - -harness_selftest 410-a-check-must-have-been-red each says what was wrong with the input never - -harness_selftest 410-a-check-must-have-been-red every committed row has five fields never - -harness_selftest 410-a-check-must-have-been-red every row has five fields and no trailing tab never - -harness_selftest 410-a-check-must-have-been-red it is still a finding, so the scan does not return success never - -harness_selftest 410-a-check-must-have-been-red lowering it is allowed, which is the direction the burn-down goes never - -harness_selftest 410-a-check-must-have-been-red merging a green run records both checks never - -harness_selftest 410-a-check-must-have-been-red nor is one merely removed never - -harness_selftest 410-a-check-must-have-been-red once the suite is covered, a new check in it IS refused never - -harness_selftest 410-a-check-must-have-been-red one --mutation cannot be attributed across several runs at once never - -harness_selftest 410-a-check-must-have-been-red premise: and it is a file git has never seen, which is the case that used to fail open never - -harness_selftest 410-a-check-must-have-been-red premise: and it really pruned nothing -- the rows are all still there never - -harness_selftest 410-a-check-must-have-been-red premise: and it reported all four of its categories, so a zero is a measurement never - -harness_selftest 410-a-check-must-have-been-red premise: and the nobudget branch does not, which is the bootstrap shape never - -harness_selftest 410-a-check-must-have-been-red premise: and the refusal removed NOTHING -- the row is still there never - -harness_selftest 410-a-check-must-have-been-red premise: and the run the scan is given holds only one of them never - -harness_selftest 410-a-check-must-have-been-red premise: and the skipped run emits exactly one of them, as a SKIP never - -harness_selftest 410-a-check-must-have-been-red premise: and the two arms it stands in for are still named in the ledger never - -harness_selftest 410-a-check-must-have-been-red premise: both are never, so this ledger's census is two never - -harness_selftest 410-a-check-must-have-been-red premise: that part has rows the skipped run cannot speak for never - -harness_selftest 410-a-check-must-have-been-red premise: the budget is a tracked file too never - -harness_selftest 410-a-check-must-have-been-red premise: the budget was restored byte-exact never - -harness_selftest 410-a-check-must-have-been-red premise: the check has history before the rename never - -harness_selftest 410-a-check-must-have-been-red premise: the fixture ledger holds two rows never - -harness_selftest 410-a-check-must-have-been-red premise: the fixture log names checks the real ledger already knows never - -harness_selftest 410-a-check-must-have-been-red premise: the gate's status block was found in the runner never - -harness_selftest 410-a-check-must-have-been-red premise: the hasbudget branch carries the budget never - -harness_selftest 410-a-check-must-have-been-red premise: the ledger holds all three of that part's rows never - -harness_selftest 410-a-check-must-have-been-red premise: the ledger holds all three rows before the scan never - -harness_selftest 410-a-check-must-have-been-red premise: the ledger is not empty, so the partition means something never - -harness_selftest 410-a-check-must-have-been-red premise: the ledger itself is a tracked file, not a variable never - -harness_selftest 410-a-check-must-have-been-red premise: the ledger tool exists never - -harness_selftest 410-a-check-must-have-been-red premise: the orphan about to be pruned carries no history never - -harness_selftest 410-a-check-must-have-been-red premise: the orphan now carries a date and a mutation never - -harness_selftest 410-a-check-must-have-been-red premise: the raised copy really does carry a higher ceiling never - -harness_selftest 410-a-check-must-have-been-red premise: the real budget is inside a git repository never - -harness_selftest 410-a-check-must-have-been-red premise: the scratch prior really is three commits behind never - -harness_selftest 410-a-check-must-have-been-red premise: the scratch repo has a committed ceiling and no upstream never - -harness_selftest 410-a-check-must-have-been-red premise: the scratch repo has a prior ceiling committed never - -harness_selftest 410-a-check-must-have-been-red premise: the skip-loop sweep is present, so its counts can be read never - -harness_selftest 410-a-check-must-have-been-red premise: the workflow file is where this part thinks it is never - -harness_selftest 410-a-check-must-have-been-red raising the ceiling above its committed value is refused never - -harness_selftest 410-a-check-must-have-been-red raising the ceiling in the tracked file is refused never - -harness_selftest 410-a-check-must-have-been-red regenerating the ledger lets the new check through never - -harness_selftest 410-a-check-must-have-been-red the budget names a ceiling and a census, and says which is which never - -harness_selftest 410-a-check-must-have-been-red the ceiling refuses being exceeded never - -harness_selftest 410-a-check-must-have-been-red the check the run still emits is not called an orphan never - -harness_selftest 410-a-check-must-have-been-red the committed census matches the committed ledger never - -harness_selftest 410-a-check-must-have-been-red the distance travels with a refusal too, not only with a pass never - -harness_selftest 410-a-check-must-have-been-red the four categories account for every ledger row never - -harness_selftest 410-a-check-must-have-been-red the gate refuses to run without the registered suite list never - -harness_selftest 410-a-check-must-have-been-red the ledger partitions into observed and never never - -harness_selftest 410-a-check-must-have-been-red the orphan scan stays a REPORT while any skip loop cannot be compared to its arms never - -harness_selftest 410-a-check-must-have-been-red the refusal says why, rather than only that it refused never - -harness_selftest 410-a-check-must-have-been-red the runner asks the tool to resolve the prior rather than naming one never - -harness_selftest 410-a-check-must-have-been-red the runner captures the gate's status rather than only its success never - -harness_selftest 410-a-check-must-have-been-red the runner invokes the ledger gate never - -harness_selftest 410-a-check-must-have-been-red the runner keeps the logs somewhere that outlives the build directory never - -harness_selftest 410-a-check-must-have-been-red the runner passes --against to the gate never - -harness_selftest 410-a-check-must-have-been-red the same check in two logs is two runs, not a duplicate never - -harness_selftest 410-a-check-must-have-been-red the same name twice in ONE log is a duplicate, and is named never - -harness_selftest 410-a-check-must-have-been-red the scan reports a finding on a skipped part never - -harness_selftest 410-a-check-must-have-been-red the stable check is not reported never - -harness_selftest 410-a-check-must-have-been-red the suites job fetches the PR base for the ceiling comparison never - -harness_selftest 420-a-deleted-part-must-be-visible and every name in the manifest is a part on disk, so a deletion reddens never - -harness_selftest 420-a-deleted-part-must-be-visible every part on disk is named in the manifest never - -harness_selftest 420-a-deleted-part-must-be-visible premise: a part present in the manifest and missing on disk is named never - -harness_selftest 420-a-deleted-part-must-be-visible premise: and a part added without listing it is named too never - -harness_selftest 420-a-deleted-part-must-be-visible premise: the manifest names something, so the comparison has two sides never - -harness_selftest 420-a-deleted-part-must-be-visible the parts manifest exists, because without it a deletion is invisible never - -harness_selftest 420-a-deleted-part-must-be-visible the three buckets account for every part on disk never - -harness_selftest 430-the-self-test-must-not-report a pg_config whose --bindir is empty is refused too, not run with a broken PATH never - -harness_selftest 430-the-self-test-must-not-report and it does not pretend to have run checks never - -harness_selftest 430-the-self-test-must-not-report and pairs each with the marker the runners require beside the status never - -harness_selftest 430-the-self-test-must-not-report and part 010 exits with exactly that status on its skip paths never - -harness_selftest 430-the-self-test-must-not-report and the refusal is the guard's own, naming the path it could not use never - -harness_selftest 430-the-self-test-must-not-report control: and the second, so a good pg_config is not refused never - -harness_selftest 430-the-self-test-must-not-report control: the pg_config this run was handed satisfies the first predicate never - -harness_selftest 430-the-self-test-must-not-report handed a pg_config that does not exist, the self-test refuses instead of exiting 0 never - -harness_selftest 430-the-self-test-must-not-report no selftest part exits 0, which would exit the driver before its summary never - -harness_selftest 430-the-self-test-must-not-report part 010's skip status is the one lib.sh calls PGC_EXIT_SKIPPED never - -harness_selftest 430-the-self-test-must-not-report premise: and a BARE exit too, which ends with the last status and is usually 0 never - -harness_selftest 430-the-self-test-must-not-report premise: and it answers --bindir with nothing never - -harness_selftest 430-the-self-test-must-not-report premise: and it finds a planted exit 0 outside a heredoc never - -harness_selftest 430-the-self-test-must-not-report premise: the driver this part is about is where it is expected never - -harness_selftest 430-the-self-test-must-not-report premise: the stub is executable, so an -x test alone would accept it never - -harness_selftest 430-the-self-test-must-not-report premise: the sweep reads every selftest part never - -harness_selftest 430-the-self-test-must-not-report premise: while a deliberate non-zero exit is not an offence never - -harness_selftest 430-the-self-test-must-not-report premise: while a fixture script ending in exit 0 inside a heredoc is not an offence never - -harness_selftest 440-a-count-grep-never-produced an empty count is not 'present' under a numeric comparison never - -harness_selftest 440-a-count-grep-never-produced and the numeric form says so on stderr rather than silently never - -harness_selftest 440-a-count-grep-never-produced and the string comparison it replaces WOULD have said present never - -harness_selftest 440-a-count-grep-never-produced no count from grep -c is compared as a string, which answers present when grep could not answer never - -harness_selftest 440-a-count-grep-never-produced premise: a real count compares the same both ways, so the conversion is behaviour-preserving never - -harness_selftest 440-a-count-grep-never-produced premise: and a zero count does too never - -harness_selftest 440-a-count-grep-never-produced premise: and it finds a planted string comparison on a grep -c never - -harness_selftest 440-a-count-grep-never-produced premise: and it finds one whose PATTERN contains a parenthesis, which the first version could not never - -harness_selftest 440-a-count-grep-never-produced premise: and the = 0 spelling too, which fails the same way never - -harness_selftest 440-a-count-grep-never-produced premise: grep -c prints nothing at all on a pattern that does not compile never - -harness_selftest 440-a-count-grep-never-produced premise: nor is one inside a generated fixture script never - -harness_selftest 440-a-count-grep-never-produced premise: the sweep has a corpus to read never - -harness_selftest 440-a-count-grep-never-produced premise: while a numeric comparison is not an offence never - -harness_selftest 440-a-count-grep-never-produced premise: while a valid pattern prints a number never - -harness_selftest 450-a-red-nightly-must-be-findable a cancelled gate is a red verdict, not a shrug never - -harness_selftest 450-a-red-nightly-must-be-findable a failure names the run so a reader can reach it never - -harness_selftest 450-a-red-nightly-must-be-findable a failure naming no job says so rather than printing an empty list never - -harness_selftest 450-a-red-nightly-must-be-findable a fire drill identifies itself in the issue it opens never - -harness_selftest 450-a-red-nightly-must-be-findable a gate nobody listed here still decides the verdict (#973) never - -harness_selftest 450-a-red-nightly-must-be-findable a green run composes the closing message, so the alert clears itself never - -harness_selftest 450-a-red-nightly-must-be-findable all skipped is green, which is a fork run and a fire drill never - -harness_selftest 450-a-red-nightly-must-be-findable an empty needs context is refused, not defaulted to green never - -harness_selftest 450-a-red-nightly-must-be-findable an unparseable context says so without a traceback never - -harness_selftest 450-a-red-nightly-must-be-findable an unrecognised result is refused rather than treated as green never - -harness_selftest 450-a-red-nightly-must-be-findable an unrecognised verdict is refused rather than treated as green never - -harness_selftest 450-a-red-nightly-must-be-findable and it is granted issues: write, which the workflow default withholds never - -harness_selftest 450-a-red-nightly-must-be-findable and it still says what went wrong, rather than saying nothing never - -harness_selftest 450-a-red-nightly-must-be-findable and names the job that failed, not just that something did never - -harness_selftest 450-a-red-nightly-must-be-findable and no per-job result variable survives to drift from the context never - -harness_selftest 450-a-red-nightly-must-be-findable and no search-index query survives in the code never - -harness_selftest 450-a-red-nightly-must-be-findable and that marker reaches the job list the reporter prints never - -harness_selftest 450-a-red-nightly-must-be-findable and the green path reuses the same title, or it would close nothing never - -harness_selftest 450-a-red-nightly-must-be-findable every gate green is a green verdict never - -harness_selftest 450-a-red-nightly-must-be-findable one gate failing is a red verdict never - -harness_selftest 450-a-red-nightly-must-be-findable premise: removing comments left the lookup itself in place never - -harness_selftest 450-a-red-nightly-must-be-findable premise: the nightly workflow and the reporter are both present never - -harness_selftest 450-a-red-nightly-must-be-findable premise: the other nightly jobs were parsed, so the comparison is real never - -harness_selftest 450-a-red-nightly-must-be-findable premise: the per-job-variable pattern sees that shape when it is present never - -harness_selftest 450-a-red-nightly-must-be-findable premise: the reporter's needs list was parsed never - -harness_selftest 450-a-red-nightly-must-be-findable the issue lookup reads past the first hundred open issues never - -harness_selftest 450-a-red-nightly-must-be-findable the reporter runs on every outcome, not only on failure never - -harness_selftest 450-a-red-nightly-must-be-findable the reporter waits on EVERY other nightly job (#973) never - -harness_selftest 450-a-red-nightly-must-be-findable the title carries no run number, so every red lands on one issue never - -harness_selftest 450-a-red-nightly-must-be-findable the verdict comes from the whole needs context, not a second list never - -harness_selftest 460-the-controller-must-record-the-binary control: and the stamp carries one field rather than two never - -harness_selftest 460-the-controller-must-record-the-binary control: without that argument the same driver degrades to source-only (#961) never - -harness_selftest 460-the-controller-must-record-the-binary every caller records the installed library's digest (#961) never - -harness_selftest 460-the-controller-must-record-the-binary premise: all three stamp call sites were found with their arguments joined never - -harness_selftest 460-the-controller-must-record-the-binary premise: and it holds exactly one stamp write never - -harness_selftest 460-the-controller-must-record-the-binary premise: nothing opens a deeper subshell inside the extracted block never - -harness_selftest 460-the-controller-must-record-the-binary premise: the controller's stamp block was extracted exactly once never - -harness_selftest 460-the-controller-must-record-the-binary premise: the extraction produced a block at all never - -harness_selftest 460-the-controller-must-record-the-binary premise: the matrix controller is present and parses never - -harness_selftest 460-the-controller-must-record-the-binary premise: the mutation removed the installed-digest argument never - -harness_selftest 460-the-controller-must-record-the-binary premise: this part was given an executable pg_config to read the prefix from never - -harness_selftest 460-the-controller-must-record-the-binary so a child suite under PGC_SKIP_BUILD reaches verified, not source-only (#961) never - -harness_selftest 460-the-controller-must-record-the-binary the controller's stamp carries BOTH fields (#961) never - -harness_selftest 470-a-skipped-arm-records-under-its-own-name every comparable skip loop names exactly the arms its sibling would emit (#994) never - -harness_selftest 470-a-skipped-arm-records-under-its-own-name premise: and it actually compared some of them never - -harness_selftest 470-a-skipped-arm-records-under-its-own-name premise: the sweep found skip loops at all never - -harness_selftest 470-a-skipped-arm-records-under-its-own-name premise: the sweep tool is present never - -native_join_runtime_filter native_join_runtime_filter 3-table answer equals filter-off never - -native_join_runtime_filter native_join_runtime_filter 3-table join order matches filter-off never - -native_join_runtime_filter native_join_runtime_filter 3-table plan has coordinator never - -native_join_runtime_filter native_join_runtime_filter ANTI refusal never - -native_join_runtime_filter native_join_runtime_filter CROSS refusal never - -native_join_runtime_filter native_join_runtime_filter LEFT refusal never - -native_join_runtime_filter native_join_runtime_filter SEMI refusal never - -native_join_runtime_filter native_join_runtime_filter baseline core Hash Join never - -native_join_runtime_filter native_join_runtime_filter baseline reads all groups never - -native_join_runtime_filter native_join_runtime_filter build rows omit NULL never - -native_join_runtime_filter native_join_runtime_filter clustered groups removed never - -native_join_runtime_filter native_join_runtime_filter clustered reads fewer groups never - -native_join_runtime_filter native_join_runtime_filter collation-mismatch answer equals heap never - -native_join_runtime_filter native_join_runtime_filter collation-mismatch bloom rejects most non-matches never - -native_join_runtime_filter native_join_runtime_filter collation-mismatch interval stays off never - -native_join_runtime_filter native_join_runtime_filter collation-mismatch plan has coordinator never - -native_join_runtime_filter native_join_runtime_filter default plan has runtime coordinator 2026-09-12 - -native_join_runtime_filter native_join_runtime_filter early limit equals heap never - -native_join_runtime_filter native_join_runtime_filter early limit has coordinator never - -native_join_runtime_filter native_join_runtime_filter empty-build answer equals heap never - -native_join_runtime_filter native_join_runtime_filter empty-build plan has coordinator never - -native_join_runtime_filter native_join_runtime_filter fact-qual conjunction equals heap never - -native_join_runtime_filter native_join_runtime_filter fact-qual plan has coordinator never - -native_join_runtime_filter native_join_runtime_filter filter ready before scan never - -native_join_runtime_filter native_join_runtime_filter int4/int8 answer equals heap never - -native_join_runtime_filter native_join_runtime_filter int4/int8 bloom rejects most non-matches never - -native_join_runtime_filter native_join_runtime_filter int4/int8 interval stays off never - -native_join_runtime_filter native_join_runtime_filter int4/int8 plan has coordinator never - -native_join_runtime_filter native_join_runtime_filter join runtime filter defaults on 2026-09-12 - -native_join_runtime_filter native_join_runtime_filter plan has build tap never - -native_join_runtime_filter native_join_runtime_filter plan has runtime coordinator never - -native_join_runtime_filter native_join_runtime_filter plan retains core Hash Join never - -native_join_runtime_filter native_join_runtime_filter projection join equals heap never - -native_join_runtime_filter native_join_runtime_filter projection outer is not wrapped never - -native_join_runtime_filter native_join_runtime_filter projection scan is chosen never - -native_join_runtime_filter native_join_runtime_filter rescan answers equal heap never - -native_join_runtime_filter native_join_runtime_filter runtime answer equals heap never - -native_join_runtime_filter native_join_runtime_filter runtime answer equals off never - -native_join_runtime_filter native_join_runtime_filter saturated answer equals heap never - -native_join_runtime_filter native_join_runtime_filter saturated bloom is disabled never - -native_join_runtime_filter native_join_runtime_filter saturated plan has coordinator never - -native_join_runtime_filter native_join_runtime_filter scattered answer equals heap never - -native_join_runtime_filter native_join_runtime_filter scattered bloom rejects most non-matches never - -native_join_runtime_filter native_join_runtime_filter scattered interval cannot drop groups never - -native_join_runtime_filter native_join_runtime_filter scattered plan has coordinator never - -native_join_runtime_filter native_join_runtime_filter scattered still reads every group never - -native_join_vector_agg native_join_vector_agg LEFT join answer equals heap never - -native_join_vector_agg native_join_vector_agg LEFT join refuses the join fold never - -native_join_vector_agg native_join_vector_agg duplicate dim keys answer equals heap never - -native_join_vector_agg native_join_vector_agg duplicate dim keys refuse the join fold never - -native_join_vector_agg native_join_vector_agg extra join filter answer equals GUC off 2026-09-12 - -native_join_vector_agg native_join_vector_agg extra join filter answer equals heap 2026-09-12 - -native_join_vector_agg native_join_vector_agg extra join filter refuses the join fold 2026-09-12 - -native_join_vector_agg native_join_vector_agg inequality join filter answer equals heap 2026-09-12 - -native_join_vector_agg native_join_vector_agg inequality join filter refuses the join fold 2026-09-12 - -native_join_vector_agg native_join_vector_agg unique join fold answer equals GUC off never - -native_join_vector_agg native_join_vector_agg unique join fold answer equals heap never - -native_join_vector_agg native_join_vector_agg unique join uses core Agg when GUC off never - -native_join_vector_agg native_join_vector_agg unique join uses vectorized agg when GUC on 2026-09-12 drop JOINREL fold +differential differential agg avg 15;16;17;18;19 never - +differential differential agg count 15;16;17;18;19 never - +differential differential agg minmax 15;16;17;18;19 never - +differential differential agg sum 15;16;17;18;19 never - +differential differential allnull chunk isnull 15;16;17;18;19 never - +differential differential allnull chunk range 15;16;17;18;19 never - +differential differential allnull chunk scan 15;16;17;18;19 never - +differential differential allnull column count 15;16;17;18;19 never - +differential differential allnull column isnull 15;16;17;18;19 never - +differential differential allnull column minmax 15;16;17;18;19 never - +differential differential allnull column scan 15;16;17;18;19 never - +differential differential bloom absent correct 15;16;17;18;19 never - +differential differential bloom k present 15;16;17;18;19 never - +differential differential bloom k range 15;16;17;18;19 never - +differential differential bloom u eq 15;16;17;18;19 never - +differential differential c_arr count 15;16;17;18;19 never - +differential differential c_arr eq 15;16;17;18;19 never - +differential differential c_arr is null 15;16;17;18;19 never - +differential differential c_arr not null 15;16;17;18;19 never - +differential differential c_arr project 15;16;17;18;19 never - +differential differential c_big count 15;16;17;18;19 never - +differential differential c_big is null 15;16;17;18;19 never - +differential differential c_big min/max 15;16;17;18;19 never - +differential differential c_big not null 15;16;17;18;19 never - +differential differential c_big project 15;16;17;18;19 never - +differential differential c_big range 15;16;17;18;19 never - +differential differential c_big sum/avg 15;16;17;18;19 never - +differential differential c_bool count 15;16;17;18;19 never - +differential differential c_bool eq 15;16;17;18;19 never - +differential differential c_bool is null 15;16;17;18;19 never - +differential differential c_bool not null 15;16;17;18;19 never - +differential differential c_bool project 15;16;17;18;19 never - +differential differential c_bytea count 15;16;17;18;19 never - +differential differential c_bytea is null 15;16;17;18;19 never - +differential differential c_bytea not null 15;16;17;18;19 never - +differential differential c_bytea project 15;16;17;18;19 never - +differential differential c_bytea range 15;16;17;18;19 never - +differential differential c_char count 15;16;17;18;19 never - +differential differential c_char is null 15;16;17;18;19 never - +differential differential c_char min/max 15;16;17;18;19 never - +differential differential c_char not null 15;16;17;18;19 never - +differential differential c_char project 15;16;17;18;19 never - +differential differential c_date count 15;16;17;18;19 never - +differential differential c_date is null 15;16;17;18;19 never - +differential differential c_date min/max 15;16;17;18;19 never - +differential differential c_date not null 15;16;17;18;19 never - +differential differential c_date project 15;16;17;18;19 never - +differential differential c_date range 15;16;17;18;19 never - +differential differential c_f4 count 15;16;17;18;19 never - +differential differential c_f4 is null 15;16;17;18;19 never - +differential differential c_f4 min/max 15;16;17;18;19 never - +differential differential c_f4 not null 15;16;17;18;19 never - +differential differential c_f4 project 15;16;17;18;19 never - +differential differential c_f4 sum/avg 15;16;17;18;19 never - +differential differential c_f8 count 15;16;17;18;19 never - +differential differential c_f8 is null 15;16;17;18;19 never - +differential differential c_f8 min/max 15;16;17;18;19 never - +differential differential c_f8 not null 15;16;17;18;19 never - +differential differential c_f8 project 15;16;17;18;19 never - +differential differential c_f8 range 15;16;17;18;19 never - +differential differential c_f8 sum/avg 15;16;17;18;19 never - +differential differential c_int count 15;16;17;18;19 never - +differential differential c_int eq 15;16;17;18;19 never - +differential differential c_int is null 15;16;17;18;19 never - +differential differential c_int min/max 15;16;17;18;19 never - +differential differential c_int not null 15;16;17;18;19 never - +differential differential c_int project 15;16;17;18;19 never - +differential differential c_int range 15;16;17;18;19 never - +differential differential c_int sum/avg 15;16;17;18;19 never - +differential differential c_iv count 15;16;17;18;19 never - +differential differential c_iv is null 15;16;17;18;19 never - +differential differential c_iv min/max 15;16;17;18;19 never - +differential differential c_iv not null 15;16;17;18;19 never - +differential differential c_iv project 15;16;17;18;19 never - +differential differential c_jsonb count 15;16;17;18;19 never - +differential differential c_jsonb eq 15;16;17;18;19 never - +differential differential c_jsonb is null 15;16;17;18;19 never - +differential differential c_jsonb not null 15;16;17;18;19 never - +differential differential c_jsonb project 15;16;17;18;19 never - +differential differential c_num count 15;16;17;18;19 never - +differential differential c_num is null 15;16;17;18;19 never - +differential differential c_num min/max 15;16;17;18;19 never - +differential differential c_num not null 15;16;17;18;19 never - +differential differential c_num project 15;16;17;18;19 never - +differential differential c_num range 15;16;17;18;19 never - +differential differential c_num sum/avg 15;16;17;18;19 never - +differential differential c_small count 15;16;17;18;19 never - +differential differential c_small is null 15;16;17;18;19 never - +differential differential c_small min/max 15;16;17;18;19 never - +differential differential c_small not null 15;16;17;18;19 never - +differential differential c_small project 15;16;17;18;19 never - +differential differential c_small sum/avg 15;16;17;18;19 never - +differential differential c_text count 15;16;17;18;19 never - +differential differential c_text is null 15;16;17;18;19 never - +differential differential c_text min/max 15;16;17;18;19 never - +differential differential c_text not null 15;16;17;18;19 never - +differential differential c_text project 15;16;17;18;19 never - +differential differential c_text range 15;16;17;18;19 never - +differential differential c_ts count 15;16;17;18;19 never - +differential differential c_ts is null 15;16;17;18;19 never - +differential differential c_ts min/max 15;16;17;18;19 never - +differential differential c_ts not null 15;16;17;18;19 never - +differential differential c_ts project 15;16;17;18;19 never - +differential differential c_ts range 15;16;17;18;19 never - +differential differential c_tstz count 15;16;17;18;19 never - +differential differential c_tstz is null 15;16;17;18;19 never - +differential differential c_tstz min/max 15;16;17;18;19 never - +differential differential c_tstz not null 15;16;17;18;19 never - +differential differential c_tstz project 15;16;17;18;19 never - +differential differential c_tstz range 15;16;17;18;19 never - +differential differential c_uuid count 15;16;17;18;19 never - +differential differential c_uuid eq 15;16;17;18;19 never - +differential differential c_uuid is null 15;16;17;18;19 never - +differential differential c_uuid not null 15;16;17;18;19 never - +differential differential c_uuid project 15;16;17;18;19 never - +differential differential c_uuid range 15;16;17;18;19 never - +differential differential c_vc count 15;16;17;18;19 never - +differential differential c_vc eq 15;16;17;18;19 never - +differential differential c_vc is null 15;16;17;18;19 never - +differential differential c_vc min/max 15;16;17;18;19 never - +differential differential c_vc not null 15;16;17;18;19 never - +differential differential c_vc project 15;16;17;18;19 never - +differential differential c_vc range 15;16;17;18;19 never - +differential differential c_ztext count 15;16;17;18;19 never - +differential differential c_ztext is null 15;16;17;18;19 never - +differential differential c_ztext min/max 15;16;17;18;19 never - +differential differential c_ztext not null 15;16;17;18;19 never - +differential differential c_ztext project 15;16;17;18;19 never - +differential differential cg boundary N=100 groups 15;16;17;18;19 never - +differential differential cg boundary N=100 range 15;16;17;18;19 never - +differential differential cg boundary N=100 scan 15;16;17;18;19 never - +differential differential cg boundary N=101 groups 15;16;17;18;19 never - +differential differential cg boundary N=101 range 15;16;17;18;19 never - +differential differential cg boundary N=101 scan 15;16;17;18;19 never - +differential differential cg boundary N=200 groups 15;16;17;18;19 never - +differential differential cg boundary N=200 range 15;16;17;18;19 never - +differential differential cg boundary N=200 scan 15;16;17;18;19 never - +differential differential cg boundary N=201 groups 15;16;17;18;19 never - +differential differential cg boundary N=201 range 15;16;17;18;19 never - +differential differential cg boundary N=201 scan 15;16;17;18;19 never - +differential differential cg boundary N=250 groups 15;16;17;18;19 never - +differential differential cg boundary N=250 range 15;16;17;18;19 never - +differential differential cg boundary N=250 scan 15;16;17;18;19 never - +differential differential cg boundary N=99 groups 15;16;17;18;19 never - +differential differential cg boundary N=99 range 15;16;17;18;19 never - +differential differential cg boundary N=99 scan 15;16;17;18;19 never - +differential differential compound 15;16;17;18;19 never - +differential differential control: the set oracle is order-blind by design 15;16;17;18;19 never - +differential differential count meta=off 15;16;17;18;19 never - +differential differential count meta=on 15;16;17;18;19 never - +differential differential dict text agg 15;16;17;18;19 never - +differential differential dict text eq 15;16;17;18;19 never - +differential differential dict text group 15;16;17;18;19 never - +differential differential dict whole-row 15;16;17;18;19 never - +differential differential empty agg 15;16;17;18;19 never - +differential differential empty count 15;16;17;18;19 never - +differential differential empty scan 15;16;17;18;19 never - +differential differential empty-vs-null empties 15;16;17;18;19 never - +differential differential empty-vs-null nulls 15;16;17;18;19 never - +differential differential empty-vs-null scan 15;16;17;18;19 never - +differential differential enc aggregate 15;16;17;18;19 never - +differential differential enc const scan 15;16;17;18;19 never - +differential differential enc lowcard eq 15;16;17;18;19 never - +differential differential enc seq range 15;16;17;18;19 never - +differential differential enc whole-row 15;16;17;18;19 never - +differential differential enc+nocompress agg 15;16;17;18;19 never - +differential differential enc+nocompress scan 15;16;17;18;19 never - +differential differential i4 float agg 15;16;17;18;19 never - +differential differential i4 ts minmax 15;16;17;18;19 never - +differential differential i4 ts range 15;16;17;18;19 never - +differential differential i4 whole-row 15;16;17;18;19 never - +differential differential matrix chunk groups>=12 15;16;17;18;19 never - +differential differential matrix row count 15;16;17;18;19 never - +differential differential matrix stripes>=2 15;16;17;18;19 never - +differential differential matrix whole-row 15;16;17;18;19 never - +differential differential order limit head 15;16;17;18;19 never - +differential differential order limit tail 15;16;17;18;19 never - +differential differential premise: the ordered oracle agrees with itself 15;16;17;18;19 never - +differential differential premise: the ordered oracle is order-sensitive 15;16;17;18;19 never - +differential differential single count 15;16;17;18;19 never - +differential differential single scan 15;16;17;18;19 never - +differential differential stripe boundary N=1000 agg 15;16;17;18;19 never - +differential differential stripe boundary N=1000 scan 15;16;17;18;19 never - +differential differential stripe boundary N=1000 stripes 15;16;17;18;19 never - +differential differential stripe boundary N=1001 agg 15;16;17;18;19 never - +differential differential stripe boundary N=1001 scan 15;16;17;18;19 never - +differential differential stripe boundary N=1001 stripes 15;16;17;18;19 never - +differential differential stripe boundary N=2000 agg 15;16;17;18;19 never - +differential differential stripe boundary N=2000 scan 15;16;17;18;19 never - +differential differential stripe boundary N=2000 stripes 15;16;17;18;19 never - +differential differential stripe boundary N=2001 agg 15;16;17;18;19 never - +differential differential stripe boundary N=2001 scan 15;16;17;18;19 never - +differential differential stripe boundary N=2001 stripes 15;16;17;18;19 never - +differential differential textbloom C absent 15;16;17;18;19 never - +differential differential textbloom C eq 15;16;17;18;19 never - +differential differential textbloom absent 15;16;17;18;19 never - +differential differential textbloom collate-mismatch 15;16;17;18;19 never - +differential differential textbloom present 15;16;17;18;19 never - +differential differential wide most 15;16;17;18;19 never - +differential differential wide nomatch 15;16;17;18;19 never - +differential differential wide point 15;16;17;18;19 never - +differential differential wide range 15;16;17;18;19 never - +differential differential wide row proj 15;16;17;18;19 never - +differential differential wide row scan 15;16;17;18;19 never - +harness_selftest 030-assertions nothing leaked into the squatter 15;16;17;18;19 never - +harness_selftest 030-assertions pgc_port_free says the squatter's port is busy 15;16;17;18;19 never - +harness_selftest 030-assertions squatter survived untouched 15;16;17;18;19 never - +harness_selftest 030-assertions suite did not settle on the squatter's port 15;16;17;18;19 never - +harness_selftest 030-assertions suite's cluster is its own 15;16;17;18;19 never - +harness_selftest 030-assertions suite's own objects are visible to it 15;16;17;18;19 never - +harness_selftest 040-the-detection-primitive-itself detection distinguishes it from ours 15;16;17;18;19 never - +harness_selftest 040-the-detection-primitive-itself detection reports a foreign cluster's directory 15;16;17;18;19 never - +harness_selftest 040-the-detection-primitive-itself guard accepts our own cluster 15;16;17;18;19 never - +harness_selftest 040-the-detection-primitive-itself guard rejects a foreign cluster 15;16;17;18;19 never - +harness_selftest 040-the-detection-primitive-itself premise: the runner answered --list-suites, so the two checks below mean something 15;16;17;18;19 never - +harness_selftest 050-the-list-must-be-read-the a name after the array's closing paren is not read as a registered suite 15;16;17;18;19 never - +harness_selftest 050-the-list-must-be-read-the and the mistake empties the whole array rather than appending to it 15;16;17;18;19 never - +harness_selftest 050-the-list-must-be-read-the positive control: and it is a whole list, not one lucky line 15;16;17;18;19 never - +harness_selftest 050-the-list-must-be-read-the positive control: the real runner's list is read, and contains isolation 15;16;17;18;19 never - +harness_selftest 050-the-list-must-be-read-the premise: the fixture really does carry the stray name 15;16;17;18;19 never - +harness_selftest 060-the-list-stays-sorted-which-is premise: C collation puts sort_status before sorted_projection 15;16;17;18;19 never - +harness_selftest 060-the-list-stays-sorted-which-is the suite list is sorted in C order, so two new suites land in different places 15;16;17;18;19 never - +harness_selftest 070-and-comm-s-two-inputs-must a file that uses comm pins the collation of every sort feeding it 15;16;17;18;19 never - +harness_selftest 070-and-comm-s-two-inputs-must and a prefix of a registered name is not treated as registered 15;16;17;18;19 never - +harness_selftest 070-and-comm-s-two-inputs-must every registered suite has a file 15;16;17;18;19 never - +harness_selftest 070-and-comm-s-two-inputs-must every suite is registered in run_all_versions.sh 15;16;17;18;19 never - +harness_selftest 070-and-comm-s-two-inputs-must negative control: and does not find one that is not 15;16;17;18;19 never - +harness_selftest 070-and-comm-s-two-inputs-must positive control: the membership test finds a name that is registered 15;16;17;18;19 never - +harness_selftest 070-and-comm-s-two-inputs-must premise: some suite still uses comm, or the check below is vacuous 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string a comment ending in a pipe is not a producer 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string a comment naming a TERMINATED tag still opens no heredoc, so the lines below it are seen 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string a comment naming a heredoc exempts nothing, so the line below it is still seen 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string an opener on a line of CODE with no terminator exempts nothing either 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string an opener with no terminator exempts nothing 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string and a pipeline split BEFORE the pipe, with the operator at column 1 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string and an indented split is reported twice, at the reader and at the producer 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string and bench/ was in the scan, which is the hole this rule had 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string and does not cover the live one above it 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string and it follows the pipe across blank and comment lines 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string and reports it at the PRODUCER's line, which is the line that has to change 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string and selftest/ was in the scan, which is the hole that reddened #923 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string and the heredoc exemption covers the one inside the heredoc, not the other 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string and the planted violation in that file is found by the pattern 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string and the scan examined the suites rather than finding nothing to read 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string and the sweep counts it once, because a hit is keyed on file:line 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string control: a real heredoc, opened in code and terminated, still exempts its body 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string control: piping a large string into grep -q reports a match as absent 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string no suite pipes a captured string into an early-exit reader 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: and bash agrees -- with no command to continue, the reader alone will not parse 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: and bash runs that file as one assignment -- no reader, no output, rc 0 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: and its second line really does hold the reader it must not flag 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: and that body line is the one the pattern would otherwise flag 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: and the exemption covers a minority of them, not the corpus 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: and the line below it is what the pattern would flag 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: and the line really does hold the reader it must not flag 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: and the old echo/printf pattern did NOT catch it 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: and the physical-line pattern alone saw neither of those two 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: and the violation between that comment and its tag is what the pattern would flag 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: and without -H it reports a line number where the key wants a path 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: bash joins a pipeline across blank and comment lines, which is why the joiner must 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: indent that same reader by a tab and the physical-line pattern sees it unaided 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: no backslash continuation is followed by a blank or a comment 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: no line opens a heredoc AND continues, which is what lets the joiner ignore bodies 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: that shape matches in both streams at one line, which is what the key is for 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: the candidate is on a line of code, not a comment 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: the continuation detector found continuations to classify 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: the file the old filename exclusion named holds no reader to exclude 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: the fixture really has two backslash continuations to classify 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: the fixture really has two heredoc openers for the detector to see 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: the heredoc exemption found heredoc lines to exempt 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: the joiner joined continuations, so the sweep is not still line-oriented 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: the opener detector found heredocs to classify 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: the physical stream names the file even when it reads only one of them 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string premise: the sweep read lines to classify 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string the continuing-opener detector finds an opener that ends in a pipe, and one that ends in a backslash 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string the gap detector finds a continuation followed by a comment, and one followed by a blank 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string the join CREATES a hit on a two-line quoted string, the sweep's one false positive 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string the joiner does not mistake a two-line || fallback for a split pipeline 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string the sweep catches a producer that is neither echo nor printf 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string the sweep does not mistake the || operator for a pipe 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string the sweep sees a pipeline split AFTER the pipe, which all six live sites were 15;16;17;18;19 never - +harness_selftest 080-no-suite-pipes-a-captured-string the sweep's pattern sees both lines of the probe 15;16;17;18;19 never - +harness_selftest 090-no-suite-hands-every-run-the no suite hands every run the same default port 15;16;17;18;19 never - +harness_selftest 090-no-suite-hands-every-run-the no test picks a port from inside the ephemeral range 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check compares two empty strings and passes, which is why the rest exist 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_num accepts a decimal and a sign 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_num refuses a psql error message 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_num refuses an md5, which is why check_text exists 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_num refuses the word a yes/no check would produce 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_num refuses two empty strings 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_num still compares two real numbers 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_num still fails two unequal numbers 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_ratio fails a ratio outside its bound 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_ratio passes a ratio inside its bound 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_ratio refuses a zero denominator rather than dividing by it 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_ratio refuses a zero numerator, which is inside every bound 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_ratio refuses an empty measurement 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_text compares two md5 hashes, which check_num cannot 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_text refuses one empty side 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_text refuses two empty strings, where plain check passes 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty check_text still fails two different strings 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty pgc_require_tools fails on one that does not 15;16;17;18;19 never - +harness_selftest 100-the-assertions-that-refuse-an-empty pgc_require_tools passes on tools that exist 15;16;17;18;19 never - +harness_selftest 110-the-harness-must-say-which-binary pgc_setup reports the installed .so 15;16;17;18;19 never - +harness_selftest 110-the-harness-must-say-which-binary the installed .so is the one this run built 15;16;17;18;19 never - +harness_selftest 120-a-failing-suite-must-surface-the a failing suite names the first fatal event in its log 15;16;17;18;19 never - +harness_selftest 120-a-failing-suite-must-surface-the premise: the 40-line tail is filler, not the marker 15;16;17;18;19 never - +harness_selftest 120-a-failing-suite-must-surface-the premise: the sub-suite failed, so its summary ran 15;16;17;18;19 never - +harness_selftest 130-the-sanitizer-subset-must-cover-the premise: at least one suite drives the C-level encoding selftest 15;16;17;18;19 never - +harness_selftest 130-the-sanitizer-subset-must-cover-the premise: run_san.sh's default subset was found and is non-empty 15;16;17;18;19 never - +harness_selftest 130-the-sanitizer-subset-must-cover-the the sanitizer subset runs every suite that drives the encoding selftest 15;16;17;18;19 never - +harness_selftest 140-a-cluster-that-will-not-start and still matches a PANIC 15;16;17;18;19 never - +harness_selftest 140-a-cluster-that-will-not-start and still matches a signal death 15;16;17;18;19 never - +harness_selftest 140-a-cluster-that-will-not-start and still matches an AddressSanitizer report 15;16;17;18;19 never - +harness_selftest 140-a-cluster-that-will-not-start but not a routine statement error 15;16;17;18;19 never - +harness_selftest 140-a-cluster-that-will-not-start nor an ordinary log line 15;16;17;18;19 never - +harness_selftest 140-a-cluster-that-will-not-start premise: the harness exposes its fatal pattern to be judged 15;16;17;18;19 never - +harness_selftest 140-a-cluster-that-will-not-start the fatal pattern matches a library that will not load 15;16;17;18;19 never - +harness_selftest 150-the-verdict-must-not-assert-a a mixed run reports both causes and neither as the whole story 15;16;17;18;19 never - +harness_selftest 150-the-verdict-must-not-assert-a and is NOT made when our own postmaster died, which is the #537 case 15;16;17;18;19 never - +harness_selftest 150-the-verdict-must-not-assert-a and so is the attempt count 15;16;17;18;19 never - +harness_selftest 150-the-verdict-must-not-assert-a and the no-squatter verdict points at the server log 15;16;17;18;19 never - +harness_selftest 150-the-verdict-must-not-assert-a premise: the verdict is composed somewhere it can be judged 15;16;17;18;19 never - +harness_selftest 150-the-verdict-must-not-assert-a the ownership claim is made when a squatter held the port every time 15;16;17;18;19 never - +harness_selftest 150-the-verdict-must-not-assert-a the port is named either way 15;16;17;18;19 never - +harness_selftest 160-and-the-log-report-must-show and a log with no fatal line still reports rather than staying silent 15;16;17;18;19 never - +harness_selftest 160-and-the-log-report-must-show premise: the log report is a function that can be fed a fixture 15;16;17;18;19 never - +harness_selftest 160-and-the-log-report-must-show the report names the symbol that was actually missing 15;16;17;18;19 never - +harness_selftest 170-and-lib-sh-must-ask-these and asks pgc_start_failure_message for the verdict 15;16;17;18;19 never - +harness_selftest 170-and-lib-sh-must-ask-these and the old start-failure verdict is not echoed inline anywhere 15;16;17;18;19 never - +harness_selftest 170-and-lib-sh-must-ask-these and the start path asks pgc_start_fatal_pattern, its deliberately wider one 15;16;17;18;19 never - +harness_selftest 170-and-lib-sh-must-ask-these premise: lib.sh is readable, or every grep below approves nothing 15;16;17;18;19 never - +harness_selftest 170-and-lib-sh-must-ask-these premise: the start-failure path still exists to be judged 15;16;17;18;19 never - +harness_selftest 170-and-lib-sh-must-ask-these the failure path asks pgc_start_log_report for the reason 15;16;17;18;19 never - +harness_selftest 170-and-lib-sh-must-ask-these the summary path asks pgc_fatal_pattern rather than hardcoding it 15;16;17;18;19 never - +harness_selftest 180-the-port-walk-must-wrap-not a free port beyond the old 300-probe bound is still found 15;16;17;18;19 never - +harness_selftest 180-the-port-walk-must-wrap-not a seed at the ceiling wraps past a busy top and still finds a port 15;16;17;18;19 never - +harness_selftest 180-the-port-walk-must-wrap-not an entirely busy band reports itself full and terminates 15;16;17;18;19 never - +harness_selftest 180-the-port-walk-must-wrap-not and the port it found is below the busy region, which is where wrapping lands 15;16;17;18;19 never - +harness_selftest 180-the-port-walk-must-wrap-not premise: and really does allow the bottom 15;16;17;18;19 never - +harness_selftest 180-the-port-walk-must-wrap-not premise: the auxiliary band has a width to wrap within 15;16;17;18;19 never - +harness_selftest 180-the-port-walk-must-wrap-not premise: the real prober was restored, or every check after this lies 15;16;17;18;19 never - +harness_selftest 180-the-port-walk-must-wrap-not premise: the stub frees exactly one port, 500 past the floor 15;16;17;18;19 never - +harness_selftest 180-the-port-walk-must-wrap-not premise: the stub really does refuse the top of the band 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not an unknown provenance is not reported as a major 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not an unparseable stamp cleans rather than guessing 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not and an empty WANT is refused rather than compared 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not and in the other direction too 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not and it is 3 bytes, not an escaped literal 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not and it says plainly that no major was recorded 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not building a DIFFERENT major needs a clean, which is the #536 case 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not building the same major again needs no clean 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not but a tree with no objects at all needs nothing, stamp or not 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not objects with NO stamp are unknown provenance and must be cleaned 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not premise: the build-stamp decision is exposed to be judged 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not premise: the stamp writer is a function that can be exercised 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not the build path asks pgc_build_needs_clean rather than merely naming it 15;16;17;18;19 never - +harness_selftest 190-an-in-tree-build-must-not the stamp lib.sh writes is exactly the major 15;16;17;18;19 never - +harness_selftest 200-additions-go-in-their-own-file premise: the parts directory exists and was sourced 15;16;17;18;19 never - +harness_selftest 200-additions-go-in-their-own-file the driver holds no checks; they all live in parts 15;16;17;18;19 never - +harness_selftest 200-additions-go-in-their-own-file the driver sources the parts by glob, not by a list 15;16;17;18;19 never - +harness_selftest 210-no-suite-assigns-a-bash-special control: reads, longer names, and the deliberate RANDOM/SECONDS seeds are not flagged 15;16;17;18;19 never - +harness_selftest 210-no-suite-assigns-a-bash-special control: the sweep catches an assignment to a bash special 15;16;17;18;19 never - +harness_selftest 210-no-suite-assigns-a-bash-special no suite assigns to a bash special variable 15;16;17;18;19 never - +harness_selftest 220-an-opt-in-upgrade-guard-must CI runs the extension-upgrade guard somewhere (#741) 15;16;17;18;19 never - +harness_selftest 220-an-opt-in-upgrade-guard-must every PGC_RUN_UPGRADE-gated suite is excluded from the coverage runner (#741) 15;16;17;18;19 never - +harness_selftest 220-an-opt-in-upgrade-guard-must premise: both not_a_suite definitions were found 15;16;17;18;19 never - +harness_selftest 220-an-opt-in-upgrade-guard-must premise: not_a_suite says no to an ordinary suite, so its yes means something 15;16;17;18;19 never - +harness_selftest 220-an-opt-in-upgrade-guard-must premise: run_coverage.sh defines not_a_suite and calls it 15;16;17;18;19 never - +harness_selftest 220-an-opt-in-upgrade-guard-must premise: the PGC_RUN_UPGRADE block was found and names at least one suite 15;16;17;18;19 never - +harness_selftest 220-an-opt-in-upgrade-guard-must premise: the population is the real test directory, not an empty glob 15;16;17;18;19 never - +harness_selftest 220-an-opt-in-upgrade-guard-must premise: there are workflow files to search 15;16;17;18;19 never - +harness_selftest 220-an-opt-in-upgrade-guard-must the coverage runner's not_a_suite agrees with the selftest's, both ways (#741) 15;16;17;18;19 never - +harness_selftest 230-a-suite-connecting-by-socket-must every suite that connects by socket path sets unix_socket_directories 15;16;17;18;19 never - +harness_selftest 230-a-suite-connecting-by-socket-must premise: at least one suite connects by a socket path, so this is not vacuous 15;16;17;18;19 never - +harness_selftest 230-a-suite-connecting-by-socket-must premise: no TCP suite is counted as a socket user 15;16;17;18;19 never - +harness_selftest 240-the-nightly-enumeration-must-not every nightly job is named in docs/testing.md (#741) 15;16;17;18;19 never - +harness_selftest 240-the-nightly-enumeration-must-not premise: at least three nightly jobs were parsed, so the list is real 15;16;17;18;19 never - +harness_selftest 240-the-nightly-enumeration-must-not premise: the nightly paragraph was located and is not empty 15;16;17;18;19 never - +harness_selftest 240-the-nightly-enumeration-must-not premise: the nightly workflow and the testing doc are both present 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse GCOV_PREFIX is exported before the suites run (#740) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse a file at 100% reads 100.0%, not a small number (#974) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse a row with absent counters never reads as 0.0% (#974) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse an absent counter prints a dash instead (#974) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse and no lcov --list call survives in the runner (#974) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse and the function rate is computed too, not copied (#974) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse premise: both stray-counter probes were located 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse premise: both the counter refusal and the lcov capture were located 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse premise: stripping comments leaves the runner's code behind 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse premise: the containment and the copy were both located 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse premise: the coverage runner is present and parses 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse premise: the generator produced a row for each of the three files 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse premise: the guard's count directory and the capture's were both located 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse premise: the redirect, the suite invocation and the copy-back were located 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse premise: the table generator is present and parses 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse the copy-back refuses a destination outside the tree (#740) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse the counters are returned beside their objects before the refusal (#740) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse the coverage runner computes the table instead of parsing lcov --list (#974) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse the coverage runner refuses zero counters before it calls lcov (#740) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse the least covered file sorts first (#974) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse the rate carries hit/found so a reader can check it (#974) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse the refusal looks in GCOV_PREFIX before the tree-wide walk (#740) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse the zero-counter guard counts the directory lcov captures (#740) 15;16;17;18;19 never - +harness_selftest 250-the-coverage-runner-must-refuse while the lcov --summary call stays, being correct on both builds (#974) 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the and it is the same suites, not merely the same count 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the every diff_query_ordered site actually names an ORDER BY 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the every suite using the ordered oracle asserts its premise 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the no diff_query site names an ORDER BY it cannot test (use diff_query_ordered) 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the premise: both comparison helpers are present 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the premise: both oracles are present 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the premise: some suite uses the ordered oracle, or the next check is vacuous 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the premise: the tree really contains continued diff_query calls to join 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the sorted_projection's two comparisons are ordered, its subject being order 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the the ordered oracle keeps the empty-result sentinel 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the the ordered oracle keeps the unique query-error sentinel 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the the ordered oracle numbers the rows as they arrive 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the the ordered oracle orders by row_number, so it keeps the query's order 15;16;17;18;19 never - +harness_selftest 260-an-ordered-comparison-must-use-the the set oracle orders by the rendered row, so it is order-blind 15;16;17;18;19 never - +harness_selftest 270-a-set-options-call-must-use-values no suite calls set_options with a value it will reject 15;16;17;18;19 never - +harness_selftest 270-a-set-options-call-must-use-values premise: and does NOT fire when the error is the point, across a continuation 15;16;17;18;19 never - +harness_selftest 270-a-set-options-call-must-use-values premise: every file containing a set_options call is in the sweep 15;16;17;18;19 never - +harness_selftest 270-a-set-options-call-must-use-values premise: the detector fires on an out-of-range value that is NOT expect_error 15;16;17;18;19 never - +harness_selftest 270-a-set-options-call-must-use-values premise: the set_options sweep read a substantial number of calls 15;16;17;18;19 never - +harness_selftest 280-the-shared-cluster-config-must-not premise: and it is the right block (it sets the port and the preload) 15;16;17;18;19 never - +harness_selftest 280-the-shared-cluster-config-must-not premise: the cluster-config block was located in lib.sh 15;16;17;18;19 never - +harness_selftest 280-the-shared-cluster-config-must-not premise: the detector fires on the line that caused #799 15;16;17;18;19 never - +harness_selftest 280-the-shared-cluster-config-must-not the per-suite escape hatch PGC_EXTRA_CONF is still applied to the config 15;16;17;18;19 never - +harness_selftest 280-the-shared-cluster-config-must-not the shared cluster config sets no pgcolumnar.* GUC 15;16;17;18;19 never - +harness_selftest 290-a-preflight-that-built-nothing a preflight that built nothing does not report PASSED 15;16;17;18;19 never - +harness_selftest 290-a-preflight-that-built-nothing a preflight that built nothing exits non-zero 15;16;17;18;19 never - +harness_selftest 290-a-preflight-that-built-nothing a preflight that built nothing says how many it built 15;16;17;18;19 never - +harness_selftest 290-a-preflight-that-built-nothing premise: and it built none of them 15;16;17;18;19 never - +harness_selftest 290-a-preflight-that-built-nothing premise: the probe run skipped every major 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable and every executable script declares one 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable and every script a document names exists 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable and every script a document names is executable 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable control: an interpreter declared without the bit is caught 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable control: and a sourced fragment, with neither, is correct 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable control: and the same file with the bit is not 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable control: cp -a preserves the execute bit, so a staged tree reads the same 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable control: the bit without an interpreter is caught too 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable every script that declares an interpreter is executable 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable premise: a runnable script one level down is inside the population 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable premise: and bench/ is in the population 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable premise: and so are the fixture host tools 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable premise: and they name at least one command in every swept directory 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable premise: the documents name a population of commands, not none 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable premise: the sourced parts are inside the population, not pruned 15;16;17;18;19 never - +harness_selftest 300-a-test-script-must-be-runnable premise: the sweep reads a population of scripts, not an empty find 15;16;17;18;19 never - +harness_selftest 310-a-compiled-artifact-must-not-be and a compiled artifact written beside its source 15;16;17;18;19 never - +harness_selftest 310-a-compiled-artifact-must-not-be and the tracked BUNDLE list names none of them 15;16;17;18;19 never - +harness_selftest 310-a-compiled-artifact-must-not-be and the tracked list names none of them 15;16;17;18;19 never - +harness_selftest 310-a-compiled-artifact-must-not-be and the tree ignores a git bundle, so the next add cannot re-add it 15;16;17;18;19 never - +harness_selftest 310-a-compiled-artifact-must-not-be and the tree ignores the directory Python writes them to 15;16;17;18;19 never - +harness_selftest 310-a-compiled-artifact-must-not-be control: a source file named like a bundle is not ignored 15;16;17;18;19 never - +harness_selftest 310-a-compiled-artifact-must-not-be no compiled Python artifact is tracked 15;16;17;18;19 never - +harness_selftest 310-a-compiled-artifact-must-not-be no git bundle is tracked 15;16;17;18;19 never - +harness_selftest 310-a-compiled-artifact-must-not-be premise: and git ls-files sees the harness it is being asked about 15;16;17;18;19 never - +harness_selftest 310-a-compiled-artifact-must-not-be premise: and that a tracked source file is not 15;16;17;18;19 never - +harness_selftest 310-a-compiled-artifact-must-not-be premise: check-ignore agrees a build object is already ignored 15;16;17;18;19 never - +harness_selftest 310-a-compiled-artifact-must-not-be premise: the source tree is a git checkout 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run 67 without its line is a failure, not an INCOMPLETE taken on trust 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run a counter that drifts is caught rather than absorbed 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run a failure outranks an unrunnable check, and both are still counted 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run a passing ratio check is counted as a pass, not a failure 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run a suite of nothing but unrunnable checks is INCOMPLETE, not SKIPPED 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run a suite whose checks all passed still exits 0 PASSED 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run a suite with none says so as zero rather than staying silent 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run an INCOMPLETE suite fails its major 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run an unrunnable check counts toward checks run 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run an unrunnable reason outside the enum fails rather than being accepted 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and 66 with its line a skip 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and 67 with its line INCOMPLETE, which is not a pass 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and a failing suite still does 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and a skip does not, which is the one that must stay true 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and a suite with no unrunnable checks reconciles too 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and allows one that does, which is what it was written to allow 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and an ordinary failure is still a failure 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and both exempt a file that keeps its own counter without lib.sh 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and it is not reported as having run no checks 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and no write-only failure flag survives in the runner 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and the suite holding it fails rather than reporting PASSED 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and the suite that holds it still passes 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run and the unrunnable ones are reported as their own count 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run every direct write to PGC_CHECKS records an outcome too 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run lib.sh defines check_unrunnable 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run lib.sh defines the INCOMPLETE exit status 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run no non-zero status is classified as a pass 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run no suite that uses lib.sh's accounting writes PGC_CHECKS directly 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run one unrunnable check makes the suite INCOMPLETE, not passed 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run premise: the classifier evalled out of the runner is callable 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run premise: the fixtures carry the shapes these rules are about 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run premise: the harness library is where this part thinks it is 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run premise: the major-verdict mapping evalled out of the runner is callable 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run premise: the runner defines the classifier this part is about to eval 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run premise: the sweep read the corpus and found sites to classify 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run the original rule flags a bump that records no outcome 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run the runner calls a clean exit a pass 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run the runner's INCOMPLETE branch calls the mapping rather than a local flag 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run the stronger rule flags that same allowed bump, which is the change 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run the summary reconciles the three states against the total 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run the unrunnable check names itself, its reason code and its detail 15;16;17;18;19 never - +harness_selftest 320-a-check-that-could-not-run while a pass does not 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole a suite with an unrunnable check exits 67 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole an INCOMPLETE suite sets the flag the major verdict actually reads 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and appears in the results string as INCOMPLETE 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and counted as incomplete, so the tally can say so 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and counts both suites as having run 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and exactly one of them as incomplete 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and is counted as having run 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and is not counted as skipped, nor is the skip count disturbed 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and its log carries the INCOMPLETE line the classifier needs 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and neither as skipped 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and no longer counts incompletes inline beside it 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and records each suite's own verdict in the results string 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and reprints the suite's own UNRUN line beneath it 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and the UNRUN line the runner prints into the matrix output 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and the run's overall status is failure 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and the summary line carries the incomplete count a reader needs 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole and the tally announces it, with the reason lifted from the log 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole control fixture: a suite whose checks all ran exits 0 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole control: and leaves the run's overall status alone 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole control: and still announces it 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole control: and still records that it ran, and how 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole control: and the major reports PASS 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole control: the same loop leaves a passing suite passing 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole every function the collect loop calls is defined here 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole premise: all five runner functions were extracted, not empty ranges 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole premise: and all five are callable 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole premise: and each extraction ends at its own closing brace 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole premise: the major-verdict branch was extracted, not an empty range 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole premise: the runner's collect loop was extracted, not an empty range 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole premise: the selftest has a workdir to build fixtures in 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole premise: the sweep found the loop's callers to check 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole running the real loop over both fixtures fails the major 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole the loop delegates each verdict to pgc_tally_suite 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole the runner classifies the file that suite actually produced 15;16;17;18;19 never - +harness_selftest 330-the-incomplete-path-must-run-whole with an incomplete suite in the tally the major reports FAIL 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from PREMISE and the target really holds sources find would otherwise hash 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from PREMISE the Makefile's recursion was actually parsed 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from PREMISE the copy discovers the same build directories as the real tree 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from PREMISE the fingerprint covers at least src 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from PREMISE the fixture's src really is a symlink 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a /./ segment hashes the same tree the same way 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a /src/.. segment hashes the same tree the same way 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a caller passing a major is caught 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a file that is not a build input does not move it 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a fingerprint different from the record is stale 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a fingerprint equal to the record is fresh 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a fingerprint is 12 hex characters 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a library newer than the running server is REFUSED 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a library older than the running server is accepted 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a missing binary timestamp is unknown, not predates 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a missing postmaster timestamp is unknown, not predates 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a new source file under objstore moves the fingerprint 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a one-line stamp yields its source fingerprint 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a recorded digest different from the installed one is replaced, not fresh 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a recorded library digest equal to the installed one is fresh 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a relative path hashes the same tree the same way 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a server older than the binary predates it 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a server started after the binary is fresh 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a server started at the same second is fresh 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a stale source is refused whatever the binary says 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a symlink to the tree hashes it the same way 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a symlinked src contributes nothing, as find -P contributes nothing 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a trailing slash hashes the same tree the same way 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a tree with no hashable file yields no fingerprint 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from a two-line stamp still yields the source fingerprint first 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from adding a source file moves it 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from an added file appears in the manifest by name 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from an added file shows up in the report 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from an empty manifest is reported as empty, not as silence 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from an unfingerprintable source reads as empty, not as the library digest 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from an unhashable tree has an empty manifest 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from an unreadable b.c yields no fingerprint, not a wrong one 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from an unreadable c.c yields no fingerprint, not a wrong one 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from an unreadable library is not a failure 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and a non-numeric timestamp is unknown rather than compared as text 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and a short first line does not splice the second into it 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and a stale source with a replaced binary is still refused for the source 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and an uncomputable current fingerprint is unknown, not stale 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and an unreadable installed library is unknown, not replaced 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and comparing two manifests names it rather than saying 'changed' 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and it says so rather than staying silent 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and removing it restores the fingerprint 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and restoring it restores the fingerprint 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and restoring the partition restores the fingerprint 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and the major is still readable in the name 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and the reader reads back the fingerprint the writer recorded 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and the refusal says the server must be restarted 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and two pg_configs for one prefix share a stamp, keyed on pkglibdir 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and yields NO library digest, rather than reusing the source hash 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from and yields the library digest second 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from but it says which question went unanswered 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from control: a caller passing a pg_config is not flagged 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from control: a readable run still reads fresh 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from control: a real content change still moves the fingerprint 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from control: a real src directory is still hashed 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from control: and it still succeeds on a writable one 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from control: and restoring the content restores the fingerprint 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from control: and the tree fingerprints again once it is readable 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from control: the same pg_config twice gives the same path 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from control: writing the value it was given 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from each manifest line is a tree-relative path and a digest 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from editing a source file moves the fingerprint 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from every directory the Makefile builds from is in the fingerprint 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from moving bytes between files moves the fingerprint 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from no caller passes a major where a pg_config belongs 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from no record at all is unknown, not fresh 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from no recorded digest is unknown, not fresh 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from no source record is unverified, not verified 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from one tree, one fingerprint, whatever the locale 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: and the stamp really was not written, so the arm is not vacuous 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: at least two locales are installed to compare 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: both fake configs report the same major, which is the whole point 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: every locale produced a fingerprint 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: the argument parser reads the second argument at all 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: the build path ran to completion, so a stamp was due 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: the partition fixture fingerprints at all 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: the same function returns a fingerprint for a real tree 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: the spelling fixture fingerprints at all 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: the sweep finds the call sites it is meant to police 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: the tree fingerprints to something when it is readable 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: the unprivileged read agrees while everything is readable 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: the unprivileged reader can source the staged harness 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from premise: the writer wrote a stamp at all 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from renaming a source file moves the fingerprint too 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from so its verdict is unknown rather than a spurious stale 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from so the tree still fingerprints from its root files alone 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from so the verdict is fresh, not unknown 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from so the verdict is unknown -- UNVERIFIED -- and never stale 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from source fresh and binary fresh is the only state that earns the claim 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from source fresh with a replaced binary is refused 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from source fresh with an unverifiable binary does not earn it 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from the fingerprint is the hash of the manifest 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from the fixed fingerprint equals what the previous implementation produced 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from the manifest is tree-relative, never absolute 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from the manifest names every file the fingerprint hashes 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from the probe is written outside the live source tree 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from the report names each hashed file 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from the report states how many files it hashed 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from the same tree fingerprints the same twice 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from the stamp writer reports failure on an unwritable target 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from the writer writes the file the reader looks for 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from two installations of one major get different stamp paths 15;16;17;18;19 never - +harness_selftest 340-the-binary-must-be-built-from two unreadable pg_configs do not alias onto one stamp 15;16;17;18;19 never - +harness_selftest 350-the-pytest-corpus-must-be and derives the pins from requirements-test.txt 15;16;17;18;19 never - +harness_selftest 350-the-pytest-corpus-must-be and it derives the file list rather than repeating it 15;16;17;18;19 never - +harness_selftest 350-the-pytest-corpus-must-be and the job asserts the driver is absent rather than assuming it 15;16;17;18;19 never - +harness_selftest 350-the-pytest-corpus-must-be premise: the CI workflow is where this part thinks it is 15;16;17;18;19 never - +harness_selftest 350-the-pytest-corpus-must-be the gate runs the harness guards 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must a drifted exit code is visible rather than absorbed 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must a drifted print shape is visible 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must a reason dropped from one side only is visible 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must premise: and that fixture is a real list rather than an empty parse 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must premise: and that fixture parses to a shape rather than to nothing 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must premise: lib.sh prints a line for an unrunnable check 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must premise: lib.sh states a closed list of unrunnable reasons 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must premise: lib.sh states an INCOMPLETE exit code this part could read 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must premise: the harness library is where this part thinks it is 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must premise: the pytest layer is where this part thinks it is 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must premise: the pytest layer prints one too 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must premise: the pytest layer states a closed list too 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must premise: the pytest layer states one too 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must the two harnesses agree on the INCOMPLETE exit code 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must the two harnesses agree on the closed list of unrunnable reasons 15;16;17;18;19 never - +harness_selftest 360-an-unrunnable-pytest-test-must the two harnesses print an unrunnable check in the same shape 15;16;17;18;19 never - +harness_selftest 380-the-pytest-cluster-helpers a caller that reimplements the digest is caught 15;16;17;18;19 never - +harness_selftest 380-the-pytest-cluster-helpers a fingerprint that reads src only is caught 15;16;17;18;19 never - +harness_selftest 380-the-pytest-cluster-helpers an import from the pytest tree is caught 15;16;17;18;19 never - +harness_selftest 380-the-pytest-cluster-helpers and a hard-coded module list is caught by the name arm 15;16;17;18;19 never - +harness_selftest 380-the-pytest-cluster-helpers and it names no module directory, so it is a derivation and not a list 15;16;17;18;19 never - +harness_selftest 380-the-pytest-cluster-helpers and no longer mixes in the bare filename 15;16;17;18;19 never - +harness_selftest 380-the-pytest-cluster-helpers and the shell keeps none either 15;16;17;18;19 never - +harness_selftest 380-the-pytest-cluster-helpers premise: the one fingerprint implementation is where this part thinks it is 15;16;17;18;19 never - +harness_selftest 380-the-pytest-cluster-helpers premise: while the real module satisfies the derivation arm 15;16;17;18;19 never - +harness_selftest 380-the-pytest-cluster-helpers the fingerprint derives its build directories from a Makefile on disk 15;16;17;18;19 never - +harness_selftest 380-the-pytest-cluster-helpers the hash mixes in each file's path relative to the tree, not its name 15;16;17;18;19 never - +harness_selftest 380-the-pytest-cluster-helpers the module imports nothing from the pytest tree 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a NEW unaccounted suite fails even while the known debt is excused 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a comment mentioning pgc_summary is not a declaration 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a declared suite that produced no accounting is caught 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a declared suite the driver never dispatched reconciles 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a file that does not exist is reported absent, not exempt 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a hash inside a word does not hide the call after it 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a log carrying lib.sh's accounting line is accounted 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a log carrying neither is not accounted 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a log claiming PASSED without the accounting line shows none 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a long suite that calls pgc_summary still declares accounting 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a longer name containing pgc_summary is not a declaration 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a passing log shows accounting 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a registered suite that is accounted by nothing FAILS 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a suite recorded as known debt passes 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a suite recorded as never dispatched that DID account is caught 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a suite that accounted passes 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a suite that calls pgc_summary declares accounting 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a suite that never calls it does not 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a suite that now accounts but is still listed as debt is reported 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a suite the driver never dispatched passes 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account a trailing comment after the call does not hide it 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account an absent log shows no accounting rather than erroring 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account an accounting line that does not start its line is refused 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account an indented comment is still a comment 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account an undeclared suite that DID account is caught too 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and a failed population reconciliation fails the major 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and a failed reconciliation sets the per-major failure flag 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and a log carrying only its OWN checks-run line is accounted too 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and a reworded producer line is refused, so the arm can fail 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and a skip, which reached the summary and counted zero 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and absent is distinguishable from a present file that does not declare 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and an incomplete 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and debt naming a suite that is not registered is reported too 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and it agrees with the real reader on a SHORT file, which is why it survived review 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and it is NAMED, so the reader does not have to diff two lists 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and it is named as that fault, not as one of the other two 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and it is named as the opposite fault, not the same one 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and it is named, which the symmetry check could never do 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and names nothing when the two readers agree 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and prose containing the word does not count as the line 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and so does a failing one, which is the point 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and sorts its inputs, because the runner appends them in SUITES order 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and the excused one is not named as a failure 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and the population reconciliation counts that same file 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and the reader answers no on it, which is the wrong answer the arm catches 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and the real function reconciles the same input, so the arm is not noise 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and the reconciliation is given that record 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and the registered file is written from the SUITES array itself 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account and without that record the same run is still caught 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account equal sets reconcile 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account every registered suite has a file 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account nor no for every one of them 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account opposite errors do not cancel: both directions are reported 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: a lib.sh accounting line is seen by the narrow reader 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: a private tally is NOT seen by the narrow reader 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: and a log with neither is seen by neither 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: and produced exactly one accounting line to be read 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: and so is the wide reader it is paired with 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: and that count excludes the definition line, which mentions it 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: and the accounted reader that feeds it 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: and the narrow count is still printed, as the lib.sh half 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: and the real function still does 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: but IS seen by the wide one, which is where the 2 came from 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: it is callable 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: pipefail is on, which is the condition the bug needs 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the declaration reader evalled out of the runner is callable 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the drift changed the line the reader looks for 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the fixture carries a well-formed accounting line, just indented 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the fixture is long enough to lose the race 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the fixture really does hide its call from the stripper 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the mutation applied -- the twin no longer sorts its inputs 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the observation reader evalled out of the runner is callable 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the population reconciliation is callable 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the real suite ran and reached its summary 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the reconciliation evalled out of the runner is callable 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the registered list is not empty, so the partition means something 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the runner defines the declaration reader this part evals 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the runner defines the observation reader this part evals 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the runner defines the own-mechanism difference this part evals 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the runner defines the population reconciliation 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the runner defines the reconciliation this part evals 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the twin script was written and is runnable 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account premise: the unsorted twin is callable 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the breakdown headline counts the wide set, not the narrow one 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the debt file is in the tree 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the grep -q shape is the one that gets this wrong under pipefail 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the identity catches comm reading unsorted input 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the own-mechanism difference names the suite the readers disagree about 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the partition over the real suite list adds up 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the population partitions, and prints inputs == sum(buckets) 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the reader accepts the line the producer actually emits 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the reader does not answer yes for every registered suite 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the reconciliation prints inputs == sum(buckets) 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the record cannot introduce a suite the source never declared 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the runner calls the population reconciliation 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the runner calls the reconciliation, not merely defines it 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the skip branch records the suite it did not dispatch 15;16;17;18;19 never - +harness_selftest 390-a-registered-suite-must-account the stripper hides no pgc_summary call in any registered suite 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a bogus reason code records FAIL, not UNRUN 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a failing check emits exactly one record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a failing check still prints its old line 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a log that never stated a count is not silently accepted 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a log whose records match its stated count reconciles 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a log with fewer records than it claims is caught 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a log with more records than it claims is caught too 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a passing check emits exactly one record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a passing check still prints its old line 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a record carrying extra fields does not reconcile 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a record missing fields does not reconcile 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a skipped ratio check emits exactly one record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a skipped timing check emits exactly one record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a suite that skipped every check did not pass 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine a verdict pgc_record cannot emit does not reconcile 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine an empty check name does not reconcile 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine an unrunnable check emits exactly one record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine an unrunnable check still prints its old line 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and a different major reaches the same field, so it is read not hardcoded 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and a harness that set no major says unknown rather than an empty field 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and it is counted 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and it is counted, so checks run: reports it 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and its major field carries the server major it ran under 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and its name field is the check's name, spaces intact 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and its verdict field says FAIL 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and its verdict field says PASS 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and its verdict field says UNRUN, which is neither of the other two 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and leaves one whose variable is assigned earlier 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and leaves one whose variable is the loop it sits in 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and names its own cause instead 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and not a check after a one-line piped loop that already closed 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and not a piped loop with no check in it 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and not one inside a process-substitution loop, which keeps its shell 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and records FAIL 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and records FAIL, because nothing was compared 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and records PASS when the ratio is inside the bound 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and still reports the two numbers 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and that place is pgc_record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and the REASON_CODE travels in the reason field, not in prose 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and the ratio check is counted as a pass, not a skip 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and the ratio check's human line is unchanged 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and the ratio check's verdict is SKIP 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and the reason still follows the major, so nothing shifted onto it 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and the timing check is counted as a pass, not a skip 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and the timing check's human line is unchanged 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and the timing check's verdict is SKIP 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and the two numbers are named, not just the verdict 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine and with timing enabled the skipped term is zero, not absent 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine check_num on a non-number emits one record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine check_num's non-measurement line is unchanged 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine check_ratio on a non-number emits one record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine check_ratio that forms a ratio emits one record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine check_ratio with a zero side emits one record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine check_text on an empty side emits one record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine check_text's empty-side line is unchanged 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine control: a well-formed record still reconciles 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine control: unknown IS a major the reconciler accepts, or the four above prove nothing 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine fewer records than counted checks is not described as a subshell 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine lib.sh bumps PGC_CHECKS in exactly one place 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine more records than counted checks names the cause, not just the arithmetic 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine no check_skip reads a name its own file never assigns 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine no file that calls check prints a SKIP outcome the count cannot see 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine no suite calls a check inside a piped loop 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine pgc_fail emits one record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine pgc_pass emits one record 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine premise: and it would name a file that calls check and echoes a SKIP 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine premise: and that is this fragment, not the suite 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine premise: it is callable 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine premise: it names a check_skip reading an unassigned variable 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine premise: lib.sh is where the check helpers live 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine premise: the fixtures carry the shapes this sweep is about 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine premise: the probe ran every helper shape once 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine premise: the sweep classified a corpus of check-calling files 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine premise: while a file that calls no check is not its business 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the accounting line reconciles four outcomes against the count 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the major [18.2] is not a major, so that record does not reconcile 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the major [] is not a major, so that record does not reconcile 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the major [eighteen] is not a major, so that record does not reconcile 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the major [pg18] is not a major, so that record does not reconcile 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the reconciliation accepts the verdict FAIL, which pgc_record emits 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the reconciliation accepts the verdict PASS, which pgc_record emits 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the reconciliation accepts the verdict SKIP, which pgc_record emits 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the reconciliation accepts the verdict UNRUN, which pgc_record emits 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the record count equals the counter the summary reports 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the record names the part the check was asked from 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the runner calls the record reconciliation, not merely defines it 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the runner defines the record reconciliation 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the same ratio check, ENABLED, emits one record and passes 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the same timing check, ENABLED, emits one record and passes 15;16;17;18;19 never - +harness_selftest 400-a-check-result-must-be-machine the sweep finds a check inside a PIPED loop 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red --mutation across two failing checks in one run is refused 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red --prune REFUSES the whole prune when any orphan carries history 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red --prune removes NOTHING from a part that skipped 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red --prune removes a historyless orphan and says which 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a PG15 run names no orphan, having seen every check the ledger claims for 15 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a before-log and an after-log together are refused, as rename-scan refuses them 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a before-log and an after-log together are refused, not silently empty 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a budget stating no census is not refused, because absence is not a contradiction 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a budget that does not exist at the prior is a note, not a refusal 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a census that matches the ledger passes 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a census that overstates the ledger is refused too, because this is not a ceiling 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a census that understates the ledger is refused 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a check in an UNCOVERED suite is not refused 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a check merely added is not reported as a rename 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a check observed red gains the date it was seen 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a check seen once claims the one major it was seen on 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a check the ledger has never seen is refused 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a clean status says nothing and does not fail the major 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a date that is not a date is refused rather than stored 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a deliberate break says so with --mutation 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a gate over a nonexistent log is an integrity failure, not a pass 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a harness that named no major adds its own token rather than a number 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a known check on a major its row does not claim is refused, because the row is a claim 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a later green run does not erase an observation 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a ledger row naming a major that is not a major is an integrity failure 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a ledger row no record in its own part matches is named an orphan 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a log carrying a FAIL is refused when no reason is given 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a major the ledger holds no row for refuses nothing, as an uncovered suite does 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a name that appeared while another disappeared is reported as a rename 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a named mutation is recorded against the check that reddened 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a real refusal is a different status from an integrity failure 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a ref that does not resolve is an integrity failure, not a bootstrap 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a ref that exists with the budget still compares 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a ref that exists without the budget is still the bootstrap case 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a refusal keeps the regenerate-the-ledger wording 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a rename in one part survives an addition in another 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a row claiming 15;18 is an orphan on a PG18 run that did not emit it 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a row in a part that SKIPPED is reported as unprunable, not as an orphan 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a row in a part the run does not contain is not called an orphan 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a run that emits every row in its parts is clean 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a run whose checks are all ledgered passes the gate 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a second major is ADDED to the set, sorted, not written over the first 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a second mutation ACCUMULATES rather than replacing the first 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a stale prior is named WITH its distance from HEAD 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red a verdict pgc_record cannot emit is an integrity failure 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red an absolute budget path resolves against git rather than shrugging 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red an empty check name is one too, because it names no check 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red an empty log is one too, because there is nothing to reconcile 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red an integrity failure says regenerating will not help 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red an older observation does not overwrite a newer one 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red an orphan carrying history is reported as carrying it 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and --prune does NOT turn that 1 into a 0, because it pruned nothing 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and CI collects from the retained path rather than the deleted one 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and a check the second run never mentioned keeps the majors it claimed 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and a genuine observation says so with --reds-are-real 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and a level prior carries no distance, so zero is silent 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and a log that does not reconcile with its own checks run: 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and a newer one does 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and a prune with nothing left to remove is clean, not an error 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and a raise against that base ref is refused 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and a record missing its verdict 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and a row naming NO major says nothing about where its check exists 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and an empty mutation is a placeholder, not an empty last field 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and an undated merge does not erase a known date 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it copies them BEFORE removing the build directory, which is the only order that works 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it entered as debt, not as an observation nothing made 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it is REFUSED, not merely printed 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it is a different sentence from the refusal, not the same one twice 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it is named, so the author knows which one 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it is that case that says the change introduces the file 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it is the new one that is named, not the one already ledgered 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it names the verdict, so the author knows which record 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it runs before the build directory is removed, which is the only place it can 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it says so rather than declining silently 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it says the change introduces the file rather than raising anything 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it says the ref does not resolve, rather than claiming the file is new 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and it says why, rather than falling back to something weaker 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and never says a change introduces a file at a ref that is not there 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and none of them ends in a tab 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and not against one that stayed green 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and nothing is written, so a refused merge is not half-applied 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and one that stayed green keeps its debt 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and only when there is a base, so a push build does not fail on it 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and records neither as ever having been red 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and that is not a failure, because a run sees ONE major 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the PG18-only row is one it cannot speak about, not one that vanished 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the addition in the other part is not called a rename 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the census line it always printed is still there 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the comparison passes when the ceiling did not rise 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the gate prints that it compared them 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the gate says out loud that it covered no rows for that major 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the history it is about to lose travels with it 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the history it would lose is printed with it 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the ledger is one row shorter afterwards 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the message says how to fix it, because regenerating is the intended action 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the refusal names both values 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the refusal names how many failed, so the author can narrow the run 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the refusal names the check that reddened 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the refusal names the raise 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the refusal quotes the claim beside the measurement 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the runner names no remote at that call site 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the scan states how many rows it could not speak about 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red and the summary keeps the two apart, so a zero orphan count is not a clean bill 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red auto refuses when GITHUB_BASE_REF names a ref that is not here 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red auto uses the base ref when it resolves, and names it 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red auto with no base ref and no upstream is an integrity failure 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red both failure arms fail the major 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red but that suite is counted as not covered, which is the debt 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red but the gate says so, so the skip is visible rather than silent 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red control: a check the ledger claims for 15 that a PG15 run did not emit IS an orphan 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red control: a prune that leaves nothing outstanding returns 0 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red control: a well-formed log still merges 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red control: an all-PASS log still merges with no flag at all 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red control: and that one did prune, so 0 is not a refusal in disguise 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red control: and the ledger really is shorter afterwards 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red control: on a covered major a new check is named and refused 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red control: the row in the part the run never mentioned SURVIVES the prune 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red control: the same log merges with a different reason, so the refusal above is --mutation-across-two-checks and not the log 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red control: the same row with a real major is read without complaint 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red control: the same two rows ARE pruned when that part's record is a PASS 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red each says what was wrong with the input 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red every committed row has six fields 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red every row has six fields and no trailing tab 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red it is still a finding, so the scan does not return success 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red lowering it is allowed, which is the direction the burn-down goes 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red merging a green run records both checks 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red nor is one merely removed 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red once the suite is covered, a new check in it IS refused 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red one --mutation cannot be attributed across several runs at once 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: and it is a file git has never seen, which is the case that used to fail open 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: and it really pruned nothing -- the rows are all still there 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: and it reported all four of its categories, so a zero is a measurement 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: and the nobudget branch does not, which is the bootstrap shape 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: and the refusal removed NOTHING -- the row is still there 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: and the run the scan is given holds only one of them 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: and the skipped run emits exactly one of them, as a SKIP 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: and the two arms it stands in for are still named in the ledger 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: both are never, so this ledger's census is two 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: that part has rows the skipped run cannot speak for 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the budget is a tracked file too 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the budget was restored byte-exact 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the check has history before the rename 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the fixture ledger holds two rows 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the fixture log names checks the real ledger already knows 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the gate's status block was found in the runner 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the hasbudget branch carries the budget 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the ledger holds all three of that part's rows 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the ledger holds all three rows before the scan 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the ledger is not empty, so the partition means something 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the ledger itself is a tracked file, not a variable 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the ledger tool exists 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the orphan about to be pruned carries no history 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the orphan now carries a date and a mutation 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the raised copy really does carry a higher ceiling 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the real budget is inside a git repository 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the scratch prior really is three commits behind 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the scratch repo has a committed ceiling and no upstream 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the scratch repo has a prior ceiling committed 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the skip-loop sweep is present, so its counts can be read 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red premise: the workflow file is where this part thinks it is 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red raising the ceiling above its committed value is refused 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red raising the ceiling in the tracked file is refused 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red regenerating the ledger lets the new check through 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red so a first run on a new major is not a failure 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the budget names a ceiling and a census, and says which is which 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the ceiling refuses being exceeded 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the check the run still emits is not called an orphan 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the committed census matches the committed ledger 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the distance travels with a refusal too, not only with a pass 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the four categories account for every ledger row 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the gate refuses to run without the registered suite list 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the ledger partitions into observed and never 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the orphan scan stays a REPORT while any skip loop cannot be compared to its arms 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the refusal says why, rather than only that it refused 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the runner asks the tool to resolve the prior rather than naming one 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the runner captures the gate's status rather than only its success 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the runner invokes the ledger gate 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the runner keeps the logs somewhere that outlives the build directory 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the runner passes --against to the gate 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the same check in two logs is two runs, not a duplicate 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the same name twice in ONE log is a duplicate, and is named 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the scan reports a finding on a skipped part 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the stable check is not reported 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red the suites job fetches the PR base for the ceiling comparison 15;16;17;18;19 never - +harness_selftest 410-a-check-must-have-been-red two checks stay two rows whatever the majors, because the key is not the major 15;16;17;18;19 never - +harness_selftest 420-a-deleted-part-must-be-visible and every name in the manifest is a part on disk, so a deletion reddens 15;16;17;18;19 never - +harness_selftest 420-a-deleted-part-must-be-visible every part on disk is named in the manifest 15;16;17;18;19 never - +harness_selftest 420-a-deleted-part-must-be-visible premise: a part present in the manifest and missing on disk is named 15;16;17;18;19 never - +harness_selftest 420-a-deleted-part-must-be-visible premise: and a part added without listing it is named too 15;16;17;18;19 never - +harness_selftest 420-a-deleted-part-must-be-visible premise: the manifest names something, so the comparison has two sides 15;16;17;18;19 never - +harness_selftest 420-a-deleted-part-must-be-visible the parts manifest exists, because without it a deletion is invisible 15;16;17;18;19 never - +harness_selftest 420-a-deleted-part-must-be-visible the three buckets account for every part on disk 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report a pg_config whose --bindir is empty is refused too, not run with a broken PATH 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report and it does not pretend to have run checks 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report and pairs each with the marker the runners require beside the status 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report and part 010 exits with exactly that status on its skip paths 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report and the refusal is the guard's own, naming the path it could not use 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report control: and the second, so a good pg_config is not refused 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report control: the pg_config this run was handed satisfies the first predicate 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report handed a pg_config that does not exist, the self-test refuses instead of exiting 0 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report no selftest part exits 0, which would exit the driver before its summary 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report part 010's skip status is the one lib.sh calls PGC_EXIT_SKIPPED 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report premise: and a BARE exit too, which ends with the last status and is usually 0 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report premise: and it answers --bindir with nothing 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report premise: and it finds a planted exit 0 outside a heredoc 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report premise: the driver this part is about is where it is expected 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report premise: the stub is executable, so an -x test alone would accept it 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report premise: the sweep reads every selftest part 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report premise: while a deliberate non-zero exit is not an offence 15;16;17;18;19 never - +harness_selftest 430-the-self-test-must-not-report premise: while a fixture script ending in exit 0 inside a heredoc is not an offence 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced an empty count is not 'present' under a numeric comparison 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced and the numeric form says so on stderr rather than silently 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced and the string comparison it replaces WOULD have said present 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced no count from grep -c is compared as a string, which answers present when grep could not answer 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced premise: a real count compares the same both ways, so the conversion is behaviour-preserving 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced premise: and a zero count does too 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced premise: and it finds a planted string comparison on a grep -c 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced premise: and it finds one whose PATTERN contains a parenthesis, which the first version could not 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced premise: and the = 0 spelling too, which fails the same way 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced premise: grep -c prints nothing at all on a pattern that does not compile 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced premise: nor is one inside a generated fixture script 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced premise: the sweep has a corpus to read 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced premise: while a numeric comparison is not an offence 15;16;17;18;19 never - +harness_selftest 440-a-count-grep-never-produced premise: while a valid pattern prints a number 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable a cancelled gate is a red verdict, not a shrug 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable a failure names the run so a reader can reach it 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable a failure naming no job says so rather than printing an empty list 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable a fire drill identifies itself in the issue it opens 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable a gate nobody listed here still decides the verdict (#973) 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable a green run composes the closing message, so the alert clears itself 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable all skipped is green, which is a fork run and a fire drill 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable an empty needs context is refused, not defaulted to green 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable an unparseable context says so without a traceback 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable an unrecognised result is refused rather than treated as green 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable an unrecognised verdict is refused rather than treated as green 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable and it is granted issues: write, which the workflow default withholds 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable and it still says what went wrong, rather than saying nothing 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable and names the job that failed, not just that something did 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable and no per-job result variable survives to drift from the context 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable and no search-index query survives in the code 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable and that marker reaches the job list the reporter prints 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable and the green path reuses the same title, or it would close nothing 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable every gate green is a green verdict 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable one gate failing is a red verdict 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable premise: removing comments left the lookup itself in place 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable premise: the nightly workflow and the reporter are both present 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable premise: the other nightly jobs were parsed, so the comparison is real 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable premise: the per-job-variable pattern sees that shape when it is present 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable premise: the reporter's needs list was parsed 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable the issue lookup reads past the first hundred open issues 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable the reporter runs on every outcome, not only on failure 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable the reporter waits on EVERY other nightly job (#973) 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable the title carries no run number, so every red lands on one issue 15;16;17;18;19 never - +harness_selftest 450-a-red-nightly-must-be-findable the verdict comes from the whole needs context, not a second list 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary control: and the stamp carries one field rather than two 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary control: without that argument the same driver degrades to source-only (#961) 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary every caller records the installed library's digest (#961) 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary premise: all three stamp call sites were found with their arguments joined 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary premise: and it holds exactly one stamp write 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary premise: nothing opens a deeper subshell inside the extracted block 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary premise: the controller's stamp block was extracted exactly once 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary premise: the extraction produced a block at all 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary premise: the matrix controller is present and parses 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary premise: the mutation removed the installed-digest argument 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary premise: this part was given an executable pg_config to read the prefix from 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary so a child suite under PGC_SKIP_BUILD reaches verified, not source-only (#961) 15;16;17;18;19 never - +harness_selftest 460-the-controller-must-record-the-binary the controller's stamp carries BOTH fields (#961) 15;16;17;18;19 never - +harness_selftest 470-a-skipped-arm-records-under-its-own-name every comparable skip loop names exactly the arms its sibling would emit (#994) 15;16;17;18;19 never - +harness_selftest 470-a-skipped-arm-records-under-its-own-name premise: and it actually compared some of them 15;16;17;18;19 never - +harness_selftest 470-a-skipped-arm-records-under-its-own-name premise: the sweep found skip loops at all 15;16;17;18;19 never - +harness_selftest 470-a-skipped-arm-records-under-its-own-name premise: the sweep tool is present 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter 3-table answer equals filter-off 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter 3-table join order matches filter-off 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter 3-table plan has coordinator 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter ANTI refusal 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter CROSS refusal 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter LEFT refusal 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter SEMI refusal 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter baseline core Hash Join 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter baseline reads all groups 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter build rows omit NULL 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter clustered groups removed 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter clustered reads fewer groups 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter collation-mismatch answer equals heap 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter collation-mismatch bloom rejects most non-matches 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter collation-mismatch interval stays off 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter collation-mismatch plan has coordinator 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter default plan has runtime coordinator 15;16;17;18;19 2026-09-12 - +native_join_runtime_filter native_join_runtime_filter early limit equals heap 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter early limit has coordinator 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter empty-build answer equals heap 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter empty-build plan has coordinator 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter fact-qual conjunction equals heap 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter fact-qual plan has coordinator 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter filter ready before scan 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter int4/int8 answer equals heap 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter int4/int8 bloom rejects most non-matches 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter int4/int8 interval stays off 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter int4/int8 plan has coordinator 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter join runtime filter defaults on 15;16;17;18;19 2026-09-12 - +native_join_runtime_filter native_join_runtime_filter plan has build tap 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter plan has runtime coordinator 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter plan retains core Hash Join 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter projection join equals heap 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter projection outer is not wrapped 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter projection scan is chosen 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter rescan answers equal heap 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter runtime answer equals heap 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter runtime answer equals off 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter saturated answer equals heap 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter saturated bloom is disabled 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter saturated plan has coordinator 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter scattered answer equals heap 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter scattered bloom rejects most non-matches 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter scattered interval cannot drop groups 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter scattered plan has coordinator 15;16;17;18;19 never - +native_join_runtime_filter native_join_runtime_filter scattered still reads every group 15;16;17;18;19 never - +native_join_vector_agg native_join_vector_agg LEFT join answer equals heap 15;16;17;18;19 never - +native_join_vector_agg native_join_vector_agg LEFT join refuses the join fold 15;16;17;18;19 never - +native_join_vector_agg native_join_vector_agg duplicate dim keys answer equals heap 15;16;17;18;19 never - +native_join_vector_agg native_join_vector_agg duplicate dim keys refuse the join fold 15;16;17;18;19 never - +native_join_vector_agg native_join_vector_agg extra join filter answer equals GUC off 15;16;17;18;19 2026-09-12 - +native_join_vector_agg native_join_vector_agg extra join filter answer equals heap 15;16;17;18;19 2026-09-12 - +native_join_vector_agg native_join_vector_agg extra join filter refuses the join fold 15;16;17;18;19 2026-09-12 - +native_join_vector_agg native_join_vector_agg inequality join filter answer equals heap 15;16;17;18;19 2026-09-12 - +native_join_vector_agg native_join_vector_agg inequality join filter refuses the join fold 15;16;17;18;19 2026-09-12 - +native_join_vector_agg native_join_vector_agg unique join fold answer equals GUC off 15;16;17;18;19 never - +native_join_vector_agg native_join_vector_agg unique join fold answer equals heap 15;16;17;18;19 never - +native_join_vector_agg native_join_vector_agg unique join uses core Agg when GUC off 15;16;17;18;19 never - +native_join_vector_agg native_join_vector_agg unique join uses vectorized agg when GUC on 15;16;17;18;19 2026-09-12 drop JOINREL fold diff --git a/test/check_ledger_budget.txt b/test/check_ledger_budget.txt index 86d8bd7b..4e54a8ad 100644 --- a/test/check_ledger_budget.txt +++ b/test/check_ledger_budget.txt @@ -45,4 +45,4 @@ suites_not_covered 249 # the number of attacked checks -- and it overcounts from the first moment this # ledger does the job it exists for. The gate prints both quantities side by side # (`rows=N | never observed red=M`) because they are different questions. -checks_never_observed_red 1171 +checks_never_observed_red 1189 diff --git a/test/selftest/410-a-check-must-have-been-red.sh b/test/selftest/410-a-check-must-have-been-red.sh index bd566350..46bf621d 100644 --- a/test/selftest/410-a-check-must-have-been-red.sh +++ b/test/selftest/410-a-check-must-have-been-red.sh @@ -934,7 +934,7 @@ _dist="$_lw/dist"; rm -rf "$_dist"; mkdir -p "$_dist" printf 'suites_not_covered 7\n' > b.txt && git add b.txt && git commit -qm base git branch -q oldbase for i in 1 2 3; do echo "x$i" > f; git add f; git commit -qm "c$i"; done ) >/dev/null 2>&1 -printf 's\tp\ta\tnever\t-\n' > "$_dist/led" +printf 's\tp\ta\t18\tnever\t-\n' > "$_dist/led" printf 'RESULT\ts\tp\ta\tPASS\t18\t\nchecks run: 1\n' > "$_dist/log" printf 's\n' > "$_dist/reg" @@ -1006,7 +1006,7 @@ _rr="$_lw/refres"; rm -rf "$_rr"; mkdir -p "$_rr" git rm -q b.txt && git commit -qm "a commit without the budget" git branch -q nobudget git checkout -q hasbudget ) >/dev/null 2>&1 -printf 's\tp\ta\tnever\t-\n' > "$_rr/led" +printf 's\tp\ta\t18\tnever\t-\n' > "$_rr/led" printf 'RESULT\ts\tp\ta\tPASS\t18\t\nchecks run: 1\n' > "$_rr/log" printf 's\n' > "$_rr/reg"