262 lines
8.5 KiB
Bash
Executable File
262 lines
8.5 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# T16 — real-window screencapture sanity check.
|
|
#
|
|
# Boots ./target/release/ely_app in the background, opens a live page through
|
|
# Servo's native surface path, captures the ELY window by its Core Graphics
|
|
# window ID, then asserts the PNG is non-trivial (size + dimensions + non-white
|
|
# center). Stderr from the app is
|
|
# tee'd to a log so a crash leaves evidence behind.
|
|
#
|
|
# Idempotent: kills any leftover ely_app processes from prior runs before
|
|
# starting, and cleans up its own background process on exit (success or fail).
|
|
|
|
set -uo pipefail
|
|
|
|
REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
|
|
cd "$REPO_ROOT"
|
|
|
|
TIMESTAMP="$(date +%Y%m%d-%H%M%S)"
|
|
SHOT_PATH="/tmp/ely-verify-${TIMESTAMP}.png"
|
|
STDERR_LOG="/tmp/ely-verify-stderr.log"
|
|
APP_BIN="${REPO_ROOT}/target/release/ely_app"
|
|
SMOKE_URL="${ELY_VERIFY_URL:-https://servo.org/}"
|
|
APP_PID=""
|
|
|
|
cleanup() {
|
|
if [[ -n "${APP_PID}" ]] && kill -0 "${APP_PID}" 2>/dev/null; then
|
|
kill "${APP_PID}" 2>/dev/null || true
|
|
# give it a beat to exit cleanly, then SIGKILL if needed
|
|
for _ in 1 2 3 4 5; do
|
|
kill -0 "${APP_PID}" 2>/dev/null || break
|
|
sleep 0.2
|
|
done
|
|
kill -9 "${APP_PID}" 2>/dev/null || true
|
|
fi
|
|
# Stragglers from prior runs / child processes
|
|
pkill -f "target/release/ely_app" 2>/dev/null || true
|
|
pkill -x "ely_app" 2>/dev/null || true
|
|
}
|
|
trap cleanup EXIT INT TERM
|
|
|
|
fail() {
|
|
echo "FAIL: $*" >&2
|
|
if [[ -s "${STDERR_LOG}" ]]; then
|
|
echo "---- stderr head (50 lines) ----" >&2
|
|
head -n 50 "${STDERR_LOG}" >&2
|
|
echo "--------------------------------" >&2
|
|
fi
|
|
exit 1
|
|
}
|
|
|
|
echo "[1/6] killing stale ely_app processes"
|
|
pkill -f "target/release/ely_app" 2>/dev/null || true
|
|
pkill -x "ely_app" 2>/dev/null || true
|
|
sleep 0.5
|
|
|
|
echo "[2/6] cargo build --release --locked -p ely_app"
|
|
if ! cargo build --release --locked -p ely_app; then
|
|
fail "cargo build failed"
|
|
fi
|
|
[[ -x "${APP_BIN}" ]] || fail "binary missing: ${APP_BIN}"
|
|
|
|
echo "[3/6] launching ${APP_BIN} ${SMOKE_URL} (stderr -> ${STDERR_LOG})"
|
|
: > "${STDERR_LOG}"
|
|
"${APP_BIN}" "${SMOKE_URL}" >/dev/null 2>"${STDERR_LOG}" &
|
|
APP_PID=$!
|
|
echo " pid=${APP_PID}"
|
|
|
|
echo "[4/6] waiting 12s for window + live page to settle"
|
|
for i in 1 2 3 4 5 6 7 8 9 10 11 12; do
|
|
sleep 1
|
|
if ! kill -0 "${APP_PID}" 2>/dev/null; then
|
|
fail "app exited early during warm-up (after ${i}s)"
|
|
fi
|
|
done
|
|
|
|
echo "[5/6] activating pid ${APP_PID} and screencapture -> ${SHOT_PATH}"
|
|
if ! osascript >/dev/null <<OSA
|
|
tell application "System Events"
|
|
set frontmost of first process whose unix id is ${APP_PID} to true
|
|
end tell
|
|
OSA
|
|
then
|
|
fail "could not activate ely_app process ${APP_PID}"
|
|
fi
|
|
sleep 1
|
|
FRONTMOST=$(osascript -e \
|
|
"tell application \"System Events\" to get frontmost of first process whose unix id is ${APP_PID}")
|
|
[[ "${FRONTMOST}" == "true" ]] || fail "ely_app process ${APP_PID} is not frontmost"
|
|
|
|
WINDOW_ID=$(/usr/bin/swift -e '
|
|
import CoreGraphics
|
|
import Darwin
|
|
import Foundation
|
|
|
|
guard CommandLine.arguments.count == 2, let targetPID = Int32(CommandLine.arguments[1]) else {
|
|
exit(64)
|
|
}
|
|
let windows = CGWindowListCopyWindowInfo(
|
|
[.optionOnScreenOnly, .excludeDesktopElements],
|
|
kCGNullWindowID
|
|
) as? [[String: Any]] ?? []
|
|
|
|
let candidates = windows.compactMap { window -> (number: UInt32, area: Double)? in
|
|
guard
|
|
let owner = window[kCGWindowOwnerPID as String] as? NSNumber,
|
|
owner.int32Value == targetPID,
|
|
let layer = window[kCGWindowLayer as String] as? NSNumber,
|
|
layer.intValue == 0,
|
|
let number = window[kCGWindowNumber as String] as? NSNumber,
|
|
let bounds = window[kCGWindowBounds as String] as? [String: Any],
|
|
let width = bounds["Width"] as? NSNumber,
|
|
let height = bounds["Height"] as? NSNumber,
|
|
width.doubleValue > 100,
|
|
height.doubleValue > 100
|
|
else {
|
|
return nil
|
|
}
|
|
|
|
return (number.uint32Value, width.doubleValue * height.doubleValue)
|
|
}
|
|
|
|
guard let window = candidates.max(by: { $0.area < $1.area }) else {
|
|
exit(1)
|
|
}
|
|
print(window.number)
|
|
' "${APP_PID}")
|
|
[[ "${WINDOW_ID}" =~ ^[0-9]+$ ]] || fail "could not resolve ELY window for pid ${APP_PID}"
|
|
echo " window_id=${WINDOW_ID}"
|
|
|
|
# -x silences the shutter sound; -l limits capture to the verified ELY window.
|
|
if ! screencapture -x -l "${WINDOW_ID}" "${SHOT_PATH}"; then
|
|
fail "screencapture invocation failed"
|
|
fi
|
|
[[ -f "${SHOT_PATH}" ]] || fail "screencapture produced no file"
|
|
|
|
echo "[6/6] verifying screenshot"
|
|
|
|
# size > 10KB
|
|
BYTES=$(stat -f%z "${SHOT_PATH}")
|
|
echo " size: ${BYTES} bytes"
|
|
if (( BYTES <= 10240 )); then
|
|
fail "screenshot too small (${BYTES} bytes <= 10KB) — likely blank/failed"
|
|
fi
|
|
|
|
# dimensions > 100x100
|
|
PIX_W=$(sips -g pixelWidth "${SHOT_PATH}" | awk '/pixelWidth:/ {print $2}')
|
|
PIX_H=$(sips -g pixelHeight "${SHOT_PATH}" | awk '/pixelHeight:/ {print $2}')
|
|
echo " dims: ${PIX_W} x ${PIX_H}"
|
|
if [[ -z "${PIX_W}" || -z "${PIX_H}" ]]; then
|
|
fail "could not read dimensions via sips"
|
|
fi
|
|
if (( PIX_W <= 100 || PIX_H <= 100 )); then
|
|
fail "screenshot dimensions too small (${PIX_W}x${PIX_H})"
|
|
fi
|
|
|
|
# Center-region non-white check. Crops a center patch with sips (built-in on
|
|
# macOS), then decodes the resulting PNG via python3 stdlib only (zlib +
|
|
# struct) — no PyObjC / no new deps. Averages RGB; FAILs if all channels
|
|
# > 248, which would mean we captured an empty white desktop.
|
|
CENTER_PATCH="${SHOT_PATH%.png}-center.png"
|
|
PATCH_PX=128
|
|
PATCH_OFF_W=$(( PIX_W / 2 - PATCH_PX / 2 ))
|
|
PATCH_OFF_H=$(( PIX_H / 2 - PATCH_PX / 2 ))
|
|
if ! sips --cropToHeightWidth "${PATCH_PX}" "${PATCH_PX}" \
|
|
--cropOffset "${PATCH_OFF_H}" "${PATCH_OFF_W}" \
|
|
"${SHOT_PATH}" --out "${CENTER_PATCH}" >/dev/null 2>&1; then
|
|
fail "sips crop failed"
|
|
fi
|
|
|
|
PY_OUT=$(/usr/bin/python3 - "${CENTER_PATCH}" <<'PYEOF'
|
|
import sys, struct, zlib
|
|
|
|
path = sys.argv[1]
|
|
with open(path, "rb") as f:
|
|
data = f.read()
|
|
if data[:8] != b"\x89PNG\r\n\x1a\n":
|
|
print("ERROR not-png"); sys.exit(3)
|
|
|
|
i = 8
|
|
width = height = bit_depth = color_type = None
|
|
idat = bytearray()
|
|
while i < len(data):
|
|
length = struct.unpack(">I", data[i:i+4])[0]
|
|
ctype = data[i+4:i+8]
|
|
payload = data[i+8:i+8+length]
|
|
i += 8 + length + 4 # skip crc
|
|
if ctype == b"IHDR":
|
|
width, height, bit_depth, color_type = struct.unpack(">IIBB", payload[:10])
|
|
elif ctype == b"IDAT":
|
|
idat.extend(payload)
|
|
elif ctype == b"IEND":
|
|
break
|
|
|
|
if bit_depth != 8 or color_type not in (2, 6):
|
|
print(f"ERROR unsupported bit_depth={bit_depth} color_type={color_type}")
|
|
sys.exit(3)
|
|
|
|
channels = 3 if color_type == 2 else 4
|
|
stride = width * channels
|
|
raw = zlib.decompress(bytes(idat))
|
|
# undo PNG row filters
|
|
out = bytearray(width * height * channels)
|
|
prev = bytearray(stride)
|
|
pos = 0
|
|
for y in range(height):
|
|
f = raw[pos]; pos += 1
|
|
row = bytearray(raw[pos:pos+stride]); pos += stride
|
|
if f == 0:
|
|
pass
|
|
elif f == 1: # Sub
|
|
for x in range(channels, stride):
|
|
row[x] = (row[x] + row[x-channels]) & 0xFF
|
|
elif f == 2: # Up
|
|
for x in range(stride):
|
|
row[x] = (row[x] + prev[x]) & 0xFF
|
|
elif f == 3: # Average
|
|
for x in range(stride):
|
|
left = row[x-channels] if x >= channels else 0
|
|
row[x] = (row[x] + (left + prev[x]) // 2) & 0xFF
|
|
elif f == 4: # Paeth
|
|
for x in range(stride):
|
|
a = row[x-channels] if x >= channels else 0
|
|
b = prev[x]
|
|
c = prev[x-channels] if x >= channels else 0
|
|
p = a + b - c
|
|
pa, pb, pc = abs(p-a), abs(p-b), abs(p-c)
|
|
pr = a if pa <= pb and pa <= pc else (b if pb <= pc else c)
|
|
row[x] = (row[x] + pr) & 0xFF
|
|
else:
|
|
print(f"ERROR filter={f}"); sys.exit(3)
|
|
out[y*stride:(y+1)*stride] = row
|
|
prev = row
|
|
|
|
rs = gs = bs = n = 0
|
|
for y in range(height):
|
|
base = y * stride
|
|
for x in range(width):
|
|
o = base + x * channels
|
|
rs += out[o]; gs += out[o+1]; bs += out[o+2]; n += 1
|
|
ar, ag, ab = rs/n, gs/n, bs/n
|
|
print(f"CENTER {width}x{height} r={ar:.1f} g={ag:.1f} b={ab:.1f}")
|
|
if ar > 248 and ag > 248 and ab > 248:
|
|
sys.exit(2)
|
|
sys.exit(0)
|
|
PYEOF
|
|
)
|
|
PY_RC=$?
|
|
echo " center: ${PY_OUT}"
|
|
rm -f "${CENTER_PATCH}"
|
|
if (( PY_RC == 2 )); then
|
|
fail "center ${PATCH_PX}x${PATCH_PX} patch is ~white — likely empty desktop or failed paint"
|
|
fi
|
|
if (( PY_RC != 0 )); then
|
|
fail "screenshot decoder rejected the center patch (exit ${PY_RC})"
|
|
fi
|
|
|
|
echo
|
|
echo "PASS"
|
|
echo "screenshot: ${SHOT_PATH}"
|
|
echo "stderr log: ${STDERR_LOG} ($(wc -l < "${STDERR_LOG}" | tr -d ' ') lines)"
|
|
exit 0
|