# shunit2 2.1.8 — shUnit2, the xUnit test framework for shell scripts.
#
# WHAT THIS PORT HAS TO ESTABLISH. shunit2 is one POSIX-sh script and the recipe
# does nothing but `install -D` it, so there is no compile to get wrong and
# "it built" says almost nothing. What can go wrong on this arm is that the
# framework runs and reports the WRONG VERDICTS -- and a framework that reports
# everything as passing is indistinguishable from `true`. So the payloads below
# have verdicts known in advance and the assertions name the exact reported
# counts and exit status.
#
# WHY FOUR PAYLOADS.
#   data/shunit2-criterion.sh  the ticket's own criterion -- one passing, one
#                              deliberately failing, one skipped case. Must
#                              report all three and exit NON-ZERO.
#   data/shunit2-features.sh   the API a real test author writes against, all
#                              of it green, exit 0. The opposite polarity: the
#                              two together show the verdict tracks the tests
#                              rather than the runner.
#   data/shunit2-negative.sh   fourteen assertion and failure forms, each made
#                              to fail exactly once. This is what makes the
#                              green of the features payload mean something: an
#                              `assertEquals` that returned 0 unconditionally
#                              would leave that file just as green and would
#                              redden all fourteen cases here. Confirmed by
#                              doing it, not assumed.
#   data/shunit2-contains.sh   the assertContains / assertNotContains family,
#                              alone, because it is the one part of shUnit2
#                              that does NOT work on this arm -- see below.
#
# WHY THE CONTAINS FAMILY IS RED, AND WHY THAT IS THE PLATFORM'S FAULT.
# Both forms are `echo "$container" | grep -F -- "$content" > /dev/null`, and
# that idiom is broken on this image by brintos/linux#87: splice(2) is unwired
# in the wasm32 syscall table, GNU grep drains a FIFO with splice() whenever
# stdout is /dev/null, gets ENOSYS, and exits 2 on a SUCCESSFUL match. So
# "needle is present" reads as "not found" here. shunit2/platform-splice below
# probes that idiom directly and is the anchor the two contains reds point at;
# nothing about shUnit2 is at fault and there is nothing to patch in the recipe.
#
# BRINTOS-WORKAROUND: brintos/linux#87 remove — the contains cases and the zsh
# arm carry the issue in their detail, purely because splice(2) is unwired.
# They are left FAILING rather than skipped, so they flip green on their own the
# day #87 closes and the zsh arm starts driving the real criterion cases; this
# comment and the attribution text are then the whole of what is left to delete.
#
# WHY BOTH SHELLS, AND THEN TWO MORE. Shell portability IS this package's
# claim, so the criterion is driven under every shell the image ships -- bash
# and dash (the two the ticket names) plus mksh and zsh -- and each must report
# the identical verdict. Three of the four do. zsh cannot be reached until #87
# is fixed: shUnit2's own zsh check is `setopt |grep "^shwordsplit$" >/dev/null`,
# the same broken idiom, so it refuses to start under zsh on this image whatever
# the caller does -- which is one attributed red, not a gap in the port.
#
# WHY failures=2 FOR ONE DELIBERATE FAILURE. shUnit2 counts a test function
# that returns non-zero as a failure IN ADDITION to any assertion that failed
# inside it, and an assertion is the natural last statement of a test -- so the
# criterion payload's single wrong answer is reported twice, once as
# `ASSERT:...` and once as `testDeliberateFailure() returned non-zero return
# code.` Both lines are asserted by name so the count is pinned to its
# mechanism and not merely to a number. The other payloads end every test
# `return 0` for exactly this reason, which is why their counts are the plain ones.
#
# WHY SHUNIT_COLOR IS SET. The default is `auto`, which resolves through
# `tput colors` and falls back to SIXTEEN when tput fails -- it never consults
# isatty(3), so shUnit2 emits ANSI escapes into a pipe. Every capture here
# therefore pins the colour mode explicitly rather than depending on the
# guest's TERM, and the colour machinery gets its own two cases.
#
# WHY THE EXTERNAL COMMANDS GET CASES. Test discovery is
# `egrep <regex> <script> | sed ... | xargs` and the tmpdir comes from
# `mktemp`; `expr` does all the arithmetic and `uname -s` picks the expr
# variant. If any of those is missing the framework does not crash -- it
# reports `Ran 0 tests.` and exits 0, which is a green run that tested nothing.
# Naming them makes that diagnosis immediate instead of inferred.

# BST-TIMEOUT: 1000  # measured 322s over 7 shunit2 runs; ~3x headroom

. "$BST_LIB"
require shunit2 shunit2/present

S2_ISSUE='brintos/linux#87'

crit="$BST_DATA/shunit2-criterion.sh"
feat="$BST_DATA/shunit2-features.sh"
neg="$BST_DATA/shunit2-negative.sh"
cont="$BST_DATA/shunit2-contains.sh"

check shunit2/payload-criterion test -f "$crit"
check shunit2/payload-features  test -f "$feat"
check shunit2/payload-negative  test -f "$neg"
check shunit2/payload-contains  test -f "$cont"

# The framework's own externals. A missing one turns every run below into a
# silent `Ran 0 tests.`, so each is named rather than diagnosed after the fact.
check shunit2/dep-egrep  command -v egrep
check shunit2/dep-xargs  command -v xargs
check shunit2/dep-expr   command -v expr
check shunit2/dep-sed    command -v sed
check shunit2/dep-uname  command -v uname

SHUNIT_COLOR=none; export SHUNIT_COLOR

# --- the platform anchor ------------------------------------------------------
# `<pipe> | grep -F <needle> >/dev/null` on a needle that IS present. Every
# other red in this suite that names $S2_ISSUE reduces to this one line, so it
# is probed first and reported in its own right rather than inferred from the
# package's misbehaviour.
if echo abcdef | grep -F cde >/dev/null 2>/dev/null; then
  _S2_SPLICE_OK=1
  bst_ok shunit2/platform-splice
else
  _S2_SPLICE_OK=0
  bst_notok shunit2/platform-splice \
    "$S2_ISSUE: 'echo abcdef | grep -F cde >/dev/null' fails on a MATCH -- $(_bst_1line "$(echo abcdef | grep -F cde 2>&1 >/dev/null)")"
fi

# --- helpers ------------------------------------------------------------------

# _s2_line <regex> : the first line of $_S2_OUT matching <regex>, or empty.
_s2_line() { printf '%s\n' "$_S2_OUT" | grep -E "$1" | head -1; }

# _s2_summary <id> <want-rc> <want-ran> <want-summary> : the three numbers every
# shunit2 run reports -- exit status, test count, and the OK/FAILED tally.
_s2_summary() {
  check_eq "$1-rc"      "$2" "$_S2_RC"
  check_eq "$1-ran"     "$3" "$(_s2_line '^Ran ')"
  check_eq "$1-summary" "$4" "$(_s2_line '^(OK|FAILED)')"
}

# s2_criterion <label> <cmd...> : the ticket's pass criterion under one shell.
s2_criterion() {
  _s2_id="shunit2/$1"; shift
  _S2_OUT=$("$@" 2>&1); _S2_RC=$?
  _s2_summary "$_s2_id" 1 "Ran 3 tests." "FAILED (failures=2,skipped=1)"
  check_eq "$_s2_id-assert" \
    "ASSERT:deliberately wrong expected:<1> but was:<2>" "$(_s2_line '^ASSERT:')"
  check_eq "$_s2_id-rcdiag" \
    "shunit2:ERROR testDeliberateFailure() returned non-zero return code." \
    "$(_s2_line 'returned non-zero return code')"
}

# _s2_feat <id-prefix> <tag> : per-feature verdict from the features payload.
# The payload echoes `R-<tag> ok` as each test's last statement and tags every
# assertion message `[<tag>]`, so the echo says the test ran at all and the
# absence of a tagged ASSERT line says its assertions held. Without the echo a
# test that never ran would be indistinguishable from one that passed.
# `grep -q` is used deliberately throughout: it does NOT take grep's
# /dev/null drain path, so these helpers keep working under $S2_ISSUE.
_s2_feat() {
  if ! printf '%s\n' "$_S2_OUT" | grep -qF "R-$2 ok"; then
    bst_notok "$1-$2" "test did not run -- $(_bst_1line "$_S2_OUT")"
  elif printf '%s\n' "$_S2_OUT" | grep -qF "ASSERT:[$2]"; then
    bst_notok "$1-$2" \
      "$(_bst_1line "$(printf '%s\n' "$_S2_OUT" | grep -F "ASSERT:[$2]" | head -1)")"
  else
    bst_ok "$1-$2"
  fi
}

# s2_features <label> <cmd...> : the all-green API payload under one shell.
s2_features() {
  _s2_id="shunit2/$1"; shift
  _S2_OUT=$("$@" 2>&1); _S2_RC=$?
  _s2_summary "$_s2_id" 0 "Ran 7 tests." "OK (skipped=1)"
  for _s2_tag in equals same null truth lifecycle tmpdir skip; do
    _s2_feat "$_s2_id" "$_s2_tag"
  done
}

# --- the ticket's criterion, under every shell the image ships ----------------

for _s2_sh in bash dash mksh; do
  if command -v "$_s2_sh" >/dev/null 2>&1; then
    s2_criterion "$_s2_sh" "$_s2_sh" "$crit"
  else
    bst_skip "shunit2/$_s2_sh-present" "$_s2_sh not installed on this image"
  fi
done

# zsh is the one shell shUnit2 does not accept as-is: it needs word splitting
# turned on and $0 handed over explicitly, and says so itself rather than
# misbehaving. On this image it cannot be reached at all -- shUnit2 tests for
# the option with `setopt |grep "^shwordsplit$" >/dev/null`, which is the very
# idiom $S2_ISSUE breaks, so the check fails however the shell is invoked.
if ! command -v zsh >/dev/null 2>&1; then
  bst_skip shunit2/zsh-present "zsh not installed on this image"
elif [ "$_S2_SPLICE_OK" -eq 0 ]; then
  # not ok, NOT skip. An attributed red is left failing on purpose: it flips
  # green on its own the day $S2_ISSUE closes, and that is the regression
  # signal the suite is bought for. A skip here would read as coverage we do
  # not have (docs/conventions/ticket-scoping-and-gates.md, the partially-red
  # self-test rule).
  bst_notok shunit2/zsh-blocked \
    "$S2_ISSUE: shUnit2's own zsh check is 'setopt |grep ^shwordsplit\$ >/dev/null', the same broken idiom, so it refuses to start under zsh however it is invoked"
else
  check_out shunit2/zsh-requires-parent 'SHUNIT_PARENT' \
    sh -c 'zsh -o shwordsplit "$1" 2>&1; exit 0' _ "$crit"
  SHUNIT_PARENT=$crit; export SHUNIT_PARENT
  s2_criterion zsh zsh -o shwordsplit "$crit"
  unset SHUNIT_PARENT
fi

# --- the API a test author writes against, under the ticket's two shells ------

for _s2_sh in bash dash; do
  if command -v "$_s2_sh" >/dev/null 2>&1; then
    s2_features "feat-$_s2_sh" "$_s2_sh" "$feat"
  else
    bst_skip "shunit2/feat-$_s2_sh-present" "$_s2_sh not installed on this image"
  fi
done

# The version comes from the running framework (SHUNIT_VERSION, echoed by the
# features payload's oneTimeSetUp), never from the recipe filename or the image
# manifest -- the tool's own answer is the one that describes what runs.
check_eq shunit2/version 2.1.8 \
  "$(printf '%s\n' "$_S2_OUT" | awk '/^R-version /{print $2; exit}')"

# setUp runs once per test. The tally is only final in oneTimeTearDown, so that
# is where the payload reports it -- an in-test assertion could only compare
# against its own ordinal, which silently becomes a tautology the day a test is
# added or removed.
check_eq shunit2/setup-per-test 7 \
  "$(printf '%s\n' "$_S2_OUT" | awk '/^R-setupcount /{print $2; exit}')"

# oneTimeTearDown is invoked TWICE per run -- once by _shunit_execSuite after
# the tests and again from shUnit2's main body after the report is printed.
# It is upstream behaviour, reproduces identically on x86-64 under bash and
# dash, and is nothing to do with this arm; it is pinned because a test author
# who releases a resource there has it released twice, and because a release
# that fixes it should redden one named case rather than pass unnoticed.
check_eq shunit2/onetimeteardown-runs-twice 2 \
  "$(printf '%s\n' "$_S2_OUT" | grep -cF 'R-onetimeteardown ok')"

# --- the contains family, which this platform breaks --------------------------
# Four behaviours whose correct verdicts are known. A working platform and this
# one produce the SAME failure count and different failing tags, so the tags are
# what is read. The two that $S2_ISSUE breaks carry it in their detail: they are
# genuine reds -- a caller really does get the wrong answer here -- but they are
# the kernel's, not shUnit2's, and not the recipe's.

_S2_OUT=$(bash "$cont" 2>&1); _S2_RC=$?
check_eq shunit2/contains-ran "Ran 4 tests." "$(_s2_line '^Ran ')"

# _s2_contains <id> <tag> <want-fail> : <want-fail>=1 when a CORRECT shUnit2
# should have failed that assertion.
_s2_contains() {
  if printf '%s\n' "$_S2_OUT" | grep -qF "ASSERT:[$2]"; then _s2_seen=1; else _s2_seen=0; fi
  if [ "$_s2_seen" -eq "$3" ]; then
    bst_ok "shunit2/$1"
  elif [ "$_S2_SPLICE_OK" -eq 0 ]; then
    bst_notok "shunit2/$1" \
      "$S2_ISSUE (splice(2) unwired; 'echo \$c | grep -F -- \$n >/dev/null' cannot match): wanted assertion-failed=$3 got=$_s2_seen"
  else
    bst_notok "shunit2/$1" "wanted assertion-failed=$3 got=$_s2_seen"
  fi
}

_s2_contains contains-present     contains-present     0
_s2_contains contains-absent      contains-absent      1
_s2_contains notcontains-absent   notcontains-absent   0
_s2_contains notcontains-present  notcontains-present  1

# --- the control: every assertion form can actually detect a wrong answer -----

if command -v bash >/dev/null 2>&1; then
  _S2_OUT=$(bash "$neg" 2>&1); _S2_RC=$?
  _s2_summary shunit2/neg 1 "Ran 14 tests." "FAILED (failures=14)"
  for _s2_form in assertEquals assertNotEquals assertSame assertNotSame \
                  assertNull assertNotNull assertTrue assertFalse \
                  fail failNotEquals failFound failNotFound failSame failNotSame; do
    if printf '%s\n' "$_S2_OUT" | grep -qF "ASSERT:[$_s2_form]"; then
      bst_ok "shunit2/neg-$_s2_form"
    else
      bst_notok "shunit2/neg-$_s2_form" \
        "no tagged ASSERT line -- the form did not report the wrong answer"
    fi
  done
else
  bst_skip shunit2/neg-present "bash not installed on this image"
fi

# --- the colour machinery, both directions ------------------------------------
# `none` must strip the escapes and `always` must emit them. The default `auto`
# is deliberately not asserted: it resolves through `tput colors` and falls back
# to 16 when tput fails, so its answer is a property of the guest's TERM rather
# than of shunit2.

_s2_esc=$(printf '\033')

_S2_OUT=$(SHUNIT_COLOR=always bash "$crit" 2>&1)
case "$_S2_OUT" in
  *"$_s2_esc"*) bst_ok shunit2/color-always ;;
  *) bst_notok shunit2/color-always "no ANSI escape in SHUNIT_COLOR=always output" ;;
esac

_S2_OUT=$(SHUNIT_COLOR=none bash "$crit" 2>&1)
case "$_S2_OUT" in
  *"$_s2_esc"*) bst_notok shunit2/color-none "ANSI escape present under SHUNIT_COLOR=none" ;;
  *) bst_ok shunit2/color-none ;;
esac