. "$BST_LIB"

# BST-TIMEOUT: 300   # one probe run plus ~230 shell extractions; the 60s default
                     # is for suites that fork far less than this one does.

# libXrandr 1.5.4 -- the client half of the RandR extension (poky
# recipes-graphics/xorg-lib). See libxrandr_%.bbappend for what the port adds
# and why.
#
# ---------------------------------------------------------------------------
# THIS IMAGE HAS NO X SERVER, AND THE HALF OF RANDR THAT MATTERS STILL RUNS
#
# Most of libXrandr's seventy entry points reach XRRFindDisplay, and nothing
# here can open a display -- section DPY is the honest answer to "did you
# configure a screen": no. What is left is not a residue. RandR's client side is
# allocation and arithmetic, and all of it runs to completion with no server:
#
#   XRRAllocGamma       ONE allocation carved into three contiguous channels
#   XRRAllocModeInfo    ONE allocation with the mode name appended to it
#   XRRAllocateMonitor  the same shape again, for the output array
#   XRRConfig*          the screen-config accessors, including a walk over a
#                       RUN-LENGTH ENCODED rate list -- a wire contract that
#                       nothing checks at compile time
#   the mode line       dotClock / (hTotal * vTotal), doublescan and interlace
#
# Every one of those is real code out of libXrandr.a, and every one is exactly
# the kind of thing that can be complete, installed and WRONG on a new
# architecture: a contiguity assumption a different alignment breaks, a struct
# the compiler padded differently, a dotClock that lost its top bits. Not one of
# them would go red if this suite only asserted that a .a and a header arrived.
#
# WHY THE EXPECTATIONS ARE WRITTEN OUT HERE RATHER THAN DIFFED AGAINST x86-64.
# Each has an absolute answer. The rotation and reflection masks are fixed by
# the RandR protocol; the rate-list layout is fixed by it too; every refresh
# fixture below was chosen so its quotient is EXACT in binary floating point, so
# these are equalities and not tolerances. A diff would also be wrong for the
# lines that are arch-dependent on purpose: `long' and a pointer are 4 bytes
# here and 8 on the build host, and section ABI exists precisely to pin the 4 --
# a blanket diff would make agreement the defect.
#
# ---------------------------------------------------------------------------
# READ A RED IN SECTION ORDER; THE FIRST SECTION TO GO RED LOCALISES THE DEFECT
#
#   1  the payload arrived            packaging only
#   2  the .pc resolves               consumers find the headers at all
#   3  the probe runs to its end      libXrandr.a executes on this arm
#   4  the ABI everything rests on    sizeof(long), and each struct's size
#   5  the gamma ramp allocator       the three-channel contiguity contract
#   6  the mode-info allocator        the appended name, and the zeroed rest
#   7  the refresh computation        dotClock / (hTotal * vTotal)
#   8  the screen-config accessors    the field loads and the rate-list walk
#   9  the monitor allocator          the appended output array
#  10  the protocol constants         the wire values, from the STAGED headers
#  11  the entry-point census         every module linked out of the archive
#  12  the display that is not there  why 5 to 9 are what this suite tests
#
# A build where 3 passes and 4 does not has a word-size fault in the toolchain
# rather than anything wrong with this recipe -- and 5, 6 and 9 will be red with
# it, because each asserts a header offset that IS a struct size. One where 11
# goes red has lost an entry point out of the archive, and the name in the red
# says which.
#
# NO CASE BELOW IS EXPECTED RED. RandR's client side needs no syscall this
# kernel lacks: it is arithmetic and a malloc. Section 12 is the platform's
# absence of a server, and it is asserted as a PASS -- the library declining to
# invent a display is the contract, not a gap.
# ---------------------------------------------------------------------------

# A root prefix, empty on the target and set only when this suite is validated
# NATIVELY under dash before it ships. The runner never sets it, so on the image
# every path below is exactly the absolute one.
R="${BST_LIBXRANDR_ROOT:-}"

INC=$R/usr/include/X11/extensions
LIB=$R/usr/lib
PCD=$R/usr/lib/pkgconfig
XT=$R/usr/libexec/libxrandr-tests

work=${TMPDIR:-/tmp}/bst-libxrandr.$$
rm -rf "$work"; mkdir -p "$work"

hasfile() {
  if [ -s "$2" ]; then bst_ok "$1"; else bst_notok "$1" "missing or empty: $2"; fi
}

# xr_line <id> <unique-prefix> <expected-remainder>
#
# The prefix is matched with grep -F rather than the whole line, so a red
# reports WHAT THE PROBE ACTUALLY SAID for that case instead of merely
# "absent". Every prefix is unique by construction: each is a section tag plus a
# case name, and the case name is followed by a space that ends it.
xr_line() {
  _l=$(grep -m 1 -F -- "$2" "$work/out" 2>/dev/null)
  check_eq "$1" "$2$3" "$_l"
}

# xr_field <id> <unique-prefix> <expected-value>
#
# The last whitespace-separated field of the matched line. Used where the line
# carries a measured number and the case is about that number alone.
xr_field() {
  _l=$(grep -m 1 -F -- "$2" "$work/out" 2>/dev/null)
  check_eq "$1" "$3" "${_l##* }"
}

# ---------------------------------------------------------------------------
# 0. THE CANARY, which is not an assertion about libXrandr at all.
#
# The guest console drops a suite's FIRST BST result line before the host parser
# sees it -- brintos/linux#96. The harness computes its pass count as
# total-minus-failures, so THE DROPPED LINE IS COUNTED AS A PASS, and a suite
# whose first case is a genuine `not ok' loses the one line that mattered. So
# the first line out of this file asserts something already true.
# Remove this case when #96 is fixed.
bst_ok libxrandr/suite-canary

# ---------------------------------------------------------------------------
# 1. THE PAYLOAD.
#
# libXrandr installs exactly one header. /usr/include/X11/extensions is shared
# with xorgproto and every other extension library, so it is asserted by NAME:
# a count taken here would start moving the day the next port lands.
hasfile libxrandr/header        "$INC/Xrandr.h"
hasfile libxrandr/archive       "$LIB/libXrandr.a"
hasfile libxrandr/pkgconfig     "$PCD/xrandr.pc"
hasfile libxrandr/probe-present "$XT/libxrandr-probe"

# No shared object means unconverted, and FILES:${PN} matching nothing is the
# port working rather than a gap. Once it converts, the red worth having is a
# libXrandr.so that is dangling or empty, which every consumer of this sysroot
# would inherit.
bst_lib_shape libxrandr/no-shared-object "$LIB/libXrandr.so" "$LIB/libXrandr.so.2"

# ---------------------------------------------------------------------------
# 2. THE .pc, which is what every consumer above this library actually reads.
#
# Requires: is the line that carries the rest of the stack. libxrandr's
# configure.ac declares x11, randrproto, xext, xextproto, xrender and
# renderproto, and a consumer that gets an incomplete list here fails to LINK
# rather than failing honestly -- the exact failure this stack exists to remove.
check_out libxrandr/pc-version  "1.5.4" grep -F "Version:" "$PCD/xrandr.pc"
check_out libxrandr/pc-libs     "-lXrandr" grep -F "Libs:" "$PCD/xrandr.pc"
check_out libxrandr/pc-req-x11  "x11" grep -E "^Requires" "$PCD/xrandr.pc"
check_out libxrandr/pc-req-xext "xext" grep -E "^Requires" "$PCD/xrandr.pc"
check_out libxrandr/pc-req-xrender "xrender" grep -E "^Requires" "$PCD/xrandr.pc"
check_out libxrandr/pc-req-randrproto "randrproto" grep -E "^Requires" "$PCD/xrandr.pc"

# ---------------------------------------------------------------------------
# 3. THE PROBE RUNS, and runs TO ITS END.
#
# Everything from here on reads $work/out, so a probe that died halfway would
# leave every later case matching nothing -- which is why its terminator is
# asserted here, before anything is extracted from the file. RANDR-TOTAL is the
# last line the probe prints and the count of measurements it emitted; the floor
# is a dated snapshot at 1.5.4 and is what turns "the run was short" from an
# invisible absence into one red with a number in it.
if [ -x "$XT/libxrandr-probe" ]; then
  "$XT/libxrandr-probe" > "$work/out" 2>"$work/err"
  _rc=$?
else
  _rc=127; : > "$work/out"; : > "$work/err"
fi
check_eq libxrandr/probe-rc "0" "$_rc"

xr_line libxrandr/probe-version "RANDR-VERSION " "1.5.4"

_total=$(grep -m 1 -F -- "RANDR-TOTAL " "$work/out" 2>/dev/null)
_total=${_total##* }
if [ -n "$_total" ] && [ "$_total" -ge 220 ] 2>/dev/null; then
  bst_ok libxrandr/probe-complete
else
  bst_notok libxrandr/probe-complete "RANDR-TOTAL absent or below the 220 floor: '$_total'"
fi

check_eq libxrandr/probe-quiet "" "$(cat "$work/err" 2>/dev/null)"

# ---------------------------------------------------------------------------
# 4. THE ABI EVERYTHING BELOW RESTS ON.
#
# wasm32-hwjs is ILP32: `long', a pointer and an int are all 4 bytes, and short
# is 2. The struct sizes are the consequence, and they are asserted outright
# because each is a HEADER OFFSET somewhere below -- XRRAllocGamma puts the
# first channel at sizeof(XRRCrtcGamma), XRRAllocModeInfo puts the name at
# sizeof(XRRModeInfo), XRRAllocateMonitor puts the output array at
# sizeof(XRRMonitorInfo). Pinning both ends is what makes a red in section 5, 6
# or 9 mean "the allocator changed" rather than "something moved, somewhere".
xr_line libxrandr/abi-long   "RANDR-ABI sizeof-long "  "4"
xr_line libxrandr/abi-ptr    "RANDR-ABI sizeof-ptr "   "4"
xr_line libxrandr/abi-int    "RANDR-ABI sizeof-int "   "4"
xr_line libxrandr/abi-short  "RANDR-ABI sizeof-short " "2"
xr_line libxrandr/abi-xid    "RANDR-ABI sizeof-XID "   "4"
xr_line libxrandr/abi-rrmode "RANDR-ABI sizeof-RRMode " "4"
xr_line libxrandr/abi-rroutput "RANDR-ABI sizeof-RROutput " "4"
xr_line libxrandr/abi-rrcrtc "RANDR-ABI sizeof-RRCrtc " "4"

# Rotation and SizeID are `unsigned short', NOT the int a reader expects. A
# rotation mask is built with RR_Reflect_Y = 32 at the top, so 16 bits is ample
# -- but a consumer that widened either of them would silently change the
# offsets of everything after it in the screen-config struct.
xr_line libxrandr/abi-rotation "RANDR-ABI sizeof-Rotation " "2"
xr_line libxrandr/abi-sizeid   "RANDR-ABI sizeof-SizeID "   "2"
xr_line libxrandr/abi-time     "RANDR-ABI sizeof-Time "     "4"
xr_line libxrandr/abi-modeflags "RANDR-ABI sizeof-XRRModeFlags " "4"

xr_line libxrandr/abi-screensize "RANDR-ABI sizeof-XRRScreenSize " "16"
xr_line libxrandr/abi-modeinfo   "RANDR-ABI sizeof-XRRModeInfo "   "56"
xr_line libxrandr/abi-crtcgamma  "RANDR-ABI sizeof-XRRCrtcGamma "  "16"
xr_line libxrandr/abi-monitorinfo "RANDR-ABI sizeof-XRRMonitorInfo " "44"
xr_line libxrandr/abi-screenconfig "RANDR-ABI sizeof-XRRScreenConfiguration " "44"
xr_line libxrandr/abi-gamma-elt  "RANDR-ABI gamma-channel-elt "    "2"

# ---------------------------------------------------------------------------
# 5. THE GAMMA RAMP ALLOCATOR -- the contiguity contract.
#
# XRRAllocGamma makes ONE allocation and points red, green and blue into it at
# `size' element intervals. That is not an implementation detail a caller may
# ignore: XRRSetCrtcGamma sends the whole ramp with a SINGLE
# Data16 (dpy, gamma->red, size * 2 * 3), one call spanning all three channels,
# and the library's own comment says so. If the channels were ever not
# contiguous, that call would send `size * 3' elements starting at red and put
# WHATEVER FOLLOWS the red channel on the wire as the user's green and blue --
# a wrong screen rather than an error.
#
# 0 and 1 are the boundaries: 0 is the degenerate allocation the reply path
# takes when the server reports no ramp at all, and 1 is the smallest size where
# the three channels are distinct. 256 is what real hardware reports.
for n in 0 1 2 3 17 256 1024; do
  xr_line libxrandr/gamma-size-$n   "RANDR-GAMMA size-$n "   "$n"
  xr_line libxrandr/gamma-header-$n "RANDR-GAMMA header-$n " "16"
  xr_line libxrandr/gamma-stride-$n "RANDR-GAMMA stride-$n " "green-red=$n blue-green=$n"
  xr_line libxrandr/gamma-roundtrip-$n "RANDR-GAMMA roundtrip-$n " "1"
  xr_line libxrandr/gamma-freed-$n  "RANDR-GAMMA freed-$n "  "1"
done

# ---------------------------------------------------------------------------
# 6. THE MODE-INFO ALLOCATOR -- the appended name, and the zeroed remainder.
#
# XRRAllocModeInfo appends the name to its own allocation and memsets everything
# else. Both halves are contracts. xrandr(1) builds a mode line field by field
# and never clears the rest, so a remainder that stopped being zero would put
# uninitialised bytes into a CreateMode request.
for n in 0 9 15; do
  xr_line libxrandr/mode-namelen-$n "RANDR-MODE namelen-$n " "$n"
  xr_line libxrandr/mode-header-$n  "RANDR-MODE header-$n "  "56"
  xr_line libxrandr/mode-nul-$n     "RANDR-MODE nul-$n "     "1"
  xr_line libxrandr/mode-zeroed-$n  "RANDR-MODE zeroed-$n "  "1"
  xr_line libxrandr/mode-freed-$n   "RANDR-MODE freed-$n "   "1"
done
xr_line libxrandr/mode-name-0  "RANDR-MODE name-0 "  "[]"
xr_line libxrandr/mode-name-9  "RANDR-MODE name-9 "  "[1920x1080]"
xr_line libxrandr/mode-name-15 "RANDR-MODE name-15 " "[1920x1080_60.00]"

# THE NAME IS COPIED AND LENGTH-BOUNDED, not strdup'd. The probe hands it a
# 22-character string and a length of 8; the library must copy exactly 8 and
# append its own NUL. A consumer building a mode from a slice of a longer
# buffer depends on it, and an implementation that reached for strlen would
# take all 22 and read past whatever the caller owned.
xr_line libxrandr/mode-name-bounded  "RANDR-MODE name-8 "     "[1024x768]"
xr_line libxrandr/mode-namelen-bounded "RANDR-MODE namelen-8 " "8"
xr_line libxrandr/mode-nul-bounded   "RANDR-MODE nul-8 "      "1"

# ---------------------------------------------------------------------------
# 7. THE REFRESH COMPUTATION over a fixture of modes with known answers.
#
# dotClock / (hTotal * vTotal), vTotal doubled for doublescan and halved for
# interlace. This is not an entry point -- it is the arithmetic EVERY consumer
# of XRRModeInfo performs, which makes it the sharpest assertion available that
# the struct's fields mean here what they mean everywhere else. A dotClock that
# lost its top bits to a narrower `unsigned long', or an hTotal/vTotal pair the
# compiler laid out differently, lands in this number and nowhere else a build
# check would look.
#
# Every fixture is exact in binary floating point, so these are equalities.
xr_line libxrandr/rate-hd1080p60   "RANDR-RATE hd1080p60 "    "60.000000"
xr_line libxrandr/rate-plain50     "RANDR-RATE plain50 "      "50.000000"
xr_line libxrandr/rate-plain75     "RANDR-RATE plain75 "      "75.000000"
xr_line libxrandr/rate-half50      "RANDR-RATE half50 "       "50.500000"

# The doublescan and interlace arms carry HALF and TWICE the vTotal of plain50
# and must land on the same 50: the correction is applied, and applied the right
# way round. Getting the two backwards is the classic RandR consumer bug, and it
# is invisible in any fixture where the flag is absent.
xr_line libxrandr/rate-doublescan  "RANDR-RATE doublescan50 " "50.000000"
xr_line libxrandr/rate-interlace   "RANDR-RATE interlace50 "  "50.000000"

# A mode with a zero total is what a server reports for a mode it cannot time,
# and dividing by it is how a display tool dies on unfamiliar hardware.
xr_line libxrandr/rate-zero-htotal "RANDR-RATE zero-htotal "  "0.000000"
xr_line libxrandr/rate-zero-vtotal "RANDR-RATE zero-vtotal "  "0.000000"

# 148.5 MHz fits in a 32-bit unsigned long with room to spare; the case exists
# because a value near the top of the range would not, and section 4 pins the
# width this depends on.
xr_line libxrandr/rate-dotclock    "RANDR-RATE dotclock-kept " "148500000"

# ---------------------------------------------------------------------------
# 8. THE SCREEN-CONFIGURATION ACCESSORS on a hand-built fixture.
#
# These read fields out of a struct the library declares privately, so the probe
# compiles against the library's own src/Xrandrint.h rather than restating the
# layout -- an upstream change makes the PORT fail to build instead of making
# this section report nonsense.
xr_line libxrandr/config-rotations "RANDR-CONFIG rotations "        "0x13"
xr_line libxrandr/config-currot    "RANDR-CONFIG current-rotation " "0x2"
xr_line libxrandr/config-nsizes    "RANDR-CONFIG nsizes "           "3"
xr_line libxrandr/config-sizes-ptr "RANDR-CONFIG sizes-same "       "1"
xr_line libxrandr/config-size-0    "RANDR-CONFIG size-0 " "1920x1080 508x286mm"
xr_line libxrandr/config-size-1    "RANDR-CONFIG size-1 " "1280x720 340x190mm"
xr_line libxrandr/config-size-2    "RANDR-CONFIG size-2 " "640x480 170x130mm"
xr_line libxrandr/config-timestamp "RANDR-CONFIG timestamp "        "0x11223344"
xr_line libxrandr/config-cfgtime   "RANDR-CONFIG config-timestamp " "0x55667788"
xr_line libxrandr/config-cursize   "RANDR-CONFIG current-size "     "1"
xr_line libxrandr/config-cfgrot    "RANDR-CONFIG current-config-rotation " "0x2"
xr_line libxrandr/config-currate   "RANDR-CONFIG current-rate "     "72"

# THE RATE LIST IS RUN-LENGTH ENCODED and the encoding is the wire format
# verbatim: for each size in order, a count followed by that many rates.
# XRRConfigRates walks it with no bounds beyond the array's own counts, and
# NOTHING in the API says so -- a consumer that indexed it as a flat array would
# read plausible-looking rubbish rather than fail. The three runs have DIFFERENT
# lengths on purpose, so an off-by-one in the skip lands on the wrong run
# instead of landing back on the right one.
xr_line libxrandr/config-rates-0 "RANDR-CONFIG rates-0 " "n=2 list=60,75 null=0"
xr_line libxrandr/config-rates-1 "RANDR-CONFIG rates-1 " "n=3 list=60,72,75 null=0"
xr_line libxrandr/config-rates-2 "RANDR-CONFIG rates-2 " "n=1 list=50 null=0"

# Past the end, the walk exhausts the array and the documented answer is a zero
# count AND a NULL -- not one or the other. A caller that checked only the
# pointer, or only the count, is what this arm is for.
xr_line libxrandr/config-rates-past-end "RANDR-CONFIG rates-3 " "n=0 list=- null=1"

# ---------------------------------------------------------------------------
# 9. THE MONITOR ALLOCATOR -- the same one-allocation shape once more.
#
# calloc, not malloc, and every field but noutput and outputs must be zero:
# XRRSetMonitor sends the struct, so a stale byte becomes a wire value.
for n in 0 1 4; do
  xr_line libxrandr/monitor-noutput-$n "RANDR-MONITOR noutput-$n " "$n"
  xr_line libxrandr/monitor-header-$n  "RANDR-MONITOR header-$n "  "44"
  xr_line libxrandr/monitor-zeroed-$n  "RANDR-MONITOR zeroed-$n "  "1"
  xr_line libxrandr/monitor-roundtrip-$n "RANDR-MONITOR roundtrip-$n " "1"
  xr_line libxrandr/monitor-freed-$n   "RANDR-MONITOR freed-$n "   "1"
done

# ---------------------------------------------------------------------------
# 10. THE PROTOCOL CONSTANTS, compiled out of the STAGED xorgproto.
#
# These are what a consumer of this sysroot actually gets, not a copy written
# down in this file -- the probe includes <X11/extensions/randr.h> from the
# image's own include tree. A port that staged the wrong xorgproto would show up
# here and nowhere else until something drew a rotated screen.
xr_line libxrandr/const-major "RANDR-CONST RANDR_MAJOR " "1"
xr_line libxrandr/const-minor "RANDR-CONST RANDR_MINOR " "6"
xr_line libxrandr/const-name  "RANDR-CONST extension-name " "RANDR"

xr_line libxrandr/const-rot-0   "RANDR-CONST RR_Rotate_0 "   "1"
xr_line libxrandr/const-rot-90  "RANDR-CONST RR_Rotate_90 "  "2"
xr_line libxrandr/const-rot-180 "RANDR-CONST RR_Rotate_180 " "4"
xr_line libxrandr/const-rot-270 "RANDR-CONST RR_Rotate_270 " "8"
xr_line libxrandr/const-refl-x  "RANDR-CONST RR_Reflect_X "  "16"
xr_line libxrandr/const-refl-y  "RANDR-CONST RR_Reflect_Y "  "32"

# The rotations are a four-bit field and the reflections sit ABOVE it. Every
# consumer masks a Rotation with one or the other, so their disjointness is the
# contract -- an overlap would make "rotated 180" and "reflected" the same bit.
xr_line libxrandr/const-rot-mask   "RANDR-CONST rotate-mask "  "15"
xr_line libxrandr/const-refl-mask  "RANDR-CONST reflect-mask " "48"
xr_line libxrandr/const-disjoint   "RANDR-CONST rotate-reflect-disjoint " "1"

xr_line libxrandr/const-hsync-pos "RANDR-CONST RR_HSyncPositive " "0x1"
xr_line libxrandr/const-hsync-neg "RANDR-CONST RR_HSyncNegative " "0x2"
xr_line libxrandr/const-vsync-pos "RANDR-CONST RR_VSyncPositive " "0x4"
xr_line libxrandr/const-vsync-neg "RANDR-CONST RR_VSyncNegative " "0x8"
xr_line libxrandr/const-interlace "RANDR-CONST RR_Interlace "     "0x10"
xr_line libxrandr/const-doublescan "RANDR-CONST RR_DoubleScan "   "0x20"
xr_line libxrandr/const-csync     "RANDR-CONST RR_CSync "         "0x40"
xr_line libxrandr/const-pixmux    "RANDR-CONST RR_PixelMultiplex " "0x800"
xr_line libxrandr/const-clockdiv  "RANDR-CONST RR_ClockDivideBy2 " "0x2000"

xr_line libxrandr/const-connected "RANDR-CONST RR_Connected "    "0"
xr_line libxrandr/const-disconn   "RANDR-CONST RR_Disconnected " "1"
xr_line libxrandr/const-unknown   "RANDR-CONST RR_UnknownConnection " "2"

xr_line libxrandr/const-scn       "RANDR-CONST RRScreenChangeNotify " "0"
xr_line libxrandr/const-notify    "RANDR-CONST RRNotify "             "1"
xr_line libxrandr/const-n-crtc    "RANDR-CONST RRNotify_CrtcChange "  "0"
xr_line libxrandr/const-n-output  "RANDR-CONST RRNotify_OutputChange " "1"
xr_line libxrandr/const-n-outprop "RANDR-CONST RRNotify_OutputProperty " "2"
xr_line libxrandr/const-n-prov    "RANDR-CONST RRNotify_ProviderChange " "3"
xr_line libxrandr/const-n-provprop "RANDR-CONST RRNotify_ProviderProperty " "4"
xr_line libxrandr/const-n-res     "RANDR-CONST RRNotify_ResourceChange " "5"
xr_line libxrandr/const-scn-mask  "RANDR-CONST RRScreenChangeNotifyMask " "1"

# ---------------------------------------------------------------------------
# 11. THE ENTRY-POINT CENSUS.
#
# Seventy client entry points, each taken BY ADDRESS in the probe, so the
# archive having lost a module is a link failure at build time rather than a
# consumer's do_compile failure months later. This case is the runtime half: it
# says every one of them is present in the binary that actually ran.
#
# The count is asserted exactly, not as a floor. Seventy is the whole of what
# the installed Xrandr.h declares at 1.5.4, so a HIGHER number here would mean
# the probe's table and the header had drifted apart, which is worth a red of
# its own.
xr_line libxrandr/sym-count "RANDR-SYM-COUNT " "70"
xr_line libxrandr/sym-null  "RANDR-SYM-NULL "  "0"

# A spot check on the ones this port is actually about -- the resource, mode,
# crtc, output, provider, monitor and property modules, one name from each, so a
# whole translation unit that fell out of the archive is named in the red rather
# than being one of seventy indistinguishable NULLs.
for f in XRRQueryExtension XRRQueryVersion XRRGetScreenResources \
         XRRGetScreenResourcesCurrent XRRGetScreenSizeRange XRRSetScreenSize \
         XRRGetOutputInfo XRRGetOutputPrimary XRRSetOutputPrimary \
         XRRGetCrtcInfo XRRSetCrtcConfig XRRGetCrtcTransform \
         XRRAllocGamma XRRFreeGamma XRRGetCrtcGamma XRRSetCrtcGamma \
         XRRGetCrtcGammaSize XRRAllocModeInfo XRRFreeModeInfo XRRCreateMode \
         XRRDestroyMode XRRAddOutputMode XRRDeleteOutputMode \
         XRRGetPanning XRRSetPanning XRRFreePanning \
         XRRGetProviderResources XRRGetProviderInfo XRRSetProviderOutputSource \
         XRRSetProviderOffloadSink XRRGetMonitors XRRSetMonitor \
         XRRDeleteMonitor XRRAllocateMonitor XRRFreeMonitors \
         XRRListOutputProperties XRRQueryOutputProperty XRRGetOutputProperty \
         XRRChangeOutputProperty XRRDeleteOutputProperty \
         XRRListProviderProperties XRRGetProviderProperty \
         XRRSelectInput XRRUpdateConfiguration XRRRootToScreen \
         XRRGetScreenInfo XRRFreeScreenConfigInfo XRRSetScreenConfig \
         XRRSetScreenConfigAndRate XRRConfigRates XRRConfigSizes; do
  xr_line libxrandr/sym-$f "RANDR-SYM $f " "linked"
done

# ---------------------------------------------------------------------------
# 12. THE DISPLAY THAT IS NOT THERE -- why sections 5 to 9 are what this
#     suite tests, asserted rather than assumed.
#
# XOpenDisplay must FAIL here, and fail by returning NULL rather than by dying:
# there is no X server on this image and no socket for one. That is a PASS. It
# is the case that justifies the shape of everything above, and if it ever
# stopped being true this suite would be under-testing the library rather than
# over-testing it -- so it is asserted, not skipped.
xr_line libxrandr/dpy-no-server "RANDR-DPY open " "NULL"

# The server-gated entry points are proven LINKED by section 11 and are
# deliberately NOT invoked: calling them through an invented Display would be
# asserting something this image cannot support. This line is the probe stating
# that it took that arm, so "no display" and "the probe skipped the section for
# some other reason" cannot be confused.
xr_line libxrandr/dpy-honest-arm "RANDR-DPY server-gated-not-invoked " "1"

rm -rf "$work"