. "$BST_LIB"
require xsltproc libxslt/present

# libxslt — the GNOME XSLT 1.0 processor. xsltproc is the CLI driver over
# libxslt + libexslt; libxml2 (already on this image) supplies the parser and
# XPath engine underneath, so this suite is the transformation layer on top of
# what 62-libxml2.test already covers.
#
# Everything is generated into $TMPDIR: the suite needs no data/ payload, and a
# short path matters because several xsltproc diagnostics quote the filename.

t=${TMPDIR:-/tmp}/bst-libxslt.$$
mkdir -p "$t" || { bst_notok libxslt/tmpdir "cannot create $t"; exit 0; }

# --- payloads ----------------------------------------------------------------

cat > "$t/doc.xml" <<'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<catalog xml:lang="en">
  <book id="b1" year="1979"><title>Godel Escher Bach</title><author>Hofstadter</author><price>29.95</price></book>
  <book id="b2" year="1985"><title>Contact</title><author>Sagan</author><price>7.50</price></book>
  <book id="b3" year="1985"><title>Blindsight</title><author>Watts</author><price>12.00</price></book>
  <note>  spaced   text  </note>
</catalog>
EOF

# identity-ish: value-of, for-each, attribute access, text output
cat > "$t/basic.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <xsl:template match="/">
    <xsl:for-each select="catalog/book">
      <xsl:value-of select="@id"/>=<xsl:value-of select="title"/>|</xsl:for-each>
  </xsl:template>
</xsl:stylesheet>
EOF

# sorting, numbering, position()/last()
cat > "$t/sort.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <xsl:template match="/">
    <xsl:for-each select="catalog/book">
      <xsl:sort select="price" data-type="number" order="ascending"/>
      <xsl:number format="1"/>:<xsl:value-of select="title"/>(<xsl:value-of select="position()"/>/<xsl:value-of select="last()"/>) </xsl:for-each>
  </xsl:template>
</xsl:stylesheet>
EOF

# named templates, params, variables, recursion, choose/if
cat > "$t/tmpl.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <xsl:template name="fact">
    <xsl:param name="n" select="1"/>
    <xsl:choose>
      <xsl:when test="$n &lt;= 1">1</xsl:when>
      <xsl:otherwise>
        <xsl:variable name="sub"><xsl:call-template name="fact"><xsl:with-param name="n" select="$n - 1"/></xsl:call-template></xsl:variable>
        <xsl:value-of select="$n * $sub"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
  <xsl:template match="/">
    <xsl:text>fact10=</xsl:text><xsl:call-template name="fact"><xsl:with-param name="n" select="10"/></xsl:call-template>
    <xsl:text> cheap=</xsl:text>
    <xsl:for-each select="catalog/book">
      <xsl:if test="price &lt; 15"><xsl:value-of select="@id"/></xsl:if>
    </xsl:for-each>
  </xsl:template>
</xsl:stylesheet>
EOF

# keys, modes, apply-templates with select
cat > "$t/key.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <xsl:key name="by-year" match="book" use="@year"/>
  <xsl:template match="/">
    <xsl:text>1985:</xsl:text><xsl:value-of select="count(key('by-year','1985'))"/>
    <xsl:text> titles:</xsl:text>
    <xsl:apply-templates select="catalog/book" mode="short"/>
  </xsl:template>
  <xsl:template match="book" mode="short"><xsl:value-of select="substring(title,1,3)"/>,</xsl:template>
</xsl:stylesheet>
EOF

# XPath 1.0 function library
cat > "$t/xpath.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <xsl:template match="/">
    <xsl:text>X-concat </xsl:text><xsl:value-of select="concat('a','b','c')"/><xsl:text>
</xsl:text>
    <xsl:text>X-substring </xsl:text><xsl:value-of select="substring('12345',2,3)"/><xsl:text>
</xsl:text>
    <xsl:text>X-substring-before </xsl:text><xsl:value-of select="substring-before('a/b','/')"/><xsl:text>
</xsl:text>
    <xsl:text>X-substring-after </xsl:text><xsl:value-of select="substring-after('a/b','/')"/><xsl:text>
</xsl:text>
    <xsl:text>X-translate </xsl:text><xsl:value-of select="translate('bar','abc','ABC')"/><xsl:text>
</xsl:text>
    <xsl:text>X-normalize </xsl:text><xsl:value-of select="normalize-space(catalog/note)"/><xsl:text>
</xsl:text>
    <xsl:text>X-strlen </xsl:text><xsl:value-of select="string-length('hello')"/><xsl:text>
</xsl:text>
    <xsl:text>X-contains </xsl:text><xsl:value-of select="contains('haystack','stack')"/><xsl:text>
</xsl:text>
    <xsl:text>X-starts </xsl:text><xsl:value-of select="starts-with('haystack','hay')"/><xsl:text>
</xsl:text>
    <xsl:text>X-sum </xsl:text><xsl:value-of select="sum(catalog/book/price)"/><xsl:text>
</xsl:text>
    <xsl:text>X-floor </xsl:text><xsl:value-of select="floor(3.7)"/><xsl:text>
</xsl:text>
    <xsl:text>X-ceiling </xsl:text><xsl:value-of select="ceiling(3.2)"/><xsl:text>
</xsl:text>
    <xsl:text>X-round </xsl:text><xsl:value-of select="round(2.5)"/><xsl:text>
</xsl:text>
    <xsl:text>X-count </xsl:text><xsl:value-of select="count(//book)"/><xsl:text>
</xsl:text>
    <xsl:text>X-name </xsl:text><xsl:value-of select="local-name(catalog/book[1])"/><xsl:text>
</xsl:text>
    <xsl:text>X-ancestor </xsl:text><xsl:value-of select="name(//title[1]/ancestor::catalog)"/><xsl:text>
</xsl:text>
    <xsl:text>X-following </xsl:text><xsl:value-of select="count(//book[1]/following-sibling::book)"/><xsl:text>
</xsl:text>
    <xsl:text>X-pred </xsl:text><xsl:value-of select="//book[@year='1985'][2]/title"/><xsl:text>
</xsl:text>
    <xsl:text>X-format </xsl:text><xsl:value-of select="format-number(1234567.891,'#,##0.00')"/><xsl:text>
</xsl:text>
    <xsl:text>X-boolean </xsl:text><xsl:value-of select="boolean(//book[@id='b9'])"/><xsl:text>
</xsl:text>
    <xsl:text>X-lang </xsl:text><xsl:for-each select="catalog/book[1]"><xsl:value-of select="lang('en')"/></xsl:for-each><xsl:text>
</xsl:text>
    <xsl:text>X-lang-root </xsl:text><xsl:value-of select="lang('en')"/><xsl:text>
</xsl:text>
  </xsl:template>
</xsl:stylesheet>
EOF

# output methods / serialization
cat > "$t/xmlout.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="xml" indent="yes" encoding="UTF-8"/>
  <xsl:template match="/">
    <out><xsl:copy-of select="catalog/book[1]"/><cdata><xsl:text>&lt;raw&amp;</xsl:text></cdata></out>
  </xsl:template>
</xsl:stylesheet>
EOF

cat > "$t/htmlout.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="html"/>
  <xsl:template match="/"><html><head><title>T</title></head><body><hr/><p>x</p></body></html></xsl:template>
</xsl:stylesheet>
EOF

cat > "$t/noxmldecl.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="xml" omit-xml-declaration="yes" cdata-section-elements="raw"/>
  <xsl:template match="/"><r><raw>a &lt; b</raw></r></xsl:template>
</xsl:stylesheet>
EOF

# stylesheet parameters
cat > "$t/param.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <xsl:param name="who" select="'nobody'"/>
  <xsl:param name="n" select="0"/>
  <xsl:template match="/">P:<xsl:value-of select="$who"/>/<xsl:value-of select="$n * 2"/></xsl:template>
</xsl:stylesheet>
EOF

# import/include precedence
cat > "$t/inc-base.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="title">BASE-<xsl:value-of select="."/></xsl:template>
  <xsl:template name="shared">SHARED</xsl:template>
</xsl:stylesheet>
EOF

cat > "$t/importer.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:import href="inc-base.xsl"/>
  <xsl:output method="text"/>
  <xsl:template match="title">OVER-<xsl:value-of select="."/>[<xsl:apply-imports/>]</xsl:template>
  <xsl:template match="/"><xsl:call-template name="shared"/><xsl:text> </xsl:text><xsl:apply-templates select="//title[1]"/></xsl:template>
</xsl:stylesheet>
EOF

# namespaces in the result tree
cat > "$t/ns.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:e="urn:example">
  <xsl:output method="xml" omit-xml-declaration="yes"/>
  <xsl:template match="/">
    <e:root><xsl:element name="dyn" namespace="urn:other"><xsl:attribute name="a">1</xsl:attribute></xsl:element></e:root>
  </xsl:template>
</xsl:stylesheet>
EOF

# EXSLT
cat > "$t/exslt.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:exsl="http://exslt.org/common"
    xmlns:str="http://exslt.org/strings"
    xmlns:math="http://exslt.org/math"
    xmlns:set="http://exslt.org/sets"
    xmlns:func="http://exslt.org/functions"
    xmlns:my="urn:my"
    extension-element-prefixes="func"
    exclude-result-prefixes="exsl str math set func my">
  <xsl:output method="text"/>
  <func:function name="my:double">
    <xsl:param name="v"/>
    <func:result select="$v * 2"/>
  </func:function>
  <xsl:template match="/">
    <xsl:variable name="rtf"><a>1</a><a>2</a></xsl:variable>
    <xsl:text>E-nodeset </xsl:text><xsl:value-of select="count(exsl:node-set($rtf)/a)"/><xsl:text>
</xsl:text>
    <xsl:text>E-tokenize </xsl:text><xsl:value-of select="count(str:tokenize('a,b,c', ','))"/><xsl:text>
</xsl:text>
    <xsl:text>E-tokenize2 </xsl:text><xsl:value-of select="str:tokenize('a,b,c', ',')[2]"/><xsl:text>
</xsl:text>
    <xsl:text>E-replace </xsl:text><xsl:value-of select="str:replace('a-b-c', '-', '+')"/><xsl:text>
</xsl:text>
    <xsl:text>E-padding </xsl:text><xsl:value-of select="concat('[', str:padding(4, '.'), ']')"/><xsl:text>
</xsl:text>
    <xsl:text>E-max </xsl:text><xsl:value-of select="math:max(//price)"/><xsl:text>
</xsl:text>
    <xsl:text>E-min </xsl:text><xsl:value-of select="math:min(//price)"/><xsl:text>
</xsl:text>
    <xsl:text>E-abs </xsl:text><xsl:value-of select="math:abs(-7)"/><xsl:text>
</xsl:text>
    <xsl:text>E-distinct </xsl:text><xsl:value-of select="count(set:distinct(//book/@year))"/><xsl:text>
</xsl:text>
    <xsl:text>E-func </xsl:text><xsl:value-of select="my:double(21)"/><xsl:text>
</xsl:text>
  </xsl:template>
</xsl:stylesheet>
EOF

# deliberately broken stylesheet (unknown top-level XSL element in the XSL ns)
cat > "$t/bad.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/"><xsl:value-of select="+++"/></xsl:template>
</xsl:stylesheet>
EOF

# not well-formed XML
printf '<a><b></a>\n' > "$t/malformed.xml"

# HTML input for --html
cat > "$t/page.html" <<'EOF'
<html><head><title>Page</title><body><p>one<p>two</body></html>
EOF

cat > "$t/html-in.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <xsl:template match="/">H:<xsl:value-of select="count(//p)"/>:<xsl:value-of select="//title"/></xsl:template>
</xsl:stylesheet>
EOF

# infinite recursion, to prove --maxdepth is enforced rather than crashing
cat > "$t/deep.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <xsl:template name="loop"><xsl:call-template name="loop"/></xsl:template>
  <xsl:template match="/"><xsl:call-template name="loop"/></xsl:template>
</xsl:stylesheet>
EOF

# xsl:message terminate
cat > "$t/terminate.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/"><xsl:message terminate="yes">STOP-HERE</xsl:message></xsl:template>
</xsl:stylesheet>
EOF

# --- 1. presence and identification ------------------------------------------

check     libxslt/version           xsltproc --version
check_out libxslt/version-libxslt   "libxslt 10143"  xsltproc --version
check_out libxslt/version-libexslt  "libexslt"       xsltproc --version
check_out libxslt/version-libxml    "compiled against libxml" xsltproc --version

# --- 2. core XSLT 1.0 engine --------------------------------------------------

check_eq libxslt/basic-forEach \
  'b1=Godel Escher Bach|b2=Contact|b3=Blindsight|' \
  "$(xsltproc "$t/basic.xsl" "$t/doc.xml" 2>/dev/null)"

# xsl:sort reorders the iteration (position()/last() follow it) while xsl:number
# keeps counting the node's place in the SOURCE tree — so the leading numbers
# come out 2,3,1, which is the assertion worth making: it distinguishes the two.
sorted=$(xsltproc "$t/sort.xsl" "$t/doc.xml" 2>/dev/null)
check_eq libxslt/sort-numeric \
  '2:Contact(1/3) 3:Blindsight(2/3) 1:Godel Escher Bach(3/3)' \
  "$(printf '%s' "$sorted" | tr -s ' ' | sed 's/ $//')"

tm=$(xsltproc "$t/tmpl.xsl" "$t/doc.xml" 2>/dev/null)
check_eq libxslt/named-template-recursion 3628800 \
  "$(printf '%s\n' "$tm" | sed -n 's/.*fact10=\([0-9]*\).*/\1/p')"
check_eq libxslt/if-and-choose b2b3 \
  "$(printf '%s\n' "$tm" | sed -n 's/.*cheap=\(.*\)$/\1/p')"

kk=$(xsltproc "$t/key.xsl" "$t/doc.xml" 2>/dev/null)
check_eq libxslt/key-lookup 2 "$(printf '%s\n' "$kk" | sed -n 's/^1985:\([0-9]*\).*/\1/p')"
check_eq libxslt/apply-templates-mode 'God,Con,Bli,' \
  "$(printf '%s\n' "$kk" | sed -n 's/.*titles:\(.*\)$/\1/p')"

imp=$(xsltproc "$t/importer.xsl" "$t/doc.xml" 2>/dev/null)
check_out libxslt/import-shared   "SHARED" printf '%s' "$imp"
check_out libxslt/import-override "OVER-Godel Escher Bach" printf '%s' "$imp"
check_out libxslt/apply-imports   "[BASE-Godel Escher Bach]" printf '%s' "$imp"

# --- 3. the XPath 1.0 function library, one value per case --------------------

xp=$(xsltproc "$t/xpath.xsl" "$t/doc.xml" 2>/dev/null)
xpv() { printf '%s\n' "$xp" | sed -n "s/^$1 //p"; }

check_eq libxslt/xpath-concat            abc         "$(xpv X-concat)"
check_eq libxslt/xpath-substring         234         "$(xpv X-substring)"
check_eq libxslt/xpath-substring-before  a           "$(xpv X-substring-before)"
check_eq libxslt/xpath-substring-after   b           "$(xpv X-substring-after)"
check_eq libxslt/xpath-translate         BAr         "$(xpv X-translate)"
check_eq libxslt/xpath-normalize-space   'spaced text' "$(xpv X-normalize)"
check_eq libxslt/xpath-string-length     5           "$(xpv X-strlen)"
check_eq libxslt/xpath-contains          true        "$(xpv X-contains)"
check_eq libxslt/xpath-starts-with       true        "$(xpv X-starts)"
check_eq libxslt/xpath-sum               49.45       "$(xpv X-sum)"
check_eq libxslt/xpath-floor             3           "$(xpv X-floor)"
check_eq libxslt/xpath-ceiling           4           "$(xpv X-ceiling)"
check_eq libxslt/xpath-round             3           "$(xpv X-round)"
check_eq libxslt/xpath-count             3           "$(xpv X-count)"
check_eq libxslt/xpath-local-name        book        "$(xpv X-name)"
check_eq libxslt/xpath-ancestor-axis     catalog     "$(xpv X-ancestor)"
check_eq libxslt/xpath-following-sibling 2           "$(xpv X-following)"
check_eq libxslt/xpath-predicate-index   Blindsight  "$(xpv X-pred)"
check_eq libxslt/xpath-format-number     '1,234,567.89' "$(xpv X-format)"
check_eq libxslt/xpath-boolean-empty     false       "$(xpv X-boolean)"
check_eq libxslt/xpath-lang              true        "$(xpv X-lang)"
# lang() reads the context node's inherited xml:lang; at match="/" the context is
# the root node, which inherits nothing — false is correct, not a miss.
check_eq libxslt/xpath-lang-root         false       "$(xpv X-lang-root)"

# --- 4. output methods and serialization --------------------------------------

xo=$(xsltproc "$t/xmlout.xsl" "$t/doc.xml" 2>/dev/null)
check_out libxslt/out-xml-decl     '<?xml version="1.0" encoding="UTF-8"?>' printf '%s' "$xo"
check_out libxslt/out-copy-of      '<book id="b1" year="1979">'             printf '%s' "$xo"
check_out libxslt/out-escaping     '&lt;raw&amp;'                           printf '%s' "$xo"
check_out libxslt/out-indent       '  <book'                                printf '%s' "$xo"

ho=$(xsltproc "$t/htmlout.xsl" "$t/doc.xml" 2>/dev/null)
check_out libxslt/out-html-meta   '<meta http-equiv="Content-Type"'  printf '%s' "$ho"
check_out libxslt/out-html-empty  '<hr>'                             printf '%s' "$ho"

no=$(xsltproc "$t/noxmldecl.xsl" "$t/doc.xml" 2>/dev/null)
check_eq  libxslt/out-omit-decl   0 "$(printf '%s\n' "$no" | grep -c '<?xml')"
check_out libxslt/out-cdata       '<![CDATA[a < b]]>' printf '%s' "$no"

nso=$(xsltproc "$t/ns.xsl" "$t/doc.xml" 2>/dev/null)
check_out libxslt/ns-literal    'xmlns:e="urn:example"' printf '%s' "$nso"
check_out libxslt/ns-xsl-element 'urn:other'            printf '%s' "$nso"

# --- 5. parameters and CLI surface --------------------------------------------

check_eq libxslt/param-default 'P:nobody/0' \
  "$(xsltproc "$t/param.xsl" "$t/doc.xml" 2>/dev/null)"
check_eq libxslt/stringparam 'P:world/0' \
  "$(xsltproc --stringparam who world "$t/param.xsl" "$t/doc.xml" 2>/dev/null)"
check_eq libxslt/param-xpath 'P:nobody/42' \
  "$(xsltproc --param n 21 "$t/param.xsl" "$t/doc.xml" 2>/dev/null)"
check_eq libxslt/param-xpath-string 'P:lit/0' \
  "$(xsltproc --param who "'lit'" "$t/param.xsl" "$t/doc.xml" 2>/dev/null)"

xsltproc --output "$t/out.txt" "$t/basic.xsl" "$t/doc.xml" 2>/dev/null
check_out libxslt/cli-output 'b2=Contact' cat "$t/out.txt"

check_eq libxslt/cli-stdin-doc 'b1=Godel Escher Bach|b2=Contact|b3=Blindsight|' \
  "$(cat "$t/doc.xml" | xsltproc "$t/basic.xsl" - 2>/dev/null)"

check_eq libxslt/cli-html-parser 'H:2:Page' \
  "$(xsltproc --html "$t/html-in.xsl" "$t/page.html" 2>/dev/null)"

check_out libxslt/cli-nonet 'b1=' xsltproc --nonet "$t/basic.xsl" "$t/doc.xml"
check_out libxslt/cli-novalid 'b1=' xsltproc --novalid "$t/basic.xsl" "$t/doc.xml"
check_out libxslt/cli-timing  'b1=' xsltproc --timing "$t/basic.xsl" "$t/doc.xml"
check_out libxslt/cli-repeat  'b1=' xsltproc --repeat "$t/basic.xsl" "$t/doc.xml"

# two documents on one command line are transformed independently (the text
# output carries no trailing newline, so count occurrences, not lines)
check_eq libxslt/cli-multi-doc 2 \
  "$(xsltproc "$t/basic.xsl" "$t/doc.xml" "$t/doc.xml" 2>/dev/null | grep -o 'b3=Blindsight' | wc -l | tr -d ' ')"

# --- 6. EXSLT (libexslt) ------------------------------------------------------

ex=$(xsltproc "$t/exslt.xsl" "$t/doc.xml" 2>/dev/null)
exv() { printf '%s\n' "$ex" | sed -n "s/^$1 //p"; }

check_eq libxslt/exslt-node-set   2      "$(exv E-nodeset)"
check_eq libxslt/exslt-tokenize   3      "$(exv E-tokenize)"
check_eq libxslt/exslt-tokenize-index b  "$(exv E-tokenize2)"
check_eq libxslt/exslt-replace    'a+b+c' "$(exv E-replace)"
check_eq libxslt/exslt-padding    '[....]' "$(exv E-padding)"
check_eq libxslt/exslt-math-max   29.95  "$(exv E-max)"
check_eq libxslt/exslt-math-min   7.5    "$(exv E-min)"
check_eq libxslt/exslt-math-abs   7      "$(exv E-abs)"
check_eq libxslt/exslt-set-distinct 2    "$(exv E-distinct)"
check_eq libxslt/exslt-func       42     "$(exv E-func)"

# date:date-time is not asserted for a value (it is the wall clock) but it must
# produce a parseable ISO-8601 stamp, which exercises libexslt's date module and
# the platform's time(2)/localtime(3) path.
cat > "$t/date.xsl" <<'EOF'
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:date="http://exslt.org/dates-and-times" exclude-result-prefixes="date">
  <xsl:output method="text"/>
  <xsl:template match="/">D <xsl:value-of select="date:date-time()"/>
Y <xsl:value-of select="date:year('2026-07-30')"/>
W <xsl:value-of select="date:day-of-week-in-month('2026-07-30')"/></xsl:template>
</xsl:stylesheet>
EOF
dt=$(xsltproc "$t/date.xsl" "$t/doc.xml" 2>/dev/null)
check_eq libxslt/exslt-date-year 2026 "$(printf '%s\n' "$dt" | sed -n 's/^Y //p')"
if printf '%s\n' "$dt" | sed -n 's/^D //p' | grep -q '^[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9]'; then
  bst_ok libxslt/exslt-date-time
else
  bst_notok libxslt/exslt-date-time "not ISO-8601: $(_bst_1line "$dt")"
fi

# --- 7. errors, exit codes and limits -----------------------------------------

check_rc  libxslt/err-bad-xpath     5 xsltproc "$t/bad.xsl" "$t/doc.xml"
check_rc  libxslt/err-malformed-doc 6 xsltproc "$t/basic.xsl" "$t/malformed.xml"
check_rc  libxslt/err-missing-doc   6 xsltproc "$t/basic.xsl" "$t/nosuch.xml"
check_rc  libxslt/err-missing-xsl   4 xsltproc "$t/nosuch.xsl" "$t/doc.xml"
check_rc  libxslt/err-terminate    10 xsltproc "$t/terminate.xsl" "$t/doc.xml"
# the message text must reach stderr — asserted separately from the rc, since
# check_out also requires rc=0 and a terminate deliberately exits 10
tmsg=$(xsltproc "$t/terminate.xsl" "$t/doc.xml" 2>&1)
case "$tmsg" in *STOP-HERE*) bst_ok libxslt/err-terminate-msg ;;
  *) bst_notok libxslt/err-terminate-msg "$(_bst_1line "$tmsg")" ;; esac

# runaway recursion must be caught by the depth limiter, not by dying: xsltproc
# reports the failure and exits non-zero, and it must still be < 128 (i.e. not a
# signal death) — on this arm an unbounded recursion is the thing most likely to
# take the whole runtime down rather than the program.
out=$(xsltproc --maxdepth 200 "$t/deep.xsl" "$t/doc.xml" 2>&1); rc=$?
if [ "$rc" -ne 0 ] && [ "$rc" -lt 128 ]; then bst_ok libxslt/maxdepth-enforced
else bst_notok libxslt/maxdepth-enforced "rc=$rc $(_bst_1line "$out")"; fi
check_out libxslt/maxdepth-message 'recursion' printf '%s' "$out"

# --- 8. libexslt really is linked in, not merely referenced -------------------
#
# This arm links everything statically, so there is no libexslt.so to look for —
# the question "did libexslt make it into the binary" is answered by asking the
# binary what it registered at start-up.

check_out libxslt/dumpextensions-runs  'Registered XSLT Extensions'          xsltproc --dumpextensions
check_out libxslt/dumpextensions-exslt '{http://exslt.org/common}node-set'   xsltproc --dumpextensions
check_out libxslt/dumpextensions-math  '{http://exslt.org/math}sqrt'         xsltproc --dumpextensions
check_out libxslt/dumpextensions-str   '{http://exslt.org/strings}split'     xsltproc --dumpextensions

rm -rf "$t"