# BST-TIMEOUT: 900   # section 7 runs five real DocBook XSLT transforms
. "$BST_LIB"

# xorg-sgml-doctools 1.12 -- the SGML entities and XML/CSS stylesheets the X.Org
# documentation set is built against (meta-oe recipes-graphics/xorg-doc). Nine
# installed files and no executable code. See xorg-sgml-doctools_%.bbappend for
# what the port adds and why.
#
# ---------------------------------------------------------------------------
# WHAT THIS IMAGE CAN ASSERT ABOUT A PACKAGE THAT IS PURE DATA
#
# Nothing here runs, so a file listing establishes only that the bytes arrived.
# Two things make much more than a listing possible, and neither was assumed --
# both were measured before this file was written.
#
# The first is that this image already carries a COMPLETE DocBook toolchain:
# xsltproc (libxslt-bin), xmllint (libxml2-utils), docbook-xsl-stylesheets,
# docbook-xml-dtd4, xmlto, and an /etc/xml/catalog that chains to both. So
# section 7 does not parse these stylesheets -- it RUNS them, over a DocBook
# fixture, and reads what came out. That is the package's entire purpose, and it
# is checkable here.
#
# The second is the CENSUS at $CENSUS, written at do_install by Python's expat
# and a text scan. Section 4 re-derives every one of its numbers through
# libxml2 -- an implementation sharing no code with expat -- so two unrelated XML
# stacks agree, file by file, on the shape of all six documents.
#
# ---------------------------------------------------------------------------
# THE PASS CRITERION SAYS "EACH XML/XSL FILE PARSES", AND THE SET IT NAMES IS
# SMALLER THAN THE INSTALL. Two of the nine files are not XML documents at all:
# defs.ent is a DTD fragment (a bare run of <!ENTITY> declarations, no root
# element) and xorg.css is CSS. `xmllint --noout` on either exits 1, correctly.
# Section 2 pins both as negative controls rather than leaving the exclusion to
# read like an oversight -- a suite that quietly skipped them would look the same
# as one whose author had not noticed, and the naive reading of the criterion
# would have shipped two permanent reds.
#
# defs.ent is not thereby unchecked: section 3 does the thing a consumer actually
# does with it -- pulls it in as an external PARAMETER entity from a probe
# document's DOCTYPE and expands the general entities it declares.
#
# ---------------------------------------------------------------------------
# THE ONE INVARIANT THAT IS ABOUT LAYOUT RATHER THAN CONTENT. xorg-xhtml.xsl and
# xorg-chunk.xsl declare <!ENTITY xorgcss SYSTEM "xorg.css"> and write &xorgcss;
# into a <style> element, so xorg.css must stay a SIBLING of them in the
# installed tree. Break that and xsltproc does not fail: it warns, substitutes
# nothing, and emits a well-formed document that has silently lost its
# stylesheet. Section 7's nocss control is what makes that visible, and it is
# scored on OUTPUT SIZE and content, not on exit status -- measured, because the
# obvious "it must fail" version of that control is green for the wrong reason.

X11=/usr/share/sgml/X11
PCDIR=/usr/share/pkgconfig
CENSUS=$(bst_local "/usr/share/xorg-sgml-doctools/CENSUS")   # tmpfs copy: a `done < "$CENSUS"` runs in this shell (brintos/linux#73)
ORACLE=/usr/share/xorg-sgml-doctools/ORACLE
CATALOG=/etc/xml/catalog

# The version the recipe pins, measured 2026-08-22. Hardcoded ON PURPOSE:
# pc-modversion-matches-census asks whether the .pc agrees with the recipe, which
# is the check that catches a .pc.in substitution that broke -- but it moves with
# a bump and so cannot notice one. This constant is what makes an upstream bump a
# changed number here rather than a silent pass.
SGML_PV=1.12

# The declared set, from three lines of Makefile.am. An EQUALITY, not a floor --
# see the bbappend. Order is the census's.
VERBATIM="defs.ent xorg.css xorg.xsl xorg-xhtml.xsl xorg-chunk.xsl xorg-fo.xsl"
GENERATED="dbs/masterdb.html.xml dbs/masterdb.pdf.xml"
XMLDOCS="xorg.xsl xorg-xhtml.xsl xorg-chunk.xsl xorg-fo.xsl dbs/masterdb.html.xml dbs/masterdb.pdf.xml"

# The first BST result line of a suite is dropped by the guest console
# (brintos/linux#96), consistently and every run. This case asserts something
# already true so that what is lost costs nothing; remove it when #96 lands.
if [ -d "$X11" ]; then bst_ok xorg-sgml-doctools/suite-canary
else bst_notok xorg-sgml-doctools/suite-canary "$X11 is not a directory"; fi

# ---------------------------------------------------------------- 1. it arrived
check xorg-sgml-doctools/x11-dir test -d "$X11"
check xorg-sgml-doctools/dbs-dir test -d "$X11/dbs"
check xorg-sgml-doctools/census-installed test -f "$CENSUS"
check xorg-sgml-doctools/oracle-installed test -f "$ORACLE"
check xorg-sgml-doctools/pc-installed test -f "$PCDIR/xorg-sgml-doctools.pc"

missing=""
for f in $VERBATIM $GENERATED; do
    [ -f "$X11/$f" ] || missing="$missing $f"
done
if [ -z "$missing" ]; then bst_ok xorg-sgml-doctools/declared-set
else bst_notok xorg-sgml-doctools/declared-set "not installed:$missing"; fi

# The other direction. The declared set is an equality, so a file that is present
# and NOT declared is as much a fault as one that is missing -- and it is the
# direction no per-name check above can see.
nfound=0
for f in "$X11"/* "$X11"/dbs/*; do [ -f "$f" ] && nfound=$((nfound + 1)); done
if [ "$nfound" -eq 8 ]; then bst_ok xorg-sgml-doctools/no-extra-files
else bst_notok xorg-sgml-doctools/no-extra-files "$nfound file(s) under $X11 against the 8 Makefile.am declares (the 9th is the .pc, elsewhere)"; fi

# ------------------------------------------- 2. the XML documents, and the two
#                                                 files that are not documents
have_xmllint=0
command -v xmllint >/dev/null 2>&1 && have_xmllint=1

if [ "$have_xmllint" -eq 1 ]; then
    # One invocation over the whole set: the argv is ~200 bytes against the
    # guest's 8192-byte __wasm32_args_buf, nowhere near the limit that wedges an
    # exec (brintos/hardwarejs#15), and xmllint names the file that failed either
    # way. --nonet because masterdb's DOCTYPE is an http SYSTEM id: libxml2 does
    # not fetch it by default, and --nonet is what makes that a property of the
    # command rather than of the default.
    ( cd "$X11" && xmllint --noout --nonet $XMLDOCS ) 2>/dev/null
    if [ $? -eq 0 ]; then bst_ok xorg-sgml-doctools/xml-wellformed
    else
        out=$( cd "$X11" && xmllint --noout --nonet $XMLDOCS 2>&1 )
        if bst_execfail "$out"; then bst_unrun xorg-sgml-doctools/xml-wellformed "$out"
        else bst_notok xorg-sgml-doctools/xml-wellformed "$out"; fi
    fi

    # Resolving the external entity as well, which is what a consumer's parse
    # does. Separate from the case above because it is a different question: the
    # first says the stylesheets are well-formed, this says xorg.css is reachable
    # from where they sit.
    #
    # SCORED ON THE RESOLVED TEXT, NOT ON THE EXIT STATUS, and that is the whole
    # point of the case. libxml2 does not fail an unresolvable external entity --
    # it warns and substitutes nothing -- so `xmllint --noent && ok` is green with
    # xorg.css deleted, with xorg.css emptied, and with it correct. The first
    # version of this case was exactly that, and the mutation run is what caught
    # it: two mutations that should have reddened it left it untouched.
    ENTXP="string-length(normalize-space(//*[local-name()='style']))"
    nent=0; badent=""
    for f in xorg-xhtml.xsl xorg-chunk.xsl; do
        n=$( cd "$X11" && xmllint --nonet --noent --xpath "$ENTXP" "$f" 2>/dev/null )
        case "$n" in
        ''|*[!0-9]*) badent="$badent $f(='$n')" ;;
        *) if [ "$n" -gt 0 ]; then nent=$((nent + 1)); else badent="$badent $f(empty)"; fi ;;
        esac
    done
    if [ "$nent" -eq 2 ]; then bst_ok xorg-sgml-doctools/xorgcss-entity-resolves
    else bst_notok xorg-sgml-doctools/xorgcss-entity-resolves "the <style> element expands to nothing in:$badent -- &xorgcss; did not resolve to $X11/xorg.css, which libxml2 reports as a warning and not an error"; fi

    # The two negative controls. They are not decoration: they are what says the
    # case above is discriminating rather than green on anything handed to it,
    # and they document why the XML set is six files and not eight.
    # The `test -f` is load-bearing: xmllint also exits 1 on a file that is not
    # there, so without it a DELETED defs.ent would leave this control green --
    # a negative control that passes when its subject is missing is the exact
    # shape of a case that asserts nothing.
    if [ -f "$X11/defs.ent" ]; then
        check_rc xorg-sgml-doctools/defs-ent-not-a-document 1 xmllint --noout --nonet "$X11/defs.ent"
    else
        bst_notok xorg-sgml-doctools/defs-ent-not-a-document "defs.ent is not installed"
    fi
    if [ -f "$X11/xorg.css" ]; then
        check_rc xorg-sgml-doctools/css-not-a-document 1 xmllint --noout --nonet "$X11/xorg.css"
    else
        bst_notok xorg-sgml-doctools/css-not-a-document "xorg.css is not installed"
    fi
else
    bst_skip xorg-sgml-doctools/xml-wellformed "xmllint not installed on this image"
    bst_skip xorg-sgml-doctools/xorgcss-entity-resolves "xmllint not installed on this image"
    bst_skip xorg-sgml-doctools/defs-ent-not-a-document "xmllint not installed on this image"
    bst_skip xorg-sgml-doctools/css-not-a-document "xmllint not installed on this image"
fi

# ------------------------------------- 3. defs.ent, used the way it is meant to
# The X.Org documents that consume this file open with
#   <!ENTITY % defs SYSTEM "defs.ent"> %defs;
# and then reference &relvers; and friends. That is what is done here, so the
# check is of the file's actual contract rather than of its bytes.
tmp=${TMPDIR:-/tmp}/bst-sgmldt.$$
if mkdir -p "$tmp" 2>/dev/null; then
    bst_ok xorg-sgml-doctools/tmpdir
else
    bst_notok xorg-sgml-doctools/tmpdir "cannot create $tmp"
fi

cens_relvers=""
cens_reldate=""
if [ -f "$CENSUS" ]; then
    cens_relvers=$(sed -n 's/^SGML-ENTITY relvers //p' "$CENSUS")
    cens_reldate=$(sed -n 's/^SGML-ENTITY reldate //p' "$CENSUS")
fi

if [ "$have_xmllint" -eq 1 ] && [ -d "$tmp" ]; then
    cat > "$tmp/ent.xml" <<EOF
<?xml version="1.0"?>
<!DOCTYPE probe [ <!ENTITY % defs SYSTEM "$X11/defs.ent"> %defs; ]>
<probe>relvers=&relvers;|reldate=&reldate;|major=&majorvers;</probe>
EOF
    entout=$(xmllint --nonet --noent "$tmp/ent.xml" 2>&1)
    if [ $? -ne 0 ]; then
        bst_notok xorg-sgml-doctools/defs-ent-parses "defs.ent does not load as an external parameter entity: $entout"
        bst_notok xorg-sgml-doctools/defs-ent-expands "not attempted -- the probe document did not parse"
    else
        bst_ok xorg-sgml-doctools/defs-ent-parses
        # The value is compared against the CENSUS rather than against a constant
        # written here: the census read it out of the shipped file with a
        # different mechanism (a text scan, not a parser), so agreement means the
        # two readings of the same bytes match -- where a hardcoded 7.7 would only
        # mean this file still says what someone typed a year ago.
        got=$(printf '%s' "$entout" | sed -n 's/.*relvers=\([^|]*\)|.*/\1/p')
        if [ -n "$cens_relvers" ]; then
            check_eq xorg-sgml-doctools/defs-ent-expands "$cens_relvers" "$got"
        else
            bst_notok xorg-sgml-doctools/defs-ent-expands "the census carries no SGML-ENTITY relvers line, so the expansion could not be compared against the build-time reading of the same file"
        fi
    fi
else
    bst_skip xorg-sgml-doctools/defs-ent-parses "xmllint not installed, or no writable tmpdir"
    bst_skip xorg-sgml-doctools/defs-ent-expands "xmllint not installed, or no writable tmpdir"
fi

# ------------------------------------------------ 4. the census, re-derived here
XP="concat('elements=',count(//*),' attrs=',count(//@*))"

nsha=0; badsha=0; firstsha=""
nxml=0; badxml=0; firstxml=""; firstxmlout=""
nmiss=0; firstmiss=""
cfiles=""; cdocs=""; celems=""; cattrs=""; cgen=""; cpar=""; cimp=""; cext=""
cpv=""; cpcver=""; nverb=0; badverb=""
nimp=0
IMPORT_URIS=""

if [ -f "$CENSUS" ]; then
    while read -r tag rest; do
        case "$tag" in
        SGML-FILE)
            name=${rest%% *}
            sz_sha=${rest#* }
            want_sha=${sz_sha#* }
            case "$name" in
            ../pkgconfig/*) path="$PCDIR/${name##*/}" ;;
            *)              path="$X11/$name" ;;
            esac
            if [ ! -f "$path" ]; then
                nmiss=$((nmiss + 1))
                [ -n "$firstmiss" ] || firstmiss="$name (named in the census, not installed)"
                continue
            fi
            nsha=$((nsha + 1))
            got_sha=$(sha256sum "$path" 2>/dev/null | cut -d' ' -f1)
            if [ "$got_sha" != "$want_sha" ]; then
                badsha=$((badsha + 1))
                [ -n "$firstsha" ] || firstsha="$name want $want_sha got '$got_sha'"
            fi
            ;;
        SGML-VERBATIM)
            nverb=$((nverb + 1))
            case "$rest" in
            *" identical") : ;;
            *) badverb="$badverb ${rest%% *}" ;;
            esac
            ;;
        SGML-XML)
            nxml=$((nxml + 1))
            name=${rest%% *}
            want=${rest#* }
            want=${want#root=* }
            [ "$have_xmllint" -eq 1 ] || continue
            [ -f "$X11/$name" ] || continue
            got=$( cd "$X11" && xmllint --nonet --xpath "$XP" "$name" 2>&1 )
            # The census line is `root=NAME elements=N attrs=M extents=K`; the
            # xpath yields only the middle two, so the comparison is on that
            # slice. extents is a property of the parse, not of the tree, and is
            # asserted in section 2 instead.
            wantslice=$(printf '%s' "$rest" | sed -n 's/.*\(elements=[0-9]* attrs=[0-9]*\).*/\1/p')
            if [ "$got" != "$wantslice" ]; then
                badxml=$((badxml + 1))
                [ -n "$firstxml" ] || { firstxml="$name want '$wantslice'"; firstxmlout="$got"; }
            fi
            ;;
        SGML-IMPORT)
            nimp=$((nimp + 1))
            IMPORT_URIS="$IMPORT_URIS ${rest#* }"
            ;;
        SGML-PC)
            for kv in $rest; do
                case "$kv" in version=*) cpcver=${kv#version=} ;; esac
            done
            ;;
        SGML-PV)
            cpv=${rest%% *}
            ;;
        SGML-TOTAL)
            for kv in $rest; do
                case "$kv" in
                files=*)    cfiles=${kv#files=} ;;
                xmldocs=*)  cdocs=${kv#xmldocs=} ;;
                elements=*) celems=${kv#elements=} ;;
                attrs=*)    cattrs=${kv#attrs=} ;;
                general=*)  cgen=${kv#general=} ;;
                params=*)   cpar=${kv#params=} ;;
                imports=*)  cimp=${kv#imports=} ;;
                extents=*)  cext=${kv#extents=} ;;
                esac
            done
            ;;
        esac
    done < "$CENSUS"
fi

if [ "$nmiss" -eq 0 ] && [ "$nsha" -gt 0 ]; then bst_ok xorg-sgml-doctools/census-files-present
else bst_notok xorg-sgml-doctools/census-files-present "$nmiss file(s) named in the census are not installed -- first: $firstmiss"; fi

if [ "$badsha" -eq 0 ] && [ "$nsha" -gt 0 ]; then bst_ok xorg-sgml-doctools/census-sha256
else bst_notok xorg-sgml-doctools/census-sha256 "$badsha of $nsha file(s) differ from the bytes the build validated -- first: $firstsha"; fi

# The verbatim comparison is the build's, not this image's -- it needs the
# tarball, which is not here. What IS checkable here is that the record exists
# and says identical for every file it covers, and that the sha256 case above ties
# those bytes to the ones on this image.
if [ "$nverb" -eq 6 ] && [ -z "$badverb" ]; then bst_ok xorg-sgml-doctools/census-verbatim
else bst_notok xorg-sgml-doctools/census-verbatim "$nverb SGML-VERBATIM line(s), differing:${badverb:- none}"; fi

if [ "$have_xmllint" -ne 1 ]; then
    bst_skip xorg-sgml-doctools/census-agrees "xmllint not installed on this image"
elif [ "$badxml" -eq 0 ] && [ "$nxml" -gt 0 ]; then
    bst_ok xorg-sgml-doctools/census-agrees
elif bst_execfail "$firstxmlout"; then
    bst_unrun xorg-sgml-doctools/census-agrees "$firstxmlout"
else
    bst_notok xorg-sgml-doctools/census-agrees "$badxml of $nxml document(s) re-derive differently -- first $firstxml got:'$firstxmlout'"
fi

# The census naming a subset of what is installed would leave every case above
# green over files nobody counted, so the two directions are asserted separately:
# every census name exists (above), and the counts match (here).
if [ "$nxml" -gt 0 ] && [ "$nxml" = "$cdocs" ]; then bst_ok xorg-sgml-doctools/census-covers-xml
else bst_notok xorg-sgml-doctools/census-covers-xml "$nxml SGML-XML line(s) against xmldocs=$cdocs in the total"; fi

if [ -n "$cfiles" ] && [ "$cfiles" = "$nsha" ] && [ "$nsha" -eq 9 ]; then bst_ok xorg-sgml-doctools/census-self-consistent
else bst_notok xorg-sgml-doctools/census-self-consistent "SGML-TOTAL says files=$cfiles against $nsha SGML-FILE line(s) checked, expected 9"; fi

if [ -n "$celems" ] && [ -n "$cattrs" ] && [ -n "$cgen" ] && [ -n "$cpar" ] && \
   [ "$celems" -gt 0 ] 2>/dev/null && [ "$cattrs" -gt 0 ] 2>/dev/null; then
    bst_ok xorg-sgml-doctools/census-totals
else
    bst_notok xorg-sgml-doctools/census-totals "the census carries no usable SGML-TOTAL line (elements='$celems' attrs='$cattrs' general='$cgen' params='$cpar') -- it was truncated, so the per-file agreement above was asserted over an unknown fraction of the set"
fi

# ------------------------------------------------------- 5. the pkg-config face
# The interface every consumer goes through: an X.Org doc build reads
# sgmlrootdir from here and appends /X11. Nothing else about the install matters
# to it.
if command -v pkg-config >/dev/null 2>&1; then
    check xorg-sgml-doctools/pc-validate pkg-config --validate xorg-sgml-doctools
    pcver=$(pkg-config --modversion xorg-sgml-doctools 2>&1)
    check_eq xorg-sgml-doctools/pc-modversion "$SGML_PV" "$pcver"
    if [ -n "$cpv" ]; then
        check_eq xorg-sgml-doctools/pc-modversion-matches-recipe "$cpv" "$pcver"
    else
        bst_notok xorg-sgml-doctools/pc-modversion-matches-recipe "the census carries no SGML-PV line, so the .pc's version could not be compared against the recipe's PV -- which is the comparison that catches a .pc.in substitution that broke"
    fi

    # ASSERTED BEHAVIOURALLY, NOT AS A STRING. pkg-config expands
    # ${pc_sysrootdir} to "/" when PKG_CONFIG_SYSROOT_DIR is unset, so the
    # reported value can carry a doubled leading slash -- a valid path, and an
    # artefact of pkg-config rather than anything about this port. What a
    # consumer needs is that sgmlrootdir/X11 is the directory holding the
    # stylesheets, so that is what is checked.
    sroot=$(pkg-config --variable=sgmlrootdir xorg-sgml-doctools 2>&1)
    if [ -n "$sroot" ] && [ -f "$sroot/X11/xorg.xsl" ]; then bst_ok xorg-sgml-doctools/pc-sgmlrootdir
    else bst_notok xorg-sgml-doctools/pc-sgmlrootdir "sgmlrootdir='$sroot' does not hold X11/xorg.xsl"; fi
else
    bst_skip xorg-sgml-doctools/pc-validate "pkg-config not installed on this image"
    bst_skip xorg-sgml-doctools/pc-modversion "pkg-config not installed on this image"
    bst_skip xorg-sgml-doctools/pc-modversion-matches-recipe "pkg-config not installed on this image"
    bst_skip xorg-sgml-doctools/pc-sgmlrootdir "pkg-config not installed on this image"
fi

# ------------------------------------- 6. the catalog the stylesheets depend on
# Three of the four stylesheets import DocBook XSL by canonical http URI. Whether
# that resolves is a property of the IMAGE, not of this package -- and it is the
# difference between a usable stylesheet and a decorative one, so it is asserted
# here rather than left to be discovered by whoever first tries to build a manual.
check xorg-sgml-doctools/catalog-present test -f "$CATALOG"

if [ "$nimp" -eq 3 ]; then bst_ok xorg-sgml-doctools/census-imports
else bst_notok xorg-sgml-doctools/census-imports "the census carries $nimp SGML-IMPORT line(s) against the pinned 3 (total says imports=$cimp)"; fi

if command -v xmlcatalog >/dev/null 2>&1 && [ -f "$CATALOG" ]; then
    nres=0; nbadres=0; firstres=""
    for u in $IMPORT_URIS; do
        nres=$((nres + 1))
        r=$(xmlcatalog "$CATALOG" "$u" 2>&1)
        case "$r" in
        file://*) p=${r#file://} ;;
        /*)       p=$r ;;
        *)        p="" ;;
        esac
        if [ -z "$p" ] || [ ! -f "$p" ]; then
            nbadres=$((nbadres + 1))
            [ -n "$firstres" ] || firstres="$u -> '$r'"
        fi
    done
    if [ "$nres" -gt 0 ] && [ "$nbadres" -eq 0 ]; then bst_ok xorg-sgml-doctools/imports-resolve
    else bst_notok xorg-sgml-doctools/imports-resolve "$nbadres of $nres xsl:import URI(s) do not resolve through $CATALOG to an installed file -- first: $firstres"; fi
else
    bst_skip xorg-sgml-doctools/imports-resolve "xmlcatalog or $CATALOG absent on this image"
fi

# ------------------------------------------- 7. the stylesheets, actually run
# The build-time oracle did exactly this on the build host (section 8 reads its
# record). Repeating it here is what turns "these bytes work somewhere" into
# "these bytes work on this image", and the two together are what let a red here
# be attributed to the platform rather than to the package.
have_xsltproc=0
command -v xsltproc >/dev/null 2>&1 && have_xsltproc=1

if [ "$have_xsltproc" -eq 1 ] && [ -d "$tmp" ]; then
    cat > "$tmp/fixture.xml" <<'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<article xmlns="http://docbook.org/ns/docbook" version="5.0">
  <title>brintOS xorg-sgml-doctools probe</title>
  <para>A paragraph, so the transform has something to render.</para>
</article>
EOF
    # Valid and resolving nothing, rather than absent or empty: an unreadable
    # catalog makes libxml2 complain about the catalog, which is a different
    # failure from an import that could not be resolved through a good one.
    cat > "$tmp/catalog-empty.xml" <<'EOF'
<?xml version="1.0"?>
<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog"/>
EOF

    xhtml_rc=0
    xsltproc --nonet --novalid -o "$tmp/out.html" "$X11/xorg-xhtml.xsl" \
        "$tmp/fixture.xml" > "$tmp/out.stdout" 2> "$tmp/out.stderr" || xhtml_rc=$?
    xhtml_b=0; [ -f "$tmp/out.html" ] && xhtml_b=$(wc -c < "$tmp/out.html")
    xhtml_css=0
    [ -f "$tmp/out.html" ] && xhtml_css=$(grep -c 'font-family' "$tmp/out.html" 2>/dev/null)
    [ -n "$xhtml_css" ] || xhtml_css=0

    if [ "$xhtml_rc" -eq 0 ] && [ "$xhtml_b" -gt 0 ]; then
        bst_ok xorg-sgml-doctools/transform-xhtml
    elif bst_execfail "$(cat "$tmp/out.stderr" 2>/dev/null)"; then
        bst_unrun xorg-sgml-doctools/transform-xhtml "$(cat "$tmp/out.stderr" 2>/dev/null)"
    else
        bst_notok xorg-sgml-doctools/transform-xhtml "xorg-xhtml.xsl exited $xhtml_rc producing $xhtml_b bytes: $(tail -n 3 "$tmp/out.stderr" 2>/dev/null)"
    fi

    # The discriminator. A transform happening proves docbook-xsl works; xorg.css
    # ending up INSIDE the output proves this package did, because it gets there
    # only through xorg-xhtml.xsl's &xorgcss; external entity.
    if [ "$xhtml_css" -gt 0 ] 2>/dev/null; then bst_ok xorg-sgml-doctools/transform-embeds-css
    else bst_notok xorg-sgml-doctools/transform-embeds-css "the transform output carries no font-family, so xorg.css was not embedded -- the &xorgcss; entity did not resolve, which xsltproc reports as a warning and not an error"; fi

    if grep -q 'xorg-sgml-doctools probe' "$tmp/out.html" 2>/dev/null; then bst_ok xorg-sgml-doctools/transform-renders-fixture
    else bst_notok xorg-sgml-doctools/transform-renders-fixture "the transform output does not carry the fixture's title, so it is not a rendering of the input"; fi

    # Control: the stock DocBook stylesheet, same fixture. Without this a green
    # transform-embeds-css would say only that some stylesheet emits CSS.
    stock=""
    for c in /usr/share/xml/docbook/xsl-stylesheets/xhtml/docbook.xsl; do
        [ -f "$c" ] && stock=$c
    done
    if [ -n "$stock" ]; then
        stock_rc=0
        xsltproc --nonet --novalid -o "$tmp/stock.html" "$stock" "$tmp/fixture.xml" \
            > /dev/null 2> "$tmp/stock.stderr" || stock_rc=$?
        stock_css=0
        [ -f "$tmp/stock.html" ] && stock_css=$(grep -c 'font-family' "$tmp/stock.html" 2>/dev/null)
        [ -n "$stock_css" ] || stock_css=0
        if [ "$stock_rc" -eq 0 ] && [ "$stock_css" -eq 0 ] 2>/dev/null; then
            bst_ok xorg-sgml-doctools/control-stock-has-no-css
        else
            bst_notok xorg-sgml-doctools/control-stock-has-no-css "the stock DocBook stylesheet exited $stock_rc with font-family count $stock_css -- if it already emits CSS, transform-embeds-css no longer attributes anything to this package"
        fi
    else
        bst_skip xorg-sgml-doctools/control-stock-has-no-css "the stock docbook-xsl xhtml stylesheet is not installed"
    fi

    # Control: a catalog that resolves nothing. If the transform still succeeded,
    # the DocBook import is being satisfied from somewhere this image did not
    # intend -- and transform-xhtml would be green without the catalog it exists
    # to exercise.
    nocat_rc=0
    XML_CATALOG_FILES="$tmp/catalog-empty.xml" xsltproc --nonet --novalid \
        -o "$tmp/nocat.html" "$X11/xorg-xhtml.xsl" "$tmp/fixture.xml" \
        > /dev/null 2>&1 || nocat_rc=$?
    if [ "$nocat_rc" -ne 0 ]; then bst_ok xorg-sgml-doctools/control-needs-catalog
    else bst_notok xorg-sgml-doctools/control-needs-catalog "xorg-xhtml.xsl transformed with a catalog that resolves nothing, so the http xsl:import is being satisfied from somewhere other than $CATALOG"; fi

    # Control: xorg.css removed from a copy of the tree. Scored on OUTPUT, not on
    # exit status -- measured on the build host, this does not make xsltproc fail;
    # it warns, substitutes nothing and emits a smaller document. A control
    # written to expect a non-zero exit would have been green for the wrong reason.
    mkdir -p "$tmp/nocss"
    cp "$X11"/*.xsl "$tmp/nocss/" 2>/dev/null
    nocss_rc=0
    xsltproc --nonet --novalid -o "$tmp/nocss.html" "$tmp/nocss/xorg-xhtml.xsl" \
        "$tmp/fixture.xml" > /dev/null 2>&1 || nocss_rc=$?
    nocss_css=0
    [ -f "$tmp/nocss.html" ] && nocss_css=$(grep -c 'font-family' "$tmp/nocss.html" 2>/dev/null)
    [ -n "$nocss_css" ] || nocss_css=0
    if [ "$xhtml_b" -eq 0 ]; then
        # Not a verdict on the control: with no reference output there is nothing
        # for it to be a control OF, and reporting it as "the CSS came from
        # elsewhere" would name the wrong cause for whatever broke the arm above.
        bst_notok xorg-sgml-doctools/control-css-is-the-sibling "not evaluated -- the reference transform produced no output, so this control has no arm to be compared against"
    elif [ "$nocss_css" -eq 0 ] 2>/dev/null; then
        bst_ok xorg-sgml-doctools/control-css-is-the-sibling
    else
        bst_notok xorg-sgml-doctools/control-css-is-the-sibling "a copy of the stylesheets with no sibling xorg.css still emitted font-family $nocss_css time(s) (rc=$nocss_rc), so the CSS is coming from somewhere other than $X11/xorg.css"
    fi

    fo_rc=0
    xsltproc --nonet --novalid -o "$tmp/out.fo" "$X11/xorg-fo.xsl" "$tmp/fixture.xml" \
        > /dev/null 2> "$tmp/fo.stderr" || fo_rc=$?
    fo_font=0
    [ -f "$tmp/out.fo" ] && fo_font=$(grep -c 'DejaVu Serif' "$tmp/out.fo" 2>/dev/null)
    [ -n "$fo_font" ] || fo_font=0
    if [ "$fo_rc" -eq 0 ] && [ "$fo_font" -gt 0 ] 2>/dev/null; then bst_ok xorg-sgml-doctools/transform-fo
    else bst_notok xorg-sgml-doctools/transform-fo "xorg-fo.xsl exited $fo_rc with DejaVu count $fo_font: $(tail -n 2 "$tmp/fo.stderr" 2>/dev/null)"; fi

    # The chunker writes files rather than a document, so it is scored on what
    # landed in an empty directory -- an -o file would be created and left empty
    # either way.
    rm -rf "$tmp/chunk"; mkdir -p "$tmp/chunk"
    chunk_rc=0
    xsltproc --nonet --novalid --stringparam base.dir "$tmp/chunk/" \
        "$X11/xorg-chunk.xsl" "$tmp/fixture.xml" > /dev/null 2> "$tmp/chunk.stderr" || chunk_rc=$?
    chunk_n=$(ls -1 "$tmp/chunk" 2>/dev/null | wc -l)
    if [ "$chunk_rc" -eq 0 ] && [ "$chunk_n" -gt 0 ] 2>/dev/null; then bst_ok xorg-sgml-doctools/transform-chunk
    else bst_notok xorg-sgml-doctools/transform-chunk "xorg-chunk.xsl exited $chunk_rc writing $chunk_n file(s): $(tail -n 2 "$tmp/chunk.stderr" 2>/dev/null)"; fi
else
    for c in transform-xhtml transform-embeds-css transform-renders-fixture \
             control-stock-has-no-css control-needs-catalog \
             control-css-is-the-sibling transform-fo transform-chunk; do
        bst_skip "xorg-sgml-doctools/$c" "xsltproc not installed, or no writable tmpdir"
    done
fi

# ---------------------------------------- 8. what the build host already proved
# The same five transforms and three controls, run at do_install on a host whose
# XSLT engine is not in question. If section 7 is red and this is green, the
# stylesheets are sound and the platform is not -- which is the distinction
# nothing else here can draw.
if [ -f "$ORACLE" ]; then
    if grep -q '^ORACLE-END fails=0$' "$ORACLE"; then bst_ok xorg-sgml-doctools/oracle-green
    else bst_notok xorg-sgml-doctools/oracle-green "the build-time oracle did not end clean: $(grep '^ORACLE-FAIL' "$ORACLE" | head -n 1)"; fi

    norc=0
    for k in ORACLE-XHTML ORACLE-CONTROL-STOCK ORACLE-CONTROL-NOCATALOG \
             ORACLE-CONTROL-NOCSS ORACLE-FO ORACLE-CHUNK; do
        grep -q "^$k " "$ORACLE" && norc=$((norc + 1))
    done
    if [ "$norc" -eq 6 ]; then bst_ok xorg-sgml-doctools/oracle-complete
    else bst_notok xorg-sgml-doctools/oracle-complete "the oracle report carries $norc of the 6 arm lines, so its verdict covers an unknown fraction of the run"; fi
else
    bst_skip xorg-sgml-doctools/oracle-green "$ORACLE is not installed"
    bst_skip xorg-sgml-doctools/oracle-complete "$ORACLE is not installed"
fi

# ---------------------------- 9. the toolchain question the ticket asked about
# The ticket's worry was that the recipe would drag a documentation toolchain onto
# the target behind a handful of entity files. It does not -- the built packages
# declare no runtime dependency at all. What is pinned here is the state that
# makes the port worth having: the toolchain is present because this image chose
# it, for xmlto and docbook, and these stylesheets are usable BECAUSE of that
# rather than by bringing it. If a future image drops libxslt-bin, section 7 goes
# to skip and this case is the one that says why in one line.
tooling=""
for t in xmllint xsltproc xmlcatalog pkg-config; do
    command -v "$t" >/dev/null 2>&1 || tooling="$tooling $t"
done
if [ -z "$tooling" ]; then bst_ok xorg-sgml-doctools/consumer-toolchain-present
else bst_notok xorg-sgml-doctools/consumer-toolchain-present "absent:$tooling -- the stylesheets are still correct but nothing on this image can drive them"; fi

rm -rf "$tmp" 2>/dev/null