Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
#!/usr/bin/env python3
"""Mutation battery for #902 / #895.
Green tests are not evidence of coverage. Every row below breaks one thing the
test files CLAIM to hold down; a row that survives is a hole in the tests, and
a row recorded as an expected survivor is a finding rather than a convenience.
python3 tests/mutate_902.py # every row
python3 tests/mutate_902.py --list
python3 tests/mutate_902.py --row min-becomes-max
A row is KILLED by a FAILURE or an ERROR. An anchor that does not match EXACTLY
ONCE is reported BROKEN, never skipped: a mutation that silently edited nothing
would be recorded as a surviving row, which is the opposite of what it means.
Refuses to start on a dirty target tree, because it restores the ORIGINAL text
from disk and would write committed text over uncommitted work.
THE MEASURED TABLE GOES IN THE HEADER OF THE TEST FILE IT DEFENDS, FROM THE
RUN -- never predicted here and never edited afterwards to match.
Every row here has a scar. FIVE of these rows are branches that ALREADY
survived a battery once, all found by the verifier of the rule: the `min` that
is the stated invariant, both abstentions, the partial-pad miss and the
courtyard-vs-body read.
Four MORE such branches exist and are deliberately NOT rows here -- the bool
check, longest-match waiver resolution, the `+ ':'` suffix guard and the whole
DRIFTED arm all lived in the staged placement driver
(`plan-pcb-placement/scripts/placement_driver.py`), which this battery never
targeted; they were killed by that driver's own `--self-test`, and left the
tree with it when the skill was retired for pcb-free-agent. Saying "nine rows" would have credited this
file with four kills it does not perform, which is the kind of arithmetic a
reader has no way to check without opening TARGETS.
"""
import argparse
import os
import subprocess
import sys
REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
KILLED, SURVIVED, BROKEN = 'KILLED', 'SURVIVED', 'BROKEN'
TARGETS = {
'fp': os.path.join(REPO, 'py_placer', 'placement', 'floorplan.py'),
'db': os.path.join(REPO, 'py_placer', 'placement', 'design_brief.py'),
'cf': os.path.join(REPO, 'py_tools', 'check_floorplan.py'),
'bc': os.path.join(REPO, 'py_tools', 'board_context.py'),
'sd': os.path.join(REPO, 'py_placer', 'placement', 'seeder.py'),
'cg': os.path.join(REPO, 'py_placer', 'placement', 'connector_geometry.py'),
'lg': os.path.join(REPO, 'py_placer', 'placement', 'legality.py'),
}
T961 = 'tests/test_961_body_overhang.py'
T902 = 'tests/test_902_proximity.py'
T895 = 'tests/test_895_boundary_criteria.py'
T891 = 'tests/test_891_board_context.py'
TSCH = 'tests/test_549_floorplan_schema.py'
#: (name, target, old, new, tests that must notice, expectation)
ROWS = [
# ---- the rule's own arithmetic -----------------------------------------
# THE INVARIANT. Every declared case gives a subject pad exactly one
# candidate partner, so min and max were indistinguishable until a case
# gave one pad six partners on one net.
('min-becomes-max', 'fp',
" if best is None or g < best[0]:",
" if best is None or g > best[0]:",
(T902,), KILLED),
# The narrowing that makes a claim about the RAIL leg rather than the
# nearest pad. Dropping it reports a number about a different pin.
('net-narrowing-dropped', 'fp',
" same = ([q for q in partners if q.net_id == pad.net_id and pad.net_id > 0]\n"
" if net_match else [])",
" same = []",
(T902,), KILLED),
# A pad NUMBER is not unique: a crystal has two ground tabs both named
# `3`. First-hit makes the answer depend on file order.
('pads-named-takes-the-first', 'fp',
" return [p for p in (fp_obj.pads or ()) if p.pad_number in want]",
" got = [p for p in (fp_obj.pads or ()) if p.pad_number in want]\n"
" return got[:1]",
(T902,), KILLED),
# A partially-wrong pad list graded CLEAN on the survivors: the guard
# fired only when EVERY name missed.
('partial-pad-miss-ignored', 'fp',
" missing = [n for n in names if n not in have]",
" missing = [] if have else [n for n in names if n not in have]",
(T902,), KILLED),
# Both abstentions could be deleted with the whole suite green, and a
# claim naming a padless part then yielded NOTHING while `proximity`
# stayed in `rules_run` -- the vacuous pass `_ARM` was dropped on.
('pads-abstention-deleted', 'fp',
" ctx.abstain(\n f\"{akey}.pads\",",
" _unused = (\n f\"{akey}.pads\",",
(T902,), KILLED),
('body-abstention-deleted', 'fp',
" ctx.abstain(f\"{akey}.basis\", why)\n continue",
" continue",
(T902,), KILLED),
# `body_local` is COURTYARD-first, and #896 says a courtyard is not a
# body. Reading it under-states every gap by the assembly margin.
# Re-anchored for #894: the ladder moved out of `_Ctx.body_rect` into the
# module-level `drawn_body_rect`, so a caller that is not grading an
# intent can share it. Same mutation, same target, one indent level out.
('body-reads-the-courtyard', 'fp',
" rect_local = None if geom is None else (geom.drawn_local\n"
" or geom.body_local)",
" rect_local = None if geom is None else geom.body_local",
(T902,), KILLED),
# A missing ref must be a FINDING, not silence: a typo would grade clean,
# which is `block_unresolved`'s failure one level over.
('missing-ref-is-silent', 'fp',
" missing = [r for r, f in ((ref, a_fp), (near, b_fp)) if f is None]",
" missing = []",
(T902,), KILLED),
# `_wants` ends in a bare `return True`, so a rule with no branch runs on
# every board and lands in `rules_run` having measured nothing.
('wants-branch-deleted', 'fp',
" if rule == 'proximity':\n return bool(intent.proximity)",
" if rule == 'proximity':\n return True",
(T902,), KILLED),
# ---- the loaders --------------------------------------------------------
# inf and nan pass both `_number(lo=)` and a `<= 0` guard, and json.load
# accepts the literals: a declared limit nothing can ever violate.
('brief-finite-check-deleted', 'db',
" if not math.isfinite(float(limit)):",
" if False:",
(T902,), KILLED),
('intent-finite-check-deleted', 'fp',
" if not math.isfinite(limit) or limit <= 0.0:",
" if limit <= 0.0:",
(T902,), KILLED),
# Three spellings of "unpadded" defeated the reverse guard, so a brief
# could declare 5mm one way and 9mm the other.
('reverse-guard-keys-on-none', 'db',
" if isinstance(pads, dict) and pads.get(ref_one):\n continue",
" if pads is not None:\n continue",
(T902,), KILLED),
('intent-reverse-guard-deleted', 'fp',
" if not (p.get('pads') or {}).get(ref) and (near, ref) in seen:",
" if False:",
(T902,), KILLED),
# A reference may contain `~`, so a bare `ref~near` id collides and one of
# two declared unknowns disappears into a set union.
('claim-id-drops-the-row', 'db',
" return f\"proximity[{row}:{ref}~{near}]\"",
" return f\"proximity[{ref}~{near}]\"",
(T902,), KILLED),
# An integer pad number matches nothing, measures nothing, grades clean.
('pad-number-type-check-gone', 'db',
" if not isinstance(n, str):",
" if False:",
(T902,), KILLED),
# ---- clause coverage ----------------------------------------------------
('coverage-uncovered-reads-graded', 'db',
" return ('uncovered', f\"`{rule}` did not run on this grade\", rule)",
" return ('graded', '', rule)",
(T902,), KILLED),
('coverage-abstention-ignored', 'db',
" if _abstention_is_about(akey, kind, ref, near, intent_doc):",
" if False:",
(T902,), KILLED),
# Trusting the row index alone charged an abstention to whatever claim sat
# at that row -- a finding about an innocent clause.
('abstention-matches-on-index-only', 'db',
" if not akey.startswith(f\"proximity[{row}:{ref}~{near}]\"):\n return False",
" if False:\n return False",
(T902,), KILLED),
# `not_claimed` and `carried` must never block, or declaring honestly is
# punished and people stop declaring.
('unknown-clauses-block', 'db',
" out['complete'] = (counts['uncovered'] == 0 and counts['abstained'] == 0\n"
" and counts['drifted'] == 0)",
" out['complete'] = (counts['uncovered'] == 0 and counts['abstained'] == 0\n"
" and counts['drifted'] == 0\n"
" and counts['not_claimed'] == 0)",
(T902,), KILLED),
# The absence message must name what is actually absent, not fabricate a
# brief that was never found.
('absence-reason-keys-on-coverage', 'cf',
" + (_brief_absence_reason(args, brief) if not brief_fragment",
" + (_brief_absence_reason(args, brief) if not coverage",
(T902,), KILLED),
# ---- #895's instrument --------------------------------------------------
# The span is the WORST shared-net pad distance: a bus is as long as its
# longest member, and the nearest pair says nothing about whether it fits.
('span-takes-the-nearest', 'bc',
" if worst is None or near > worst:",
" if worst is None or near < worst:",
(T891, T895), KILLED),
# ---- #961: the overhang band's currency ---------------------------------
# Rows that put back a piece of the pre-#961 reading (the occupancy
# number where a body is measured, the declared edge alone instead of the
# sum), plus one per branch the change added: the setback gate it left on
# the old reading, the seeder's second rung, the emitter widening, the
# per-part copper evidence, side and layer-token selection, the source
# memo and the text block.
('layer-token-must-be-quoted', 'cg',
" lm = re.search(r'\\(layer\\s+\"?([FB]\\.(?:Fab|SilkS))\"?\\)', item)",
" lm = re.search(r'\\(layer\\s+\"([FB]\\.(?:Fab|SilkS))\"\\)', item)",
(T961,), KILLED),
('format-text-evidence-deleted', 'fp',
" if r.edge_connector_evidence:\n"
" # #961: the number each band was graded on and its CURRENCY, printed",
" if False:\n"
" # #961: the number each band was graded on and its CURRENCY, printed",
(T961,), KILLED),
('band-reads-the-occupancy', 'fp',
" band, overhang_basis, body = _band_amount(ctx, ref, c.get('edge'),\n"
" amount)",
# `body_measured: False`, not `{}`: an empty dict made the row KILL by a
# KeyError in the evidence builder before any currency assertion ran.
" band, overhang_basis, body = amount, 'legacy', {'body_measured': False}",
(T961,), KILLED),
# The graded number is summed over every side, as the occupancy reading
# was; reading the declared edge alone lets a corner overhang escape.
('band-drops-the-other-sides', 'cg',
" return row['body_outside_mm'], 'body:' + row['body_layer'], row",
" return row['body_overhang_mm'], 'body:' + row['body_layer'], row",
(T961,), KILLED),
# The one gate #961 deliberately leaves on the occupancy reading.
('setback-gate-reads-the-body', 'fp',
" if setback is not None and amount <= legality.EPS:",
" if setback is not None and band <= legality.EPS:",
(T961,), KILLED),
('exempt-reads-the-occupancy', 'fp',
" band, _basis, _body = _band_amount(self, ref, c.get('edge'),\n"
" amt)",
" band, _basis, _body = amt, 'legacy', {}",
(T961,), KILLED),
('seat-band-reads-the-occupancy', 'sd',
" amt, _basis, _body = band_amount(geometry, part.ref, edge, amt,\n"
" state.edge_gate.margin,\n"
" pose=(x, y, part.rot))",
" _body = {}",
(T961,), KILLED),
('second-rung-deleted', 'sd',
" if band is not None and converged:\n"
" return _body_band_correct(state, ref, edge, x, y, target, band)",
" if False:\n"
" return _body_band_correct(state, ref, edge, x, y, target, band)",
(T961,), KILLED),
('emitter-widening-deleted', 'fp',
" if (body['body_measured']\n"
" and body['body_outside_mm'] > amt + legality.EPS):",
" if (False\n"
" and body['body_outside_mm'] > amt + legality.EPS):",
(T961,), KILLED),
('copper-findings-unsliced', 'fp',
" findings = [f for f in copper['findings']\n"
" if str(f['pad_ref']).startswith(prefix)]",
" findings = list(copper['findings'])",
(T961,), KILLED),
('copper-gap-board-wide', 'fp',
" gap = (copper.get('minimum_gap_by_ref_mm') or {}).get(ref)",
" gap = copper.get('minimum_gap_mm')",
(T961,), KILLED),
# Round 4 review: the pad-extent arithmetic behind the seat's copper
# check and the conjunct's fallback for pads the edge grader cannot
# model. Every row below was a live survivor of the reviewer's battery.
('exempt-certifies-an-unmodellable-pad', 'fp',
" or (_copper_outside_mm(self, ref) <= legality.EPS\n"
" and not _unmodellable_pads(self, ref)))",
" or _copper_outside_mm(self, ref) <= legality.EPS)",
(T961,), KILLED),
('copper-ignores-unmodellable-pads', 'fp',
" if unsupported and fp is not None:",
" if False and fp is not None:",
(T961,), KILLED),
('pb-tilt-keeps-the-footprint-rotation', 'cg',
" pad.size_y / 2.0, tilt - base))",
" pad.size_y / 2.0, tilt))",
(T961,), KILLED),
('pb-tilt-taken-absolute', 'cg',
" tilt = -(pad.rect_rotation or 0.0)\n if tilt == 0.0:",
" tilt = abs(pad.rect_rotation or 0.0)\n if tilt == 0.0:",
(T961,), KILLED),
('pb-recovery-branch-deleted', 'cg',
" if tilt == 0.0:\n # The broad phase bakes",
" if False:\n # The broad phase bakes",
(T961,), KILLED),
('pb-recovery-sign-flipped', 'cg',
" tilt = ((getattr(pad, 'rotation', 0.0) or 0.0) + 45) % 90 - 45",
" tilt = -(((getattr(pad, 'rotation', 0.0) or 0.0) + 45) % 90 - 45)",
(T961,), KILLED),
('copper-fallback-clobbers-the-exact-reading', 'fp',
" worst = max(worst, pad_copper_outside(",
" worst = 0.0 + (pad_copper_outside(",
(T961,), KILLED),
('copper-fallback-measures-every-pad', 'fp',
" (fp.x, fp.y, fp.rotation or 0.0), only=unsupported))",
" (fp.x, fp.y, fp.rotation or 0.0), only=None))",
(T961,), KILLED),
('unmodelled-predicate-ignored', 'fp',
" and not legality.pad_shape_is_modelled(pad)}",
" and False}",
(T961,), KILLED),
('body-overhang-is-the-signed-value', 'cg',
" body_overhang_mm=max(0.0, signed),",
" body_overhang_mm=signed,",
(T961,), KILLED),
('pb-tilt-keeps-the-parsed-sign', 'cg',
" tilt = -(pad.rect_rotation or 0.0)",
" tilt = pad.rect_rotation or 0.0",
(T961,), KILLED),
('pb-half-extents-halved-again', 'cg',
" boxes.append((index, pad.local_x, pad.local_y, pad.size_x / 2.0,",
" boxes.append((index, pad.local_x, pad.local_y, pad.size_x / 4.0,",
(T961,), KILLED),
('pb-no-copper-or-castellated-pads-are-kept', 'cg',
" if _pad_has_no_copper(pad) or getattr(pad, 'castellated', False):",
" if False:",
(T961,), KILLED),
('pco-x-extent-drops-the-y-term', 'cg',
" ex, ey = hx * ca + hy * sa, hx * sa + hy * ca",
" ex, ey = hx * ca, hx * sa + hy * ca",
(T961,), KILLED),
('pco-pad-transform-sign-flipped', 'cg',
" px, py = x + c * lx + s * ly, y - s * lx + c * ly",
" px, py = x + c * lx + s * ly, y + s * lx + c * ly",
(T961,), KILLED),
('pco-trial-rotation-ignored', 'cg',
" angle = math.radians(tilt + rot)",
" angle = math.radians(tilt)",
(T961,), KILLED),
('seat-copper-tolerated-to-half-a-mm', 'sd',
# Single-line and unique (#1051 phase 5): `if off > 1e-9:` now also
# sits in stage 0's fixed-pose check. Shifting the SEAT predicate's
# measured overhang by 0.5 is the same mutant as `off > 0.5` there.
" off = pad_copper_outside(geometry, zero, part.ref, (x, y, part.rot))",
" off = pad_copper_outside(geometry, zero, part.ref, (x, y, part.rot)) - 0.5",
(T961,), KILLED),
('ev-shortfall-is-the-smallest', 'fp',
" 'shortfall_mm': round(max((f['shortfall_mm'] for f in findings),",
" 'shortfall_mm': round(min((f['shortfall_mm'] for f in findings),",
(T961,), KILLED),
('ev-unmeasured-disposition-dropped', 'fp',
" elif unmeasured or copper['rules_unmeasured']:",
" elif copper['rules_unmeasured']:",
(T961,), KILLED),
# Round 3 review: the seat predicate's copper, the arc guard nothing
# pinned, and the evidence/marker branches its own battery reached.
('poly-arc-measured-as-chord', 'cg',
" if re.search(r'\\(arc\\b', item):",
" if False:",
(T961,), KILLED),
('seat-ignores-pad-copper', 'sd',
" off = pad_copper_outside(geometry, zero, part.ref, (x, y, part.rot))",
" off = 0.0",
(T961,), KILLED),
('copper-conjunct-not-body-scoped', 'fp',
" copper_out = (_copper_outside_mm(ctx, ref)\n"
" if body.get('body_measured') else 0.0)",
" copper_out = _copper_outside_mm(ctx, ref)",
(T961,), KILLED),
('marker-refuses-a-padless-part', 'cg',
" if not pads:\n hit = True",
" if not pads:\n hit = False",
(T961,), KILLED),
('marker-ignores-rotation', 'cg',
" rot = math.radians(fp.rotation or 0.0)",
" rot = 0.0",
(T961,), KILLED),
('marker-counts-npth-pads', 'cg',
" pads = ([p for p in (fp.pads or ())\n"
" if getattr(p, 'pad_type', '') != 'np_thru_hole']\n"
" or list(fp.pads or ()))",
" pads = list(fp.pads or ())",
(T961,), KILLED),
('marker-verdict-shared-between-parts', 'cg',
" hit = self._encloses.get(ref)",
" hit = next(iter(self._encloses.values()), None)",
(T961,), KILLED),
('evidence-missing-from-json', 'fp',
" 'edge_connector_evidence': r.edge_connector_evidence,",
" 'edge_connector_evidence': [],",
(T961,), KILLED),
('evidence-margin-faked', 'fp',
" 'effective_margin_mm': ctx.gate.margin,",
" 'effective_margin_mm': 0.0,",
(T961,), KILLED),
('copper-nocopper-reads-pass', 'fp',
" elif gap is None:\n copper_disposition = 'no copper pads measured'",
" elif gap is None:\n copper_disposition = 'pass'",
(T961,), KILLED),
('copper-walks-the-whole-board', 'fp',
" subset = copy(self.pcb)\n subset.footprints = {",
" subset = self.pcb\n _unused = {",
(T961,), KILLED),
# #975: the loop moved into `EdgeCopperContext.grade`, one indent in; same mutation.
('per-part-minimum-last-wins', 'lg',
" minimum_by_ref[ref] = min(minimum_by_ref.get(ref, gap), gap)",
" minimum_by_ref[ref] = gap",
(T961,), KILLED),
# Round 3: five branches round 2 covered with a test but no row.
('fab-falls-back-to-silk', 'cg',
" layer = next((side + suffix for suffix in ('.Fab', '.SilkS')",
" layer = next((side + suffix for suffix in ('.SilkS', '.Fab')",
(T961,), KILLED),
('any-outline-is-rectangular', 'cg',
" rectangular = bool(bounds) and _segments_cover_rectangle(",
" rectangular = bool(bounds) or _segments_cover_rectangle(",
(T961,), KILLED),
('text-box-is-body-geometry', 'cg',
" if kind in ('text', 'text_box'):",
" if kind in ('text',):",
(T961,), KILLED),
('exempt-count-gate-reads-the-band', 'fp',
" if (amt > legality.EPS and copper_ok",
" if (band > legality.EPS and copper_ok",
(T961,), KILLED),
('emitter-widens-on-the-declared-edge', 'fp',
" if (body['body_measured']\n"
" and body['body_outside_mm'] > amt + legality.EPS):",
" if (body['body_measured']\n"
" and body['body_overhang_mm'] > amt + legality.EPS):",
(T961,), KILLED),
# Round 2: the three seeder call sites that hand the band to
# `_edge_correct`, and the second rung's own arithmetic. Each survived the
# round-2 review's mutations with every test green.
('seat-ladder-drops-the-band', 'sd',
" x, y, converged = _edge_correct(state, ref, edge, x, y,\n"
" overhang, band=(lo, hi_eff))",
" x, y, converged = _edge_correct(state, ref, edge, x, y,\n"
" overhang, band=None)",
(T961,), KILLED),
('stage-one-slide-drops-the-band', 'sd',
" _x, _y, _conv = _edge_correct(\n"
" state, ref, edge, _x, _y, overhang,\n"
" band=(lo, float(hi) if hi is not None\n"
" else max(2.0 * overhang, lo + 1.0)))",
" _x, _y, _conv = _edge_correct(\n"
" state, ref, edge, _x, _y, overhang, band=None)",
(T961,), KILLED),
('stage-one-final-drops-the-band', 'sd',
" x, y, converged = _edge_correct(\n"
" state, ref, edge, x, y, overhang,\n"
" band=(lo, float(hi) if hi is not None\n"
" else max(2.0 * overhang, lo + 1.0)))",
" x, y, converged = _edge_correct(\n"
" state, ref, edge, x, y, overhang, band=None)",
(T961,), KILLED),
('rung-north-sign-flipped', 'sd',
" if edge == 'north':\n y -= err",
" if edge == 'north':\n y += err",
(T961,), KILLED),
('rung-lo-dropped', 'sd',
" or (lo - 0.02) <= row['body_outside_mm'] <= (hi + 0.02)):",
" or row['body_outside_mm'] <= (hi + 0.02)):",
(T961,), KILLED),
('rung-always-converged', 'sd',
" and abs(target - row['body_outside_mm']) < 0.02)",
" or True)",
(T961,), KILLED),
# Round 2: a band on the body must still see copper off the outline.
('copper-off-outline-licensed', 'fp',
" if copper_out > legality.EPS:\n yield Violation(",
" if False:\n yield Violation(",
(T961,), KILLED),
('exempt-ignores-copper', 'fp',
" copper_ok = (not _body.get('body_measured')\n"
" or (_copper_outside_mm(self, ref) <= legality.EPS\n"
" and not _unmodellable_pads(self, ref)))",
" copper_ok = True",
(T961,), KILLED),
('castellated-copper-counted', 'fp',
" and getattr(pads[index], 'castellated', False)):",
" and False):",
(T961,), KILLED),
('marker-accepted-as-body', 'cg',
" if not self._encloses_own_pads(ref, fp, points):",
" if False:",
(T961,), KILLED),
('bside-reads-front', 'cg',
" points, layer, reason = self.source.envelope(ref, footprint_side(fp))",
" points, layer, reason = self.source.envelope(ref, 'F')",
(T961,), KILLED),
# A board rewritten in place must not be answered from its old text.
('source-cache-ignores-content', 'cg',
" hashlib.blake2b(raw, digest_size=16).digest(),",
" b'',",
(T961,), KILLED),
]
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from mutation_anchors import preflight # noqa: E402
preflight(__file__)
def _dirty():
r = subprocess.run(['git', 'status', '--porcelain'] +
sorted(set(TARGETS.values())),
cwd=REPO, capture_output=True, text=True)
return [ln for ln in r.stdout.splitlines() if ln.strip()]
def run_row(row, keep=False):
name, target, old, new, tests, _expect = row
path = TARGETS[target]
with open(path, encoding='utf-8') as fh:
original = fh.read()
if original.count(old) != 1:
return BROKEN, f'anchor matched {original.count(old)} time(s)'
try:
with open(path, 'w', encoding='utf-8', newline='\n') as fh:
fh.write(original.replace(old, new, 1))
for t in tests:
r = subprocess.run([sys.executable, os.path.join(REPO, t)],
cwd=REPO, capture_output=True, text=True)
if r.returncode != 0:
return KILLED, f'{t} exit {r.returncode}'
return SURVIVED, ''
finally:
if not keep:
with open(path, 'w', encoding='utf-8', newline='\n') as fh:
fh.write(original)
def main():
ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
ap.add_argument('--list', action='store_true')
ap.add_argument('--row', action='append', default=[])
a = ap.parse_args()
if a.list:
for name, target, _o, _n, tests, expect in ROWS:
print(f" {name:38} {target:3} {expect:8} {' '.join(tests)}")
return 0
dirty = _dirty()
if dirty:
print('REFUSING: the target tree is dirty. This restores the ORIGINAL '
'text from disk and would write committed text over uncommitted '
'work.')
for ln in dirty:
print(f' {ln}')
return 2
rows = [r for r in ROWS if not a.row or r[0] in a.row]
if a.row and not rows:
print(f'no row matches {a.row}')
return 2
counts = {KILLED: 0, SURVIVED: 0, BROKEN: 0}
disagreed = 0
for row in rows:
got, detail = run_row(row)
counts[got] += 1
flag = 'ok ' if got == row[5] else 'DISAGREES'
if got != row[5]:
disagreed += 1
print(f' {row[0]:38} {got:9} {flag} {detail}')
print(f"\n{len(rows)} rows: {counts[KILLED]} killed, "
f"{counts[SURVIVED]} survived, {counts[BROKEN]} broken, "
f"{disagreed} disagreeing with expectation")
return 1 if (counts[BROKEN] or disagreed) else 0
if __name__ == '__main__':
sys.exit(main())
8b2a3278aThis file is pinned to the selected release. Download the original to open it in your design tool.