. "$BST_LIB"
# BST-TIMEOUT: 1800  # SEVEN python3 starts, and they are the whole cost. One is
#                    # `import', one is the probe, and FIVE are the console
#                    # script -- which cannot share a process with anything,
#                    # because being a separate process reached through argv and
#                    # a pipe is the entire claim it makes.
#                    #
#                    # The conversion work itself is a 156-byte fixture and a
#                    # 1101-rule stylesheet: microseconds beside an interpreter
#                    # start on this arm. 1800 is 99-python3-wcwidth's 1200 plus
#                    # headroom for the four extra starts.
#                    #
#                    # NOT MEASURED ON TARGET YET: this port's first on-target
#                    # run is the batch verify. The measured elapsed replaces
#                    # this note in the test plan rather than in this comment,
#                    # which would cost an image build to keep the shipped suite
#                    # byte-identical.
#
# python3-ansi2html 1.9.1 (meta-openembedded/meta-python
# recipes-devtools/python/python3-ansi2html_1.9.1.bb -- `inherit pypi
# python_setuptools_build_meta', PyPI sdist) on the wasm32-hwjs glibc image.
#
# ============================================================================
# WHAT THE PACKAGE DOES.
# ============================================================================
#
# Terminal output in, a web page out. ANSI SGR escape sequences -- the bytes a
# program writes to colour its own output -- become HTML spans carrying the
# matching styles, either as a bare FRAGMENT to paste into a page or as a
# COMPLETE DOCUMENT with its own embedded stylesheet.
#
# So the deliverable is a transformation, and the suite is a table over it: the
# fixture holds ONE construct per line -- a foreground colour, a background
# colour, bold, underline, a 256-colour foreground index, a 256-colour
# background index, all four at once, and a reset -- and each line is asserted
# separately. A red then names WHICH construct broke, where a single assertion
# over the whole output would only say that 300 bytes differ somewhere.
#
# `frag-plain' and `frag-after-reset' are the controls of that table: text
# outside any escape, and text following a reset, must come through UNWRAPPED.
# A converter that wrapped everything would satisfy every colour case above and
# fail these two.
#
# ============================================================================
# THE DOCUMENT MODE, AND THE ONE CLAIM IT HAS TO MAKE.
# ============================================================================
#
# `doc-undefined-classes' is the case this suite is built around. A full
# document carries its own <style> block, and the block is PRUNED to what the
# body actually uses -- so the invariant is that every class the body references
# is defined in it. A document referencing `ansi38-208' and defining only the
# base rules would render the 256-colour run in the default colour and look, to
# anything short of this check, like a working conversion. The expected value is
# the empty string: the list of references with no rule.
#
# `doc-defined-count' is the other half. Eleven rules -- five base plus the six
# classes the fixture uses -- against the 1101 that `headers-rules' measures for
# the whole table. Equal numbers would mean the pruning stopped happening.
#
# ============================================================================
# WHAT inline=True ACTUALLY CHANGES -- MEASURED, AND NOT WHAT WAS ASSUMED.
# ============================================================================
#
# The obvious reading, and the one this ticket was filed with, is that
# `inline=True' carries the styles on the elements and emits NO stylesheet at
# all. That is half right, and the half that is wrong is worth stating plainly
# because it is the half a caller would rely on:
#
#   * IN THE BODY it is exactly true. `inline-body-no-class' asserts zero
#     `class="' in the <pre>, and `inline-body-style' asserts seven spans
#     carrying `style="' instead -- the same seven the class-mode body wrapped.
#   * AT DOCUMENT LEVEL IT IS FALSE. `produce_headers()' runs either way, so the
#     full document still carries a <style> block -- and
#     `doc-inline-same-headers' asserts the two blocks are BYTE-IDENTICAL. The
#     inline document therefore ships eleven rules nothing in it references.
#
# The output a caller wanting "styles on the elements and nothing else" needs is
# the FRAGMENT, and `inline-frag-no-style-tag' is what says so. All of this is
# measured against the built wasm32 package's own bytes; none of it is inferred
# from the docs.
#
# ============================================================================
# THE CONSOLE SCRIPT, AND WHY IT IS FIVE SEPARATE PROCESSES.
# ============================================================================
#
# /usr/bin/ansi2html is the package's other half and it is not reachable from
# inside the probe: what it claims is that the same converter, reached through
# argv and a PIPE, produces the same bytes. So the shell drives it, and the
# comparison is byte equality against artifacts the probe wrote in its own
# process -- `cli-doc', `cli-frag', `cli-ifrag' are `cmp' against api-doc.html,
# api-frag.html and api-ifrag.html. A substring check would pass on a script
# that dropped a line.
#
# `cli-version' is not cosmetic and is the case most likely to red on a
# packaging change. main() calls importlib.metadata.version("ansi2html") BEFORE
# it parses a single argument, so a package whose .dist-info did not ship has a
# CLI that cannot start AT ALL -- while every library case here would stay
# green, because ansi2html/_version.py carries its own __version__. The two are
# independent statements of the version and `version-agrees' compares them.
#
# That same importlib.metadata call is why the built package's Depends names
# python3-compression: importlib.metadata pulls in zipfile. It is a real runtime
# edge on this image, not a packaging artefact.
#
# ============================================================================
# WHY IT PORTS: PURE PYTHON, NO C, AND ONE STALE DEPENDENCY.
# ============================================================================
#
# This image's python3 is ONE STATIC BINARY with an empty lib-dynload and no
# dynamic loader (BRINTOS-1476; 99-python3 asserts both). A module carrying a
# compiled extension could not be imported here -- not "would be slow", could
# not be imported.
#
# ansi2html ships no .c, .pyx or .so; its imports are argparse, io, re, sys,
# collections, typing and importlib.metadata, all sub-packages of the ported
# python3. `pkg-no-so' is a REGRESSION TRIPWIRE for a version bump that grew
# one, not a statement about today.
#
# ONE MEASURED DISCREPANCY, STATED RATHER THAN QUIETLY CARRIED. The recipe
# declares RDEPENDS:${PN} = "python3-six python3-compression" and the built
# control stanza carries `python3-six' -- but 1.9.1's sources contain NO
# reference to six, and its own requires.txt names it for no python version at
# all. `pkg-depends-six' asserts what the package actually declares (so the
# suite reports the image as it is) and `six-not-imported' asserts what it
# actually uses. The dependency is already satisfied on this image
# (BRINTOS-1744), so it costs this port nothing; the pair is what would notice a
# release that really did grow the import the recipe already pays for.
#
# ============================================================================
# EVERY LITERAL BELOW IS MEASURED, AND AGAINST WHAT.
# ============================================================================
#
# Measured on x86-64 against the sdist the recipe's SRC_URI sha256 pins
# (5c6837a1...ec71, digest verified before anything was read), and again against
# the bytes unpacked from the built python3-ansi2html_1.9.1-r0_wasm32.deb. All
# SEVEN shipped files -- __init__.py, __main__.py, _version.py, converter.py,
# style.py, util.py, py.typed -- are BYTE-IDENTICAL between the two, so the
# control run is over the same bytes the target will execute; the probe's output
# differs only in `module_file'. The console script was run from the deb's own
# /usr/bin/ansi2html and produced output byte-identical to the API's in all
# three modes.
#
# The control interpreter is CPython 3.10 and the image ships 3.12. Nothing
# asserted here is version-sensitive -- the package uses no 3.11+ syntax and its
# output is templated strings -- but the gap is stated rather than papered over.
#
# THE ON-TARGET RESULT IS NOT YET MEASURED. The batch verify is this port's
# first run on wasm32-hwjs, and everything this file says about how it will go
# is a PREDICTION.

P=python3-ansi2html

# THE CANARY, which asserts nothing about python3-ansi2html.
#
# A suite's FIRST BST result line is lost between the guest's printf and the
# host's read -- per-suite, deterministic, and NOT a defect in the host tool
# (BRINTOS-1149 established that and filed it as linux-in-the-browser#177). The
# harness computes its pass count as total-minus-failures, so THE DROPPED LINE
# IS COUNTED AS A PASS. A nothing-case therefore stands in that position and the
# eaten line costs nothing. It sits ahead of the `require' guards deliberately,
# because a `require' that skips would emit its skip as the first line and be
# eaten too.
#
# Remove this case when linux-in-the-browser#177 is fixed.
bst_ok $P/suite-canary

require python3 $P/python3-present

SITE=/usr/lib/python3.12/site-packages
PKGDIR=$SITE/ansi2html
DI=$SITE/ansi2html-1.9.1.dist-info
PKGLIST=/var/lib/dpkg/info/python3-ansi2html.list
PROBE=$BST_DATA/python3-ansi2html-probe.py
FIXTURE=$BST_DATA/ansi2html-fixture.ansi
SCRIPT=/usr/bin/ansi2html
tmp=${TMPDIR:-/tmp}
W=$tmp/bst-ansi2html.$$
mkdir -p "$W" || { bst_notok $P/workdir "cannot create $W"; exit 0; }

# ------------------------------------------------------------- the payload ---
# WHICH COPY ANSWERED. `import' further down is the functional statement; these
# say the package landed where this image installed it, so a module that
# imported out of some other path on sys.path stays distinguishable from one
# that did not.
check $P/site-packages-dir test -d "$SITE"
check $P/package-dir       test -d "$PKGDIR"
check $P/module-init       test -f "$PKGDIR/__init__.py"
check $P/module-converter  test -s "$PKGDIR/converter.py"
check $P/module-style      test -s "$PKGDIR/style.py"
check $P/module-util       test -s "$PKGDIR/util.py"
check $P/module-version    test -s "$PKGDIR/_version.py"
# __main__.py is what the console script imports `main' from, so it is the file
# whose absence breaks the CLI while leaving the library whole.
check $P/module-main       test -s "$PKGDIR/__main__.py"

# THE CONSOLE SCRIPT, AS A FILE, BEFORE ANYTHING TRIES TO RUN IT. `cli-version'
# below is the functional statement; this one separates "the script did not
# ship" from "the script ran and got the wrong answer", which are different
# packaging failures with the same symptom at the CLI.
check $P/script-present test -f "$SCRIPT"
check $P/script-exec    test -x "$SCRIPT"

# NO COMPILED EXTENSION ANYWHERE THE PACKAGE PUT ANYTHING. On this image a .so
# could not be loaded at all (see the header), so this is the case that fails a
# version bump which grew one -- loudly, here, instead of at `import' later.
#
# The list is copied to tmpfs first and never redirected from the rootfs: a
# top-level stdin redirect on the virtiofs root makes dup2(2) return 513 and ash
# EXITS, ending the suite silently (brintos/linux#73).
cat "$PKGLIST" > "$W/pkgf" 2>/dev/null || : > "$W/pkgf"
check $P/pkg-list-present test -s "$W/pkgf"
check_eq $P/pkg-no-so "" \
  "$(grep -E '\.so($|\.)' "$W/pkgf" 2>/dev/null)"

# EVERY REGULAR FILE THE PACKAGE SHIPS IS PYTHON, ITS METADATA, OR THE ONE
# SCRIPT. The case above names the failure that is expected; this one catches
# the shape nobody predicted -- a binary, a .pyd, a stray data file -- without
# having to enumerate what it might be.
#
# Two exemptions, both measured off the built deb rather than guessed:
# /usr/bin/ansi2html, which is the console script and the point of the package;
# and ansi2html/py.typed, the zero-byte PEP 561 marker that tells a type checker
# the inline annotations are authoritative. A dpkg .list names DIRECTORIES too,
# and without a trailing slash, so each entry is tested for being a regular file
# first.
_bad=""
while IFS= read -r _f; do
  [ -f "$_f" ] || continue
  case "$_f" in
    *.py|*.pyc)         continue ;;
    */__pycache__/*)    continue ;;
    */*.dist-info/*)    continue ;;
    */ansi2html/py.typed) continue ;;
    /usr/bin/ansi2html) continue ;;
  esac
  _bad="$_bad $_f"
done < "$W/pkgf"
check_eq $P/pkg-only-python "" "$_bad"

# ----------------------------------------------------------- the dist-info ---
# NOT DECORATION ON THIS PACKAGE. The console script reads it at startup through
# importlib.metadata (see the header), so these four cases are a precondition
# for `cli-version' rather than a metadata formality.
check $P/dist-info-dir      test -d "$DI"
check $P/dist-info-metadata test -f "$DI/METADATA"
check_out $P/dist-info-name    "Name: ansi2html"  cat "$DI/METADATA"
check_out $P/dist-info-version "Version: 1.9.1"   cat "$DI/METADATA"
# top_level.txt names the ONE importable this package installs -- what an
# `import ansi2html' has to match, and what a wheel that renamed the package
# would change first.
check_out $P/dist-info-top-level "ansi2html" cat "$DI/top_level.txt"
# The entry point the console script was generated FROM. `script-present' says a
# file is at /usr/bin/ansi2html; this says the packaging still agrees about what
# that file should call.
check_out $P/dist-info-entry-point "ansi2html = ansi2html.__main__:main" \
  cat "$DI/entry_points.txt"

# ------------------------------------------------------------- the package ---
# dpkg KNOWS the package. Every case above would look identical if some other
# package had installed the same files, so this is the one that says
# python3-ansi2html is a real package this image installed rather than an
# IMAGE_INSTALL line that resolved to nothing.
#
# The stanza is read from a tmpfs copy for the same reason as the file list, and
# the anchor is exact -- an unanchored match would also take the -dev or -dbg
# stanza of the same family.
sed -n '/^Package: python3-ansi2html$/,/^$/p' /var/lib/dpkg/status > "$W/st" 2>/dev/null
check $P/pkg-known test -s "$W/st"
check_out $P/pkg-installed "Status: install ok installed" cat "$W/st"

# THE RUNTIME DEPENDENCIES, AS dpkg RECORDED THEM. Three, and they are not
# equally justified -- see the header. python3-core and python3-compression are
# real (the latter because importlib.metadata pulls in zipfile); python3-six is
# declared by the recipe and used by nothing, which `six-not-imported' below is
# the other half of.
grep '^Depends:' "$W/st" > "$W/dep" 2>/dev/null || : > "$W/dep"
check $P/pkg-depends-line        test -s "$W/dep"
check_out $P/pkg-depends-core        "python3-core"        cat "$W/dep"
check_out $P/pkg-depends-compression "python3-compression" cat "$W/dep"
check_out $P/pkg-depends-six         "python3-six"         cat "$W/dep"

# ------------------------------------------------------------- the fixture ---
# The 156 bytes every conversion case below is about. If it did not ship, every
# one of them reds naming a different missing span; this says the cause is the
# fixture.
check $P/fixture-present test -s "$FIXTURE"

# ---------------------------------------------------------- the interpreter ---
# THE IMPORT, ON ITS OWN, BEFORE THE PROBE. If ansi2html cannot be imported then
# every probe case below reds at once and each names a different symptom; this
# case is what says the cause is the import. It is also the cheapest possible
# statement of the deliverable.
check $P/import python3 -c 'import ansi2html'

# ---------------------------------------------------------------- the probe ---
if [ ! -f "$PROBE" ]; then
  bst_notok $P/probe-present "$PROBE did not ship"
  rm -rf "$W"
  exit 0
fi
bst_ok $P/probe-present

# ONE interpreter start for everything the library does. bst_probe bounds it and
# keeps BOTH streams: a probe that dies early otherwise leaves every case below
# reporting got:'' and naming a symptom each, with the actual traceback nowhere.
# The bound is generous because a python3 start on this arm is tens of seconds
# before any work begins.
#
# A2H_OUT is where the probe writes the three artifacts the console-script cases
# `cmp' against -- one interpreter produces both sides of that comparison, so a
# difference is the script's rather than the fixture's.
bst_probe $P/probe-run "$W/probe" 900 \
  env A2H_FIXTURE="$FIXTURE" A2H_OUT="$W" python3 "$PROBE"

OUT="$W/probe"
# Read a single key. The probe emits each key at most once, so head -n 1 is
# defensive rather than load-bearing; the anchors keep `frag_l1' distinguishable
# from `ifrag_l1', and `headers_rules' from `headers_rules_after_truecolor'.
pv() { grep "^$1=" "$OUT" 2>/dev/null | head -n 1 | cut -d= -f2-; }

# THE EVIDENCE PLANE. If the probe emitted nothing, every case below is reading
# an absent file: each would red with got:'' and the set would read exactly like
# a broken library, when what actually happened is that no measurement was
# taken.
#
# The word `unscorable' is PARSED -- brintos_local_verify re-measures a suite
# that prints it on a fresh guest rather than trusting a shared boot's numbers
# (BRINTOS-1644) -- so it goes in this structural check, not in a comment.
#
# The cases below still print their reds: withdraw, do not hide. This case is
# what says what those reds measure.
if [ -s "$OUT" ]; then
  bst_ok $P/probe-output
else
  bst_notok $P/probe-output "probe produced no output; every case below is unscorable"
fi
# The probe's last line. A probe killed part-way emits a prefix of its keys, and
# every case reading a key it never reached would red as a wrong ANSWER rather
# than an absent one.
check_eq $P/probe-complete "1" "$(pv done)"

# ---------------------------------------------------------- identity, version ---
check_eq $P/version        "1.9.1"                          "$(pv version)"
check_eq $P/md-version     "1.9.1"                          "$(pv md_version)"
# The two are independent: one comes from ansi2html/_version.py, the other from
# the installed .dist-info through importlib.metadata. They can disagree only if
# the packaging and the source disagree, which is exactly the case a version
# bump gets wrong.
check_eq $P/version-agrees "True"                           "$(pv version_agrees)"
check_eq $P/all-exports    "Ansi2HTMLConverter __version__"  "$(pv all_exports)"
# WHICH copy answered. Asserted as a prefix of the image's own site-packages
# rather than an exact path, so it stays true across a python3 micro bump.
check_out $P/module-path "$PKGDIR/__init__.py" echo "$(pv module_file)"

# The stale RDEPENDS, from the other side -- see the header and
# `pkg-depends-six'. Importing ansi2html must not pull six in, and 1.9.1 does
# not; a release that started to would flip this and leave every other case
# green.
check_eq $P/six-not-imported       "False" "$(pv six_imported)"
# typing_extensions is imported only below python 3.8. This image is 3.12, so
# the fallback branch must not be taken -- and if it ever were, the package
# would need a dependency this image does not carry.
check_eq $P/typing-ext-not-imported "False" "$(pv typing_ext_imported)"

# ------------------------------------------------------------- the fixture ---
# The bytes the conversion table below is a function of, pinned by digest. A
# fixture that changed would move every expected span at once, and this is the
# case that would say so instead of leaving nine reds looking like nine bugs.
check_eq $P/fixture-bytes "156" "$(pv fixture_bytes)"
check_eq $P/fixture-sha \
  "01469c4c00fb2d03033dd423b8286582703687aef7a6b93d5040a3843e55c003" \
  "$(pv fixture_sha)"
# Fourteen ESC bytes: seven constructs, each opened and reset.
check_eq $P/fixture-esc "14" "$(pv fixture_esc)"

# ------------------------------------------- THE CONVERSION, CONSTRUCT BY CONSTRUCT ---
# Ten lines because the fixture ends in a newline, so the split yields a trailing
# empty element -- `frag-trailing' asserts it rather than leaving it as an
# off-by-one nobody checked.
check_eq $P/frag-lines "10" "$(pv frag_lines)"
check_eq $P/frag-sha \
  "fa8b0ce02abb3e1c3171d0ae34d75650fab768754abb8d2a083d9febeb15e59c" \
  "$(pv frag_sha)"

# CONTROL: text outside any escape comes through UNWRAPPED. A converter that
# wrapped everything would pass all seven colour cases below and fail this one.
check_eq $P/frag-plain       'plain'                                  "$(pv frag_l1)"
# SGR 31 -- the eight basic foreground colours, `ansiNN' named after the code.
check_eq $P/frag-fg-red      '<span class="ansi31">fg-red</span>'     "$(pv frag_l2)"
# SGR 42 -- the basic background colours, a separate branch of the same state.
check_eq $P/frag-bg-green    '<span class="ansi42">bg-green</span>'   "$(pv frag_l3)"
# SGR 1 and 4 -- attributes rather than colours, which is a third branch again.
check_eq $P/frag-bold        '<span class="ansi1">bold</span>'        "$(pv frag_l4)"
check_eq $P/frag-underline   '<span class="ansi4">underline</span>'   "$(pv frag_l5)"
# SGR 38;5;N and 48;5;N -- the 256-colour indexed palette. The class name carries
# the INDEX after a hyphen, so this is where a parser that stopped at the first
# `;' would fail.
check_eq $P/frag-fg256       '<span class="ansi38-208">fg256-208</span>' "$(pv frag_l6)"
check_eq $P/frag-bg256       '<span class="ansi48-17">bg256-17</span>'   "$(pv frag_l7)"
# FOUR CODES IN ONE ESCAPE, and the ordering of the emitted classes is part of
# the assertion: attributes first, then foreground, then background. One span,
# not four nested ones.
check_eq $P/frag-all-four \
  '<span class="ansi1 ansi4 ansi31 ansi42">all-four</span>' "$(pv frag_l8)"
# CONTROL: after SGR 0 the state is clear again, so this line is unwrapped. A
# converter that leaked state across the reset would wrap it.
check_eq $P/frag-after-reset 'after-reset'                            "$(pv frag_l9)"
check_eq $P/frag-trailing    ''                                       "$(pv frag_l10)"

# ------------------------------------------------------ THE DOCUMENT MODE ---
check_eq $P/doc-doctype     "True" "$(pv doc_doctype)"
check_eq $P/doc-style-open  "1"    "$(pv doc_style_open)"
check_eq $P/doc-style-close "1"    "$(pv doc_style_close)"
check_eq $P/doc-pre-class   "1"    "$(pv doc_pre_class)"
# The six classes the body references, sorted.
check_eq $P/doc-used-classes \
  "ansi1 ansi31 ansi38-208 ansi4 ansi42 ansi48-17" "$(pv doc_used_classes)"
# THE CASE THIS SUITE IS BUILT AROUND -- see the header. Every class the body
# references has a rule in the embedded stylesheet; the expected value is the
# empty list of those that do not.
check_eq $P/doc-undefined-classes "" "$(pv doc_undefined_classes)"
# Eleven: five base rules plus the six above. Against `headers-rules' 1101, this
# is what says the document's stylesheet is PRUNED to what it uses.
check_eq $P/doc-defined-count "11" "$(pv doc_defined_count)"
# The class-mode body carries no inline styles at all -- the complement of
# `inline-body-style' below, and what makes the two modes distinguishable rather
# than merely different.
check_eq $P/doc-body-no-inline "0" "$(pv doc_body_inline_styles)"

# ----------------------------------------------------------- inline=True ----
# In the BODY, the swap is total: no classes, seven styled spans.
check_eq $P/inline-body-no-class "0" "$(pv inline_body_class)"
check_eq $P/inline-body-style    "7" "$(pv inline_body_style)"
# AND THE STYLESHEET IS STILL THERE, BYTE-IDENTICAL to the class-mode one. This
# is the case that corrects the assumption the ticket was filed with -- see the
# header. The inline document ships eleven rules nothing in it references.
check_eq $P/doc-inline-same-headers "True" "$(pv doc_equals_inline_headers)"
# The output that DOES carry styles and nothing else is the FRAGMENT.
check_eq $P/inline-frag-no-style-tag "False" "$(pv inline_frag_style_tag)"
check_eq $P/inline-frag-no-class     "0"     "$(pv inline_frag_class)"
check_eq $P/inline-frag-style        "7"     "$(pv inline_frag_style)"

# The same seven constructs again, as declarations rather than class names. This
# is where the SCHEME's actual colour values become visible -- `ansi31' above
# says only "red by name", `color: #aa0000' says which red.
check_eq $P/ifrag-fg-red \
  '<span style="color: #aa0000">fg-red</span>'                "$(pv ifrag_l2)"
check_eq $P/ifrag-bg-green \
  '<span style="background-color: #00aa00">bg-green</span>'   "$(pv ifrag_l3)"
check_eq $P/ifrag-bold \
  '<span style="font-weight: bold">bold</span>'               "$(pv ifrag_l4)"
check_eq $P/ifrag-underline \
  '<span style="text-decoration: underline">underline</span>' "$(pv ifrag_l5)"
# The 256-colour indices resolved to their palette entries: 208 is orange, 17 a
# dark blue. Note `background' rather than `background-color' for the indexed
# form -- upstream emits a different property here than for the basic colours,
# which is the kind of detail only a byte-exact assertion catches.
check_eq $P/ifrag-fg256 \
  '<span style="color: #ff8700">fg256-208</span>'             "$(pv ifrag_l6)"
check_eq $P/ifrag-bg256 \
  '<span style="background: #00005f">bg256-17</span>'         "$(pv ifrag_l7)"
# All four declarations in one attribute, semicolon-separated, in the same order
# the classes appeared in.
check_eq $P/ifrag-all-four \
  '<span style="font-weight: bold; text-decoration: underline; color: #aa0000; background-color: #00aa00">all-four</span>' \
  "$(pv ifrag_l8)"

# ------------------------------------------------------- the other options ---
# ESCAPING IS ON BY DEFAULT, and it is the security-shaped case here: the input
# is terminal output, so `<b>' in it must not become markup in the page. `&amp'
# becoming `&amp;amp' is the same rule applied to an ampersand that was already
# an entity -- the converter escapes bytes, it does not try to parse them.
check_eq $P/escape   '&lt;b&gt;&amp;amp<span class="ansi31">x</span>' "$(pv escape)"
# The explicit opt-out, for input already known to be markup.
check_eq $P/unescape '<b>x' "$(pv unescape)"
# 24-BIT COLOUR takes a different path from the indexed palette: the class name
# is synthesised from the packed r/g/b triple, 1/64/255 zero-padded to
# 001064255, and its rule is added to the stylesheet on the fly.
check_eq $P/truecolor '<span class="ansi38-001064255">tc</span>' "$(pv truecolor)"
check_eq $P/linkify \
  'see <a href="http://e.com/">http://e.com/</a> x' "$(pv linkify)"
# Line ids for anchoring into the output. The probe folds the newline to `|' so
# the boundary stays visible in this assertion -- the runner parses line by
# line, so a real newline here would split one result into stray text.
check_eq $P/markup-lines \
  '<span id="line-0">a</span>|<span id="line-1">b</span>' "$(pv markup_lines)"
# LaTeX is the second output format the same converter produces, sharing the
# escape-parsing front end with HTML. One case keeps a port that broke only the
# LaTeX back end from passing everything else.
check_eq $P/latex '\textcolor{ansi31}{r}' "$(pv latex)"

# The palettes the package ships. A build that lost style.py's data would still
# import and still convert -- into an empty scheme.
check_eq $P/scheme-count "8" "$(pv scheme_count)"
check_eq $P/scheme-names \
  "ansi2html dracula mint-terminal osx osx-basic osx-solid-colors solarized xterm" \
  "$(pv scheme_names)"
# The FULL rule table, against the document's pruned eleven.
check_eq $P/headers-rules "1101" "$(pv headers_rules)"
# ONE RULE MORE, from the same converter, because the `truecolor' case ran in
# between: `add_truecolor_style_rule' records 24-bit rules in MODULE-level
# state, so every converter constructed afterwards reports them too. Upstream's
# behaviour, harmless here, and asserted so it is a stated fact with a number on
# it rather than an ordering the next editor of this file could break silently.
check_eq $P/headers-truecolor-leak "1102" "$(pv headers_rules_after_truecolor)"
check_eq $P/util-read "['a\n', 'b\n']" "$(pv util_read)"

# ------------------------------------------------------- THE CONSOLE SCRIPT ---
# Five separate processes, because being a separate process is the claim -- see
# the header. The probe wrote its three artifacts into $W; these compare the
# script's bytes against them.
check_eq $P/api-files "3" "$(pv api_files)"

if [ ! -x "$SCRIPT" ]; then
  bst_notok $P/cli-usable "$SCRIPT is not executable; the five CLI cases below cannot run"
else
  bst_ok $P/cli-usable

  # THE dist-info READ AT STARTUP. main() calls
  # importlib.metadata.version("ansi2html") before parsing any argument, so this
  # is the case that reds if the .dist-info did not ship -- while every library
  # case above stays green off ansi2html/_version.py.
  check_out $P/cli-version "ansi2html 1.9.1" "$SCRIPT" --version

  # THE FIXTURE THROUGH A PIPE, in each of the three modes, compared BYTE FOR
  # BYTE against what the API produced in the probe's process. `cat f | prog' is
  # also what keeps the redirect off the top-level shell: a stdin redirect from
  # the virtiofs root makes dup2(2) return 513 and ash exits (brintos/linux#73),
  # while the pipe forks first.
  cat "$FIXTURE" | "$SCRIPT"           > "$W/cli-doc.html"   2>"$W/cli-doc.err"
  cat "$FIXTURE" | "$SCRIPT" --partial > "$W/cli-frag.html"  2>"$W/cli-frag.err"
  cat "$FIXTURE" | "$SCRIPT" -i -p     > "$W/cli-ifrag.html" 2>"$W/cli-ifrag.err"
  check $P/cli-doc   cmp -s "$W/api-doc.html"   "$W/cli-doc.html"
  check $P/cli-frag  cmp -s "$W/api-frag.html"  "$W/cli-frag.html"
  check $P/cli-ifrag cmp -s "$W/api-ifrag.html" "$W/cli-ifrag.html"

  # THE STYLESHEET ALONE, which is the mode a caller uses to emit headers once
  # and fragments many times. 1101 rules, the same figure `headers-rules'
  # measured through the API.
  ( "$SCRIPT" --headers < /dev/null ) > "$W/cli-hdr.txt" 2>/dev/null
  check_out $P/cli-headers-open '<style type="text/css">' cat "$W/cli-hdr.txt"
  check_eq  $P/cli-headers-rules "1101" \
    "$(awk '{sub(/^[ \t]+/,"")} /^\./{n++} END{print n+0}' "$W/cli-hdr.txt")"

  # ARGUMENT VALIDATION. `--scheme' is a choices= argument, so an unknown value
  # must be REFUSED rather than silently falling back to the default -- argparse
  # exits 2. This is the case that says the CLI is parsing its arguments at all
  # rather than ignoring them.
  check_rc $P/cli-bad-scheme 2 sh -c 'printf x | '"$SCRIPT"' --scheme no-such-scheme'
fi

rm -rf "$W"