summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--build/snap.zig5
-rw-r--r--test/process/tty_boot.zig3
-rw-r--r--test/process/tty_editing.zig3
-rw-r--r--test/process/tty_images.zig3
-rw-r--r--test/process/tty_layout.zig3
-rw-r--r--test/process/tty_terminals.zig3
-rw-r--r--test/process/tty_themes.zig3
-rw-r--r--test/process_test.zig93
-rw-r--r--test/tty.zig1066
9 files changed, 1174 insertions, 8 deletions
diff --git a/build/snap.zig b/build/snap.zig
index 4f9b8f63..e7f4069c 100644
--- a/build/snap.zig
+++ b/build/snap.zig
@@ -65,10 +65,13 @@ pub fn addTty(b: *std.Build, opts: struct {
const run_process_test = b.addRunArtifact(process_test);
run_process_test.addArtifactArg(opts.exe);
for (opts.addons) |a| run_process_test.addPrefixedFileArg("--addon=", a.getEmittedBin());
+ run_process_test.addPrefixedFileArg("--lspmock=", lspmock.getEmittedBin());
run_process_test.addArg(if (opts.gui) "--backend=gui" else "--backend=tui");
run_process_test.addPassthruArgs();
+ // The tty cases' goldens are test/snapshots/'s, from the build root.
+ run_process_test.setCwd(b.path("."));
run_process_test.has_side_effects = true;
- b.step("process-test", "run the process tests: real sessions driven over their sockets (-- [filter])").dependOn(&run_process_test.step);
+ b.step("process-test", "run the process tests: real sessions over their sockets, the tty's in a pty each (-- [--update] [filter])").dependOn(&run_process_test.step);
// The window's own, run in full when asked (test/process/window.zig):
// the monkey over every Motion, and the frames against
// this machine's goldens (PARDES_GUI_GOLDEN=update rewrites them).
diff --git a/test/process/tty_boot.zig b/test/process/tty_boot.zig
new file mode 100644
index 00000000..79413cbf
--- /dev/null
+++ b/test/process/tty_boot.zig
@@ -0,0 +1,3 @@
+//! The tty frontend's own cases (test/tty.zig), starting: argv, the flags, the topbar's builtins, dumps and loads.
+
+pub const cases = .{};
diff --git a/test/process/tty_editing.zig b/test/process/tty_editing.zig
new file mode 100644
index 00000000..8d125aeb
--- /dev/null
+++ b/test/process/tty_editing.zig
@@ -0,0 +1,3 @@
+//! The tty frontend's own cases (test/tty.zig), editing: modes, selections, look, search, the language client, diffs.
+
+pub const cases = .{};
diff --git a/test/process/tty_images.zig b/test/process/tty_images.zig
new file mode 100644
index 00000000..9cd67a40
--- /dev/null
+++ b/test/process/tty_images.zig
@@ -0,0 +1,3 @@
+//! The tty frontend's own cases (test/tty.zig), image panes drawn in a terminal (petscii glyph art).
+
+pub const cases = .{};
diff --git a/test/process/tty_layout.zig b/test/process/tty_layout.zig
new file mode 100644
index 00000000..bd551013
--- /dev/null
+++ b/test/process/tty_layout.zig
@@ -0,0 +1,3 @@
+//! The tty frontend's own cases (test/tty.zig), columns, panes and tags: placement, grips, drags, collapse, the window ops.
+
+pub const cases = .{};
diff --git a/test/process/tty_terminals.zig b/test/process/tty_terminals.zig
new file mode 100644
index 00000000..3a3ad072
--- /dev/null
+++ b/test/process/tty_terminals.zig
@@ -0,0 +1,3 @@
+//! The tty frontend's own cases (test/tty.zig), terminal panes: tty mode, its keys and mouse, scrollback, commands.
+
+pub const cases = .{};
diff --git a/test/process/tty_themes.zig b/test/process/tty_themes.zig
new file mode 100644
index 00000000..fab132ae
--- /dev/null
+++ b/test/process/tty_themes.zig
@@ -0,0 +1,3 @@
+//! The tty frontend's own cases (test/tty.zig), colours: themes, syntax, markup, a pager's SGR, the cursor line.
+
+pub const cases = .{};
diff --git a/test/process_test.zig b/test/process_test.zig
index b1f64a45..bab80183 100644
--- a/test/process_test.zig
+++ b/test/process_test.zig
@@ -1,10 +1,14 @@
//! The process tests (T2 of docs/next-tests.md): each case starts a real
//! pardes through test/process.zig and drives it over its socket. A file
-//! in test/process/ a section of the book, as test/behaviour/'s are.
+//! in test/process/ a section of the book, as test/behaviour/'s are. The
+//! tty frontend's own (test/process/tty_*.zig) drive it through a pty of
+//! its own instead (test/tty.zig), on the tty alone.
//!
-//! pardes-process-test <pardes> [filter]
+//! pardes-process-test <pardes> [--backend=tui|gui] [--addon=<lib>]...
+//! [--lspmock=<exe>] [--update] [filter]
const std = @import("std");
const process = @import("process.zig");
+const tty = @import("tty.zig");
const files = .{
@import("process/builtins.zig"),
@@ -20,9 +24,22 @@ const files = .{
@import("process/window.zig"),
};
+/// Each case in a child of its own (Tty.init sets the child's environment
+/// and directory), a core's worth at once, as each has a directory of its
+/// own. One that fails runs again alone with the settle probe's wider bet
+/// before it counts: a loaded machine loses the narrow one (tty.beCareful).
+const tty_files = .{
+ @import("process/tty_boot.zig"),
+ @import("process/tty_editing.zig"),
+ @import("process/tty_layout.zig"),
+ @import("process/tty_themes.zig"),
+ @import("process/tty_images.zig"),
+ @import("process/tty_terminals.zig"),
+};
+
pub fn main(init: std.process.Init) !void {
- const all = try init.minimal.args.toSlice(init.arena.allocator());
- // <pardes> [--backend=tui|gui] [--addon=<lib>]... [filter]
+ const arena = init.arena.allocator();
+ const all = try init.minimal.args.toSlice(arena);
var args: [3][:0]const u8 = undefined;
var n: usize = 0;
for (all[1..]) |a| {
@@ -30,22 +47,28 @@ pub fn main(init: std.process.Init) !void {
process.backend = std.meta.stringToEnum(process.Backend, a["--backend=".len..]) orelse return error.Usage;
} else if (std.mem.startsWith(u8, a, "--addon=")) {
if (process.naddons == process.addons.len) return error.Usage;
- process.addons[process.naddons] = try std.Io.Dir.cwd().realPathFileAlloc(init.io, a["--addon=".len..], init.arena.allocator());
+ process.addons[process.naddons] = try std.Io.Dir.cwd().realPathFileAlloc(init.io, a["--addon=".len..], arena);
process.naddons += 1;
+ } else if (std.mem.startsWith(u8, a, "--lspmock=")) {
+ tty.lspmock = try std.Io.Dir.cwd().realPathFileAlloc(init.io, a["--lspmock=".len..], arena);
+ } else if (std.mem.eql(u8, a, "--update")) {
+ tty.update = true;
} else if (n < args.len) {
args[n] = a;
n += 1;
}
}
if (n < 1) return error.Usage;
- const exe = args[0];
+ // Absolute: a tty case runs in a directory of its own.
+ const exe = try std.Io.Dir.cwd().realPathFileAlloc(init.io, args[0], arena);
const filter: []const u8 = if (n > 1) args[1] else "";
+ tty.goldens = try std.Io.Dir.cwd().realPathFileAlloc(init.io, "test/snapshots", arena);
const gpa = std.heap.page_allocator;
const on = @tagName(process.backend);
var failed: usize = 0;
var skipped: usize = 0;
var ran: usize = 0;
- inline for (files) |file| inline for (file.cases) |case| {
+ if (!tty.update) inline for (files) |file| inline for (file.cases) |case| {
if (std.mem.indexOf(u8, case[0], filter) != null) {
ran += 1;
const t0 = process.nowMs();
@@ -61,6 +84,62 @@ pub fn main(init: std.process.Init) !void {
}
}
};
+ if (process.backend == .tui) {
+ // pid and case of each child running, and the cases that failed.
+ const jobs: usize = if (tty.update) 1 else @max(1, (std.Thread.getCpuCount() catch 4) * 5 / 4);
+ var running: std.ArrayList(struct { pid: std.c.pid_t, name: []const u8 }) = .empty;
+ var again: std.ArrayList([]const u8) = .empty;
+ inline for (tty_files) |file| inline for (file.cases) |case| {
+ if (std.mem.indexOf(u8, case[0], filter) != null) {
+ ran += 1;
+ while (running.items.len >= jobs) try reap(arena, &running, &again, &skipped);
+ const pid = std.c.fork();
+ if (pid == 0) std.process.exit(runTty(case, gpa, exe));
+ if (pid < 0) return error.ForkFailed;
+ try running.append(arena, .{ .pid = pid, .name = case[0] });
+ }
+ };
+ while (running.items.len > 0) try reap(arena, &running, &again, &skipped);
+ tty.beCareful();
+ for (again.items) |name| {
+ std.debug.print("again, alone: {s}\n", .{name});
+ inline for (tty_files) |file| inline for (file.cases) |case| {
+ if (std.mem.eql(u8, case[0], name)) {
+ const pid = std.c.fork();
+ if (pid == 0) std.process.exit(runTty(case, gpa, exe));
+ var status: c_int = 0;
+ _ = std.c.waitpid(pid, &status, 0);
+ if (status != 0) failed += 1;
+ }
+ };
+ }
+ }
std.debug.print("{d} of {d} process tests failed on {s} ({d} skipped)\n", .{ failed, ran, on, skipped });
if (failed > 0 or ran == 0) std.process.exit(1);
}
+
+/// One tty case, in the child: 0 passed, 1 failed, 2 skipped.
+fn runTty(case: anytype, gpa: std.mem.Allocator, exe: [:0]const u8) u8 {
+ const t0 = process.nowMs();
+ if (case[1](gpa, exe)) {
+ std.debug.print("{s} [tui] {d} ms {s}\n", .{ if (tty.update) "UPDATED" else "PASS", process.nowMs() - t0, case[0] });
+ return 0;
+ } else |err| {
+ if (err == error.SkipZigTest) return 2;
+ if (@errorReturnTrace()) |t| std.debug.dumpErrorReturnTrace(t);
+ std.debug.print("FAIL [tui] {d} ms {s}: {t}\n", .{ process.nowMs() - t0, case[0], err });
+ return 1;
+ }
+}
+
+fn reap(arena: std.mem.Allocator, running: anytype, again: *std.ArrayList([]const u8), skipped: *usize) !void {
+ var status: c_int = 0;
+ const pid = std.c.waitpid(-1, &status, 0);
+ for (running.items, 0..) |job, i| {
+ if (job.pid != pid) continue;
+ // A child killed (a crash in the runner itself) failed too.
+ if (status == 2 << 8) skipped.* += 1 else if (status != 0) try again.append(arena, job.name);
+ _ = running.swapRemove(i);
+ return;
+ }
+}
diff --git a/test/tty.zig b/test/tty.zig
new file mode 100644
index 00000000..d139cb6a
--- /dev/null
+++ b/test/tty.zig
@@ -0,0 +1,1066 @@
+//! 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/<name>.golden, which `zig build process-test -- --update
+//! <filter>` 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/<name>/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
+//! `|<row>`, the rest only the rows that changed, as `|<n>: <row>`. 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 = "";
+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/<name>: 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 (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 {
+ 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;
+ }
+
+ /// 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 <i><tail>` 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-<ch> and a-<ch>. After esc,
+ /// settle: vaxis reads the next byte in the same batch as alt-<ch>.
+ 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 + " <elided>\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, " <elided>\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/<pid>/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 <label> grid=CxR cursor=X,Y` then either the whole screen as
+/// `|<row text>` (first capture of a case, or after a resize) or just the
+/// rows that changed as `|<n>: <row text>`. An indexed row is a patch against
+/// the previous capture; an unindexed one is a frame.
+fn snapText(arena: std.mem.Allocator, h: *eh.Harness, label: []const u8, prev: *Prev) ![]u8 {
+ const text = try h.screenText();
+ defer h.gpa.free(text);
+ const c = h.cursor();
+ const rows = try arena.alloc([]const u8, h.rows);
+ var it = std.mem.splitScalar(u8, text, '\n');
+ for (rows) |*r| r.* = try arena.dupe(u8, std.mem.trimEnd(u8, it.next() orelse "", " "));
+
+ var out: std.ArrayList(u8) = .empty;
+ try out.appendSlice(arena, try std.fmt.allocPrint(arena, "== snap {s} grid={d}x{d} cursor={d},{d}\n", .{
+ label, h.cols, h.rows, c.x, c.y,
+ }));
+ if (prev.snap.len == rows.len and prev.snap_cols == h.cols) {
+ for (rows, prev.snap, 0..) |now, was, i| {
+ if (std.mem.eql(u8, now, was)) continue;
+ // no trailing space when a row goes blank: a whitespace-trimming
+ // editor or `git apply --whitespace=fix` would rewrite it and the
+ // golden would then fail like a regression
+ try out.appendSlice(arena, if (now.len == 0)
+ try std.fmt.allocPrint(arena, "|{d}:\n", .{i})
+ else
+ try std.fmt.allocPrint(arena, "|{d}: {s}\n", .{ i, now }));
+ }
+ } else {
+ // A full frame stops at the last row with anything on it: the blank
+ // tail of the grid is the same information as the `grid=CxR` header.
+ var end = rows.len;
+ while (end > 0 and rows[end - 1].len == 0) end -= 1;
+ for (rows[0..end]) |r| {
+ try out.appendSlice(arena, "|");
+ try out.appendSlice(arena, r);
+ try out.appendSlice(arena, "\n");
+ }
+ }
+ prev.snap = rows;
+ prev.snap_cols = h.cols;
+ return out.items;
+}
+
+/// Per-row style runs from the harness emulator: `|y: x0-x1 fg,bg,attrs ...`.
+/// fg/bg: d (default) | pN (palette) | #rrggbb. attrs: b f i k r v x + u U ~ . -
+/// for underline single/double/curly/dotted/dashed. Deltas the same way
+/// `snapText` does - the row already carries its own index, so a patch and a
+/// frame are spelled identically here. The header carries the grid because a
+/// style capture has no cursor: without it an unchanged style would be a label
+/// line asserting nothing at all.
+fn snapStyle(arena: std.mem.Allocator, h: *eh.Harness, label: []const u8, prev: *Prev) ![]u8 {
+ const rows = try styleRows(arena, h);
+ var out: std.ArrayList(u8) = .empty;
+ try out.appendSlice(arena, try std.fmt.allocPrint(arena, "== style {s} grid={d}x{d}\n", .{ label, h.cols, h.rows }));
+ const delta = prev.style.len == rows.len and prev.style_cols == h.cols;
+ for (rows, 0..) |now, i| {
+ if (delta and std.mem.eql(u8, now, prev.style[i])) continue;
+ try out.appendSlice(arena, "|");
+ try out.appendSlice(arena, now);
+ try out.appendSlice(arena, "\n");
+ }
+ prev.style = rows;
+ prev.style_cols = h.cols;
+ return out.items;
+}
+
+fn styleRows(arena: std.mem.Allocator, h: *eh.Harness) ![]const []const u8 {
+ const out = try arena.alloc([]const u8, h.rows);
+ for (out, 0..) |*dst, y_usize| {
+ const y: u16 = @intCast(y_usize);
+ var row: std.ArrayList(u8) = .empty;
+ try row.appendSlice(arena, try std.fmt.allocPrint(arena, "{d}:", .{y}));
+ var key_buf: [64]u8 = undefined;
+ var run_key: [64]u8 = undefined;
+ var run_len: usize = 0;
+ var run_start: u16 = 0;
+ // A blank's ink shows nowhere, and the tty leaves whatever ink the
+ // terminal had there (tui.zig blankInk), so it depends on the frames
+ // before: a blank is written with the ink of the cell before it.
+ var ink_buf: [16]u8 = undefined;
+ var ink: []const u8 = "d";
+ var x: u16 = 0;
+ while (x <= h.cols) : (x += 1) {
+ var key: []const u8 = if (x == h.cols) "\x00end" else cellKey(h, x, y, &key_buf);
+ if (x < h.cols) {
+ const comma = std.mem.indexOfScalar(u8, key, ',') orelse key.len;
+ if (inklessBlank(h, x, y)) {
+ var joined: [64]u8 = undefined;
+ const rest = key[comma..];
+ @memcpy(joined[0..ink.len], ink);
+ @memcpy(joined[ink.len..][0..rest.len], rest);
+ @memcpy(key_buf[0 .. ink.len + rest.len], joined[0 .. ink.len + rest.len]);
+ key = key_buf[0 .. ink.len + rest.len];
+ } else {
+ @memcpy(ink_buf[0..comma], key[0..comma]);
+ ink = ink_buf[0..comma];
+ }
+ }
+ if (x == 0) {
+ @memcpy(run_key[0..key.len], key);
+ run_len = key.len;
+ continue;
+ }
+ if (std.mem.eql(u8, key, run_key[0..run_len])) continue;
+ try row.appendSlice(arena, try std.fmt.allocPrint(arena, " {d}-{d} ", .{ run_start, x - 1 }));
+ try row.appendSlice(arena, run_key[0..run_len]);
+ @memcpy(run_key[0..key.len], key);
+ run_len = key.len;
+ run_start = x;
+ }
+ dst.* = row.items;
+ }
+ return out;
+}
+
+/// A cell whose ink shows nowhere: no text but a space, and no underline,
+/// strike or reverse to draw with it.
+fn inklessBlank(h: *eh.Harness, x: u16, y: u16) bool {
+ const ci = h.term.screens.active.pages.getCell(.{ .viewport = .{ .x = x, .y = y } }) orelse return false;
+ if (ci.cell.wide == .spacer_tail) return false;
+ if (ci.cell.hasText() and ci.cell.codepoint() != ' ') return false;
+ const flags = ci.style().flags;
+ return !flags.inverse and !flags.strikethrough and flags.underline == .none;
+}
+
+fn cellKey(h: *eh.Harness, x: u16, y: u16, buf: *[64]u8) []const u8 {
+ const ci = h.term.screens.active.pages.getCell(.{ .viewport = .{ .x = x, .y = y } }) orelse return "d,d,";
+ if (ci.cell.wide == .spacer_tail) return "d,d,";
+ const style = ci.style();
+ var n: usize = 0;
+ var tmp: [16]u8 = undefined;
+ const fg = colorStr(style.fg_color, &tmp);
+ @memcpy(buf[n..][0..fg.len], fg);
+ n += fg.len;
+ buf[n] = ',';
+ n += 1;
+ var tmp2: [16]u8 = undefined;
+ const bg: []const u8 = switch (ci.cell.content_tag) {
+ .bg_color_palette => std.fmt.bufPrint(&tmp2, "p{d}", .{ci.cell.content.color_palette.data}) catch "?",
+ .bg_color_rgb => blk: {
+ const rgb = ci.cell.content.color_rgb;
+ break :blk std.fmt.bufPrint(&tmp2, "#{x:0>2}{x:0>2}{x:0>2}", .{ rgb.r, rgb.g, rgb.b }) catch "?";
+ },
+ else => colorStr(style.bg_color, &tmp2),
+ };
+ @memcpy(buf[n..][0..bg.len], bg);
+ n += bg.len;
+ buf[n] = ',';
+ n += 1;
+ if (style.flags.bold) {
+ buf[n] = 'b';
+ n += 1;
+ }
+ if (style.flags.faint) {
+ buf[n] = 'f';
+ n += 1;
+ }
+ if (style.flags.italic) {
+ buf[n] = 'i';
+ n += 1;
+ }
+ if (style.flags.blink) {
+ buf[n] = 'k';
+ n += 1;
+ }
+ if (style.flags.inverse) {
+ buf[n] = 'r';
+ n += 1;
+ }
+ if (style.flags.invisible) {
+ buf[n] = 'v';
+ n += 1;
+ }
+ if (style.flags.strikethrough) {
+ buf[n] = 'x';
+ n += 1;
+ }
+ const ul: []const u8 = switch (style.flags.underline) {
+ .none => "",
+ .single => "u",
+ .double => "U",
+ .curly => "~",
+ .dotted => ".",
+ .dashed => "-",
+ };
+ @memcpy(buf[n..][0..ul.len], ul);
+ n += ul.len;
+ return buf[0..n];
+}
+
+fn colorStr(color: ghostty_vt.Style.Color, buf: *[16]u8) []const u8 {
+ return switch (color) {
+ .none => "d",
+ .palette => |idx| std.fmt.bufPrint(buf, "p{d}", .{idx}) catch "?",
+ .rgb => |rgb| std.fmt.bufPrint(buf, "#{x:0>2}{x:0>2}{x:0>2}", .{ rgb.r, rgb.g, rgb.b }) catch "?",
+ };
+}
+
+fn keyBytes(name: []const u8) ?[]const u8 {
+ const map = .{
+ .{ "enter", "\r" }, .{ "esc", "\x1b" }, .{ "tab", "\t" },
+ .{ "bs", "\x7f" }, .{ "space", " " }, .{ "up", "\x1b[A" },
+ .{ "down", "\x1b[B" }, .{ "right", "\x1b[C" }, .{ "left", "\x1b[D" },
+ .{ "home", "\x1b[H" }, .{ "end", "\x1b[F" }, .{ "pgup", "\x1b[5~" },
+ .{ "pgdn", "\x1b[6~" },
+ };
+ inline for (map) |e| if (std.mem.eql(u8, name, e[0])) return e[1];
+ const S = struct {
+ var buf: [2]u8 = undefined;
+ };
+ if (name.len == 1) {
+ S.buf[0] = name[0];
+ return S.buf[0..1];
+ }
+ if (name.len == 3 and name[1] == '-') {
+ if (name[0] == 'c' and name[2] >= 'a' and name[2] <= 'z') {
+ S.buf[0] = name[2] - 'a' + 1;
+ return S.buf[0..1];
+ }
+ if (name[0] == 'a') {
+ S.buf = .{ 0x1b, name[2] };
+ return S.buf[0..2];
+ }
+ }
+ return null;
+}
+
+/// SGR button code, with an optional `ctrl-` prefix folded in as bit 4 —
+/// which is exactly how a terminal encodes a modified click, and how vaxis
+/// decodes one (Parser.zig mouse_bits.ctrl = 0b00010000).
+fn buttonCode(name: []const u8) ?u16 {
+ if (std.mem.startsWith(u8, name, "ctrl-")) {
+ const base = buttonCode(name["ctrl-".len..]) orelse return null;
+ return base + 16;
+ }
+ // Shift: over a program that tracks the mouse, pardes's own gesture.
+ if (std.mem.startsWith(u8, name, "shift-")) {
+ const base = buttonCode(name["shift-".len..]) orelse return null;
+ return base + 4;
+ }
+ if (std.mem.eql(u8, name, "left")) return 0;
+ if (std.mem.eql(u8, name, "middle")) return 1;
+ if (std.mem.eql(u8, name, "right")) return 2;
+ return null;
+}
+
+fn readFileAlloc(arena: std.mem.Allocator, path: []const u8) ![]u8 {
+ const path_z = try arena.dupeSentinel(u8, path, 0);
+ const fd = libc.open(path_z, .{ .ACCMODE = .RDONLY });
+ if (fd < 0) return error.OpenFailed;
+ defer _ = libc.close(fd);
+ const end = libc.lseek(fd, 0, libc.SEEK.END);
+ if (end < 0 or libc.lseek(fd, 0, libc.SEEK.SET) < 0) return error.ReadFailed;
+ const buf = try arena.alloc(u8, @intCast(end));
+ var pos: usize = 0;
+ while (pos < buf.len) {
+ const n = libc.read(fd, buf[pos..].ptr, buf.len - pos);
+ if (n < 0) {
+ if (libc.errno(n) == .INTR) continue;
+ return error.ReadFailed;
+ }
+ if (n == 0) return error.ReadFailed;
+ pos += @intCast(n);
+ }
+ var extra: [1]u8 = undefined;
+ while (true) {
+ const n = libc.read(fd, &extra, extra.len);
+ if (n < 0 and libc.errno(n) == .INTR) continue;
+ if (n != 0) return error.ReadFailed;
+ break;
+ }
+ return buf;
+}
+
+fn mkdir(arena: std.mem.Allocator, path: []const u8, exist_ok: bool) !void {
+ const path_z = try arena.dupeSentinel(u8, path, 0);
+ const rc = libc.mkdir(path_z, 0o755);
+ if (rc != 0) {
+ if (exist_ok and libc.errno(rc) == .EXIST) return;
+ return error.MkdirFailed;
+ }
+}
+
+fn rmrf(path: []const u8) void {
+ var path_buf: [4096:0]u8 = undefined;
+ if (path.len >= path_buf.len) return;
+ @memcpy(path_buf[0..path.len], path);
+ path_buf[path.len] = 0;
+ const pid = libc.fork();
+ if (pid == 0) {
+ const argv: [4:null]?[*:0]const u8 = .{ "rm", "-rf", @as([*:0]const u8, @ptrCast(&path_buf)), null };
+ _ = execvp("rm", &argv);
+ libc._exit(127);
+ }
+ if (pid < 0) return;
+ var status: c_int = 0;
+ _ = libc.waitpid(pid, &status, 0);
+}
+
+fn printFirstDiff(golden: []const u8, actual: []const u8) void {
+ var gi = std.mem.splitScalar(u8, golden, '\n');
+ var ai = std.mem.splitScalar(u8, actual, '\n');
+ var n: usize = 1;
+ while (true) : (n += 1) {
+ const g = gi.next();
+ const a = ai.next();
+ if (g == null and a == null) return;
+ if (g != null and a != null and std.mem.eql(u8, g.?, a.?)) continue;
+ std.debug.print(" first diff at golden line {d}:\n -{s}\n +{s}\n", .{ n, g orelse "<eof>", a orelse "<eof>" });
+ return;
+ }
+}