# BST-TIMEOUT: 600   # three instantiations of an 8.4 MB probe + one pass over a 1.3 MB archive
. "$BST_LIB"

# glog (meta-oe recipes-support/glog, 0.6.0 at SRCREV b33e3bad) -- Google's
# application-level logging library. Severity-levelled LOG() streams, CHECK()
# assertions, and one file per severity carrying a fixed four-line header. The
# fourth port of the C++ round (BRINTOS-1094), after abseil-cpp, re2 and gflags.
#
# ---------------------------------------------------------------------------
# TWO CONSUMERS, BECAUSE THEY PROVE DIFFERENT THINGS
#
#   The PAYLOAD blocks assert what a downstream recipe reaches -- the seven
#   headers, the archive and its seven translation units, the pkg-config file,
#   the CMake package -- plus, unlike gflags, a genuine _ZTV/_ZTI triple.
#   glog HAS polymorphic classes (LogSink, base::Logger, LogMessage::LogStream,
#   base_logging::LogStreamBuf), so this port can point at 107 vtable and
#   typeinfo records in the shipped archive: a record a C compile of the same
#   sources cannot emit, and therefore direct evidence that the C++ arm of the
#   toolchain worked.
#
#   data/glog-probe is a CONSUMER of that payload: a program compiled against
#   these headers and LINKED AGAINST THIS BUILD'S libglog.a, built by the
#   recipe so it cannot drift from what shipped.
#
#   THE PROBE IS NOT DECORATION HERE -- IT IS THE ONLY THING THAT COULD HAVE
#   CAUGHT THIS PORT'S REAL DEFECT. As first built, libglog.a carried
#   `U backtrace`: glog saw execinfo.h in the sysroot, selected
#   stacktrace_generic-inl.h, and called glibc's backtrace(), which needs
#   _Unwind_Backtrace and _Unwind_GetIP -- neither of which exists on this arm.
#   An undefined symbol in a static archive is not an error until something
#   links it, and a static-only port ships no program, so the recipe went
#   green, the headers and the archive were all present, and a file-presence
#   suite would have reported a clean pass on a library NO CONSUMER ON THIS
#   IMAGE COULD EVER LINK. The bbappend pins HAVE_EXECINFO_H off; this suite
#   exists so that the day something unpins it, the failure is visible here.
#
# WHAT IS COMPARED BYTE-FOR-BYTE. The probe's scripted run is compared line for
# line against data/glog-native.txt -- the identical source built and run on
# x86-64 from the glog-native recipe -- with no tolerance band. Four fields in
# glog's output legitimately differ between any two runs on any two machines
# (the log file's creation date, the hostname, the process's running duration,
# and the thread id in each line prefix); the PROBE replaces each with a fixed
# token before printing, so the comparison still asserts the field was present
# and well-formed. Nothing else is normalised, and one differing line is a
# defect.
#
# The log FILENAMES are made deterministic rather than normalised, which is the
# stronger position and is available here: SetLogDestination() replaces glog's
# <prog>.<host>.<user>.log.<SEV>.<date>-<time>.<pid> base name outright and
# FLAGS_timestamp_in_logfile_name=false drops the suffix, so both arms write
# exactly <dir>/probe.<SEV>.
#
# BOTH ARMS ARE CONFIGURED IDENTICALLY, which is what makes the control an
# oracle rather than a second opinion. The bbappend pins HAVE__UNWIND_BACKTRACE
# off as well as HAVE_EXECINFO_H -- on the target glog's own configure test
# already answers no, but natively libgcc provides the symbol and glog would
# otherwise compile a real stack-trace dumper the target cannot have. Pinned,
# both arms take the same no-op arm, so a difference in the compared stream
# means the port rather than a feature one side compiled and the other did not.
#
# THE ANCHORED CASES EXIST BECAUSE AN ORACLE CAN BE WRONG. A control captured
# from an already-broken build would make every compared line agree with it. So
# the things glog's own documentation and this probe's source fix -- the four
# header lines, the severity nesting, the suppressed LOG_IF, the minloglevel
# floor, the CHECK contract -- are ALSO asserted against literals here. Those
# hold whatever the control says.
# ---------------------------------------------------------------------------

# A root prefix, empty on the target and set only when this suite is validated
# natively before it ships. The runner never sets it.
R="${BST_GLOG_ROOT:-}"

ARCHIVE=$R/usr/lib/libglog.a
INCDIR=$R/usr/include/glog
PC=$R/usr/lib/pkgconfig/libglog.pc
CMDIR=$R/usr/lib/cmake/glog
PROBE=$BST_DATA/glog-probe
NATIVE=$BST_DATA/glog-native.txt

if [ ! -f "$ARCHIVE" ]; then
  bst_skip glog/present "glog not installed on this image"
  exit 0
fi
bst_ok glog/present

nl='
'
tmp=${TMPDIR:-/tmp}

# has <case-id> <haystack-with-leading-and-trailing-newline> <exact line>
# A shell `case` rather than a grep: this suite has ~100 content assertions and
# an exec apiece is what killed the first draft of the abseil suite on target,
# where every process is a fresh instantiation of a multi-megabyte module.
has() {
  case "$2" in
    *"$nl$3$nl"*) bst_ok "$1" ;;
    *) bst_notok "$1" "missing: $3" ;;
  esac
}
# sub <case-id> <haystack> <substring>
sub() {
  case "$2" in
    *"$3"*) bst_ok "$1" ;;
    *) bst_notok "$1" "missing: $3" ;;
  esac
}
# hasnt <case-id> <haystack> <needle>  -- substring, for "must NOT be there"
hasnt() {
  case "$2" in
    *"$3"*) bst_notok "$1" "present but must not be: $3" ;;
    *) bst_ok "$1" ;;
  esac
}

# --- the package is whole ----------------------------------------------------

check glog/hdr-logging     test -f "$INCDIR/logging.h"
check glog/hdr-raw-logging test -f "$INCDIR/raw_logging.h"
check glog/hdr-severity    test -f "$INCDIR/log_severity.h"
check glog/hdr-stl-logging test -f "$INCDIR/stl_logging.h"
check glog/hdr-vlog-is-on  test -f "$INCDIR/vlog_is_on.h"
check glog/hdr-export      test -f "$INCDIR/export.h"
check glog/hdr-platform    test -f "$INCDIR/platform.h"
check glog/staticlib       test -f "$ARCHIVE"

# Shape, not absence: this arm converts to shared libraries per recipe
# (BRINTOS-1740), so a .so here is a conversion, not a policy breach.
bst_lib_shape glog/no-shared "$R/usr/lib/libglog*.so*"
if [ -n "$(find "$R/usr/lib" -maxdepth 1 -name 'libglog*.la' 2>/dev/null)" ]; then
  bst_notok glog/no-la "a libtool .la is installed"
else
  bst_ok glog/no-la
fi

# --- the declared surface, read out of the shipped headers -------------------
#
# One `cat` per header and `case` matching over the result: the point is that
# the header a downstream recipe would include really declares what it is
# supposed to, not merely that a file of that name exists.

H=$nl$(cat "$INCDIR/logging.h" 2>/dev/null)$nl
sub glog/decl-init        "$H" "InitGoogleLogging(const char* argv0)"
sub glog/decl-shutdown    "$H" "ShutdownGoogleLogging()"
sub glog/decl-setdest     "$H" "SetLogDestination(LogSeverity severity,"
sub glog/decl-setsymlink  "$H" "SetLogSymlink(LogSeverity severity,"
sub glog/decl-flush       "$H" "FlushLogFiles(LogSeverity min_severity)"
sub glog/decl-addsink     "$H" "AddLogSink(LogSink *destination)"
sub glog/decl-removesink  "$H" "RemoveLogSink(LogSink *destination)"
sub glog/decl-truncate    "$H" "TruncateLogFile(const char* path, uint64 limit, uint64 keep);"
sub glog/decl-setextension "$H" "SetLogFilenameExtension("
sub glog/decl-logtostderr "$H" "LogToStderr()"
# LogSink is the polymorphic class the vtable assertions below point at, and
# the extension point an application uses to capture log output.
sub glog/decl-class-logsink "$H" "class GLOG_EXPORT LogSink"
sub glog/decl-sink-send     "$H" "virtual void send("
sub glog/decl-class-logmessage "$H" "class GLOG_EXPORT LogMessage"
sub glog/decl-class-logmessagefatal "$H" "class GLOG_EXPORT LogMessageFatal"
# The macros are the library's whole user-facing idiom.
sub glog/macro-log        "$H" "#define LOG(severity)"
sub glog/macro-log-if     "$H" "#define LOG_IF(severity, condition)"
sub glog/macro-log-every  "$H" "#define LOG_EVERY_N(severity, n)"
sub glog/macro-vlog       "$H" "#define VLOG(verboselevel)"
sub glog/macro-check      "$H" "#define CHECK(condition)"
sub glog/macro-check-eq   "$H" "#define CHECK_EQ(val1, val2)"
sub glog/macro-check-ne   "$H" "#define CHECK_NE(val1, val2)"
sub glog/macro-check-notnull "$H" "#define CHECK_NOTNULL(val)"
sub glog/macro-check-streq "$H" "#define CHECK_STREQ(s1, s2)"
sub glog/macro-dlog       "$H" "#define DLOG(severity)"
# The flags the probe sets. Declared here rather than in gflags because
# WITH_GFLAGS=OFF: glog defines its own storage, asserted in the archive below.
sub glog/flag-logtostderr  "$H" "DECLARE_bool(logtostderr)"
sub glog/flag-alsologtostderr "$H" "DECLARE_bool(alsologtostderr)"
sub glog/flag-timestamp-name "$H" "DECLARE_bool(timestamp_in_logfile_name)"
sub glog/flag-minloglevel  "$H" "DECLARE_int32(minloglevel)"
sub glog/flag-stderrthreshold "$H" "DECLARE_int32(stderrthreshold)"
sub glog/flag-log-dir      "$H" "DECLARE_string(log_dir)"
sub glog/flag-log-prefix   "$H" "DECLARE_bool(log_prefix)"

S=$nl$(cat "$INCDIR/log_severity.h" 2>/dev/null)$nl
# The four severities, and NUM_SEVERITIES. glog's severity model -- a message
# goes to the file of its own level and to every level below it -- is what the
# three nested dumps assert, and it starts here.
sub glog/sev-info    "$S" "GLOG_INFO = 0"
sub glog/sev-warning "$S" "GLOG_WARNING = 1"
sub glog/sev-error   "$S" "GLOG_ERROR = 2"
sub glog/sev-fatal   "$S" "GLOG_FATAL = 3"
sub glog/sev-num     "$S" "NUM_SEVERITIES = 4"

RL=$nl$(cat "$INCDIR/raw_logging.h" 2>/dev/null)$nl
# RAW_LOG is glog's async-signal-safe path -- no allocation, no locks. It is
# what a signal handler or an OOM path uses, so its absence would narrow the
# port in a way nothing else here would notice.
sub glog/decl-raw-log   "$RL" "#define RAW_LOG(severity"
sub glog/decl-raw-check "$RL" "#define RAW_CHECK(condition, message)"

VL=$nl$(cat "$INCDIR/vlog_is_on.h" 2>/dev/null)$nl
sub glog/decl-vlog-is-on "$VL" "#define VLOG_IS_ON(verboselevel)"

# --- pkg-config: how a downstream recipe finds this package at all -----------

check glog/pkgconfig test -f "$PC"
if [ -f "$PC" ]; then
  PCC=$nl$(cat "$PC")$nl
  has glog/pc-name    "$PCC" "Name: libglog"
  has glog/pc-version "$PCC" "Version: 0.6.0"
  has glog/pc-libs    "$PCC" "Libs: -L\${libdir} -lglog"
  has glog/pc-cflags  "$PCC" "Cflags: -I\${includedir}"
  has glog/pc-libdir  "$PCC" "libdir=/usr/lib"
  # Libs.private is EMPTY on this arm and that is correct rather than a
  # truncation: WITH_GFLAGS=OFF removes the -lgflags glog would otherwise
  # carry, WITH_UNWIND=OFF removes -lunwind, and this glibc merged libpthread
  # into libc, so a static consumer needs nothing beyond -lglog. Asserted
  # because a value appearing here later would mean the port had acquired a
  # dependency this image cannot satisfy.
  hasnt glog/pc-no-gflags  "$PCC" "-lgflags"
  hasnt glog/pc-no-unwind  "$PCC" "-lunwind"
fi

# --- the CMake package, which is what glog's consumers actually use ---------

check glog/cm-config   test -f "$CMDIR/glog-config.cmake"
check glog/cm-version  test -f "$CMDIR/glog-config-version.cmake"
check glog/cm-targets  test -f "$CMDIR/glog-targets.cmake"
check glog/cm-noconfig test -f "$CMDIR/glog-targets-noconfig.cmake"
check glog/cm-modules  test -f "$CMDIR/glog-modules.cmake"
if [ -f "$CMDIR/glog-targets-noconfig.cmake" ]; then
  CMN=$nl$(cat "$CMDIR/glog-targets-noconfig.cmake")$nl
  # The import record must name the ARCHIVE. A .so here would mean the CMake
  # package describes an artifact this image does not carry -- which is the
  # failure a consumer meets at find_package() time, long after the port
  # looked green.
  sub   glog/cm-target   "$CMN" "glog::glog"
  sub   glog/cm-imports-a "$CMN" "libglog.a"
  hasnt glog/cm-no-so    "$CMN" "libglog.so"
fi

# --- the archive itself ------------------------------------------------------

case "$(head -c 8 "$ARCHIVE" 2>/dev/null)" in
  '!<arch>'*) bst_ok glog/ar-magic ;;
  *) bst_notok glog/ar-magic "libglog.a does not start with the ar magic" ;;
esac

# One pass over the whole archive, mapping every byte that cannot occur inside
# a member name or an Itanium-mangled symbol to a newline, and pulling out only
# the lines that carry a needle. That is 3 execs for the ~30 assertions below.
nf=$tmp/bst-glog-needles.$$
hf=$tmp/bst-glog-hits.$$
cat > "$nf" <<'NEEDLES'
logging.cc.o
raw_logging.cc.o
utilities.cc.o
vlog_is_on.cc.o
demangle.cc.o
symbolize.cc.o
signalhandler.cc.o
_ZN6google17InitGoogleLoggingEPKc
_ZN6google21ShutdownGoogleLoggingEv
_ZN6google17SetLogDestinationEiPKc
_ZN6google13SetLogSymlinkEiPKc
_ZN6google13FlushLogFilesEi
_ZN6google10AddLogSinkEPNS_7LogSinkE
_ZN6google13RemoveLogSinkEPNS_7LogSinkE
_ZN6google15TruncateLogFileEPKc
_ZN6google16SetStderrLoggingEi
_ZN6google11LogToStderrEv
_ZN6google16EnableLogCleanerEj
_ZN6google15LogMessageFatalC1EPKci
_ZN6google4base21CheckOpMessageBuilderC1EPKc
_ZN6google19CheckstrcmptrueImplEPKcS1_S1_
_ZTVN6google7LogSinkE
_ZTVN6google4base6LoggerE
_ZTVN6google10LogMessage9LogStreamE
_ZTVN6google12base_logging12LogStreamBufE
_ZN6google10LogMessageC1EPKciiPNSt3__112basic_string
_ZN3fLB17FLAGS_logtostderrE
_ZN3fLB21FLAGS_alsologtostderrE
_ZN3fLB16FLAGS_log_prefixE
GetStackTrace
NEEDLES
cat "$ARCHIVE" 2>/dev/null | tr -c 'A-Za-z0-9_.' '\n' | grep -F -f "$nf" > "$hf" 2>/dev/null
HITS=$nl$(cat "$hf" 2>/dev/null)$nl
rm -f "$nf" "$hf"

# The seven translation units this port compiled. Named one by one rather than
# counted, so a member silently dropped by a future recipe change points at
# itself instead of at a number. symbolize.cc.o and signalhandler.cc.o are in
# the list even though WITH_SYMBOLIZE=OFF: the files compile to their no-op
# arms rather than being excluded, and their absence would mean something
# larger had changed.
sub glog/member-logging     "$HITS" "logging.cc.o"
sub glog/member-raw-logging "$HITS" "raw_logging.cc.o"
sub glog/member-utilities   "$HITS" "utilities.cc.o"
sub glog/member-vlog-is-on  "$HITS" "vlog_is_on.cc.o"
sub glog/member-demangle    "$HITS" "demangle.cc.o"
sub glog/member-symbolize   "$HITS" "symbolize.cc.o"
sub glog/member-signalhandler "$HITS" "signalhandler.cc.o"

# Itanium-mangled entry points, in the `google` namespace.
sub glog/sym-init       "$HITS" "_ZN6google17InitGoogleLoggingEPKc"
sub glog/sym-shutdown   "$HITS" "_ZN6google21ShutdownGoogleLoggingEv"
sub glog/sym-setdest    "$HITS" "_ZN6google17SetLogDestinationEiPKc"
sub glog/sym-setsymlink "$HITS" "_ZN6google13SetLogSymlinkEiPKc"
sub glog/sym-flush      "$HITS" "_ZN6google13FlushLogFilesEi"
sub glog/sym-addsink    "$HITS" "_ZN6google10AddLogSinkEPNS_7LogSinkE"
sub glog/sym-removesink "$HITS" "_ZN6google13RemoveLogSinkEPNS_7LogSinkE"
sub glog/sym-truncate   "$HITS" "_ZN6google15TruncateLogFileEPKc"
sub glog/sym-stderrlog  "$HITS" "_ZN6google16SetStderrLoggingEi"
sub glog/sym-logtostderr "$HITS" "_ZN6google11LogToStderrEv"
sub glog/sym-logcleaner "$HITS" "_ZN6google16EnableLogCleanerEj"

# The CHECK machinery, which is the half of glog that is not logging: the FATAL
# message object, the operand-rendering builder every CHECK_EQ goes through,
# and one of the four string comparators.
sub glog/sym-fatal      "$HITS" "_ZN6google15LogMessageFatalC1EPKci"
sub glog/sym-checkop    "$HITS" "_ZN6google4base21CheckOpMessageBuilderC1EPKc"
sub glog/sym-checkstreq "$HITS" "_ZN6google19CheckstrcmptrueImplEPKcS1_S1_"

# THE VTABLES. Unlike gflags (BRINTOS-1100), which has no polymorphic class at
# all, glog defines four -- and a _ZTV record is something a C compile of the
# same sources cannot emit under any flags. This is the port's strongest single
# piece of C++ evidence, and LogSink's is the one that matters to a consumer:
# it is the documented extension point for capturing log output.
sub glog/vtable-logsink      "$HITS" "_ZTVN6google7LogSinkE"
sub glog/vtable-logger       "$HITS" "_ZTVN6google4base6LoggerE"
sub glog/vtable-logstream    "$HITS" "_ZTVN6google10LogMessage9LogStreamE"
sub glog/vtable-logstreambuf "$HITS" "_ZTVN6google12base_logging12LogStreamBufE"

# `NSt3__1` inside glog's OWN symbols is libc++'s inline namespace: a symbol
# mangled against THIS arm's standard library, which a C compile could not
# produce and a libstdc++ compile would spell differently.
sub glog/sym-libcxx-logmessage "$HITS" "_ZN6google10LogMessageC1EPKciiPNSt3__112basic_string"

# glog's own flag storage. WITH_GFLAGS=OFF, so these are glog's internal
# definitions rather than gflags registrations -- their presence is the
# link-level evidence that the flags the probe sets are compiled in.
sub glog/flagvar-logtostderr     "$HITS" "_ZN3fLB17FLAGS_logtostderrE"
sub glog/flagvar-alsologtostderr "$HITS" "_ZN3fLB21FLAGS_alsologtostderrE"
sub glog/flagvar-log-prefix      "$HITS" "_ZN3fLB16FLAGS_log_prefixE"

# THE REGRESSION GUARD FOR THIS PORT'S ACTUAL DEFECT, stated as a fact about
# the archive's SHAPE rather than as the absence of a string. No stacktrace
# implementation is compiled into this port at all: utilities.h picks one by
# #including a stacktrace_*-inl.h into utilities.cc, and every one of them
# defines GetStackTrace(), so that symbol is present if and only if some
# implementation was selected. Measured on the shipped archive: zero
# occurrences.
#
# That is what keeps the port linkable. With HAVE_EXECINFO_H defined --
# execinfo.h IS in this sysroot, so the check answers yes on its own --
# utilities.h:103 selects stacktrace_generic-inl.h, whose GetStackTrace calls
# glibc's backtrace(), which needs _Unwind_Backtrace and _Unwind_GetIP; this
# arm provides neither, and brintos-libcxx's libunwind.a defines eight other
# _Unwind_* entry points but not those two. As first built, libglog.a carried
# `U backtrace` and NO PROGRAM COULD LINK IT -- silently, because an undefined
# symbol in a static archive is not an error until something links it.
#
# GetStackTrace rather than `backtrace` as the needle, and that is not
# cosmetic: glog has a FLAG called log_backtrace_at, so its own symbol table
# carries FLAGS_log_backtrace_at and a bare `backtrace` needle matches the
# healthy archive. It did, on the first dry run of this suite.
hasnt glog/no-stacktrace-impl "$HITS" "GetStackTrace"

# --- the probe: does the shipped archive LOG, and log correctly? ------------

if [ ! -f "$PROBE" ]; then
  bst_notok glog/probe-present "$PROBE missing -- the library cannot be proven to run"
elif [ ! -f "$NATIVE" ]; then
  bst_notok glog/native-present "$NATIVE missing -- no x86-64 control for the probe run"
else
  bst_ok glog/probe-present
  bst_ok glog/native-present

  # do_install stages data/* at 0644 and the deployed rootfs is read-only at
  # browser runtime, so the payload cannot be executed where it lies. Stage an
  # executable copy under TMPDIR, as every probe-driven suite here does.
  pd=$tmp/bst-glog.$$
  p=$pd/glog-probe
  logs=$pd/logs
  mkdir -p "$logs" 2>/dev/null
  if cp "$PROBE" "$p" 2>/dev/null && chmod 0755 "$p" 2>/dev/null && [ -x "$p" ]; then
    bst_ok glog/probe-exec

    # === 1. the scripted run =================================================
    out=$("$p" run "$logs" 2>"$pd/run.err"); rc=$?
    errout=$(cat "$pd/run.err" 2>/dev/null)

    if [ "$rc" -eq 0 ]; then bst_ok glog/probe-rc
    else bst_notok glog/probe-rc "probe exited $rc"; fi

    # stderrthreshold is FATAL and nothing fatal happens in this mode, so glog
    # must have written NOTHING to the console. A port that duplicated every
    # WARNING to stderr would still pass every file assertion below.
    if [ -z "$errout" ]; then bst_ok glog/probe-silent-stderr
    else bst_notok glog/probe-silent-stderr "$(_bst_1line "$errout")"; fi

    O=$nl$out$nl

    # The whole-stream gate. Kept separate from the anchored cases below,
    # because a probe that died before printing anything would leave those with
    # nothing to disagree with and could look like a shorter clean run.
    case "$O" in
      *"${nl}GLOG-PROBE-OK${nl}") bst_ok glog/probe-complete ;;
      *) bst_notok glog/probe-complete "probe did not reach its final line" ;;
    esac

    if [ "$out" = "$(cat "$NATIVE" 2>/dev/null)" ]; then
      bst_ok glog/probe-matches-x86-64
    else
      first=$(printf '%s\n' "$out" | diff - "$NATIVE" 2>/dev/null | head -4)
      bst_notok glog/probe-matches-x86-64 "$(_bst_1line "${first:-output differs from the control}")"
    fi

    # --- anchored cases: literals glog's contract fixes ----------------------

    # The files SetLogDestination named were created, and the one for a
    # severity nothing was logged at was not. glog creates a severity's file
    # lazily, on its first message, so probe.FATAL's absence is a real
    # statement about laziness rather than about the path being wrong.
    has glog/file-info    "$O" "GL-file-INFO 1"
    has glog/file-warning "$O" "GL-file-WARNING 1"
    has glog/file-error   "$O" "GL-file-ERROR 1"
    has glog/file-fatal-absent "$O" "GL-file-FATAL-absent 1"

    # THE FIXED FOUR-LINE HEADER, which is the part of glog's file format the
    # ticket names. Line 4 is asserted verbatim because it is a constant in
    # glog's source, not a rendering of anything: it documents the prefix
    # format and changes only if the library does.
    has glog/header-created  "$O" "Log file created at: <DATE> <TIME>"
    has glog/header-machine  "$O" "Running on machine: <HOST>"
    has glog/header-duration "$O" "Running duration (h:mm:ss): <DURATION>"
    has glog/header-format   "$O" "Log line format: [IWEF]yyyymmdd hh:mm:ss.uuuuuu threadid file:line] msg"

    # THE SEVERITY NESTING. A message goes to its own severity's file and to
    # every file below it, so INFO carries all three lines, WARNING two and
    # ERROR one. Asserted as three whole framed blocks rather than as
    # individual lines: the point is not that the error line reached the ERROR
    # file, it is that the warning line did NOT.
    case "$O" in
      *"== ERROR ==${nl}Log file created at: <DATE> <TIME>${nl}Running on machine: <HOST>${nl}Running duration (h:mm:ss): <DURATION>${nl}Log line format: [IWEF]yyyymmdd hh:mm:ss.uuuuuu threadid file:line] msg${nl}E<STAMP> <TID> glog-probe.cc:"*)
        bst_ok glog/nesting-error-file-header ;;
      *) bst_notok glog/nesting-error-file-header "the ERROR file does not open with the four-line header followed by an E line" ;;
    esac
    # The ERROR block is the last thing before the final line, so this pattern
    # pins its ENTIRE contents: header, one error line, and nothing else.
    case "$O" in
      *"] error-line${nl}GLOG-PROBE-OK${nl}") bst_ok glog/nesting-error-file-only-error ;;
      *) bst_notok glog/nesting-error-file-only-error "the ERROR file carries something after its single error line" ;;
    esac

    # One line per severity, each recording the SOURCE LINE it was logged from
    # -- glog takes __FILE__/__LINE__ at the macro and basenames the path
    # (logging.cc:1659), which is why the file is `glog-probe.cc` on both arms
    # regardless of how the recipe compiled it. That basenaming is why this
    # port needs none of the bare-relative-name care gflags did.
    sub glog/line-info    "$O" "I<STAMP> <TID> glog-probe.cc:152] info-line"
    sub glog/line-warning "$O" "W<STAMP> <TID> glog-probe.cc:153] warning-line"
    sub glog/line-error   "$O" "E<STAMP> <TID> glog-probe.cc:154] error-line"

    # C++-STYLE STREAMS, which are the reason glog exists rather than printf
    # logging. Both doubles are exactly representable, so the rendering is
    # fixed; `b=1` is operator<<(bool) without boolalpha, which is the default.
    sub glog/stream-inserters "$O" "] stream n=42 d=2.5 s=str c=x b=1"

    # LOG_IF's two arms. The suppressed one is the case that matters: a LOG_IF
    # that logged regardless would be invisible to any assertion that only
    # looked at what IS in the file.
    sub   glog/logif-true       "$O" "] conditional-line"
    hasnt glog/logif-suppressed "$O" "suppressed-line"

    # The CHECK macros on their PASSING side, so the failing case below is a
    # refusal rather than a macro that always aborts.
    sub glog/checks-passed "$O" "] checks-passed"

    # FLAGS_minloglevel is glog's runtime severity floor. Raised to ERROR, the
    # INFO and WARNING calls under it produced nothing at all; lowered again,
    # logging resumed. Both halves are asserted, because a floor that silenced
    # the library permanently would pass the first half alone.
    hasnt glog/floor-suppressed-info    "$O" "below-floor-info"
    hasnt glog/floor-suppressed-warning "$O" "below-floor-warning"
    sub   glog/floor-restored           "$O" "] floor-restored"

    # === 2. the CHECK failure contract ======================================
    #
    # The half of glog a user meets when something is wrong: a failed CHECK
    # writes its message to stderr and ABORTS. It does this without throwing,
    # which is why this arm's -fno-exceptions costs glog nothing.
    cfout=$("$p" checkfail "$logs" 2>&1); cfrc=$?
    if [ "$cfrc" -ne 0 ]; then bst_ok glog/checkfail-aborts
    else bst_notok glog/checkfail-aborts "a failed CHECK_EQ exited 0"; fi
    CF=$nl$cfout$nl
    # The rendered operands are the part a bare "check failed" cannot give you,
    # and the part that needs the C++ stream machinery to work.
    sub glog/checkfail-message  "$CF" "Check failed: have == want (1 vs. 2) probe-check-msg"
    sub glog/checkfail-severity "$CF" "F"
    # It died at the CHECK, so nothing after it ran.
    hasnt glog/checkfail-nooutput "$CF" "GL-checkfail-survived"

    # NO STACK TRACE BODY, AND THAT IS THE PORT'S DELIBERATE, PERMANENT SHAPE
    # rather than a defect or a workaround awaiting a platform fix. glog wants
    # an unwinder for the failure-signal handler and this arm has none:
    # WITH_UNWIND=OFF because there is no libunwind in the target sysroot
    # outside brintos-libcxx's private copy, WITH_SYMBOLIZE=OFF because wasm32
    # has no ELF images to read symbols out of, and HAVE_EXECINFO_H pinned off
    # because glibc's backtrace() is unlinkable here. glog still prints its
    # trace HEADER, so the assertion is that the header is there and the body
    # -- the `    @ 0x...` frame lines -- is not.
    sub   glog/checkfail-trace-header "$CF" "*** Check failure stack trace: ***"
    hasnt glog/checkfail-no-frames    "$CF" "    @ "

    # LOG(FATAL) is the same path reached without a comparison, so both spellings
    # of "abort now" are covered.
    fout=$("$p" fatal "$logs" 2>&1); frc=$?
    if [ "$frc" -ne 0 ]; then bst_ok glog/fatal-aborts
    else bst_notok glog/fatal-aborts "LOG(FATAL) exited 0"; fi
    FO=$nl$fout$nl
    sub   glog/fatal-message  "$FO" "] probe-fatal-msg"
    hasnt glog/fatal-nooutput "$FO" "GL-fatal-survived"

    rm -rf "$pd"
  else
    rm -rf "$pd"
    bst_notok glog/probe-exec "cannot stage an executable copy of $PROBE"
  fi
fi