tricu

http_headers.py (24553B)

---

 #!/usr/bin/env python3
 """Opt-in artifact-only HTTP header regression; no compilation or socket IO.
 
 --subject must be a full, explicitly compiled HTTP module (unqualified exports).
 The immutable reference predates the rewrite; it is never rebuilt from subject.
 Default coverage checks strict CRLF/header syntax, with explicit reasons and old/
 new expectations for semantic changes. --legacy-behavior reproduces the original
 readability-only corpus, including retired malformed-numeral characterizations.
 Current lowering accepts canonical bytes; out-of-contract legacy cases are listed
 explicitly in reports, not executed against a candidate or silently re-oracled.
 Preparation/provenance stays with native_library_migration.py; this runner proves
 behavior of the selected artifact, not its correspondence to working source.
 """
 import argparse
 from dataclasses import dataclass, replace
 import hashlib
 import json
 from pathlib import Path
 import re
 import time
 
 from bundle_dag import merge_bundles, read
 from fixture_sources import snapshot_bytes
 from process_rss import run_guarded
 from stable_bundle import byte_tree
 
 ROOT = Path(__file__).resolve().parent.parent
 REFERENCE_SHA256 = 'dc7b9f12056ceb08ca0487ad19886b0c0c8643802363ff1dd7a91e46af73a1d1'
 REFERENCE_METADATA_SHA256 = '7cdc0e247e7c3a13bcc7634735eee270a315f2c86939832a1d103aa445faeb9b'
 EXPORTS = ('toLowerAsciiByte', 'httpHeaderLineReply', 'parseHeaders',
            'readLineBytes', 'httpLineReply')
 LEAF, TRUE = b'\0', b'\1\0'
 
 
 def sha(payload):
     return hashlib.sha256(payload).hexdigest()
 
 
 def pair(left, right):
     return b'\2' + left + right
 
 
 def number(value):
     if value < 0:
         raise ValueError('negative tree numeral')
     bits = []
     while value:
         bits.append(TRUE if value & 1 else LEAF)
         value >>= 1
     return tree_list(bits)
 
 
 def tree_list(values, tail=LEAF):
     return b''.join(b'\2' + value for value in values) + tail
 
 
 def result(ok, payload, rest=LEAF):
     return pair(TRUE if ok else LEAF, pair(payload, rest))
 
 
 def reply(ok, payload, rest=LEAF, consumed=True, committed=False):
     return result(ok, payload, pair(rest, pair(TRUE if consumed else LEAF,
                                              TRUE if committed else LEAF)))
 
 
 def diagnostic(code, expected, found=LEAF, context=b'header-line'):
     return pair(number(code), pair(byte_tree(expected), pair(found,
                 pair(LEAF, tree_list([byte_tree(context)])))))
 
 
 def headers(values, rest=b''):
     return result(True, tree_list([pair(byte_tree(k), byte_tree(v)) for k, v in values]),
                   byte_tree(rest))
 
 
 BAD_REQUEST = result(False, number(400), byte_tree(b'Bad Request\n'))
 
 
 @dataclass(frozen=True)
 class Case:
     label: str
     export: str
     input: bytes
     expected: bytes | None
     category: str = 'independent'
     change: str | None = None
     reference_expected: bytes | None = None
 
 
 def cases():
     rows = [Case(f'ascii-{n:03}', 'toLowerAsciiByte', number(n),
                  number(n + 32 if 65 <= n <= 90 else n)) for n in range(256)]
     # Bytes and expected fields are independently authored, not parsed by a
     # second implementation of the subject algorithm. "characterization" labels
     # permissiveness that must be reviewed explicitly before a policy change.
     examples = [
         ('one', b'Host: localhost\r\n\r\nbody', [(b'host', b'localhost')], b'body'),
         ('order', b'Z: last\r\nA: first\r\n\r\nbody', [(b'z', b'last'), (b'a', b'first')], b'body'),
         ('duplicates', b'Host: one\r\nHOST: two\r\n\r\nx', [(b'host', b'one'), (b'host', b'two')], b'x'),
         ('empty-value', b'X:\r\n\r\nx', [(b'x', b'')], b'x'),
         ('colons', b'X: a:b:c\r\n\r\nx', [(b'x', b'a:b:c')], b'x'),
         ('leading-spaces', b'X:    value\r\n\r\n', [(b'x', b'value')], b''),
         ('blank', b'\r\nbody', [], b'body'),
         ('binary-remainder', b'X: y\r\n\r\n\x00\xff\r\nX: z', [(b'x', b'y')], b'\x00\xff\r\nX: z'),
         ('many', b'X: y\r\n' * 32 + b'\r\nbody', [(b'x', b'y')] * 32, b'body'),
         ('long-value', b'X: ' + b'a' * 512 + b'\r\n\r\nend', [(b'x', b'a' * 512)], b'end'),
     ]
     permissive = [
         ('empty-input', b'', [], b''),
         ('eof-header', b'Host: localhost', [(b'host', b'localhost')], b''),
         ('eof-after-line', b'Host: localhost\r\n', [(b'host', b'localhost')], b''),
         ('bare-lf', b'X: y\n\nbody', [(b'x', b'y')], b'body'),
         ('embedded-cr', b'X\r-Name: a\rb\r\n\r\nx', [(b'x-name', b'ab')], b'x'),
         ('cr-only', b'\r', [], b''),
         ('tab-value', b'X: \t value\r\n\r\n', [(b'x', b'\t value')], b''),
         ('trailing-whitespace', b'X: value \t\r\n\r\n', [(b'x', b'value \t')], b''),
         ('space-name', b'Bad Name: value\r\n\r\n', [(b'bad name', b'value')], b''),
         ('space-before-colon', b'Host : value\r\n\r\n', [(b'host ', b'value')], b''),
         ('leading-tab-name', b'\tHost: value\r\n\r\n', [(b'\thost', b'value')], b''),
         ('nul-name', b'X\x00: y\r\n\r\n', [(b'x\x00', b'y')], b''),
         ('high-byte-name', b'X\xff: y\r\n\r\n', [(b'x\xff', b'y')], b''),
         ('nul-value', b'X: a\x00b\r\n\r\n', [(b'x', b'a\x00b')], b''),
     ]
     for category, group in [('independent', examples), ('characterization', permissive)]:
         rows += [Case(label, 'parseHeaders', byte_tree(raw), headers(fields, rest), category)
                  for label, raw, fields, rest in group]
     rows += [Case(label, 'parseHeaders', byte_tree(raw), BAD_REQUEST) for label, raw in [
         ('missing-colon', b'Host\r\n\r\n'), ('missing-colon-eof', b'Host'),
         ('empty-name', b': bad\r\n\r\n'), ('whitespace-line', b' \r\n\r\n'),
         ('second-invalid', b'X: y\r\nBad\r\n\r\nbody'),
         ('folded-line', b'X: y\r\n continuation\r\n\r\n'),
     ]]
     for label, raw, line, rest in [
         ('line-crlf', b'hi\r\nx', b'hi', b'x'),
         ('line-blank', b'\r\nx', b'', b'x'),
         ('line-lf', b'hi\nx', b'hi', b'x'),
         ('line-eof', b'hi', b'hi', b''),
         ('line-empty', b'', b'', b''),
         ('line-embedded-cr', b'h\ri\r\nx', b'hi', b'x'),
     ]:
         rows.append(Case(label, 'readLineBytes', byte_tree(raw),
                          pair(byte_tree(line), byte_tree(rest)), 'characterization'))
         rows.append(Case(label + '-reply', 'httpLineReply', byte_tree(raw),
                          reply(True, byte_tree(line), byte_tree(rest), bool(raw)), 'characterization'))
     rows += [
         Case('reply-valid', 'httpHeaderLineReply', byte_tree(b'Host:  a:b'),
              reply(True, pair(byte_tree(b'host'), byte_tree(b'a:b')))),
         Case('reply-empty-value', 'httpHeaderLineReply', byte_tree(b'X:'),
              reply(True, pair(byte_tree(b'x'), LEAF))),
         Case('reply-missing-colon', 'httpHeaderLineReply', byte_tree(b'Host'),
              reply(False, diagnostic(1, b'colon'))),
         Case('reply-empty-name', 'httpHeaderLineReply', byte_tree(b': bad'),
              reply(False, diagnostic(2, b'header-name', number(58)), byte_tree(b': bad'), False)),
         Case('reply-empty-input', 'httpHeaderLineReply', LEAF,
              reply(False, diagnostic(1, b'header-name'), consumed=False)),
     ]
     # Noncanonical numerals and malformed list/tree shapes have deliberately
     # no independent policy oracle yet. Preserve the old result for discussion.
     malformed = [TRUE, b'\1\1\0', pair(pair(LEAF, LEAF), LEAF),
                  pair(LEAF, TRUE)]
     lower_inputs = malformed + [number(n)[:-1] + b'\2\0\0' for n in (0, 65, 90, 97)]
     lower_inputs += [number(256), number(65535)]
     rows += [Case(f'lower-shape-{i}', 'toLowerAsciiByte', value, None, 'differential-only')
              for i, value in enumerate(lower_inputs)]
     # Exercise the old lowercaser's seven-cell path with malformed *bits*, not
     # just short malformed numerals. It can preserve a malformed low bit while
     # changing the high bits: treating every noncanonical input as identity
     # would silently change behavior.
     for n in (64, 65, 90, 91):
         bits = [TRUE if n & (1 << bit) else LEAF for bit in range(7)]
         for position in range(7):
             for shape, bad in enumerate((b'\1\1\0', pair(LEAF, LEAF), pair(TRUE, LEAF))):
                 changed = bits.copy()
                 changed[position] = bad
                 rows.append(Case(f'lower-bit-{n}-{position}-{shape}', 'toLowerAsciiByte',
                                  tree_list(changed), None, 'differential-only'))
         for tail in (TRUE, pair(LEAF, LEAF)):
             rows.append(Case(f'lower-tail-{n}-{sha(tail)[:6]}', 'toLowerAsciiByte',
                              tree_list(bits, tail), None, 'differential-only'))
     stream_inputs = [TRUE, b'\1\1\0', b'\1\2\0\0', byte_tree(b'X: y')[:-1] + TRUE,
                      pair(TRUE, byte_tree(b': y\r\n\r\nbody')),
                      byte_tree(b'\r\n')[:-1] + TRUE,
                      byte_tree(b'X: y\r\n\r\n')[:-1] + TRUE]
     rows += [Case(f'headers-shape-{i}', 'parseHeaders', value, None, 'differential-only')
              for i, value in enumerate(stream_inputs)]
     return rows
 
 
 
 def retired_case(case):
     """Only the approved canonical-byte boundary; keep structural/suffix checks."""
     return (case.label.startswith(('lower-shape-', 'lower-bit-', 'lower-tail-'))
             or case.label == 'headers-shape-4')
 
 
 def syntax_cases():
     """RFC 9110 §§5.1,5.5,5.6.2/3; RFC 9112 §§2.2,5/5.1/5.2.
 
     Independent grammar membership and complete expected trees, not a second
     parser implementation. Old observations stay in cases() and the frozen bundle.
     """
     corrections = {}
     def correct(labels, expected, reason):
         for label in labels.split():
             corrections[label] = (expected, reason)
     correct('empty-input eof-header eof-after-line cr-only', BAD_REQUEST,
             'require CRLF lines and a terminating blank line')
     correct('bare-lf embedded-cr', BAD_REQUEST, 'reject bare LF/CR instead of deleting bytes')
     correct('space-name space-before-colon leading-tab-name nul-name high-byte-name',
             BAD_REQUEST, 'field names must be nonempty HTTP tokens')
     correct('nul-value', BAD_REQUEST, 'reject field-value controls except HTAB')
     for label in ('tab-value', 'trailing-whitespace'):
         correct(label, headers([(b'x', b'value')]), 'trim SP/HTAB at both field-value edges')
     correct('line-crlf', result(True, byte_tree(b'hi'), byte_tree(b'x')),
             'line helper returns Result, not an ambiguous pair')
     correct('line-blank', result(True, LEAF, byte_tree(b'x')),
             'line helper returns Result, not an ambiguous pair')
     correct('line-lf line-eof line-empty line-embedded-cr', BAD_REQUEST,
             'line helper propagates invalid/truncated lines as 400')
     for label, code, found, rest, consumed in [
         ('line-lf-reply', 2, number(10), b'\nx', True),
         ('line-eof-reply', 1, LEAF, b'', True),
         ('line-empty-reply', 1, LEAF, b'', False),
         ('line-embedded-cr-reply', 2, number(13), b'\ri\r\nx', True),
     ]:
         correct(label, reply(False, diagnostic(code, b'CRLF', found, b'http-line'),
                              byte_tree(rest), consumed), 'line failure reports suffix and consumption')
     correct('headers-shape-0 headers-shape-1 headers-shape-2 headers-shape-3', BAD_REQUEST,
             'malformed/truncated list cannot stand in for a terminating blank line')
     rows = []
     for case in cases():
         if retired_case(case):
             continue
         if case.label in corrections:
             expected, reason = corrections[case.label]
             case = replace(case, expected=expected, reference_expected=case.expected,
                            category='corrected', change=reason)
         rows.append(case)
 
     token = b"!#$%&'*+-.^_`|~0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
     for n in range(256):
         byte = bytes([n])
         name_ok = n in token
         value_ok = n == 9 or 32 <= n <= 126 or 128 <= n <= 255
         rows.append(Case(f'name-byte-{n:03}', 'parseHeaders', byte_tree(byte + b': y\r\n\r\nbody'),
             headers([(byte.lower(), b'y')], b'body') if name_ok else BAD_REQUEST,
             change=None if name_ok else 'reject invalid token-name bytes'))
         rows.append(Case(f'value-byte-{n:03}', 'parseHeaders', byte_tree(b'X: a' + byte + b'b\r\n\r\nbody'),
             headers([(b'x', b'a' + byte + b'b')], b'body') if value_ok else BAD_REQUEST,
             change=None if value_ok else 'reject invalid field-value bytes'))
     for label, raw, fields, rest, change in [
         ('all-token-punctuation', token + b': ok\r\n\r\n', [(token.lower(), b'ok')], b'', None),
         ('ows-only', b'X:\t  \t\r\n\r\n', [(b'x', b'')], b'', 'trim SP/HTAB at both edges'),
         ('ows-and-interior', b'X:\t a \t b\t \r\n\r\n', [(b'x', b'a \t b')], b'', 'trim edges, preserve interior'),
         ('obs-text', b'X: \x80\xff\r\n\r\n', [(b'x', b'\x80\xff')], b'', None),
         ('opaque-body', b'X: y\r\n\r\n\r\n\x00\xffBad Name: x\n', [(b'x', b'y')],
          b'\r\n\x00\xffBad Name: x\n', None),
     ]:
         rows.append(Case(label, 'parseHeaders', byte_tree(raw), headers(fields, rest), change=change))
     block = b'A: b\r\nB:\t c\r\n\r\n'
     for end in range(len(block)):
         rows.append(Case(f'truncated-block-{end:02}', 'parseHeaders', byte_tree(block[:end]), BAD_REQUEST,
                          change='every incomplete header-block prefix must fail'))
     for label, raw in [
         ('bare-cr-name', b'X\rY: z\r\n\r\n'), ('bare-cr-value', b'X: a\rb\r\n\r\n'),
         ('extra-cr', b'X: y\r\r\n\r\n'), ('lf-blank', b'X: y\r\n\nbody'),
         ('cr-blank', b'X: y\r\n\r'), ('tab-fold', b'X: y\r\n\tcontinued\r\n\r\n'),
     ]:
         rows.append(Case(label, 'parseHeaders', byte_tree(raw), BAD_REQUEST,
                          change='reject malformed line endings, truncation and folding'))
     for label, raw, line, rest in [
         ('request-get', b'GET / HTTP/1.1\r\nx', (b'GET', b'/', b'HTTP/1.1'), b'x'),
         ('request-post', b'POST /foo HTTP/1.1\r\n', (b'POST', b'/foo', b'HTTP/1.1'), b''),
         ('request-empty-fields-unchanged', b'  \r\nx', (b'', b'', b''), b'x'),
     ]:
         fields = pair(byte_tree(line[0]), pair(byte_tree(line[1]), byte_tree(line[2])))
         rows.append(Case(label, 'parseRequestLine', byte_tree(raw), result(True, fields, byte_tree(rest))))
     for label, raw in [
         ('request-lf', b'GET / HTTP/1.1\n'), ('request-eof', b'GET / HTTP/1.1'),
         ('request-cr-eof', b'GET / HTTP/1.1\r'), ('request-cr-method', b'GE\rT / HTTP/1.1\r\n'),
         ('request-cr-target', b'GET /a\rb HTTP/1.1\r\n'),
         ('request-cr-version', b'GET / HTTP/1.\r1\r\n'), ('request-empty', b''),
         ('request-blank', b'\r\n'), ('request-extra-field', b'GET / HTTP/1.1 extra\r\n'),
         ('request-no-version', b'GET /\r\n'),
     ]:
         rows.append(Case(label, 'parseRequestLine', byte_tree(raw), BAD_REQUEST))
     for label, raw, expected, change in [
         ('reply-space-name', b'Bad Name: v',
          reply(False, diagnostic(2, b'colon', number(32)), byte_tree(b' Name: v')),
          'reject spaces within token names'),
         ('reply-leading-tab', b'\tX: v',
          reply(False, diagnostic(2, b'header-name', number(9)), byte_tree(b'\tX: v'), False),
          'reject leading whitespace/folding'),
         ('reply-nul-value', b'X: a\x00b',
          reply(False, diagnostic(2, b'header-value', number(0)), byte_tree(b'\x00b')),
          'reject invalid value suffix instead of accepting its prefix'),
         ('reply-del-value', b'X: a\x7fb',
          reply(False, diagnostic(2, b'header-value', number(127)), byte_tree(b'\x7fb')),
          'reject invalid value suffix instead of accepting its prefix'),
         ('reply-ows', b'X:\t a b\t ', reply(True, pair(byte_tree(b'x'), byte_tree(b'a b'))),
          'trim edges, preserve interior'),
     ]:
         rows.append(Case(label, 'httpHeaderLineReply', byte_tree(raw), expected, change=change))
     for label, raw, found, rest, consumed in [
         ('line-bare-cr-reply', b'hi\r', 13, b'\r', True),
         ('line-initial-cr-reply', b'\rx', 13, b'\rx', False),
         ('line-initial-lf-reply', b'\nx', 10, b'\nx', False),
     ]:
         rows.append(Case(label, 'httpLineReply', byte_tree(raw),
             reply(False, diagnostic(2, b'CRLF', number(found), b'http-line'), byte_tree(rest), consumed),
             change='reject bare CR/LF; keep offending suffix and prior consumption'))
     return rows
 
 def parse_tree_output(text):
     text = text.strip()
     if not re.fullmatch('[012]+', text):
         raise ValueError('expected only a complete ternary result')
     tree = bytes(int(char) for char in text)
     slots = 1
     for tag in tree:
         if slots == 0:
             raise ValueError('trailing ternary tree')
         slots += tag - 1
     if slots:
         raise ValueError('truncated ternary tree')
     return tree
 
 
 def expect(actual, expected, label):
     if actual != expected:
         raise ValueError(f'{label}: complete result differs (actual {sha(actual)}, expected {sha(expected)})')
 
 
 def check_case(case, before, after):
     if (case.change or before is None) and case.expected is None:
         raise ValueError('changed/new behavior requires an independent oracle: ' + case.label)
     if case.expected is not None:
         expect(after, case.expected, case.label + ' subject oracle')
     if before is not None:
         old_expected = case.reference_expected if case.change else case.expected
         if old_expected is not None:
             expect(before, old_expected, case.label + ' reference oracle')
         if not case.change:
             expect(after, before, case.label + ' differential')
 
 
 def reference(fixtures):
     bundle = fixtures / 'http-headers-reference.arboricx'
     encoded = (fixtures / 'http-headers-reference.json').read_bytes()
     if sha(encoded) != REFERENCE_METADATA_SHA256:
         raise ValueError('immutable HTTP reference metadata mismatch')
     metadata = json.loads(encoded)
     if sha(bundle.read_bytes()) != REFERENCE_SHA256 or metadata['bundle_sha256'] != REFERENCE_SHA256:
         raise ValueError('immutable HTTP reference digest mismatch')
     snapshot_bytes(fixtures, metadata['source_digest'])
     if set(read(bundle)[3]) != set(EXPORTS) or metadata['exports'] != list(EXPORTS):
         raise ValueError('HTTP reference export mismatch')
     return bundle, metadata
 
 
 class Runner:
     def __init__(self, executable, directory):
         self.exe, self.root = executable.resolve(), directory
         self.store = directory / 'store'
         self.started = time.monotonic()
         self.calls = []
 
     def run(self, label, arguments):
         remaining = 600 - (time.monotonic() - self.started)
         if remaining <= 0:
             raise RuntimeError('HTTP regression exceeded ten-minute whole-run guard')
         command = [str(self.exe), 'arboricx', *map(str, arguments),
                    '+RTS', '-N1', '-M512m', '-RTS']
         started = time.monotonic()
         try:
             output, peak = run_guarded(command, memory_mib=1024, seconds=min(30, remaining))
         except Exception as error:
             (self.root / (label + '.log')).write_text(str(getattr(error, 'output', error)))
             raise
         self.calls.append(dict(label=label, seconds=time.monotonic()-started, peak_kib=peak))
         return output
 
     def imported(self, bundle, label):
         text = self.run(label, ['import', '--file', bundle, '--store', self.store, '--indexed'])
         match = re.search(r'Created module alias .* -> ([0-9a-f]{64})', text)
         if not match:
             raise ValueError('missing imported module identity')
         return match[1]
 
     def invoke(self, pin, case, side):
         source = self.root / (case.label + '.input.tree')
         source.write_bytes(case.input)
         value = parse_tree_output(self.run(case.label + '-' + side,
             ['run', '--module', pin, '--name', case.export, '--store', self.store,
              '--arg-tree-file', source, '--format', 'ternary']))
         (self.root / (case.label + '-' + side + '.tree')).write_bytes(value)
         return value
 
 
 def main():
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument('tricu', type=Path)
     parser.add_argument('--subject', type=Path, required=True)
     parser.add_argument('--directory', type=Path, required=True, help='must not exist')
     parser.add_argument('--case', action='append', help='repeatable exact case label; default all')
     parser.add_argument('--legacy-behavior', action='store_true', help='reproduce pre-correction readability corpus')
     args = parser.parse_args()
     selected = cases() if args.legacy_behavior else syntax_cases()
     if args.case:
         unknown = set(args.case) - {case.label for case in selected}
         if unknown:
             parser.error('unknown cases: ' + ', '.join(sorted(unknown)))
         selected = [case for case in selected if case.label in args.case]
     root = args.directory.resolve()
     root.mkdir(parents=True, exist_ok=False)
     runner = Runner(args.tricu, root)
     report = dict(complete=False, scope='selected artifact behavior; not source provenance or HTTP conformance',
                   runtime_sha256=sha(runner.exe.read_bytes()),
                   runner_sha256=sha(Path(__file__).read_bytes()), cases=[],
                   retired_out_of_contract_cases=[] if args.legacy_behavior else
                     [case.label for case in cases() if retired_case(case)])
     try:
         baseline, metadata = reference(ROOT / 'test/fixtures')
         report['reference'] = metadata
         # Copy first: all reported identities refer to the exact selected bytes,
         # not a path that could be republished midway through the run.
         subject = root / 'subject-original.arboricx'
         subject.write_bytes(args.subject.read_bytes())
         report['subject_sha256'] = sha(subject.read_bytes())
         workers = root / 'subject.arboricx'
         exports = sorted(set(EXPORTS) | {case.export for case in selected})
         merge_bundles(workers, [(subject, [(name, name) for name in exports])], prune_unreachable=True)
         old = runner.imported(baseline, 'reference-import')
         new = runner.imported(workers, 'subject-import')
         report.update(reference_manifest=old, subject_manifest=new,
                       selected_bundle_sha256=sha(workers.read_bytes()))
         print('HTTP subject SHA256:', report['subject_sha256'], flush=True)
         for case in selected:
             before = runner.invoke(old, case, 'reference') if case.export in EXPORTS else None
             after = runner.invoke(new, case, 'subject')
             check_case(case, before, after)
             report['cases'].append(dict(label=case.label, export=case.export, category=case.category,
                 input_sha256=sha(case.input), result_sha256=sha(after),
                 reference_result_sha256=sha(before) if before is not None else None,
                 change=case.change, differs_from_reference=(before != after) if before is not None else None,
                 independent_oracle=case.expected is not None))
         # A changed selected subject must not silently resolve to the reference.
         # Substitute a different real export; no source/compiler preparation.
         mutant = root / 'wrong-subject.arboricx'
         merge_bundles(mutant, [(subject, [(('readLineBytes' if name == 'parseHeaders' else name), name)
                                          for name in EXPORTS])], prune_unreachable=True)
         wrong = runner.imported(mutant, 'wrong-subject-import')
         control = Case('selection-control', 'parseHeaders', byte_tree(b'X: y\r\n\r\nbody'),
                        headers([(b'x', b'y')], b'body'))
         actual = runner.invoke(wrong, control, 'mutant')
         try:
             expect(actual, control.expected, 'wrong selected subject')
         except ValueError:
             report['wrong_subject_rejected'] = True
         else:
             raise ValueError('wrong selected subject unexpectedly passed')
         report['complete'] = True
     except Exception as error:
         report['failure'] = str(error)
         raise
     finally:
         report.update(seconds=time.monotonic()-runner.started, invocations=runner.calls)
         (root / 'report.json').write_text(json.dumps(report, indent=2) + '\n')
     print(f'PASS: {len(selected)} header cases + wrong-subject control; {report["seconds"]:.2f}s')
 
 
 if __name__ == '__main__':
     main()