. "$BST_LIB"
# BST-TIMEOUT: 1200  # THREE python3 starts, and they are the whole cost.
#                    # Everything else reads the filesystem or dpkg with shell
#                    # builtins, or greps one probe transcript.
#                    #
#                    # The three: a bare `import typogrify', a second import
#                    # whose STDERR is the assertion, and the probe -- which
#                    # takes ONE start for 81 measurements, upstream's own 40
#                    # doctests among them.
#                    #
#                    # The work inside a start is regex substitution over three
#                    # dozen fixtures under 200 characters, plus doctest.testmod
#                    # over filters.py, which measures 0.01s on the x86-64
#                    # control. Microseconds beside an interpreter start on this
#                    # arm, which is tens of seconds before the first line of the
#                    # program runs.
#                    #
#                    # 1200 is 400s per start, against the ~60s a python3 start
#                    # has measured at here. The start dominates and nothing in
#                    # this file is quadratic in anything.
#                    #
#                    # NOT MEASURED ON TARGET YET: this port's first on-target
#                    # run is the batch verify. The measured elapsed goes in the
#                    # test plan rather than in this comment, which would cost an
#                    # image build to keep the shipped suite byte-identical.
#
# python3-typogrify 2.0.7 (poky/meta recipes-devtools/python/
# python3-typogrify_2.0.7.bb, `inherit pypi setuptools3', PyPI sdist unmodified,
# plus a meta-brintos bbappend that adds one RDEPENDS) on the wasm32-hwjs glibc
# image.
#
# ============================================================================
# WHAT THE PACKAGE DOES.
# ============================================================================
#
# typogrify applies typographic conventions to HTML. Six filters do the work and
# `typogrify()' composes them:
#
#   amp             a free-standing `&' becomes <span class="amp">&amp;</span>
#   caps            a run of two or more capitals becomes <span class="caps">
#   initial_quotes  a block's OPENING quote becomes <span class="dquo"|"quo">
#   smartypants     straight quotes and dashes become curly entities
#   titlecase       Title Case, with small words left lowercase
#   widont          the space between a block's last two words becomes &nbsp;
#
# The point of each is that it must know when a character is NOT what it looks
# like -- an `&' inside a tag attribute is not text, a capital run inside a
# <script> is not prose, and the "last two words" are a BLOCK's, not the
# document's. A naive regex passes a coverage suite and fails all three. That is
# why the corpus below is chosen by case rather than by count.
#
# ============================================================================
# EVERY EXPECTED VALUE HERE WAS MEASURED, NOT PREDICTED.
# ============================================================================
#
# The probe emits ascii() of each filter's OUTPUT and this file asserts the
# literal string. All of them were read off an x86-64 control -- CPython 3.12.3,
# the image's own minor -- running THIS BUILD'S OWN .deb (unpacked and put on
# PYTHONPATH beside the ported python3-smartypants, python3-jinja2 and
# python3-markupsafe .debs), not the PyPI sdist and not a reading of the source.
# A red therefore names the exact string the target produced against the exact
# string a correct interpreter produces, which is the only comparison that says
# anything about the port.
#
# ============================================================================
# TWO THINGS THE TICKET'S OWN DESCRIPTION GETS WRONG, MEASURED HERE INSTEAD.
# ============================================================================
#
# 1. THERE IS NO `ordinal' FILTER. The ticket asks for one to be asserted. No
#    release of typogrify has ever shipped it -- it is `django.contrib.humanize'
#    that has `ordinal', and typogrify's public surface is the eleven names
#    `public-names' pins below. The absence is asserted BY NAME
#    (`no-ordinal-filter') so a later reader does not conclude the suite forgot
#    to cover it.
#
# 2. <script> AND <style> ARE NOT IN THE DEFAULT IGNORE SET. The ticket says
#    text inside <pre>, <code>, <script> and <style> must be left untouched.
#    Only the first two are: `process_ignores' hard-codes
#    `set(['pre', 'code'])' (filters.py:68) and takes anything else only from an
#    explicit ignore_tags argument. So `typogrify()' DOES rewrite the inside of
#    a <script>, and `tg-script-default' asserts the rewrite:
#
#        typogrify('<script>var a = "KU" & b;</script>')
#          == '<script>var a = "KU" <span class="amp">&amp;</span> b;</script>'
#
#    which is a <span> inserted into JavaScript -- upstream's behaviour, not
#    this image's, and asserted as such rather than as a fault of the port. The
#    repair is asserted beside it (`tg-script-ignored', with ignore_tags), so the
#    pair says which reading is the library's default and which is the caller's.
#
#    `caps' ALONE does skip <script>, which is what makes this easy to get
#    wrong: it tokenizes with smartypants' HTML tokenizer and never looks inside
#    a skipped tag, so `caps-script-skipped' passes while `tg-script-default'
#    shows the composed filter rewriting the same region. The two are asserted
#    together deliberately -- `amp' is the one that reaches in, and the
#    difference is between filters, not between arms.
#
# ============================================================================
# WHAT THIS SUITE SAYS ABOUT THE DEPENDENCIES.
# ============================================================================
#
# python3-smartypants (BRINTOS-1965, already ported) is asserted to be what
# supplies the quote conversion, in three readings that together mean it:
# `smartypants-file' resolves the module to the ported package's own file on the
# rootfs, `smartypants-agrees' shows typogrify's filter and a direct call
# producing identical bytes, and `smartypants-missing-raises' hides the module
# from the import system and shows the filter raising TypogrifyError -- which is
# what a template sees -- rather than ImportError.
#
# python3-jinja2 is added by the meta-brintos bbappend because
# typogrify/templatetags/jinja_filters.py imports jinja2 at MODULE scope and
# ships whatever the recipe says; it is already on this image, so the
# declaration changes no rootfs. `jinja-binding-filters' is the case that
# measures it.
#
# python3-django is deliberately NOT declared and is not on this image, so
# typogrify/templatetags/typogrify_tags.py ships as a file that cannot be
# imported. `django-binding' asserts exactly that -- ModuleNotFoundError naming
# `django' -- and `django-file-present' asserts the file is nonetheless on the
# rootfs. A red on the first would mean django had appeared on the image, not
# that this port had broken. The bbappend records why.
#
# BRINTOS-2046 (the empty Py* export surface that refuses a CPython extension at
# dlopen on this image) does not reach this port. typogrify is pure Python, and
# so is the jinja2 path it now depends on: python3-markupsafe ships
# `_speedups.c' and `_speedups.pyi' and NO `_speedups.so' on this arm, so
# MarkupSafe takes its pure-Python fallback and no extension is dlopen'd.
# Checked against the built .deb rather than assumed.

P=python3-typogrify
bst_ok $P/suite-canary
require python3 $P/python3-present

SITE=/usr/lib/python3.12/site-packages
PKGDIR=$SITE/typogrify
DI=$SITE/typogrify-2.0.7.dist-info
PKGLIST=/var/lib/dpkg/info/python3-typogrify.list
PROBE=$BST_DATA/python3-typogrify-probe.py

tmp=${TMPDIR:-/tmp}
W=$tmp/bst-typogrify.$$
mkdir -p "$W" || { bst_notok $P/workdir "cannot create $W"; exit 0; }

# ---------------------------------------------------------------- on disk ---
check $P/site-packages-dir  test -d "$SITE"
check $P/package-dir        test -d "$PKGDIR"
check $P/package-init       test -s "$PKGDIR/__init__.py"
check $P/module-filters     test -s "$PKGDIR/filters.py"
check $P/subpkg-packages    test -d "$PKGDIR/packages"
check $P/subpkg-titlecase   test -s "$PKGDIR/packages/titlecase/__init__.py"
check $P/subpkg-titlecase-tests test -s "$PKGDIR/packages/titlecase/tests.py"
check $P/subpkg-templatetags test -d "$PKGDIR/templatetags"
check $P/binding-jinja      test -s "$PKGDIR/templatetags/jinja_filters.py"
check $P/binding-django     test -s "$PKGDIR/templatetags/typogrify_tags.py"
check $P/no-flat-module     test ! -f "$SITE/typogrify.py"
check $P/pycache-init       test -s "$PKGDIR/__pycache__/__init__.cpython-312.pyc"
check $P/pycache-filters    test -s "$PKGDIR/__pycache__/filters.cpython-312.pyc"
check $P/pycache-jinja      test -s "$PKGDIR/templatetags/__pycache__/jinja_filters.cpython-312.pyc"
# The django binding BYTE-COMPILES even though it cannot import: `import django'
# is a runtime statement, not a compile-time one.
check $P/pycache-django     test -s "$PKGDIR/templatetags/__pycache__/typogrify_tags.cpython-312.pyc"

# --------------------------------------------------------- what dpkg says ---
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)"
check_eq $P/pkg-no-bin "" \
  "$(grep -E '^/usr/s?bin/' "$W/pkgf" 2>/dev/null)"
# Pure Python: nothing but .py, .pyc and dist-info metadata may ship.
_bad=""
while IFS= read -r _f; do
  [ -f "$_f" ] || continue
  case "$_f" in
    *.py|*.pyc)      continue ;;
    */__pycache__/*) continue ;;
    */*.dist-info/*) continue ;;
  esac
  _bad="$_bad $_f"
done < "$W/pkgf"
check_eq $P/pkg-only-python "" "$_bad"

check $P/dist-info-dir        test -d "$DI"
check $P/dist-info-metadata   test -f "$DI/METADATA"
check_out $P/dist-info-name     "Name: typogrify"  cat "$DI/METADATA"
check_out $P/dist-info-version  "Version: 2.0.7"   cat "$DI/METADATA"
check_out $P/dist-info-requires "Requires-Dist: smartypants" cat "$DI/METADATA"
check_out $P/dist-info-top-level "typogrify"       cat "$DI/top_level.txt"
check_out $P/dist-info-purelib  "Root-Is-Purelib: true" cat "$DI/WHEEL"
check_out $P/dist-info-tag      "Tag: py3-none-any"     cat "$DI/WHEEL"
check $P/dist-info-license    test -s "$DI/LICENSE.txt"

sed -n '/^Package: python3-typogrify$/,/^$/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"
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-smartypants "python3-smartypants" cat "$W/dep"
# Added by the meta-brintos bbappend -- see the header.
check_out $P/pkg-depends-jinja2      "python3-jinja2"      cat "$W/dep"
# Deliberately absent. A red here means django reached this image.
check_eq $P/pkg-no-django-depends "" \
  "$(grep -o 'python3-django' "$W/dep" 2>/dev/null)"
check $P/pkg-no-ptest test ! -e /var/lib/dpkg/info/python3-typogrify-ptest.list

# ------------------------------------------------------------- it imports ---
check $P/import python3 -c 'import typogrify.filters'
check_eq $P/import-quiet "" \
  "$(python3 -c 'import typogrify.filters' 2>&1)"

# ----------------------------------------------------------------- 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
bst_probe $P/probe-run "$W/probe" 900 python3 "$PROBE"
OUT="$W/probe"
pv() { grep "^$1=" "$OUT" 2>/dev/null | head -n 1 | cut -d= -f2-; }
if [ -s "$OUT" ]; then
  bst_ok $P/probe-output
else
  bst_notok $P/probe-output "the probe emitted nothing -- python3 did not start, or died before its first line; every CASE below is unscorable"
fi
check_eq $P/probe-complete "yes" "$(pv probe_done)"
check_eq $P/emitted-count  "83"  "$(pv emitted_count)"

# ------------------------------------------------------- identity/closure ---
check_eq $P/module-answered "$PKGDIR/__init__.py" "$(pv module_file)"
check_eq $P/filters-answered "$PKGDIR/filters.py" "$(pv filters_file)"
check_eq $P/is-package    "yes"   "$(pv is_package)"
check_eq $P/version       "2.0.7" "$(pv version)"
check_eq $P/dist-version  "2.0.7" "$(pv dist_version)"
check_eq $P/dist-requires "smartypants >=1.8.3" "$(pv dist_requires)"

# Only the typogrify-owned half of the delta is a fact about this package: the
# stdlib half is startup-dependent -- a warm interpreter has already imported
# functools/collections/operator, a pristine one imports them here, via re.
check_eq $P/closure-delta \
  "typogrify,typogrify.filters,typogrify.packages,typogrify.packages.titlecase" \
  "$(pv closure_delta | tr ',' '\n' | grep '^typogrify' | tr '\n' ',' | sed 's/,$//')"
check_eq $P/closure-nonstdlib "none" "$(pv closure_nonstdlib)"
# smartypants is reached from INSIDE two functions, so a bare import must not
# pull it in. This is what makes python3-smartypants a runtime, not import, dep.
check_eq $P/closure-lazy-smartypants "no" "$(pv closure_has_smartypants)"

# --------------------------------------------------------------- surface ---
check_eq $P/has-amp            "yes" "$(pv has_amp)"
check_eq $P/has-caps           "yes" "$(pv has_caps)"
check_eq $P/has-initial-quotes "yes" "$(pv has_initial_quotes)"
check_eq $P/has-smartypants    "yes" "$(pv has_smartypants)"
check_eq $P/has-widont         "yes" "$(pv has_widont)"
check_eq $P/has-titlecase      "yes" "$(pv has_titlecase)"
check_eq $P/has-typogrify      "yes" "$(pv has_typogrify)"
check_eq $P/has-applyfilters   "yes" "$(pv has_applyfilters)"
check_eq $P/has-process-ignores "yes" "$(pv has_process_ignores)"
# See the header, point 1: there is no ordinal filter and never has been.
check_eq $P/no-ordinal-filter  "no"  "$(pv has_ordinal)"
check_eq $P/public-names \
  "TypogrifyError,amp,applyfilters,caps,initial_quotes,process_ignores,re,smartypants,titlecase,typogrify,widont" \
  "$(pv public_names)"
check_eq $P/has-error-class    "yes" "$(pv has_TypogrifyError)"
check_eq $P/error-is-exception "yes" "$(pv error_is_exception)"

# ------------------------------------------------------------------- amp ---
# All three spellings of the entity normalise to the same wrapped output.
check_eq $P/amp-plain   "'One <span class=\"amp\">&amp;</span> two'" "$(pv amp_plain)"
check_eq $P/amp-entity  "'One <span class=\"amp\">&amp;</span> two'" "$(pv amp_entity)"
check_eq $P/amp-numeric "'One <span class=\"amp\">&amp;</span> two'" "$(pv amp_numeric)"
check_eq $P/amp-nbsp \
  "'One&nbsp;<span class=\"amp\">&amp;</span>&nbsp;two'" "$(pv amp_nbsp)"
# An ampersand already inside a span.amp must not be wrapped a second time.
check_eq $P/amp-no-double-wrap \
  "'One <span class=\"amp\">&amp;</span> two'" "$(pv amp_already_wrapped)"
# An `&' inside a tag ATTRIBUTE is not text.
check_eq $P/amp-in-attribute \
  "'<link href=\"xyz.html\" title=\"One & Two\">xyz</link>'" "$(pv amp_in_attribute)"
check_eq $P/amp-in-url \
  "'&ldquo;this&rdquo; <span class=\"amp\">&amp;</span> <a href=\"/?that&amp;test\">that</a>'" \
  "$(pv amp_in_url)"

# ------------------------------------------------------------------ caps ---
check_eq $P/caps-plain \
  "'A message from <span class=\"caps\">KU</span>'" "$(pv caps_plain)"
check_eq $P/caps-digits \
  "'A message from <span class=\"caps\">2KU2</span> with digits'" "$(pv caps_digits)"
# The trailing dot is inside the span; the two spaces after it are not.
check_eq $P/caps-dotted \
  "'Dotted caps followed by spaces should never include them in the wrap <span class=\"caps\">D.O.T.</span>  like so.'" \
  "$(pv caps_dotted)"
check_eq $P/caps-apostrophe \
  "'<span class=\"caps\">JIMMY\\'S</span>'" "$(pv caps_apostrophe)"
check_eq $P/caps-inline-tags \
  "'<i><span class=\"caps\">D.O.T.</span></i><span class=\"caps\">HE34T</span><b><span class=\"caps\">RFID</span></b>'" \
  "$(pv caps_inline_tags)"
# caps alone DOES skip <script> -- via smartypants' tokenizer. Compare
# tg-script-default below, where the composed filter does not.
check_eq $P/caps-script-skipped \
  "'<SCRIPT>CAPS</script> more <span class=\"caps\">CAPS</span>'" \
  "$(pv caps_script_skipped)"
# A single capital is not a run; two is the minimum.
check_eq $P/caps-single-letter-untouched \
  "'A single I is not caps'" "$(pv caps_single_letter)"

# -------------------------------------------------------- initial_quotes ---
check_eq $P/iq-double \
  "'<span class=\"dquo\">\"</span>With primes\"'" "$(pv iq_double)"
check_eq $P/iq-single \
  "'<span class=\"quo\">\\'</span>With single primes\\''" "$(pv iq_single)"
check_eq $P/iq-inside-link \
  "'<a href=\"#\"><span class=\"dquo\">\"</span>With primes and a link\"</a>'" \
  "$(pv iq_inside_link)"
check_eq $P/iq-smartypanted \
  "'<span class=\"dquo\">&#8220;</span>With smartypanted quotes&#8221;'" \
  "$(pv iq_smartypanted)"
# Only a BLOCK's opening quote is wrapped, not any quote.
check_eq $P/iq-midsentence-untouched \
  "'He said \"hello\" to me'" "$(pv iq_midsentence)"

# ----------------------------------------------------------- smartypants ---
check_eq $P/sp-quotes   "'The &#8220;Green&#8221; man'" "$(pv sp_quotes)"
check_eq $P/sp-emdash   "'Some text &#8212; and more'"  "$(pv sp_emdash)"
check_eq $P/sp-ellipsis "'Wait&#8230; what'"            "$(pv sp_ellipsis)"

# ---------------------------------------------------------------- widont ---
check_eq $P/wd-simple       "'A very simple&nbsp;test'" "$(pv wd_simple)"
check_eq $P/wd-one-word     "'Test'"                    "$(pv wd_one_word)"
check_eq $P/wd-leading-space "' Test'"                  "$(pv wd_leading_space)"
# THE BLOCK CASE: each paragraph gets its own nbsp, not the document's last two.
check_eq $P/wd-per-block \
  "'<p>In a couple of&nbsp;paragraphs</p><p>paragraph&nbsp;two</p>'" \
  "$(pv wd_two_paragraphs)"
check_eq $P/wd-link-in-heading \
  "'<h1><a href=\"#\">In a link inside a&nbsp;heading</i> </a></h1>'" \
  "$(pv wd_link_in_heading)"
check_eq $P/wd-link-then-text \
  "'<h1><a href=\"#\">In a link</a> followed by other&nbsp;text</h1>'" \
  "$(pv wd_link_then_text)"
check_eq $P/wd-empty-html   "'<h1><a href=\"#\"></a></h1>'" "$(pv wd_empty_html)"
# A bare div is not one of widont's blocks; a p inside one is.
check_eq $P/wd-div-untouched "'<div>Divs get no love!</div>'" "$(pv wd_div_ignored)"
check_eq $P/wd-pre-untouched "'<pre>Neither do PREs</pre>'"   "$(pv wd_pre_ignored)"
check_eq $P/wd-div-with-p \
  "'<div><p>But divs with paragraphs&nbsp;do!</p></div>'" "$(pv wd_div_with_p)"
check_eq $P/wd-li-single-word "'<ul><li>Test</p></li><ul>'" "$(pv wd_li)"

# ------------------------------------------------------------- titlecase ---
# The vendored in-tree typogrify.packages.titlecase, not an external dependency.
check_eq $P/tc-simple        "'This Is a Title'"      "$(pv tc_simple)"
check_eq $P/tc-small-words   "'A Tale of Two Cities'" "$(pv tc_small_words)"
check_eq $P/tc-all-caps-kept "'IBM and the FBI'"      "$(pv tc_all_caps_kept)"

# ------------------------------------------------- typogrify(), composed ---
# Everything at once: initial_quotes, smartypants, amp, caps and widont.
check_eq $P/tg-document \
  "'<h2><span class=\"dquo\">&#8220;</span>Jayhawks&#8221; <span class=\"amp\">&amp;</span> <span class=\"caps\">KU</span> fans act extremely&nbsp;obnoxiously</h2>'" \
  "$(pv tg_document)"
# <pre> and <code> ARE the default ignore set: the region is byte-identical,
# and the <p> beside it shows the filters did run.
check_eq $P/tg-pre-untouched \
  "'<pre>\"KU\" & stuff</pre><p><span class=\"dquo\">&#8220;</span><span class=\"caps\">KU</span>&#8221; <span class=\"amp\">&amp;</span>&nbsp;stuff</p>'" \
  "$(pv tg_pre_untouched)"
check_eq $P/tg-code-untouched \
  "'<code>\"KU\" & stuff</code><p><span class=\"dquo\">&#8220;</span><span class=\"caps\">KU</span>&#8221; <span class=\"amp\">&amp;</span>&nbsp;stuff</p>'" \
  "$(pv tg_code_untouched)"
# See the header, point 2. <script>/<style> are NOT ignored by default, and amp
# reaches inside. Asserted as upstream's behaviour, not as a fault of the port.
check_eq $P/tg-script-default \
  "'<script>var a = \"KU\" <span class=\"amp\">&amp;</span> b;</script>'" \
  "$(pv tg_script_default)"
check_eq $P/tg-style-default \
  "'<style>/* \"<span class=\"caps\">KU</span>\" <span class=\"amp\">&amp;</span> x */</style>'" \
  "$(pv tg_style_default)"
# The repair, beside the default: an explicit ignore_tags does reach them.
check_eq $P/tg-script-ignored \
  "'<script>var a = \"KU\" & b;</script>'" "$(pv tg_script_ignored)"
check_eq $P/tg-style-ignored \
  "'<style>/* \"KU\" & x */</style>'" "$(pv tg_style_ignored)"

# -------------------------------------------------------- process_ignores ---
check_eq $P/pi-default \
  "[('<pre>processed</pre>', False), ('<p>processed</p>', True)]" "$(pv pi_default)"
check_eq $P/pi-nested \
  "[('<code>processed</code>', False), ('<p>processed', True), ('<pre>processed</pre>', False), ('</p>', True)]" \
  "$(pv pi_nested)"
check_eq $P/pi-explicit-tag \
  "[('<code>processed</code>', False), ('<p>processed<pre>processed</pre></p>', False)]" \
  "$(pv pi_explicit)"
check_eq $P/pi-class-selector \
  "[('<span class=\"test\">processed</span>', False), ('<span>processed', True), ('<div>processed</div>', False), ('</span>', True)]" \
  "$(pv pi_class_selector)"

# ----------------------------------- python3-smartypants is the supplier ---
check_eq $P/smartypants-file    "$SITE/smartypants.py" "$(pv smartypants_file)"
check_eq $P/smartypants-version "2.0.0"                "$(pv smartypants_version)"
check_eq $P/smartypants-agrees  "yes"                  "$(pv smartypants_agrees)"
# With the module hidden, the filter raises typogrify's OWN error -- which is
# what a Django/Jinja template catches -- rather than a bare ImportError.
check_eq $P/smartypants-missing-raises "TypogrifyError" "$(pv smartypants_missing_raises)"
check_eq $P/caps-missing-raises        "TypogrifyError" "$(pv caps_missing_raises)"

# ------------------------------------------------------ template bindings ---
check_eq $P/jinja-binding-filters \
  "amp,caps,initial_quotes,smartypants,titlecase,typogrify,widont" \
  "$(pv jinja_binding_filters)"
# The jinja binding registers plain filters; it ships no Extension subclass.
check_eq $P/jinja-no-extension "no" "$(pv jinja_has_extension)"
# Deliberately unimportable -- see the header and the bbappend.
check_eq $P/django-binding-absent "ModuleNotFoundError:django" "$(pv django_binding)"
check_eq $P/django-file-present   "yes" "$(pv django_file_present)"

# --------------------------------------------- upstream's own doctest suite ---
# filters.py carries its entire specification as doctests; `_test()' is what
# runs them upstream. There is no unittest file in this package.
check_eq $P/doctest-attempted "40" "$(pv doctest_attempted)"
check_eq $P/doctest-failed    "0"  "$(pv doctest_failed)"
check_eq $P/titlecase-tests-import "imported" "$(pv titlecase_tests_import)"

rm -rf "$W"