. "$BST_LIB"
require jpnevulator jpnevulator/present

# jpnevulator 2.3.6+git (meta-oe recipes-extended) -- Freddy Spierenburg's serial
# sniffer. It has exactly two actions. --read opens every interface it was given,
# select(2)s on them and writes a hex (or binary) dump of whatever arrives, with
# an optional ASCII column and an optional byte-count column. --write does the
# reverse: it parses a hex dump out of its input file and writes the bytes it
# decodes to the interface, optionally appending a checksum, a CRC-16 or a CRC-8.
#
# THIS IMAGE EXPOSES NO SERIAL PORT THAT WILL OPEN. /dev/ttySER0 is registered by
# the wasm32 driver on every image and refuses open(2) with -ENODEV until a host
# WebSerial port attaches (the grant boundary, linux-in-the-browser#60 M2); there
# is no /dev/ttyS0 at all. That is a property of the platform rather than of the
# port, and it is what the probe below establishes rather than assumes.
#
# What makes almost all of this suite REAL ASSERTIONS anyway is one fact about
# the source: jpnevulator's interface open is tty.c::ttyOpen(), which is a bare
#
#     open(name, O_RDWR)
#
# with no tcgetattr, no isatty and no termios of any kind. So an ORDINARY FILE
# named by --tty is a perfectly good interface in both directions, and the whole
# of the dump formatter, the hex parser, the checksum arms and the argument
# validation can be driven end to end with no tty anywhere. The suite splits:
#
#   ASSERTED FOR REAL -- the usage and version banners and which stream they use,
#   every argument-validation diagnostic, the dump formatting (default width, the
#   ASCII column, --width wrapping, --byte-count offsets, --base=2 binary and the
#   non-printable substitution) driven from a file, and the write direction
#   including a byte-exact dump->parse->bytes round trip and all four trailer
#   arms. None of these needs a tty and none of them is a proxy for one.
#
#   PROBED, then skipped -- the serial capture over /dev/ttySER0, the one thing
#   that genuinely needs the port. The probe is jpnevulator's OWN open of it, so
#   a probe that fails IS the port failing rather than a stand-in for it, and the
#   skip reason carries what it said.
#
#   PROBED, then RUN -- the same capture over a pty pair, which is a real tty and
#   which this kernel does provide (78-libutempter asserts the whole
#   posix_openpt/grantpt/unlockpt/ptsname sequence green). --pty is jpnevulator's
#   own acquisition of it, so this exercises the select/read/format path over a
#   character device with a line discipline, not over a regular file.
#
# EVERY INVOCATION IS BOUNDED, and that is not decoration. jpnevulator's read
# loop is `for(;count!=0;)` with count defaulting to -1, so a --read with no
# --count NEVER RETURNS -- on a regular file it spins at 100% CPU on a select
# that is always ready and a read that always returns 0. An unbounded case here
# would not fail, it would take the machine. Two independent bounds are used
# together: every read case that is meant to dump names a --count, and every
# invocation in the file runs under `timeout`. The validation cases take a third
# and stronger one -- they name an interface that cannot be opened, so option
# parsing emits the diagnostic and jpnevulator exits at "No available interface"
# WITHOUT EVER ENTERING THE LOOP.
#
# Every expectation below was executed against jpnevulator at SRCREV bc1d4f65
# built natively on x86-64 before it was written down, rc and bytes compared.

TO="timeout 20"
t=${TMPDIR:-/tmp}/bst-jpnevulator.$$
mkdir -p "$t"

# The fixtures. Written here rather than shipped in data/ because a suite must
# not redirect stdin from the virtiofs root (brintos/linux#73) and because both
# directions want to write as well as read.
#
# f16 is exactly one full dump line at the default width of 16. f19 adds three
# non-printable bytes so the wrap, the short-line padding and the '.' ASCII
# substitution all have something to act on. NUL is deliberately not among them:
# the fixture is built by the shell's printf, and a NUL in that path is not worth
# depending on when 0x01/0x7F/0xFF answer the same question.
printf 'Hello, brintOS!\n' > "$t/f16"
cp "$t/f16" "$t/f19"
printf '\001\177\377' >> "$t/f19"

# An interface name nothing can open. Used by every validation case so the
# diagnostic is reached and the read loop is not.
ABSENT=/dev/bst-jpnevulator-absent

# _case <id> <want-rc> <needle> <cmd...> : ok iff <cmd> exits <want-rc> AND its
# combined output contains <needle>. Both halves are needed almost everywhere
# here: jpnevulator answers --version and --help with status 1, answers a
# validation complaint with whatever the run went on to do, and puts the whole of
# the information in the string.
_case() {
	_cid=$1; _cwant=$2; _cn=$3; shift 3
	_co=$($TO "$@" </dev/null 2>&1); _cr=$?
	case "$_co" in *"$_cn"*) _ch=1 ;; *) _ch=0 ;; esac
	if [ "$_cr" -eq "$_cwant" ] && [ "$_ch" -eq 1 ]; then bst_ok "$_cid"
	elif bst_execfail "$_co"; then bst_unrun "$_cid" "$_co"
	else bst_notok "$_cid" "rc=$_cr want=$_cwant needle:'$_cn' got:'$(_bst_1line "$_co")'"; fi
}

# --- the package -------------------------------------------------------------
check      jpnevulator/path    test -x /usr/bin/jpnevulator
check_out  jpnevulator/on-path "/usr/bin/jpnevulator" command -v jpnevulator
check      jpnevulator/manpage test -s /usr/share/man/man1/jpnevulator.1.gz

# --- the version banner ------------------------------------------------------
# --version RETURNS 1, not 0: options.c returns optionsRtrnVersion, main.c maps
# every non-ok parse to jpnevulatorRtrnOptions == 1. A port that "fixed" that to
# 0 would be a behavioural change, so the status is pinned as hard as the text.
_case jpnevulator/version-text 1 "jpnevulator version 2.3.6"       jpnevulator --version
_case jpnevulator/version-rc   1 "Freddy Spierenburg"              jpnevulator --version
_case jpnevulator/version-gpl  1 "GNU General Public License"      jpnevulator --version

_vs=$($TO jpnevulator --version 2>/dev/null </dev/null)
case "$_vs" in
	*"jpnevulator version 2.3.6"*) bst_ok jpnevulator/version-on-stdout ;;
	*) bst_notok jpnevulator/version-on-stdout "banner not on stdout: '$(_bst_1line "$_vs")'" ;;
esac

# --- the usage banner --------------------------------------------------------
# usage() is one printf of one string, so the four lines below are four
# independent pins on that string rather than four spellings of one case: an
# option compiled out of the parser would take its word out of exactly one of
# them.
_case jpnevulator/help-usage 1 "Usage: jpnevulator [--version] [--help]"    jpnevulator --help
_case jpnevulator/help-tty   1 "[--tty=tty] [--pty [=alias]]"               jpnevulator --help
_case jpnevulator/help-base  1 "[--control-poll=microseconds] [--count=bytes] [--base] <file>" jpnevulator --help
_case jpnevulator/help-crc   1 "[--checksum] [--crc16=poly]"                jpnevulator --help

_hs=$($TO jpnevulator --help 2>/dev/null </dev/null)
case "$_hs" in
	*"Usage: jpnevulator"*) bst_ok jpnevulator/help-on-stdout ;;
	*) bst_notok jpnevulator/help-on-stdout "usage not on stdout: '$(_bst_1line "$_hs")'" ;;
esac

# --- argument validation -----------------------------------------------------
# Each of these names $ABSENT, so the diagnostic is emitted during the parse and
# the process then exits 2 at "No available interface to read from" without ever
# reaching the read loop. --count=0 is the one that makes this mandatory rather
# than tidy: the value is DISCARDED, which leaves count at its -1 default, and
# -1 is the spin-forever case.
_case jpnevulator/reject-count-0    2 "Discarding count. It should be bigger than zero."       jpnevulator --read --count=0        --tty=$ABSENT
_case jpnevulator/reject-width-0    2 "Discarding width. It should be bigger than zero."       jpnevulator --read --width=0        --tty=$ABSENT
_case jpnevulator/reject-size-0     2 "Discarding size. It should be bigger than zero."        jpnevulator --read --size=0         --tty=$ABSENT
_case jpnevulator/reject-dline-0    2 "Discarding line delay. It should be bigger than zero."  jpnevulator --read --delay-line=0   --tty=$ABSENT
_case jpnevulator/reject-dbyte-0    2 "Discarding byte delay. It should be bigger than zero."  jpnevulator --read --delay-byte=0   --tty=$ABSENT
_case jpnevulator/reject-cpoll-0    2 "Discarding control poll. It should be bigger than zero." jpnevulator --read --control-poll=0 --tty=$ABSENT
_case jpnevulator/reject-base       2 "Unsupported base unit selected, cowardly using default base(=16) unit." jpnevulator --read --base=7 --tty=$ABSENT
# Both orders, because the message names the action that WON and the winner is
# whichever flag came last -- a parser that took the first would still satisfy a
# single case here.
_case jpnevulator/read-then-write   0 "Use --read or --write, but not both. Performing a write this time." jpnevulator --read --write --tty=$ABSENT
_case jpnevulator/write-then-read   2 "Use --read or --write, but not both. Performing a read this time."  jpnevulator --write --read --tty=$ABSENT
_case jpnevulator/unknown-option    2 "unrecognized option"                                    jpnevulator --read --bst-no-such-option --tty=$ABSENT

# No action at all defaults to a WRITE, which is the one arm of this block that
# does not exit 2 -- jpnevulatorWrite() reports the unopenable interface and
# still returns 0. Pinned as measured rather than as expected.
_case jpnevulator/no-action-defaults 0 "Use of --read or --write mandatory. Defaulting to write this time." jpnevulator --tty=$ABSENT

# The unopenable interface itself, both halves. The second needle is the
# whole-run verdict, which is what separates "one interface was refused" from
# "nothing is left to read".
_case jpnevulator/absent-iface-msg 2 "Unable to open interface $ABSENT: No such file or directory" jpnevulator --read --count=4 --tty=$ABSENT
_case jpnevulator/absent-iface-rc  2 "No available interface to read from"                         jpnevulator --read --count=4 --tty=$ABSENT

# Every diagnostic above is fprintf(stderr). A port that let one reach stdout
# would corrupt the dump of every caller that pipes it.
_es=$($TO jpnevulator --read --width=0 --tty=$ABSENT 2>/dev/null </dev/null)
if [ -z "$_es" ]; then bst_ok jpnevulator/errors-on-stderr
else bst_notok jpnevulator/errors-on-stderr "a diagnostic reached stdout: '$(_bst_1line "$_es")'"; fi

# --- the dump formatter, driven from a file ----------------------------------
# ttyOpen() is a bare open(name,O_RDWR), so a regular file is an interface. The
# expectations are byte-exact against the native run; the ASCII column is
# separated by a TAB, which is why the two ascii cases build their expectation
# with printf rather than quoting a literal.
_d16=$($TO jpnevulator --read --count=16 --tty="$t/f16" 2>/dev/null </dev/null)
check_eq jpnevulator/dump-hex "48 65 6C 6C 6F 2C 20 62 72 69 6E 74 4F 53 21 0A" "$_d16"

_TAB=$(printf '\t')
_a16=$($TO jpnevulator --read --ascii --count=16 --tty="$t/f16" 2>/dev/null </dev/null)
check_eq jpnevulator/dump-ascii \
	"48 65 6C 6C 6F 2C 20 62 72 69 6E 74 4F 53 21 0A${_TAB}Hello, brintOS!." "$_a16"

_b16=$($TO jpnevulator --read --count=16 --base=2 --tty="$t/f16" 2>/dev/null </dev/null)
check_eq jpnevulator/dump-base2 \
	"01001000 01100101 01101100 01101100 01101111 00101100 00100000 01100010 01110010 01101001 01101110 01110100 01001111 01010011 00100001 00001010" "$_b16"

# The wrap. Five lines out of nineteen bytes at width 4, the last of them short.
_w4=$($TO jpnevulator --read --ascii --width=4 --count=19 --tty="$t/f19" 2>/dev/null </dev/null)
check_eq jpnevulator/dump-width4 "$(printf '48 65 6C 6C\tHell\n6F 2C 20 62\to, b\n72 69 6E 74\trint\n4F 53 21 0A\tOS!.\n01 7F FF   \t...')" "$_w4"

# The byte-count column is the running per-interface offset in 8 hex digits, and
# it advances by the width rather than by the line: 00000000 then 00000010.
_bc=$($TO jpnevulator --read --byte-count --count=19 --tty="$t/f19" 2>/dev/null </dev/null)
check_eq jpnevulator/dump-bytecount \
	"$(printf '00000000\t48 65 6C 6C 6F 2C 20 62 72 69 6E 74 4F 53 21 0A\n00000010\t01 7F FF')" "$_bc"

# isprint(3) decides the ASCII column, and 0x01/0x7F/0xFF are all non-printable,
# so the short last line reads "..." -- the substitution asserted on its own.
case "$_w4" in *"01 7F FF   ${_TAB}..."*) bst_ok jpnevulator/dump-nonprintable ;;
	*) bst_notok jpnevulator/dump-nonprintable "expected '01 7F FF' to render as '...': '$(_bst_1line "$_w4")'" ;;
esac

# A --count that is satisfied ends the run cleanly. This is the case that says
# the loop TERMINATES, which every other read case above depends on.
check_rc jpnevulator/dump-rc 0 $TO jpnevulator --read --count=16 --tty="$t/f16"

# --- the write direction, and the round trip ---------------------------------
# --write parses a hex dump out of its input file and writes the decoded bytes to
# the interface. With a regular file on both ends this is the formatter's exact
# inverse and needs no tty either.
printf '48 65 6C 6C 6F 0A\n' > "$t/hex"
: > "$t/out"
check_rc jpnevulator/write-rc 0 $TO jpnevulator --write --tty="$t/out" "$t/hex"
check_eq jpnevulator/write-bytes "48 65 6c 6c 6f 0a" "$(od -An -tx1 < "$t/out" | tr -s ' ' | sed 's/^ //;s/ $//' | tr -d '\n')"

# THE round trip: dump f19, feed the dump straight back in, and compare the bytes
# against the original. This is the single strongest assertion in the file --
# formatter and parser both, over all nineteen bytes including the three
# non-printable ones, with no tty and no expectation typed by hand.
$TO jpnevulator --read --count=19 --tty="$t/f19" > "$t/rt.hex" 2>/dev/null </dev/null
: > "$t/rt.bin"
$TO jpnevulator --write --tty="$t/rt.bin" "$t/rt.hex" >/dev/null 2>&1 </dev/null
check jpnevulator/roundtrip cmp -s "$t/f19" "$t/rt.bin"

# The four trailer arms. Each appends two bytes to the 0x41 0x42 message and each
# value is an ANSWER computed by the package, not output drift: sum 0x83 padded
# with 0x00, CRC-16 with the default 0xA001 polynomial, CRC-8 with the default
# 0x07 polynomial and its hardcoded 0x0D terminator, and --fuck-up corrupting the
# low half of the checksum on purpose.
printf '41 42\n' > "$t/ab"
_trailer() {
	: > "$t/tr"
	$TO jpnevulator --write $2 --tty="$t/tr" "$t/ab" >/dev/null 2>&1 </dev/null
	check_eq "jpnevulator/$1" "$3" "$(od -An -tx1 < "$t/tr" | tr -s ' ' | sed 's/^ //;s/ $//' | tr -d '\n')"
}
_trailer write-checksum --checksum          "41 42 83 00"
_trailer write-crc16    --crc16             "41 42 b0 61"
_trailer write-crc8     --crc8              "41 42 aa 0d"
_trailer write-fuckup   "--checksum --fuck-up" "41 42 83 ff"

# --print echoes the message it is about to send; --no-send suppresses the send
# and keeps the echo, which is the pair that makes jpnevulator usable as a hex
# parser with no interface at all.
_case jpnevulator/write-print 0 "41 42" jpnevulator --write --print --tty="$t/tr" "$t/ab"
: > "$t/ns"
_case jpnevulator/write-no-send-prints 0 "41 42" jpnevulator --write --no-send --print --tty="$t/ns" "$t/ab"
check_eq jpnevulator/write-no-send-writes-nothing "0" "$(wc -c < "$t/ns" | tr -d ' ')"

# --- probe: is there a serial port on this machine? --------------------------
# The probe is jpnevulator's own open of /dev/ttySER0 -- the exact ttyOpen() call
# the capture would make, not a stand-in for it. Three worlds are self-consistent
# and one is not:
#
#   no /dev/ttySER0            -> no serial capture is possible; skip.
#   /dev/ttySER0, open refused -> the grant boundary; no host WebSerial port is
#                                 attached. Skip, carrying what it said.
#   /dev/ttySER0, open granted -> a port exists; RUN the capture.
#
# A refusal is not a red: it is this image's documented unattended state
# (linux-in-the-browser#60 M2), the same one 59-picocom records for the same
# device.
if [ ! -c /dev/ttySER0 ]; then
	bst_ok jpnevulator/probe-serial
	_serial_why="/dev/ttySER0 is absent on this kernel"
	_serial=0
else
	bst_ok jpnevulator/probe-serial
	_so=$($TO jpnevulator --read --count=1 --tty=/dev/ttySER0 2>&1 >/dev/null </dev/null)
	case "$_so" in
		*"Unable to open interface /dev/ttySER0"*)
			_serial=0
			_serial_why="jpnevulator's own open of /dev/ttySER0 was refused: $(_bst_1line "$_so")" ;;
		*)  _serial=1 ;;
	esac
fi
if [ "$_serial" -eq 0 ]; then
	bst_skip jpnevulator/serial-capture "$_serial_why"
else
	# A port that opens but delivers nothing is not a failure of the port either,
	# so the bound is what decides and rc=124 is reported as the timeout it is.
	_sc=$($TO jpnevulator --read --ascii --count=1 --tty=/dev/ttySER0 2>&1 </dev/null); _scr=$?
	if [ "$_scr" -eq 0 ]; then bst_ok jpnevulator/serial-capture
	elif [ "$_scr" -eq 124 ]; then
		bst_skip jpnevulator/serial-capture "/dev/ttySER0 opened but delivered no byte within the bound"
	else bst_notok jpnevulator/serial-capture "rc=$_scr $(_bst_1line "$_sc")"; fi
fi

# --- probe only: the pty acquisition, NOT a capture over it ------------------
# --pty is jpnevulator's own posix_openpt/grantpt/unlockpt/ptsname acquisition
# (pty.c::ptyOpen), and it announces the slave it got on stderr. That probe is a
# timeout-wrapped invocation like every other one in this file, so it is bounded
# and it stays.
#
# THE CAPTURE OVER THE SLAVE IS GONE, and this is measured, not cautious. The
# capture needed the suite shell itself to open the announced slave to feed it
# ('printf Hello > "$_pts"'), and a redirection is performed by the shell, so no
# `timeout` can wrap it: an open that does not return takes the suite shell, and
# with it the machine. On 2026-08-26 that is exactly what happened, twice on one
# image -- once with this suite first among eight, and again on the fresh boot
# the runner gives a quarantined suite alone. Both captures end at the same
# point: '==BST-BEGIN==', the kernel's own '[k] wasm-serial: open(/dev/ttySER0)
# REFUSED' printk from the serial probe above, and then nothing at all until
# '[hardwarejs] powering off'. The suite reports per-suite, so a suite that never
# returns publishes none of the ~45 cases it had already passed. The same image
# without this suite completed 376 cases across seven sibling suites.
#
# The bound is what places it: everything above here is wrapped in $TO and all of
# it ran, which is what the serial probe's printk proves. This block held the
# file's only construct with no bound at all, and a grep across all 764 suites in
# the layer finds no other suite that opens a pts slave from its shell.
#
# The write direction is still used for the probe because it is bounded by its
# input: a --read --pty would block forever waiting for a byte nobody will send.
_po=$($TO jpnevulator --write --pty </dev/null 2>&1); _por=$?
case "$_po" in
	*"slave pts device is /dev/"*) bst_ok jpnevulator/probe-pty; _pty=1 ;;
	*) bst_ok jpnevulator/probe-pty; _pty=0
	   _pty_why="jpnevulator could not acquire a pty (rc=$_por): $(_bst_1line "$_po")" ;;
esac

_pty_capture_why="not attempted on this image: feeding the announced slave requires the suite shell to open it by name, which no timeout can bound, and that open wedged the guest on 2026-08-26 (two boots, no case output published at all). The acquisition itself is asserted by jpnevulator/probe-pty above; the read/format path it would have exercised is asserted over a regular file by the dump and roundtrip cases."
if [ "$_pty" -eq 0 ]; then
	bst_skip jpnevulator/pty-capture       "$_pty_why"
	bst_skip jpnevulator/pty-capture-ascii "$_pty_why"
else
	bst_skip jpnevulator/pty-capture       "$_pty_capture_why"
	bst_skip jpnevulator/pty-capture-ascii "$_pty_capture_why"
fi

rm -rf "$t"