//! A pardes in a pty of its own, driven as a terminal user drives it: keys //! and the mouse as a terminal's bytes, its screen read back through its //! own ghostty-vt (e2e_harness.zig). The tty cases (test/process/tty_*.zig) //! are what the tty frontend draws and how it reads its input, which no //! in-process session sees: each case's captures (`snap` the text and the //! cursor, `style` every cell's ink, `snap9p` the core's own /screen, //! `snapFile` a file on disk) are compared at `done` with //! test/snapshots/.golden, which `zig build process-test -- --update //! ` rewrites (one case at a time, then a plain run, and a diff of //! the golden for moved shell output, a flake, before keeping it). //! //! A case runs in a fixed directory, /tmp/pardes-snap//cwd, whose //! path the goldens record, with a fake home: bash with a `$ ` prompt (a //! golden taken against this machine's login shell would be a golden for //! this machine), messages that leave when dismissed, no wall clock //! (PARDES_NOTIME), a virtual core clock (PARDES_TEST_CLOCK), and language //! servers off but the mock `.rs` speaks to. `init` sets this process's //! environment and directory for it: process_test.zig runs each tty case in //! a child of its own, several at once. //! //! A capture is a DELTA against the previous capture of the same kind: the //! first one (and any after a resize or a new start) is the whole screen as //! `|`, the rest only the rows that changed, as `|: `. Before //! this, every frame restated every row, so 82% of golden lines were a copy //! of the line above and one added builtin word rewrote 78 goldens. //! //! A mouse column may be `@Word`, `@Word#2` or `@Word+4` instead of a //! number: the column of a word on that row of the live grid (resolveCol). //! Chrome words move, and a frozen column silently clicks whatever moved //! into it. const std = @import("std"); const libc = std.c; const ghostty_vt = @import("ghostty-vt"); const eh = @import("e2e_harness.zig"); const process = @import("process.zig"); extern "c" fn setenv(name: [*:0]const u8, value: [*:0]const u8, overwrite: c_int) c_int; extern "c" fn execvp(file: [*:0]const u8, argv: [*:null]const ?[*:0]const u8) c_int; extern "c" fn system(cmd: [*:0]const u8) c_int; /// `--update`: each case's captures written to its golden, not compared. pub var update = false; /// The repository's test/snapshots, absolute: a case runs elsewhere. pub var goldens: []const u8 = "test/snapshots"; /// The deterministic mock language server `.rs` files speak to /// (`--lspmock=`); empty leaves every language client off. pub var lspmock: []const u8 = ""; /// `--replay`: every session a case starts records its tape /// (PARDES_RECORD, src/tape.zig), and the case fails unless each replays /// (PARDES_REPLAY) into its three replicas, the session's dump at its end /// loaded to its digest: what a real session's host answered (its shells, /// ptys and files) replayed, as the T1 runner's `--replay` replays an /// in-process session's. `replay_with`, another build of pardes (a /// window's), replays each tape too, agreeing in the replica that draws /// nothing, as a replica client draws none of its session's frames. pub var replay = false; pub var replay_with: ?[]const u8 = null; const base_dir = "/tmp/pardes-snap"; const gpa = std.heap.page_allocator; pub const Tty = struct { arena: std.mem.Allocator, exe: [:0]const u8, name: []const u8, /// /tmp/pardes-snap/: home/, cwd/, dump.zon. base: []const u8, config_home: []const u8, /// The dump path the session's Dump writes and `-l` reads back /// (PARDES_DUMP): per case, so cases need not take turns. dump: [:0]const u8, h: ?eh.Harness = null, /// Captures are deltas against these (see Prev). prev: Prev = .{}, out: std.ArrayList(u8) = .empty, pub fn init(_: std.mem.Allocator, exe: [:0]const u8, name: []const u8) !Tty { // A child's, never freed: the child exits with the case. const arena_state = try gpa.create(std.heap.ArenaAllocator); arena_state.* = .init(gpa); const arena = arena_state.allocator(); // Another run of the same case (another checkout's) would trample // the fixed directory its golden records: wait for it instead. The // lock is held until this child exits; CLOEXEC, or an orphaned bash // the case forked would hold it for ever. try mkdir(arena, base_dir, true); const lock = libc.open(try std.fmt.allocPrintSentinel(arena, "{s}/{s}.lock", .{ base_dir, name }, 0), .{ .ACCMODE = .WRONLY, .CREAT = true, .CLOEXEC = true }, @as(libc.mode_t, 0o644)); if (lock >= 0) _ = libc.flock(lock, std.posix.LOCK.EX); const base = try std.fmt.allocPrint(arena, "{s}/{s}", .{ base_dir, name }); rmrf(base); try mkdir(arena, base, false); const home = try std.fmt.allocPrint(arena, "{s}/home", .{base}); const work = try std.fmt.allocPrint(arena, "{s}/cwd", .{base}); try mkdir(arena, home, false); try mkdir(arena, work, false); // deterministic shell: fixed prompt, no history, no user rc leakage try eh.writeFile(try std.fmt.allocPrintSentinel(arena, "{s}/.bashrc", .{home}, 0), "PS1='$ '\nHISTFILE=\n"); _ = setenv("HOME", try arena.dupeSentinel(u8, home, 0), 1); // Hermetic even when the developer exports an XDG directory that // points outside this fake home: its config, and its data directory // (dumps, the addons its start scan loads). const config_home = try std.fmt.allocPrintSentinel(arena, "{s}/.config", .{home}, 0); _ = setenv("XDG_CONFIG_HOME", config_home, 1); const data_home = try std.fmt.allocPrintSentinel(arena, "{s}/.local/share", .{home}, 0); _ = setenv("XDG_DATA_HOME", data_home, 1); if (process.naddons > 0) for ([_][]const u8{ "/.local", "/.local/share", "/.local/share/pardes", "/.local/share/pardes/addons" }) |sub| try mkdir(arena, try std.fmt.allocPrint(arena, "{s}{s}", .{ home, sub }), true); for (process.addons[0..process.naddons]) |lib| { // libpdf.so as pdf.so: the name a build installs it as. const lib_name = std.fs.path.basename(lib); const installed = if (std.mem.startsWith(u8, lib_name, "lib")) lib_name[3..] else lib_name; if (libc.symlink(lib, try std.fmt.allocPrintSentinel(arena, "{s}/pardes/addons/{s}", .{ data_home, installed }, 0)) != 0) return error.SymlinkFailed; } // The default shell is $SHELL, whatever this machine's user logs in // with (fish's prompt carries a hostname): every case runs bash, set // through the ordinary startup config. Messages leave the moment // they are dismissed: a linger is time, and time cannot be a golden. try mkdir(arena, config_home, false); try mkdir(arena, try std.fmt.allocPrint(arena, "{s}/pardes", .{config_home}), false); try eh.writeFile(try std.fmt.allocPrintSentinel(arena, "{s}/pardes/init", .{config_home}, 0), "Shell bash\nMessageLinger 0\n"); _ = setenv("TERM", "xterm-256color", 1); _ = setenv("LC_ALL", "C", 1); // No wall clock (the language views' durations, a message's time of // day), and a virtual core clock: animation moves a frame per // timed-out wait, whatever the machine's load (host_io.testClock). _ = setenv("PARDES_NOTIME", "1", 1); _ = setenv("PARDES_TEST_CLOCK", "1", 1); // Hermetic language clients: `.rs` speaks to the mock, every other // spec is off, so a stray `.c` never spawns this machine's clangd. _ = setenv("PARDES_LSP_RS", try arena.dupeSentinel(u8, lspmock, 0), 1); for ([_][*:0]const u8{ "PARDES_LSP_C", "PARDES_LSP_GO", "PARDES_LSP_TS", "PARDES_LSP_PY" }) |v| _ = setenv(v, "", 1); const dump = try std.fmt.allocPrintSentinel(arena, "{s}/dump.zon", .{base}, 0); _ = setenv("PARDES_DUMP", dump, 1); if (replay) { try mkdir(arena, try std.fmt.allocPrint(arena, "{s}/tapes", .{base}), false); _ = setenv("PARDES_RECORD", try std.fmt.allocPrintSentinel(arena, "{s}/tapes/s-", .{base}, 0), 1); } if (libc.chdir(try arena.dupeSentinel(u8, work, 0)) < 0) return error.ChdirFailed; return .{ .arena = arena, .exe = exe, .name = name, .base = base, .config_home = config_home, .dump = dump }; } pub fn deinit(t: *Tty) void { if (t.h) |*h| h.deinit(); } /// The captures against the golden, or written to it under `--update`. pub fn done(t: *Tty) !void { if (replay) { // The session over first: its tape is whole. if (t.h) |*h| h.deinit(); t.h = null; try t.replayTapes(t.exe, false); if (replay_with) |other| try t.replayTapes(other, true); } const path = try std.fmt.allocPrint(t.arena, "{s}/{s}.golden", .{ goldens, t.name }); if (update) return eh.writeFile(try t.arena.dupeSentinel(u8, path, 0), t.out.items); const want = readFileAlloc(t.arena, path) catch ""; if (std.mem.eql(u8, want, t.out.items)) return; const drew = try std.fmt.allocPrint(t.arena, "{s}/drew.golden", .{t.base}); try eh.writeFile(try t.arena.dupeSentinel(u8, drew, 0), t.out.items); std.debug.print(" {s}: not its golden {s} (what it drew: {s})\n", .{ t.name, path, drew }); printFirstDiff(want, t.out.items); return error.GoldenMismatch; } /// Each tape the case's sessions wrote, replayed by `exe`. fn replayTapes(t: *Tty, exe: []const u8, headless: bool) !void { const tapes_dir = try std.fmt.allocPrint(t.arena, "{s}/tapes", .{t.base}); const io = std.Io.Threaded.global_single_threaded.io(); var d = try std.Io.Dir.cwd().openDir(io, tapes_dir, .{ .iterate = true }); defer d.close(io); var it = d.iterate(); var tapes: usize = 0; while (try it.next(io)) |entry| { if (!std.mem.endsWith(u8, entry.name, ".tape")) continue; tapes += 1; const cmd = try std.fmt.allocPrintSentinel(t.arena, "PARDES_RECORD= PARDES_REPLAY='{s}/{s}' {s}timeout 300 '{s}' > '{s}/{s}.replay' 2>&1", .{ tapes_dir, entry.name, if (headless) "" else "PARDES_REPLAY_DUMP=1 ", exe, tapes_dir, entry.name }, 0); if (system(cmd) == 0) continue; const said = readFileAlloc(t.arena, try std.fmt.allocPrint(t.arena, "{s}/{s}.replay", .{ tapes_dir, entry.name })) catch ""; // Another build's replay need agree only in the replica that draws nothing. if (headless) if (std.mem.indexOf(u8, said, ": headless replica: ")) |at| { if (std.mem.startsWith(u8, std.mem.trimStart(u8, said[at + ": headless replica: ".len ..], "0123456789"), " digests agree")) continue; }; std.debug.print(" {s}: its tape {s} did not replay:\n{s}", .{ t.name, entry.name, said }); return error.Diverged; } if (tapes == 0) return error.NoTape; } /// A setting appended to the startup config the fake home has, so a /// case can pin one instead of spelling out what a default implies. /// Before `start`. pub fn config(t: *Tty, line: []const u8) !void { try eh.appendFile(try std.fmt.allocPrintSentinel(t.arena, "{s}/pardes/init", .{t.config_home}, 0), try std.fmt.allocPrint(t.arena, "{s}\n", .{line})); } /// A file in the case's directory. pub fn file(t: *Tty, name: []const u8, data: []const u8) !void { try eh.writeFile(try t.arena.dupeSentinel(u8, name, 0), data); } /// A file of `n` lines, `line ` each: long AND wide, which /// a horizontal scroll needs. pub fn lines(t: *Tty, name: []const u8, n: usize, tail: []const u8) !void { try t.file(name, try numberedLines(t.arena, n, tail)); } /// The diagonal-split test picture of the old e2e (white over blue), /// 512x512 with the white half a fixed LCG noise, at `name`. Both /// halves are load-bearing: the clean edge is what the block and /// sextant glyphs match exactly, the noise is fine enough (one source /// pixel per matcher subcell at this size) that the ASCII bitmaps win /// instead, so the Ascii toggle visibly changes the art, which a 64x64 /// picture cannot show (its cells average down to a flat colour). pub fn ppmDiag(t: *Tty, name: []const u8) !void { try t.file(name, try diagonal(t.arena)); } pub fn dir(t: *Tty, name: []const u8) !void { try mkdir(t.arena, name, false); } /// A writer that is NOT a pardes pane, run in the case's directory as a /// child of the runner: a rename-over is how a formatter replaces a /// file, a different inotify event from a pane's write, and whatever the /// app then shows it woke up for by itself. pub fn run(t: *Tty, cmd: []const u8) !void { if (system(try t.arena.dupeSentinel(u8, cmd, 0)) != 0) return error.RunFailed; } /// The app started in a pty `rows` by `cols`, with `args`; a case may /// start it again (a dump, then `-l`), a new screen captured whole. pub fn start(t: *Tty, rows: u16, cols: u16, args: []const []const u8) !void { var argv: [6]?[*:0]const u8 = @splat(null); for (args, 0..) |a, i| argv[i] = (try t.arena.dupeSentinel(u8, a, 0)).ptr; if (t.h) |*h| h.deinit(); t.prev = .{}; t.h = try eh.Harness.initArgv(gpa, t.exe.ptr, rows, cols, argv[0..args.len]); } /// A file's contents as a capture, base64 payloads elided: they encode /// raw pty byte history, whose micro-timing differs run to run. pub fn snapFile(t: *Tty, label: []const u8, path: []const u8) !void { try t.out.appendSlice(t.arena, try snapFileText(t.arena, label, try readFileAlloc(t.arena, path))); } /// Pump until `needle` is on the grid. pub fn wait(t: *Tty, ms: i64, needle: []const u8) !void { try t.live().expectWaitFor(needle, ms, "tty wait"); } /// Pump for a fixed time. pub fn settle(t: *Tty, ms: i64) !void { try t.live().pump(ms); } /// Pump until the screen holds still (waitStable). pub fn stable(t: *Tty, quiet: i64, timeout: i64) !void { try waitStable(t.live(), quiet, timeout); } /// Bytes typed at the terminal. pub fn send(t: *Tty, bytes: []const u8) !void { try t.live().send(bytes); } /// Keys by name, space-separated: enter esc tab bs space up down left /// right home end pgup pgdn, a character, c- and a-. After esc, /// settle: vaxis reads the next byte in the same batch as alt-. pub fn key(t: *Tty, names: []const u8) !void { var it = std.mem.tokenizeScalar(u8, names, ' '); while (it.next()) |name| try t.live().send(keyBytes(name) orelse return error.BadKey); } /// An SGR mouse press, release or drag (motion with it held) of /// `[ctrl-|shift-]left|middle|right` at a 1-based cell. pub fn press(t: *Tty, button: []const u8, col: []const u8, row: u16) !void { try t.mouse(button, col, row, 0, 'M'); } pub fn release(t: *Tty, button: []const u8, col: []const u8, row: u16) !void { try t.mouse(button, col, row, 0, 'm'); } pub fn drag(t: *Tty, button: []const u8, col: []const u8, row: u16) !void { try t.mouse(button, col, row, 32, 'M'); } fn mouse(t: *Tty, button: []const u8, col_spec: []const u8, row: u16, add: u16, fin: u8) !void { const b = buttonCode(button) orelse return error.BadButton; const col = try resolveCol(t.live(), col_spec, row); try t.live().send(try std.fmt.allocPrint(t.arena, "\x1b[<{d};{d};{d}{c}", .{ b + add, col, row, fin })); } /// Button-less motion (hover). pub fn motion(t: *Tty, col_spec: []const u8, row: u16) !void { const col = try resolveCol(t.live(), col_spec, row); try t.live().send(try std.fmt.allocPrint(t.arena, "\x1b[<35;{d};{d}M", .{ col, row })); } /// One wheel tick, `up` or `down`. pub fn wheel(t: *Tty, dir_name: []const u8, col_spec: []const u8, row: u16) !void { const b: u16 = if (std.mem.eql(u8, dir_name, "up")) 64 else 65; const col = try resolveCol(t.live(), col_spec, row); try t.live().send(try std.fmt.allocPrint(t.arena, "\x1b[<{d};{d};{d}M", .{ b, col, row })); } pub fn resize(t: *Tty, rows: u16, cols: u16) !void { try t.live().resize(rows, cols); } /// The grid's text and cursor (snapText). pub fn snap(t: *Tty, label: []const u8) !void { try t.out.appendSlice(t.arena, try snapText(t.arena, t.live(), label, &t.prev)); } /// Every cell's ink, as style runs (snapStyle). pub fn style(t: *Tty, label: []const u8) !void { try t.out.appendSlice(t.arena, try snapStyle(t.arena, t.live(), label, &t.prev)); } /// The core's own cells and styles, read over its 9P socket (snap9p). pub fn snap9p(t: *Tty, label: []const u8) !void { try t.out.appendSlice(t.arena, try snap9pText(t.arena, t.live(), label, &t.prev)); } fn live(t: *Tty) *eh.Harness { if (t.h) |*h| return h; @panic("a tty case used the app before `start`"); } }; /// A failed case is run again alone: nothing else competes then, so the /// wider probes are cheap, and its verdict is the one reported. pub fn beCareful() void { probe_after_ms = 40; probe_hold_ms = 300; } fn copyBytes(out: []u8, pos: *usize, bytes: []const u8) void { @memcpy(out[pos.*..][0..bytes.len], bytes); pos.* += bytes.len; } fn decimalDigits(value: usize) usize { var v = value; var digits: usize = 1; while (v >= 10) : (digits += 1) v /= 10; return digits; } fn numberedLines(arena: std.mem.Allocator, n: usize, tail: []const u8) ![]u8 { var total: usize = 0; for (1..n + 1) |i| total += "line ".len + decimalDigits(i) + tail.len + 1; const out = try arena.alloc(u8, total); var pos: usize = 0; for (1..n + 1) |i| { const line = try std.fmt.bufPrint(out[pos..], "line {d}{s}\n", .{ i, tail }); pos += line.len; } return out; } fn diagonal(arena: std.mem.Allocator) ![]u8 { const header = "P6\n512 512\n255\n"; const out = try arena.alloc(u8, header.len + 512 * 512 * 3); @memcpy(out[0..header.len], header); var pos = header.len; var seed: u64 = 12345; var py: usize = 0; while (py < 512) : (py += 1) { var px: usize = 0; while (px < 512) : (px += 1) { seed = seed *% 1103515245 +% 12345; const v: u8 = @truncate(seed >> 16); const pixel: [3]u8 = if (px + py < 512) .{ v, v, v } else .{ 0, 0, 255 }; @memcpy(out[pos..][0..pixel.len], &pixel); pos += pixel.len; } } return out; } fn snapFileText(arena: std.mem.Allocator, label: []const u8, contents: []const u8) ![]u8 { const header = try std.fmt.allocPrint(arena, "== file {s}\n", .{label}); var total = header.len + "== end file\n".len; var lines = std.mem.splitScalar(u8, contents, '\n'); while (lines.next()) |line| { if (std.mem.indexOf(u8, line, "_b64 = \"") != null) { const eq = std.mem.indexOfScalar(u8, line, '=').?; total += eq + 1 + " \n".len; } else { total += line.len + 1; } } const out = try arena.alloc(u8, total); var pos: usize = 0; copyBytes(out, &pos, header); lines = std.mem.splitScalar(u8, contents, '\n'); while (lines.next()) |line| { if (std.mem.indexOf(u8, line, "_b64 = \"") != null) { const eq = std.mem.indexOfScalar(u8, line, '=').?; copyBytes(out, &pos, line[0 .. eq + 1]); copyBytes(out, &pos, " \n"); } else { copyBytes(out, &pos, line); copyBytes(out, &pos, "\n"); } } copyBytes(out, &pos, "== end file\n"); return out; } /// Pump until the captured state — grid text AND cursor — has not changed for /// `quiet` ms (bounded by `timeout`). The one sync primitive that needs no /// needle: used before every snap so a capture is taken at rest, not /// mid-repaint. /// /// Same oracle as before, timed continuously instead of in fixed windows. The /// old loop pumped a whole `quiet` window, compared, and pumped another — so /// even an app that fell silent immediately cost 2 × 700ms, and 446 `stable`s /// cost the suite ten minutes. This one sleeps in poll until the app writes, /// and returns `quiet` ms after the LAST change. Waiting on the change rather /// than on silence is what keeps it honest: pardes finishes a repaint with a /// late cursor move, hundreds of ms after its last burst of text. fn waitStable(h: *eh.Harness, quiet: i64, timeout: i64) !void { const t0 = eh.nowMs(); const deadline = t0 + timeout; var prev = try stateKey(h); defer h.gpa.free(prev); var last_change = t0; var asleep_since: i64 = 0; while (true) { const now = eh.nowMs(); const since = now - last_change; if (since >= quiet) { return; } // Fast path: the screen has held still, the pty is empty in both // directions (so the app has CONSUMED everything the case just sent // — otherwise an app still asleep in its event loop looks finished), // and nothing in its process tree is runnable. Held across two probes, // because a pane's shell can write and sleep a scheduler tick before // the app wakes to read it. if (since >= probe_after_ms and h.pending() == 0 and treeAsleep(h.pid)) { if (asleep_since == 0) { asleep_since = now; } else if (now - asleep_since >= probe_hold_ms) { return; } } else if (since >= probe_after_ms) { asleep_since = 0; } if (now >= deadline) return error.NeverStable; const nap = if (since >= probe_after_ms) probe_every_ms else probe_after_ms - since; if (!try h.pumpOnce(@min(nap, deadline - now))) continue; while (try h.pumpOnce(0)) {} // drain the burst before comparing const cur = try stateKey(h); if (std.mem.eql(u8, cur, prev)) { h.gpa.free(cur); continue; } h.gpa.free(prev); prev = cur; last_change = eh.nowMs(); asleep_since = 0; } } // How long the screen must hold still before the sleep probe is trusted at all, // how often it is taken, and how long it must stay true. // // The hold is the one number that cannot be reasoned down to zero. When the app // writes to a pane's pty the kernel parks the bytes in a flip buffer and leaves // the hand-off to a kworker: until that runs, the app is asleep, the shell is // asleep, nothing is runnable and no /proc or ioctl query can see the round trip // in flight (a pty master cannot even be reopened through /proc//fd — it // mints a fresh pty). So the hold is a bet on kworker latency, and a loaded // machine loses it. The parallel pass bets small; the serial re-run that decides // the verdict bets big. // // Only the SUM is the safety margin: a return cannot happen before // `probe_after_ms + probe_hold_ms` after the last change either way. The split // is pure cost, and the two halves cost differently - the arm window is one // `poll()` sleep, while every `probe_every_ms` of hold is a full `treeAsleep()` // walk of the app's process tree. Measured across the suite: 796 armed probes, // 54 of them saw a later change, none later than 11ms at 20 jobs. That is the // scheduler-tick case. The number the sum is really sized for is bigger and // found by adversarial measurement: a theme transition sleeps // `pardes.frame_ms` (16ms) between frames with the whole tree asleep, and // under `taskset -c 0,1` those gaps stretch to 57ms. 60ms total stays. var probe_after_ms: i64 = 50; const probe_every_ms: i64 = 5; var probe_hold_ms: i64 = 10; /// Is every process in the app's tree asleep? Walks /proc from the app's pid /// through `children`, checking every thread's run state: `R` (runnable) or /// `D` (uninterruptible) anywhere means work is still in flight — a repaint, /// a fork, a shell mid-command — so a quiet pty proves nothing. Anything else /// (`S`, or a zombie waiting to be reaped) is idle. /// /// This is what replaces the wall-clock window: the app finishes a keystroke /// in ~10ms, and the scripts' 400-700ms `stable` windows were insurance /// against not being able to tell "finished" from "paused mid-fork". fn treeAsleep(root: libc.pid_t) bool { var stack: [64]libc.pid_t = undefined; stack[0] = root; var n: usize = 1; var path_buf: [64:0]u8 = undefined; var buf: [4096]u8 = undefined; while (n > 0) { n -= 1; const pid = stack[n]; const dir_path = std.fmt.bufPrintSentinel(&path_buf, "/proc/{d}/task", .{pid}, 0) catch continue; const dir = libc.opendir(dir_path) orelse continue; // exited between steps defer _ = libc.closedir(dir); while (libc.readdir(dir)) |d| { const tid = std.mem.sliceTo(@as([*:0]const u8, @ptrCast(&d.name)), 0); if (tid[0] == '.') continue; const stat = readProc(&buf, std.fmt.bufPrintSentinel(&path_buf, "/proc/{d}/task/{s}/stat", .{ pid, tid }, 0) catch continue) orelse continue; // "pid (comm) S ..." — comm can hold spaces and parens, so the // state is the char two past the LAST ')' const close = std.mem.lastIndexOfScalar(u8, stat, ')') orelse continue; if (close + 2 >= stat.len) continue; switch (stat[close + 2]) { // R/D: still working. Z: just exited, so its parent is about to // be woken to reap it and carry on — a pane's shell sitting in // wait4 over a zombie `ls` looks asleep, but the prompt it is // about to print is what hides the echoed command line in the // goldens. 'R', 'D', 'Z' => return false, else => {}, } const kids = readProc(&buf, std.fmt.bufPrintSentinel(&path_buf, "/proc/{d}/task/{s}/children", .{ pid, tid }, 0) catch continue) orelse continue; var it = std.mem.tokenizeAny(u8, kids, " \n"); while (it.next()) |k| { if (n >= stack.len) return false; // deeper than we can walk: assume busy stack[n] = std.fmt.parseInt(libc.pid_t, k, 10) catch continue; n += 1; } } } return true; } /// Read a small /proc file into `buf` (procfs needs one read, no stat). fn readProc(buf: []u8, path: [*:0]const u8) ?[]const u8 { const fd = libc.open(path, .{ .ACCMODE = .RDONLY, .CLOEXEC = true }); if (fd < 0) return null; defer _ = libc.close(fd); const got = libc.read(fd, buf.ptr, buf.len); if (got <= 0) return null; return buf[0..@intCast(got)]; } /// What a capture is made of: grid text, cursor cell, and a compact digest of /// every cell style. Style used not to matter to `stable`, which let a /// color-only animation look idle while the TUI frontend was deliberately /// asleep between frames; a following `snapstyle` then caught a midpoint. fn stateKey(h: *eh.Harness) ![]u8 { const text = try h.screenText(); defer h.gpa.free(text); const c = h.cursor(); var styles = std.hash.Wyhash.init(0x5354_594c_4553_2121); var y: u16 = 0; while (y < h.rows) : (y += 1) { var x: u16 = 0; while (x < h.cols) : (x += 1) { var key_buf: [64]u8 = undefined; styles.update(cellKey(h, x, y, &key_buf)); styles.update("\x00"); } } return std.fmt.allocPrint(h.gpa, "{d},{d},{x}\n{s}", .{ c.x, c.y, styles.final(), text }); } /// A mouse column: either a screen column, or `@Word` / `@Word#2` - the column /// of a WORD found on that row of the LIVE grid. /// /// Chrome words move. When `Newtty` was added to every tail and `Joincol` and /// `Changelog` to the topbar, six scripts kept their frozen columns and started /// clicking a different word: `tutor.snap` clicked `Grep` instead of `Tutor`, /// `exec.snap`/`respawn.snap`/`tagalign.snap` clicked `Newtty` instead of `Del`, /// `find.snap` clicked `Joincol` instead of `Find`, `windowops.snap` clicked /// `Tutor` instead of `Debug` - and `--update` blessed all of it, so 256 golden /// lines were green while asserting the opposite of their script's first line. /// Naming the word instead of its column makes that class of drift impossible: /// the word is either there to be clicked or the case fails loudly. /// /// The match is boundary-anchored, which is not a detail: `New` is a prefix of /// `Newcol` and of `Newtty`, and `@New` resolving to `Newcol` is exactly the bug /// this is here to prevent. `#n` picks the nth occurrence for a row that holds /// two panes' tags, and `+n`/`-n` addresses a column NEAR a word - which is how /// a click that means "in the gap the right-aligned builtins leave after the /// path" is spelled without depending on how wide those builtins are. fn resolveCol(h: *eh.Harness, spec: []const u8, row: u16) !u16 { if (spec.len == 0 or spec[0] != '@') return std.fmt.parseInt(u16, spec, 10); var word = spec[1..]; var want: usize = 1; var offset: i32 = 0; // parsed off the end, so a word may hold a `-` or a `#` itself if (std.mem.lastIndexOfAny(u8, word, "+-")) |sign| { if (sign > 0) { if (std.fmt.parseInt(i32, word[sign + 1 ..], 10)) |n| { offset = if (word[sign] == '-') -n else n; word = word[0..sign]; } else |_| {} } } if (std.mem.lastIndexOfScalar(u8, word, '#')) |hash| { if (std.fmt.parseInt(usize, word[hash + 1 ..], 10)) |n| { want = n; word = word[0..hash]; } else |_| {} } if (word.len == 0 or want == 0) return error.BadScript; if (row == 0 or row > h.rows) return error.WordRowMissing; // One byte per CELL, not per byte of UTF-8: a mouse column is a cell, and // a tag row can hold a wide glyph or the U+254E column divider left of the // word. Non-ASCII cells become 0xff, which is not a word byte, so they // read as boundaries - every chrome word is ASCII. var cells: [1024]u8 = undefined; const line = rowCells(h, row - 1, &cells); var seen: usize = 0; var from: usize = 0; while (std.mem.indexOfPos(u8, line, from, word)) |at| : (from = at + 1) { if (at > 0 and wordByte(line[at - 1])) continue; const after = at + word.len; if (after < line.len and wordByte(line[after])) continue; seen += 1; if (seen != want) continue; // SGR columns are 1-based const col = @as(i32, @intCast(at + 1)) + offset; if (col < 1 or col > @as(i32, h.cols)) return error.BadScript; return @intCast(col); } std.debug.print(" no \"{s}\" #{d} on row {d}: {s}\n", .{ word, want, row, std.mem.trimEnd(u8, line, " ") }); return error.WordNotOnRow; } fn rowCells(h: *eh.Harness, y: u16, buf: *[1024]u8) []const u8 { const n = @min(h.cols, buf.len); var x: u16 = 0; while (x < n) : (x += 1) { const ci = h.term.screens.active.pages.getCell(.{ .viewport = .{ .x = x, .y = y } }); buf[x] = blk: { const cell = (ci orelse break :blk ' ').cell; if (cell.content_tag != .codepoint and cell.content_tag != .codepoint_grapheme) break :blk ' '; const cp = cell.content.codepoint.data; break :blk if (cp == 0) ' ' else if (cp < 128) @intCast(cp) else 0xff; }; } return buf[0..n]; } fn wordByte(c: u8) bool { return std.ascii.isAlphanumeric(c) or c == '_'; } /// A capture, kept so the NEXT capture of the same kind can be emitted as the /// rows that changed instead of the whole screen again. 81.7% of re-captured /// rows used to be byte-identical to the previous capture in the same case, /// which is why one word added to a tagline rewrote 78 goldens: every frame /// re-stated every row of chrome. The delta keeps the assertion (a row that /// moves still shows up, and a capture whose only change is the cursor is /// exactly the empty delta its case means) and drops the restatement. const Prev = struct { snap: []const []const u8 = &.{}, style: []const []const u8 = &.{}, ninep: []const []const u8 = &.{}, // per kind: one shared width let a `snapstyle` between a `resize` and the // next `snap` re-arm the guard, and the post-resize frame then came out as // a delta against rows of the old width - dropping every row whose text is // width-invariant, which is every left-aligned chrome row there is. snap_cols: u16 = 0, style_cols: u16 = 0, ninep_cols: u16 = 0, }; const Screen9p = struct { cols: u16, rows: u16, cursor: ?struct { x: u16, y: u16, bar: bool }, cells: []const struct { []const u8, usize }, styles: []const struct { fg: Color, bg: Color, bold: bool, dim: bool, italic: bool, blink: bool, reverse: bool, invisible: bool, strikethrough: bool, ul: enum { off, single, double, curly, dotted, dashed }, font_role: enum { body, tagline }, }, const Color = union(enum) { default, index: u8, rgb: [3]u8, fn text(color: Color, buf: *[16]u8) []const u8 { return switch (color) { .default => "d", .index => |index| std.fmt.bufPrint(buf, "p{d}", .{index}) catch unreachable, .rgb => |rgb| std.fmt.bufPrint(buf, "#{x:0>2}{x:0>2}{x:0>2}", .{ rgb[0], rgb[1], rgb[2] }) catch unreachable, }; } }; }; fn snap9pText(arena: std.mem.Allocator, h: *eh.Harness, label: []const u8, prev: *Prev) ![]u8 { var files = process.of(gpa, h); defer files.deinit(); const bytes = try files.read("/screen"); const parsed = try std.json.parseFromSlice(Screen9p, gpa, bytes, .{}); defer parsed.deinit(); const screen = parsed.value; if (screen.cols != h.cols or screen.rows != h.rows or screen.cols == 0 or screen.rows == 0 or screen.cells.len != @as(usize, screen.cols) * screen.rows or screen.styles.len == 0) return error.Screen9pDimensions; if (screen.cursor) |cursor| { if (cursor.x >= screen.cols or cursor.y >= screen.rows) return error.Screen9pCursor; } for (screen.cells) |cell| { if (cell[1] >= screen.styles.len or !std.unicode.utf8ValidateSlice(cell[0])) return error.Screen9pCell; } const keys = try arena.alloc([]const u8, screen.styles.len); for (screen.styles, keys) |style, *key| { var flags: [8]u8 = undefined; var len: usize = 0; inline for (.{ "bold", "dim", "italic", "blink", "reverse", "invisible", "strikethrough" }, "bfikrvx") |field, flag| { if (@field(style, field)) { flags[len] = flag; len += 1; } } if (style.ul != .off) { flags[len] = switch (style.ul) { .off => unreachable, .single => 'u', .double => 'U', .curly => '~', .dotted => '.', .dashed => '-', }; len += 1; } var fg_buf: [16]u8 = undefined; var bg_buf: [16]u8 = undefined; key.* = try std.fmt.allocPrint(arena, "{s},{s},{s},{s}", .{ style.fg.text(&fg_buf), style.bg.text(&bg_buf), flags[0..len], @tagName(style.font_role), }); } var out: std.ArrayList(u8) = .empty; try out.appendSlice(arena, try std.fmt.allocPrint(arena, "== 9p {s} grid={d}x{d} cursor=", .{ label, screen.cols, screen.rows })); try out.appendSlice(arena, if (screen.cursor) |c| try std.fmt.allocPrint(arena, "{d},{d},{s}\n", .{ c.x, c.y, if (c.bar) "bar" else "block" }) else "none\n"); const rows = try arena.alloc([]const u8, screen.rows); const delta = prev.ninep.len == rows.len and prev.ninep_cols == screen.cols; for (rows, 0..) |*row, y| { var text_row: std.ArrayList(u8) = .empty; const cells = screen.cells[y * screen.cols ..][0..screen.cols]; for (cells) |cell| try text_row.appendSlice(arena, cell[0]); var capture: std.ArrayList(u8) = .empty; const trimmed = std.mem.trimEnd(u8, text_row.items, " "); try capture.appendSlice(arena, if (trimmed.len == 0) try std.fmt.allocPrint(arena, "|{d}:\n", .{y}) else try std.fmt.allocPrint(arena, "|{d}: {s}\n", .{ y, trimmed })); var annotated = false; for (cells, 0..) |cell, x| { if (cell[0].len == 1) continue; if (!annotated) try capture.appendSlice(arena, try std.fmt.allocPrint(arena, "+{d}:", .{y})); const glyph = try std.json.Stringify.valueAlloc(arena, cell[0], .{}); try capture.appendSlice(arena, try std.fmt.allocPrint(arena, " {d}={s}", .{ x, glyph })); annotated = true; } if (annotated) try capture.append(arena, '\n'); try capture.appendSlice(arena, try std.fmt.allocPrint(arena, "@{d}:", .{y})); var start: usize = 0; for (1..cells.len + 1) |x| { const key = keys[cells[start][1]]; if (x != cells.len and std.mem.eql(u8, key, keys[cells[x][1]])) continue; try capture.appendSlice(arena, try std.fmt.allocPrint(arena, " {d}-{d} {s}", .{ start, x - 1, key })); start = x; } try capture.append(arena, '\n'); row.* = capture.items; if (!delta or !std.mem.eql(u8, row.*, prev.ninep[y])) try out.appendSlice(arena, row.*); } prev.ninep = rows; prev.ninep_cols = screen.cols; return out.items; } /// `== snap