diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-08 23:49:04 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-09 01:28:28 -0300 |
| commit | 174e031985db910b4907ba324d6fd12c67898a5a (patch) | |
| tree | 5bcb0dbc1dbab457fcf4a4b95572a1631bb3ade1 | |
| parent | 21277ffc6b08f458eb9a1210a3818e40b14293d2 (diff) | |
| download | pardes-174e031985db910b4907ba324d6fd12c67898a5a.tar.gz pardes-174e031985db910b4907ba324d6fd12c67898a5a.zip | |
tests: monkey and replay are modes of the T1 runner and snapshot.zig goes: behaviour-test runs test/monkey9p.zig bare (its smoke), `-- --monkey <seeds>` drives an in-process session with test/monkey.zig's input (keys, leader bursts, the mouse, tiny resizes, over /kbdin, /mousein and Session.resize) hunting panics and hangs, `-- --replay` records each seed's sessions as a tape in memory and replays it (tape.replayBytes, replayMain's loop: three replicas and the dump), and `process-test -- --replay` records and replays the tty cases' real sessions as `zig build replay` did (with the addons it lacked, so images passes); the snap, snap-driver-test, monkey, monkey-test (it no longer compiled), replay and monkey-session steps, pardes-snap and build/snap.zig (now build/process.zig) go; checked: a counter outside the core bumped at the 40th update diverges every T1 seed and 89 of 103 old tapes, one bumped on terminal output diverges no T1 seed but 69 tty cases and 70 old tapes (why the tty replay stays), a panic on a window under 5x5 is found by the T1 monkey (seeds 1 8 17 20) and the old one (seed 13)
Co-Authored-By: Claude Fable 5.1 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
| -rw-r--r-- | .gitignore | 6 | ||||
| -rw-r--r-- | build.zig | 46 | ||||
| -rw-r--r-- | build/process.zig | 87 | ||||
| -rw-r--r-- | build/snap.zig | 168 | ||||
| -rw-r--r-- | src/tape.zig | 39 | ||||
| -rw-r--r-- | test/monkey.zig | 254 | ||||
| -rw-r--r-- | test/monkey9p.zig | 162 | ||||
| -rw-r--r-- | test/process_test.zig | 10 | ||||
| -rw-r--r-- | test/session.zig | 31 | ||||
| -rw-r--r-- | test/snapshot.zig | 1753 | ||||
| -rw-r--r-- | test/tty.zig | 45 |
11 files changed, 363 insertions, 2238 deletions
@@ -3,9 +3,9 @@ zig-out* .zig-cache/ .zig-cache/* test/__pycache__/ -# a failing snapshot writes <stem>.actual beside its golden; it is the failure -# report, not a source of truth, and eleven had been committed by accident -test/snapshots/*.actual +# a failing macOS snapshot writes <stem>.actual beside its golden; it is the +# failure report, not a source of truth, and eleven had been committed by +# accident (a tty case writes what it drew under /tmp/pardes-snap instead) test/macos-snapshots/*.actual # a REAL rust-analyzer pointed at the client fixture (which its Cargo.toml # invites) runs cargo there, and cargo writes a target/ and a lock beside the @@ -1,7 +1,7 @@ const std = @import("std"); const builtin = @import("builtin"); const mupdf_build = @import("mupdf.zig"); -const snap_build = @import("build/snap.zig"); +const process_build = @import("build/process.zig"); const grammar_manifest = @import("src/grammar_manifest.zig"); /// The package manifest, imported UNTYPED on purpose — see the `version` /// option in `shellOptions` for why that word is load-bearing. @@ -760,13 +760,13 @@ pub fn build(b: *std.Build) void { vaxis_mod.root_source_file = files.getDirectory().path(b, "main.zig"); } - var ghostty_vt_for_snap: ?*std.Build.Module = null; + var ghostty_vt_for_tests: ?*std.Build.Module = null; const ghostty_simd = !target.result.os.tag.isDarwin() or b.graph.host.result.os.tag.isDarwin(); const ghostty_optimize: std.lang.Optimize = if (optimize == .debug) .safe else optimize; const ghostty_dep = b.lazyDependency("ghostty", .{ .target = target, .optimize = ghostty_optimize, .simd = ghostty_simd, .@"app-runtime" = .none, .@"emit-xcframework" = false }); if (ghostty_dep) |dep| { const ghostty_vt = dep.module("ghostty-vt"); - ghostty_vt_for_snap = ghostty_vt; + ghostty_vt_for_tests = ghostty_vt; ghostty_vt.addImport("uucode", uucode_mod); patchGhosttyKitty(b, io, dep, ghostty_vt); ghostty_core_vt = ghostty_vt; @@ -1221,12 +1221,12 @@ pub fn build(b: *std.Build) void { } const addons: []const *std.Build.Step.Compile = if (pdf_addon) |l| b.allocator.dupe(*std.Build.Step.Compile, &.{ image_addon, l }) catch @panic("OOM") else &.{image_addon}; - snap_build.addTty(b, .{ + process_build.add(b, .{ .exe = exe, .addons = addons, .target = target, .optimize = optimize, - .ghostty_vt = ghostty_vt_for_snap, + .ghostty_vt = ghostty_vt_for_tests, .cloud9 = cloud9, .gui = platform == .gui, }); @@ -1240,7 +1240,7 @@ pub fn build(b: *std.Build) void { .link_libc = true, }), }); - if (ghostty_vt_for_snap) |vt| image_harness.root_module.addImport("ghostty-vt", vt); + if (ghostty_vt_for_tests) |vt| image_harness.root_module.addImport("ghostty-vt", vt); switch (target.result.os.tag) { .freebsd, .netbsd, .openbsd => image_harness.root_module.linkSystemLibrary("util", .{}), else => {}, @@ -1274,7 +1274,7 @@ pub fn build(b: *std.Build) void { .link_libc = true, }), }); - if (ghostty_vt_for_snap) |vt| kitty_harness.root_module.addImport("ghostty-vt", vt); + if (ghostty_vt_for_tests) |vt| kitty_harness.root_module.addImport("ghostty-vt", vt); switch (target.result.os.tag) { .freebsd, .netbsd, .openbsd => kitty_harness.root_module.linkSystemLibrary("util", .{}), else => {}, @@ -1428,7 +1428,7 @@ pub fn build(b: *std.Build) void { }); perf.root_module.addImport("pardes", core_module); // --live drives the real binary through a pty (test/e2e_harness.zig). - if (ghostty_vt_for_snap) |vt| perf.root_module.addImport("ghostty-vt", vt); + if (ghostty_vt_for_tests) |vt| perf.root_module.addImport("ghostty-vt", vt); perf.root_module.addOptions("perf_options", perf_options); const run_perf = b.addRunArtifact(perf); run_perf.has_side_effects = true; @@ -1588,7 +1588,7 @@ pub fn build(b: *std.Build) void { }); session_module.addImport("pardes", core_module); // The scripted language server its language words ask - // (Session.initLanguage), as the snapshot scripts' do. + // (Session.initLanguage), as the tty cases do. const session_options = b.addOptions(); session_options.addOptionPath("lspmock", b.addExecutable(.{ .name = "pardes-lspmock", @@ -1632,7 +1632,7 @@ pub fn build(b: *std.Build) void { // window's word knows which build it runs in. behaviour_module.addImport("pardes_config", core_module.import_table.get("pardes_config").?); const behaviour_tests = b.addTest(.{ .root_module = behaviour_module, .filters = test_filters }); - const behaviour_test_step = b.step("behaviour-test", "run the behavioural tests, through the 9P tree alone (test/behaviour/)"); + const behaviour_test_step = b.step("behaviour-test", "run the behavioural tests, through the 9P tree alone (test/behaviour/), and the T1 runner (-- [--seed N]... | --monkey <seeds> | --replay)"); _ = units.add(b, behaviour_tests, behaviour_test_step); // An addon's own test: `--addon-test` over the fake (the template) // and the snake (a shipped example, built but not installed), each @@ -1659,10 +1659,12 @@ pub fn build(b: *std.Build) void { addon_test_step.dependOn(&compare.step); if (lib == pdf_addon) mupdf_check.dependOn(&compare.step); }; - // The 9P monkey at T1 (test/monkey9p.zig): random requests against - // an in-process session, the documented rules checked after each. - // Its fixed-seed smoke run is part of behaviour-test. - const monkey_session = b.addExecutable(.{ + // The T1 runner (test/monkey9p.zig): its modes over an in-process + // session, random 9P requests with the documented rules checked + // after each, random input hunting panics (`-- --monkey <seeds>`), + // and its seeds' tapes replayed (`-- --replay`). Bare, a short + // fixed-seed run of the first, part of behaviour-test. + const t1_runner = b.addExecutable(.{ .name = "pardes-monkey-session", .root_module = b.createModule(.{ .target = target, @@ -1671,17 +1673,11 @@ pub fn build(b: *std.Build) void { .link_libc = true, }), }); - monkey_session.root_module.addImport("session", session_module); - const run_monkey_session = b.addRunArtifact(monkey_session); - run_monkey_session.addPassthruArgs(); - run_monkey_session.has_side_effects = true; - b.step("monkey-session", "random 9P requests against an in-process session, checking the documented rules (-- [--seed N]... [--steps M] [--only i,j,k] [--no-shrink] [-v])").dependOn(&run_monkey_session.step); - const run_monkey_session_smoke = b.addRunArtifact(monkey_session); - run_monkey_session_smoke.addArg("--smoke"); - run_monkey_session_smoke.has_side_effects = true; - const monkey_session_smoke_step = b.step("monkey-session-smoke", "a short fixed-seed run of monkey-session (part of behaviour-test)"); - monkey_session_smoke_step.dependOn(&run_monkey_session_smoke.step); - if (test_filters.len == 0) behaviour_test_step.dependOn(&run_monkey_session_smoke.step); + t1_runner.root_module.addImport("session", session_module); + const run_t1_runner = b.addRunArtifact(t1_runner); + run_t1_runner.addPassthruArgs(); + run_t1_runner.has_side_effects = true; + if (test_filters.len == 0) behaviour_test_step.dependOn(&run_t1_runner.step); // Kitty graphics conformance at the core: what a terminal pane's // program sends, what it reads back, what ghostty stores and what a diff --git a/build/process.zig b/build/process.zig new file mode 100644 index 00000000..bec37d65 --- /dev/null +++ b/build/process.zig @@ -0,0 +1,87 @@ +const std = @import("std"); + +/// The process tests (test/process_test.zig): real sessions over their +/// sockets, and the tty's own cases each in a pty of its own +/// (test/tty.zig), on the runner they share (test/process.zig); and the +/// window's own, run in full when asked. +pub fn add(b: *std.Build, opts: struct { + exe: *std.Build.Step.Compile, + /// The addons the build made (image, pdf), which every session loads: + /// each `--addon=<lib>`, linked into its data directory's addons. + addons: []const *std.Build.Step.Compile, + target: std.Build.ResolvedTarget, + optimize: std.builtin.OptimizeMode, + ghostty_vt: ?*std.Build.Module, + cloud9: *std.Build.Module, + /// The build is the window's (-Dplatform=gui): the process tests drive it. + gui: bool = false, +}) void { + const ninep_client = b.createModule(.{ + .target = opts.target, + .optimize = opts.optimize, + .root_source_file = b.path("src/9p_io.zig"), + .link_libc = true, + }); + ninep_client.addImport("cloud9", opts.cloud9); + // The language server a tty case's `.rs` files speak to. + const lspmock = b.addExecutable(.{ + .name = "pardes-lspmock", + .root_module = b.createModule(.{ + .target = opts.target, + .optimize = opts.optimize, + .root_source_file = b.path("test/lspmock.zig"), + .link_libc = true, + }), + }); + const process_test = b.addExecutable(.{ + .name = "pardes-process-test", + .root_module = b.createModule(.{ + .target = opts.target, + .optimize = opts.optimize, + .root_source_file = b.path("test/process_test.zig"), + .link_libc = true, + }), + }); + if (opts.ghostty_vt) |vt| process_test.root_module.addImport("ghostty-vt", vt); + process_test.root_module.addImport("9p_io", ninep_client); + process_test.root_module.addImport("cloud9", opts.cloud9); + switch (opts.target.result.os.tag) { + .freebsd, .netbsd, .openbsd => process_test.root_module.linkSystemLibrary("util", .{}), + else => {}, + } + 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 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). + const monkey_gui_step = b.step("monkey-gui", "random input to the hidden window across the effect settings (-Dplatform=gui; PARDES_GUI_MONKEY_SEED, _STEPS)"); + const gui_golden_step = b.step("gui-golden", "the hidden window's scenes against test/gui-goldens.txt, this machine's (-Dplatform=gui; PARDES_GUI_GOLDEN=update rewrites)"); + if (opts.gui) { + const run_monkey_gui = b.addRunArtifact(process_test); + run_monkey_gui.addArtifactArg(opts.exe); + for (opts.addons) |a| run_monkey_gui.addPrefixedFileArg("--addon=", a.getEmittedBin()); + run_monkey_gui.addArgs(&.{ "--backend=gui", "window: a monkey" }); + run_monkey_gui.setEnvironmentVariable("PARDES_GUI_MONKEY", "all"); + run_monkey_gui.has_side_effects = true; + monkey_gui_step.dependOn(&run_monkey_gui.step); + const run_gui_golden = b.addRunArtifact(process_test); + run_gui_golden.addArtifactArg(opts.exe); + for (opts.addons) |a| run_gui_golden.addPrefixedFileArg("--addon=", a.getEmittedBin()); + run_gui_golden.addArgs(&.{ "--backend=gui", "window: its scenes" }); + run_gui_golden.setEnvironmentVariable("PARDES_GUI_GOLDEN", b.graph.environ_map.get("PARDES_GUI_GOLDEN") orelse "check"); + run_gui_golden.setCwd(b.path(".")); + run_gui_golden.has_side_effects = true; + gui_golden_step.dependOn(&run_gui_golden.step); + } else { + monkey_gui_step.dependOn(&b.addFail("monkey-gui needs -Dplatform=gui").step); + gui_golden_step.dependOn(&b.addFail("gui-golden needs -Dplatform=gui").step); + } +} diff --git a/build/snap.zig b/build/snap.zig deleted file mode 100644 index e7f4069c..00000000 --- a/build/snap.zig +++ /dev/null @@ -1,168 +0,0 @@ -const std = @import("std"); - -pub fn addTty(b: *std.Build, opts: struct { - exe: *std.Build.Step.Compile, - /// The addons the build made (image, pdf), which every session loads: - /// each `--addon=<lib>`, linked into its data directory's addons. - addons: []const *std.Build.Step.Compile, - target: std.Build.ResolvedTarget, - optimize: std.builtin.OptimizeMode, - ghostty_vt: ?*std.Build.Module, - cloud9: *std.Build.Module, - /// The build is the window's (-Dplatform=gui): the process tests drive it. - gui: bool = false, -}) void { - const snap = b.addExecutable(.{ - .name = "pardes-snap", - .root_module = b.createModule(.{ - .target = opts.target, - .optimize = opts.optimize, - .root_source_file = b.path("test/snapshot.zig"), - .link_libc = true, - }), - }); - if (opts.ghostty_vt) |vt| snap.root_module.addImport("ghostty-vt", vt); - const ninep_client = b.createModule(.{ - .target = opts.target, - .optimize = opts.optimize, - .root_source_file = b.path("src/9p_io.zig"), - .link_libc = true, - }); - ninep_client.addImport("cloud9", opts.cloud9); - snap.root_module.addImport("9p_io", ninep_client); - snap.root_module.addImport("cloud9", opts.cloud9); - switch (opts.target.result.os.tag) { - .freebsd, .netbsd, .openbsd => snap.root_module.linkSystemLibrary("util", .{}), - else => {}, - } - const lspmock = b.addExecutable(.{ - .name = "pardes-lspmock", - .root_module = b.createModule(.{ - .target = opts.target, - .optimize = opts.optimize, - .root_source_file = b.path("test/lspmock.zig"), - .link_libc = true, - }), - }); - // The process tests (test/process_test.zig): real sessions over their - // sockets, on the runner the snap scripts share (test/process.zig). - const process_test = b.addExecutable(.{ - .name = "pardes-process-test", - .root_module = b.createModule(.{ - .target = opts.target, - .optimize = opts.optimize, - .root_source_file = b.path("test/process_test.zig"), - .link_libc = true, - }), - }); - if (opts.ghostty_vt) |vt| process_test.root_module.addImport("ghostty-vt", vt); - process_test.root_module.addImport("9p_io", ninep_client); - process_test.root_module.addImport("cloud9", opts.cloud9); - switch (opts.target.result.os.tag) { - .freebsd, .netbsd, .openbsd => process_test.root_module.linkSystemLibrary("util", .{}), - else => {}, - } - 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 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). - const monkey_gui_step = b.step("monkey-gui", "random input to the hidden window across the effect settings (-Dplatform=gui; PARDES_GUI_MONKEY_SEED, _STEPS)"); - const gui_golden_step = b.step("gui-golden", "the hidden window's scenes against test/gui-goldens.txt, this machine's (-Dplatform=gui; PARDES_GUI_GOLDEN=update rewrites)"); - if (opts.gui) { - const run_monkey_gui = b.addRunArtifact(process_test); - run_monkey_gui.addArtifactArg(opts.exe); - for (opts.addons) |a| run_monkey_gui.addPrefixedFileArg("--addon=", a.getEmittedBin()); - run_monkey_gui.addArgs(&.{ "--backend=gui", "window: a monkey" }); - run_monkey_gui.setEnvironmentVariable("PARDES_GUI_MONKEY", "all"); - run_monkey_gui.has_side_effects = true; - monkey_gui_step.dependOn(&run_monkey_gui.step); - const run_gui_golden = b.addRunArtifact(process_test); - run_gui_golden.addArtifactArg(opts.exe); - for (opts.addons) |a| run_gui_golden.addPrefixedFileArg("--addon=", a.getEmittedBin()); - run_gui_golden.addArgs(&.{ "--backend=gui", "window: its scenes" }); - run_gui_golden.setEnvironmentVariable("PARDES_GUI_GOLDEN", b.graph.environ_map.get("PARDES_GUI_GOLDEN") orelse "check"); - run_gui_golden.setCwd(b.path(".")); - run_gui_golden.has_side_effects = true; - gui_golden_step.dependOn(&run_gui_golden.step); - } else { - monkey_gui_step.dependOn(&b.addFail("monkey-gui needs -Dplatform=gui").step); - gui_golden_step.dependOn(&b.addFail("gui-golden needs -Dplatform=gui").step); - } - const run_snap = b.addRunArtifact(snap); - run_snap.addArtifactArg(opts.exe); - run_snap.addPrefixedFileArg("--lspmock=", lspmock.getEmittedBin()); - for (opts.addons) |a| run_snap.addPrefixedFileArg("--addon=", a.getEmittedBin()); - run_snap.addPassthruArgs(); - // scripts fork children and drive real ptys: never cached, never "up to date" - run_snap.has_side_effects = true; - const snap_step = b.step("snap", "run the snapshot parity suite (-- --update regenerates goldens)"); - snap_step.dependOn(&run_snap.step); - // Random scripts through pardes-snap, hunting panics (test/monkey.zig): - // not a gate, it is slow and random over seeds; a seed replays. - const monkey = b.addExecutable(.{ - .name = "pardes-monkey", - .root_module = b.createModule(.{ - .target = opts.target, - .optimize = opts.optimize, - .root_source_file = b.path("test/monkey.zig"), - .link_libc = true, - }), - }); - const run_monkey = b.addRunArtifact(monkey); - run_monkey.addArtifactArg(snap); - run_monkey.addArtifactArg(opts.exe); - run_monkey.addPassthruArgs(); - run_monkey.has_side_effects = true; - b.step("monkey", "random snapshot scripts hunting panics (-- <seeds> [steps] [--from=N] [--out=DIR])").dependOn(&run_monkey.step); - // The replay-divergence gate (src/tape.zig, docs/next-daemon.md): every - // snapshot script and `replay-seeds` monkey seeds with each session's - // tape recorded, each replayed into two replicas at different - // addresses and one that never draws, every digest checked; and at each - // session's end its dump loaded, which must be that session, digest for - // digest, and dump again to the same bytes (phase 2). - const tapes = ".zig-cache/tapes"; - const run_replay = b.addRunArtifact(snap); - run_replay.addArtifactArg(opts.exe); - run_replay.addPrefixedFileArg("--lspmock=", lspmock.getEmittedBin()); - run_replay.addArgs(&.{ "--tape=" ++ tapes, "--dump" }); - // Each script's tape replayed by another build too: a window's build - // replaying a terminal's sessions, as its replica of one does. - if (b.option([]const u8, "replay-with", "another build of pardes `zig build replay` replays every script's tape with too (a pardes-gui, say)")) |other| - run_replay.addArg(b.fmt("--replay-with={s}", .{other})); - run_replay.setCwd(b.path(".")); - run_replay.has_side_effects = true; - const seeds = b.option(u32, "replay-seeds", "monkey seeds `zig build replay` records and replays (default 20)") orelse 20; - const run_monkey_replay = b.addRunArtifact(monkey); - run_monkey_replay.addArtifactArg(snap); - run_monkey_replay.addArtifactArg(opts.exe); - run_monkey_replay.addArgs(&.{ b.fmt("{d}", .{seeds}), "70", "--tape=" ++ tapes ++ "/monkey", "--dump", "--out=" ++ tapes ++ "/monkey" }); - run_monkey_replay.setCwd(b.path(".")); - run_monkey_replay.has_side_effects = true; - // One pardes-snap run at a time (its lock): the scripts, then the seeds. - run_monkey_replay.step.dependOn(&run_replay.step); - // The same seeds with three terminals on the session, each a view of - // it, typed into in turn (views.zig). - const run_views_replay = b.addRunArtifact(monkey); - run_views_replay.addArtifactArg(snap); - run_views_replay.addArtifactArg(opts.exe); - run_views_replay.addArgs(&.{ b.fmt("{d}", .{seeds}), "70", "--views=3", "--tape=" ++ tapes ++ "/monkey-views", "--dump", "--out=" ++ tapes ++ "/monkey-views" }); - run_views_replay.setCwd(b.path(".")); - run_views_replay.has_side_effects = true; - run_views_replay.step.dependOn(&run_monkey_replay.step); - b.step("replay", "record every snapshot script's and -Dreplay-seeds monkey seeds' tapes (one terminal and three) and require each to replay without diverging, and each session's dump to load to its digest").dependOn(&run_views_replay.step); - const monkey_tests = b.addTest(.{ .root_module = monkey.root_module }); - b.step("monkey-test", "test the monkey's generator and panic detector").dependOn(&b.addRunArtifact(monkey_tests).step); - const run_driver_test = b.addRunArtifact(snap); - run_driver_test.addArg("--self-test"); - run_driver_test.has_side_effects = true; - b.step("snap-driver-test", "test snapshot retry evidence and failure reporting").dependOn(&run_driver_test.step); -} diff --git a/src/tape.zig b/src/tape.zig index 2354fb06..b1bcc31d 100644 --- a/src/tape.zig +++ b/src/tape.zig @@ -129,21 +129,20 @@ pub const Site = enum(u16) { /// listed is a compile error (`call`). An error union is listed as /// `anyerror!` its payload: an error goes by its name (walk.encode). pub const results = .{ - void, bool, - u32, i64, - [8]u8, ?u64, - []const u8, ?[]const u8, - ?std.Io.File.Kind, ?pardes.filesystem.Resolved, - pardes.filesystem.OsReadWrite, anyerror!pardes.filesystem.OsStat, - anyerror![]const u8, - anyerror![]u8, anyerror!void, - terminal.Told, ?pardes.ctlfs.pty.Printed, - @typeInfo(@TypeOf(terminal.greeting)).@"fn".return_type.?, + void, bool, + u32, i64, + [8]u8, ?u64, + []const u8, ?[]const u8, + ?std.Io.File.Kind, ?pardes.filesystem.Resolved, + pardes.filesystem.OsReadWrite, anyerror!pardes.filesystem.OsStat, + anyerror![]const u8, anyerror![]u8, + anyerror!void, terminal.Told, + ?pardes.ctlfs.pty.Printed, @typeInfo(@TypeOf(terminal.greeting)).@"fn".return_type.?, []pardes.Stream.Batch, - // What only the authority holds (`authority`): a closed pane's record, - // Recent's entry for a closed jump, the closed panes' names. - ?@import("Store.zig").Record, ?@import("recent.zig").Entry, - []const @import("Store.zig").Named, + // What only the authority holds (`authority`): a closed pane's record, + // Recent's entry for a closed jump, the closed panes' names. + ?@import("Store.zig").Record, + ?@import("recent.zig").Entry, []const @import("Store.zig").Named, @import("Kind.zig").Outcome, }; @@ -1253,6 +1252,14 @@ pub fn replayMain(io: std.Io, path: []const u8) u8 { std.debug.print("replay: cannot read {s}: {t}\n", .{ path, err }); return 2; }; + return if (replayBytes(gpa, bytes, path, libc.getenv("PARDES_REPLAY_DUMP") != null)) 0 else 1; +} + +/// `bytes`, a tape named `path`, replayed into three replicas, each digest +/// checked, and with `dump` the session's dump at its end loaded to its +/// digest and dumped to its bytes again: true when none diverged. An +/// in-process session's tape too (test/session.zig's replayTape). +pub fn replayBytes(gpa: std.mem.Allocator, bytes: []const u8, path: []const u8, dump: bool) bool { const runs = [_]struct { name: []const u8, headless: bool }{ .{ .name = "first", .headless = false }, // The first replica's memory is still held: this one's lies elsewhere. @@ -1262,7 +1269,7 @@ pub fn replayMain(io: std.Io, path: []const u8) u8 { var failed = false; for (runs) |run| { var t: Tape = .{ .gpa = gpa, .replay = true, .headless = run.headless, .scratch = .init(gpa), .arena = .init(gpa) }; - t.dump_check = std.mem.eql(u8, run.name, "first") and libc.getenv("PARDES_REPLAY_DUMP") != null; + t.dump_check = std.mem.eql(u8, run.name, "first") and dump; on = &t; defer on = null; _ = replayUnit(&t, bytes); @@ -1279,7 +1286,7 @@ pub fn replayMain(io: std.Io, path: []const u8) u8 { } else std.debug.print("replay {s}: {s} replica: {d} digests agree\n", .{ path, run.name, t.digests }); if (t.dump_check and t.diverged == null) std.debug.print("replay {s}: {d} dumps loaded to their digests and dumped to their bytes again ({d} bytes)\n", .{ path, t.dumps, t.dump_bytes }); } - return if (failed) 1 else 0; + return !failed; } test "a syscall that is no site, made replaying, diverges the replay and poisons a speculation" { diff --git a/test/monkey.zig b/test/monkey.zig deleted file mode 100644 index 243f2fbe..00000000 --- a/test/monkey.zig +++ /dev/null @@ -1,254 +0,0 @@ -// pardes-monkey: random snapshot scripts against the tty, hunting panics. -// -// zig build monkey -Dplatform=tui -- <seeds> [steps] [--from=N] [--out=DIR] [--keep] -// -// Each seed makes one script (a fixed seed makes the same script, so a hit -// replays): keys and leader bursts, typing, mouse presses, drags and wheel, -// tiny resizes, prompts and long prompt text, over files of bad UTF-8 and -// wide glyphs. pardes-snap runs it with --update into DIR (default -// /tmp/pardes-monkey), and a panic is a record in the app's crash file -// (src/crash.zig, in the script's fake home: found even when the crash cut -// the script short) or a `.zig:N:N: 0x` stack frame in the report or the -// grid it captured (a trace renders INTO the screen). A hit keeps DIR/seed-N.snap, its captures and its report; the rest are deleted. -// A panic's trace can scroll off a small grid: replay the kept script, or -// run the app in a larger pty. Every hit gets a fix and a pinned regression -// script in test/snapshots/. -// -// Not a test gate: it is slow, random over seeds and aimed at finding, not -// holding. Shell text typed into a pane only ever runs in the throwaway -// script directory, and its alphabet has no path characters. -const std = @import("std"); -const libc = std.c; - -const Script = struct { - out: std.ArrayListUnmanaged(u8) = .empty, - gpa: std.mem.Allocator, - rows: u16 = 24, - cols: u16 = 80, - - fn line(s: *Script, comptime fmt: []const u8, args: anytype) !void { - try s.out.print(s.gpa, fmt ++ "\n", args); - } -}; - -// Workspace-tag words: clicked with the middle button they run, and the -// harness finds their column on row 1 while the window is wide enough. -const commands = [_][]const u8{ "Newcol", "Find", "Grep", "Joincol", "Help", "Dump", "NextColor", "Debug" }; -const leader_keys = "abcdefghijklmnopqrstuvwxyz0123456789$^"; -const typed = "abcdefghijklmnopqrstuvwxyz0123456789 -_=+,:;()"; - -fn generate(gpa: std.mem.Allocator, seed: u64, steps: usize) ![]u8 { - var prng = std.Random.DefaultPrng.init(seed); - const random = prng.random(); - var s: Script = .{ .gpa = gpa }; - try s.line("# pardes-monkey seed {d}, {d} steps", .{ seed, steps }); - try s.line("file bad.txt hello \\xff\\xfe world\\nlatin-1 caf\\xe9 tail\\ntruncated \\xe6\\x97 here\\nend\\n", .{}); - try s.line("file wide.txt {s}tail\\nsecond line\\n", .{std.mem.asBytes(&@as([8][37]u8, @splat("\\xe6\\x97\\xa5\\xe6\\x9c\\xac\\xe8\\xaa\\x9e ".*)))}); - try s.line("lines long.txt 400 some words after the number, long enough to wrap in a narrow pane", .{}); - try s.line("start 24 80 bad.txt", .{}); - try s.line("wait 8000 Newcol Joincol", .{}); - try s.line("stable 300 5000", .{}); - for (0..steps) |step| { - const wide = s.cols >= 70 and s.rows >= 6; - switch (random.uintLessThan(u8, 12)) { - // A workspace word, run with a middle click: new columns make - // narrow panes, Find and Grep open prompts. - 0, 1 => if (wide) { - const word = commands[random.uintLessThan(usize, commands.len)]; - try s.line("press middle @{s} 1", .{word}); - try s.line("release middle @{s} 1", .{word}); - }, - // Typing: into a prompt when one is up, far past its band. - 2, 3 => { - var text: [200]u8 = undefined; - const n = random.intRangeAtMost(usize, 1, if (random.uintLessThan(u8, 4) == 0) text.len else 12); - for (text[0..n]) |*c| c.* = typed[random.uintLessThan(usize, typed.len)]; - try s.line("text {s}", .{text[0..n]}); - }, - 4 => try s.line("key {s}", .{switch (random.uintLessThan(u8, 10)) { - 0 => "enter", - 1 => "tab", - 2 => "bs", - 3 => "up", - 4 => "down", - 5 => "left", - 6 => "right", - 7 => "pgdn", - 8 => "home", - else => "end", - }}), - 5 => { - try s.line("key esc", .{}); - try s.line("settle 120", .{}); - }, - // A leader burst: space and a chord's keys. - 6 => { - var chord: [3][2]u8 = undefined; - const n = random.intRangeAtMost(usize, 1, 3); - for (chord[0..n]) |*c| c.* = .{ leader_keys[random.uintLessThan(usize, leader_keys.len)], 0 }; - try s.out.appendSlice(gpa, "key space"); - for (chord[0..n]) |c| try s.out.print(gpa, " {c}", .{c[0]}); - try s.out.append(gpa, '\n'); - }, - 7, 8 => { - const buttons = [_][]const u8{ "left", "middle", "right" }; - const button = buttons[random.uintLessThan(usize, buttons.len)]; - const col = random.intRangeAtMost(u16, 1, s.cols); - const row = random.intRangeAtMost(u16, 1, s.rows); - try s.line("press {s} {d} {d}", .{ button, col, row }); - if (random.boolean()) try s.line("drag {s} {d} {d}", .{ button, random.intRangeAtMost(u16, 1, s.cols), random.intRangeAtMost(u16, 1, s.rows) }); - try s.line("release {s} {d} {d}", .{ button, random.intRangeAtMost(u16, 1, s.cols), random.intRangeAtMost(u16, 1, s.rows) }); - }, - 9 => try s.line("wheel {s} {d} {d}", .{ if (random.boolean()) "up" else "down", random.intRangeAtMost(u16, 1, s.cols), random.intRangeAtMost(u16, 1, s.rows) }), - 10 => try s.line("motion {d} {d}", .{ random.intRangeAtMost(u16, 1, s.cols), random.intRangeAtMost(u16, 1, s.rows) }), - // Tiny windows as often as ordinary ones. - else => { - s.rows = if (random.boolean()) random.intRangeAtMost(u16, 1, 6) else random.intRangeAtMost(u16, 7, 40); - s.cols = if (random.boolean()) random.intRangeAtMost(u16, 1, 20) else random.intRangeAtMost(u16, 21, 140); - try s.line("resize {d} {d}", .{ s.rows, s.cols }); - }, - } - try s.line("settle 30", .{}); - if (step % 10 == 9) try s.line("snap s{d}", .{step}); - } - try s.line("stable 300 5000", .{}); - try s.line("snap end", .{}); - return s.out.toOwnedSlice(gpa); -} - -/// A stack frame of a Zig panic trace, `.zig:12:34: 0x`, of the app's: the -/// harness's own error trace (a script it could not finish) is not a hit. -fn hasTrace(bytes: []const u8) bool { - var lines = std.mem.splitScalar(u8, bytes, '\n'); - while (lines.next()) |line| { - if (std.mem.indexOf(u8, line, "test/snapshot.zig") != null or std.mem.indexOf(u8, line, "test/e2e_harness.zig") != null) continue; - if (frameIn(line)) return true; - } - return false; -} - -fn frameIn(bytes: []const u8) bool { - var from: usize = 0; - while (std.mem.indexOfPos(u8, bytes, from, ".zig:")) |at| : (from = at + 1) { - var i = at + ".zig:".len; - var digits: usize = 0; - while (i < bytes.len and std.ascii.isDigit(bytes[i])) : (i += 1) digits += 1; - if (digits == 0 or i >= bytes.len or bytes[i] != ':') continue; - i += 1; - digits = 0; - while (i < bytes.len and std.ascii.isDigit(bytes[i])) : (i += 1) digits += 1; - if (digits > 0 and std.mem.startsWith(u8, bytes[i..], ": 0x")) return true; - } - return false; -} - -test "a panic trace is found, and ordinary colons are not" { - try std.testing.expect(hasTrace(" /src/draw.zig:814:31: 0x4212821 in joinNotice")); - try std.testing.expect(!hasTrace("draw.zig:814 is where it was; 12:30: 0x")); - try std.testing.expect(!hasTrace("/x/test/snapshot.zig:197:28: 0x1279761 in main (snapshot.zig)")); -} - -test "a seed makes the same script every time" { - const a = try generate(std.testing.allocator, 42, 50, 3); - defer std.testing.allocator.free(a); - const b = try generate(std.testing.allocator, 42, 50, 3); - defer std.testing.allocator.free(b); - try std.testing.expectEqualStrings(a, b); -} - -fn readAll(gpa: std.mem.Allocator, io: std.Io, path: []const u8) []u8 { - return std.Io.Dir.cwd().readFileAlloc(io, path, gpa, .limited(64 << 20)) catch &.{}; -} - -pub fn main(init: std.process.Init) !void { - const gpa = std.heap.page_allocator; - const io = init.io; - const args = try init.minimal.args.toSlice(init.arena.allocator()); - if (args.len < 4) { - std.debug.print("usage: pardes-monkey <pardes-snap> <pardes> <seeds> [steps] [--from=N] [--out=DIR] [--keep] [--tape=DIR] [--dump]\n", .{}); - std.process.exit(2); - } - const snap = args[1]; - const app = args[2]; - var seeds: u64 = 20; - var steps: usize = 70; - var from: u64 = 1; - var out: []const u8 = "/tmp/pardes-monkey"; - // Keep every script and capture, not only a hit's: to see what it did. - var keep = false; - // --tape=DIR: each seed's sessions record their tapes there and the - // seed is a hit if one does not replay (pardes-snap --tape). - var tape: ?[]const u8 = null; - // --dump (with --tape): each replay loads the session's dump at its end - // too (pardes-snap --dump). - var dump = false; - var positional: usize = 0; - for (args[3..]) |a| { - if (std.mem.startsWith(u8, a, "--from=")) { - from = try std.fmt.parseInt(u64, a["--from=".len..], 10); - } else if (std.mem.eql(u8, a, "--keep")) { - keep = true; - } else if (std.mem.startsWith(u8, a, "--tape=")) { - tape = a; - } else if (std.mem.eql(u8, a, "--dump")) { - dump = true; - } else if (std.mem.startsWith(u8, a, "--out=")) { - out = a["--out=".len..]; - } else { - switch (positional) { - 0 => seeds = try std.fmt.parseInt(u64, a, 10), - 1 => steps = try std.fmt.parseInt(usize, a, 10), - else => {}, - } - positional += 1; - } - } - std.Io.Dir.cwd().createDirPath(io, out) catch {}; - var hits: usize = 0; - var seed = from; - while (seed < from + seeds) : (seed += 1) { - const script = try generate(gpa, seed, steps); - defer gpa.free(script); - var path_buf: [4096]u8 = undefined; - const path = try std.fmt.bufPrint(&path_buf, "{s}/seed-{d}.snap", .{ out, seed }); - try std.Io.Dir.cwd().writeFile(io, .{ .sub_path = path, .data = script }); - const run = std.process.run(gpa, io, .{ - .argv = if (tape) |t| (if (dump) &.{ snap, app, "--update", "--no-retry", "--jobs=1", t, "--dump", path } else &.{ snap, app, "--update", "--no-retry", "--jobs=1", t, path }) else &.{ snap, app, "--update", "--no-retry", "--jobs=1", path }, - .stdout_limit = .limited(64 << 20), - .stderr_limit = .limited(64 << 20), - }) catch |err| { - std.debug.print("seed {d}: pardes-snap did not run ({t})\n", .{ seed, err }); - continue; - }; - defer gpa.free(run.stdout); - defer gpa.free(run.stderr); - var golden_buf: [4096]u8 = undefined; - const golden_path = try std.fmt.bufPrint(&golden_buf, "{s}/seed-{d}.golden", .{ out, seed }); - const golden = readAll(gpa, io, golden_path); - defer gpa.free(golden); - // The app's own crash file (src/crash.zig) in the script's fake home: - // found even when the crash cut the script short of a capture. - var crash_buf: [4096]u8 = undefined; - const crash_path = try std.fmt.bufPrint(&crash_buf, "/tmp/pardes-snap/seed-{d}/home/.config/pardes/crashes", .{seed}); - const crashes = readAll(gpa, io, crash_path); - defer gpa.free(crashes); - const diverged = tape != null and (std.mem.indexOf(u8, run.stdout, "DIVERGED") != null or std.mem.indexOf(u8, run.stderr, "DIVERGED") != null); - if (crashes.len != 0 or diverged or hasTrace(run.stdout) or hasTrace(run.stderr) or hasTrace(golden)) { - hits += 1; - var log_buf: [4096]u8 = undefined; - const log_path = try std.fmt.bufPrint(&log_buf, "{s}/seed-{d}.log", .{ out, seed }); - const both = try std.mem.concat(gpa, u8, &.{ crashes, run.stdout, run.stderr }); - defer gpa.free(both); - try std.Io.Dir.cwd().writeFile(io, .{ .sub_path = log_path, .data = both }); - std.debug.print("{s} seed {d}: {s}\n", .{ if (diverged) "DIVERGED" else "PANIC", seed, path }); - } else if (!keep) { - std.Io.Dir.cwd().deleteFile(io, path) catch {}; - std.Io.Dir.cwd().deleteFile(io, golden_path) catch {}; - std.debug.print("ok seed {d}\n", .{seed}); - } else { - std.debug.print("ok seed {d} (kept)\n", .{seed}); - } - } - std.debug.print("{d} of {d} seeds panicked; kept in {s}\n", .{ hits, seeds, out }); - if (hits != 0) std.process.exit(1); -} diff --git a/test/monkey9p.zig b/test/monkey9p.zig index 39a1a187..c9dd5083 100644 --- a/test/monkey9p.zig +++ b/test/monkey9p.zig @@ -4,8 +4,19 @@ //! /log said meanwhile. It was test/monkey9p.py, which drove a real //! `pardes --detach` over its socket. //! -//! zig build monkey-session -Dplatform=tui -- [--seed N]... [--steps M] [--only i,j,k] [--no-shrink] [-v] -//! zig build monkey-session-smoke -Dplatform=tui (part of behaviour-test) +//! zig build behaviour-test -Dplatform=tui (a short fixed-seed run) +//! zig build behaviour-test -Dplatform=tui -- [--seed N]... [--steps M] [--only i,j,k] [--no-shrink] [-v] +//! zig build behaviour-test -Dplatform=tui -- --monkey <seeds> [--steps M] +//! zig build behaviour-test -Dplatform=tui -- --replay [--monkey <seeds>] +//! +//! The T1 runner's modes: this, the rules over random 9P requests; with +//! `--monkey`, random input (keys, the mouse, resizes) hunting panics and +//! hangs, as test/monkey.zig's random snapshot scripts did through a real +//! pty; with `--replay`, those seeds (20 unless named) each recording the +//! tape of what its sessions consumed and replaying it, as `PARDES_REPLAY` +//! replays a real session's: into two replicas at different addresses and +//! one that never draws, every digest checked, and each session's dump +//! loaded to its digest and dumped to its bytes again (src/tape.zig). //! //! A step's op is drawn from the seed alone: the panes, columns and held //! files it names are tokens (`{p3}`: /index's 4th serial, mod its length, @@ -45,6 +56,9 @@ const write_max = msize - 23; const room = msize - 24; /// A step that has not finished in this long is a hang. const hang_ms = 30_000; +/// What the runs are (see the top): the rules, the input, or the input +/// with every session's tape replayed. +var run_mode: enum { rules, input, replay } = .rules; const fixtures = [_][2][]const u8{ .{ "alpha.txt", "alpha beta gamma\nsecond line\n\nthird after a blank\n" }, @@ -71,12 +85,11 @@ const words = [_][]const u8{ }; const shell_lines = [_][]const u8{ "true", "false", "echo hi", "echo m9p", "sleep 1", "ls", "cat nonexist", "printf abc", "exit 3", "seq 1 2000", "yes | head -n 3000", "date", "pwd", "env | wc" }; const builtins = [_][]const u8{ - "Look", "Exec", "Kill", "Dump", "Msg", "NextColor", "Themes", "DumpThemes", "TreeContext", "PdfFit", "PdfTint", "PdfSections", "Petscii", - "Palette", "Ascii", "Save", "New", "Newcol", "Del", "Filter", "Mode", "Togglettymode", "Edit", "Undo", "Redo", "Collapse", - "Delcol", "DelAbove", "DelBelow", "Term", "Repl", "Joincol", "Config", "LocationsConfig", "Messages", "Mini", "Find", "Grep", "Left", - "Down", "Up", "Right", "Back", "Forward", "Last", "Recent", "Jumplist", "Wrap", "Debug", - "Verbose", "InactiveDim", "DumpDir", "Theme", "Get", "Put", "Undo", "Redo", "Zerox", "Snarf", "Paste", "Cut", - "Sort", "Font", "Local", + "Look", "Exec", "Kill", "Dump", "Msg", "NextColor", "Themes", "DumpThemes", "TreeContext", "PdfFit", "PdfTint", "PdfSections", "Petscii", + "Palette", "Ascii", "Save", "New", "Newcol", "Del", "Filter", "Mode", "Togglettymode", "Edit", "Undo", "Redo", "Collapse", + "Delcol", "DelAbove", "DelBelow", "Term", "Repl", "Joincol", "Config", "LocationsConfig", "Messages", "Mini", "Find", "Grep", "Left", + "Down", "Up", "Right", "Back", "Forward", "Last", "Recent", "Jumplist", "Wrap", "Debug", "Verbose", "InactiveDim", "DumpDir", + "Theme", "Get", "Put", "Undo", "Redo", "Zerox", "Snarf", "Paste", "Cut", "Sort", "Font", "Local", }; const pane_files = [_][]const u8{ "name", "body", "tag", "ctl", "addr", "dot", "limit", "data", "xdata", "sel", "dirty", "mark", "scroll", "errors", "event", "look", "exec", "tagexec", "pty", "pty/run", "pty/data", "pty/ctl", "pty/status" }; const root_files = [_][]const u8{ "README", "index", "status", "focus", "ctl", "commands", "recent", "dumps", "look", "exec", "log", "screen", "listeners", "layout", "tag", "tagexec", "pane", "pane/new", "col", "" }; @@ -364,8 +377,75 @@ const Op = union(enum) { /// Down to the empty window (every pane closed but `keep`, the columns /// too), sometimes rebuilt with a new pane. clear: struct { keep: ?usize, cols: bool, rebuild: bool }, + /// The input modes' (genInput): runes at /kbdin, lines at /mousein, a + /// word on the screen clicked with the middle button (a workspace + /// word run), the window resized to `[cols, rows]`. + keys: []const u8, + mouse: []const u8, + word: []const u8, + resize: [2]u16, }; +// --------------------------------------------------------------------------- +// The tty monkey's input (--monkey): it was test/monkey.zig, random +// snapshot scripts through a real pty hunting panics. Keys and leader +// bursts, typing (sometimes far past a prompt's band), the mouse's presses, +// drags, wheel and hover, and windows as tiny as ordinary ones, at the +// fixtures' panes (bad UTF-8, wide glyphs). A hit is a panic or a hang, +// which the parent reports and shrinks as any failure; the rules are not +// checked between its steps. + +/// Workspace words, run with a middle click: new columns make narrow +/// panes, Find and Grep open prompts. +const monkey_words = [_][]const u8{ "Newcol", "Find", "Grep", "Joincol", "Help", "Dump", "NextColor", "Debug" }; +const leader_keys = "abcdefghijklmnopqrstuvwxyz0123456789$^"; +const typed = "abcdefghijklmnopqrstuvwxyz0123456789 -_=+,:;()"; +/// Enter, Tab, Backspace, the arrows, Page Down, Home and End as kbdin's +/// runes (docs/typ/reference.typ, Other files). +const named_keys = [_][]const u8{ "\n", "\t", "\x08", "\u{f00e}", "\u{f800}", "\u{f011}", "\u{f012}", "\u{f013}", "\u{f00d}", "\u{f018}" }; + +fn genInput(r: Random, a: Allocator, size: *[2]u16) Op { + const cols = size[0]; + const rows = size[1]; + switch (below(r, 12)) { + 0, 1 => if (cols >= 70 and rows >= 6) return .{ .word = pick(r, &monkey_words) }, + 2, 3 => { + const n = range(r, 1, if (below(r, 4) == 0) 201 else 13); + const text = a.alloc(u8, n) catch oom(); + for (text) |*c| c.* = typed[below(r, typed.len)]; + return .{ .keys = text }; + }, + 4 => return .{ .keys = pick(r, &named_keys) }, + 5 => return .{ .keys = "\x1b" }, + 6 => { + var chord: std.ArrayList(u8) = .empty; + chord.append(a, ' ') catch oom(); + for (0..range(r, 1, 4)) |_| chord.append(a, leader_keys[below(r, leader_keys.len)]) catch oom(); + return .{ .keys = chord.items }; + }, + 7, 8 => { + const button: u8 = pick(r, &[_]u8{ 1, 2, 4 }); + var lines: std.ArrayList(u8) = .empty; + lines.print(a, "m {d} {d} {d}\n", .{ below(r, cols), below(r, rows), button }) catch oom(); + if (r.boolean()) lines.print(a, "m {d} {d} {d}\n", .{ below(r, cols), below(r, rows), button }) catch oom(); + lines.print(a, "m {d} {d} 0\n", .{ below(r, cols), below(r, rows) }) catch oom(); + return .{ .mouse = lines.items }; + }, + 9 => { + const x = below(r, cols); + const y = below(r, rows); + return .{ .mouse = print(a, "m {d} {d} {d}\nm {d} {d} 0\n", .{ x, y, @as(u8, if (r.boolean()) 8 else 16), x, y }) }; + }, + 10 => return .{ .mouse = print(a, "m {d} {d} 0\n", .{ below(r, cols), below(r, rows) }) }, + else => { + size[1] = @intCast(if (r.boolean()) range(r, 1, 7) else range(r, 7, 41)); + size[0] = @intCast(if (r.boolean()) range(r, 1, 21) else range(r, 21, 141)); + return .{ .resize = size.* }; + }, + } + return .{ .keys = "" }; +} + fn seq(a: Allocator, ops: []const Op) Op { return .{ .seq = a.dupe(Op, ops) catch oom() }; } @@ -522,11 +602,22 @@ const Ctx = struct { step: usize = 0, fail_kind: []const u8 = "", fail_why: []const u8 = "", + /// Sessions whose tape did not replay (--replay). + diverged: usize = 0, fn s(c: *Ctx) *Session { return &c.sess.?; } + /// The tape of the session just ended replayed (--replay): a + /// divergence is a failure at the step it ended. + fn replayed(c: *Ctx, at_step: usize) void { + if (run_mode != .replay or Session.replayTape(c.gpa)) return; + c.diverged += 1; + std.debug.print("[seed {d} step {d}] FAIL replay: a replica diverged\n", .{ c.seed, at_step }); + std.debug.print("mky fail {d} replay:diverged\n", .{at_step -| 1}); + } + fn fail(c: *Ctx, a: Allocator, kind: []const u8, comptime f: []const u8, args: anytype) error{Fail} { c.fail_kind = kind; c.fail_why = print(a, f, args); @@ -543,7 +634,10 @@ const Ctx = struct { /// close does not end it), the session's own first pane removed, and /// half the time a follower of the log. fn fresh(c: *Ctx, at_step: usize) !void { - if (c.sess) |*old| old.deinit(); + if (c.sess) |*old| { + old.deinit(); + c.replayed(at_step); + } c.sess = null; _ = c.life.reset(.free_all); c.serials = .empty; @@ -556,7 +650,10 @@ const Ctx = struct { const la = c.life.allocator(); for (fixtures) |fx| try putFile(la, c.root, fx[0], fx[1]); removeFile(la, c.root, "fresh.txt"); - c.sess = try Session.initFile(c.gpa, fixtures[0][1]); + // The input modes start as `pardes` does, everything after on the + // tape: a file set in place before the first input is not. + if (run_mode == .replay) try Session.recordTape(c.gpa); + c.sess = try if (run_mode == .rules) Session.initFile(c.gpa, fixtures[0][1]) else Session.initTerm(c.gpa); const s_ = c.s(); const first = try serialsOf(la, (try readAll(c, la, "/index")) orelse ""); for (fixtures[0..3]) |fx| try s_.write("/look", print(la, "{s}/{s}\n", .{ c.root, fx[0] })); @@ -939,6 +1036,11 @@ fn exec(c: *Ctx, a: Allocator, res: *Res, op: Op) anyerror!void { .host => |o| if (o.data) |data| try putFile(a, c.root, o.name, data) else removeFile(a, c.root, o.name), .seq => |ops| for (ops) |sub| try exec(c, a, res, sub), .clear => unreachable, // resolved into a seq + // A refusal is an answer; a panic or a hang is what is hunted. + .keys => |typed_keys| _ = c.s().refused("/kbdin", typed_keys) catch {}, + .mouse => |lines| _ = c.s().refused("/mousein", lines) catch {}, + .word => |w| c.s().click(w, 0, 2) catch {}, + .resize => |size| c.s().resize(size[0], size[1]), } } @@ -1323,6 +1425,7 @@ fn runStep(c: *Ctx, a: Allocator, raw: Op) Fail!void { }; // Closing the session's last pane quits it (docs/typ/reference.typ). if (c.s().ended()) return error.Ended; + if (run_mode != .rules) return; checks(c, a, &res) catch |err| switch (err) { error.Fail => return error.Fail, else => return c.fail(a, "checker", "after {s}: {t}", .{ what, err }), @@ -1392,6 +1495,8 @@ fn fuzz(gpa: Allocator, seed: u64, steps: usize, only: ?[]const usize, verbose: var step_arena: std.heap.ArenaAllocator = .init(gpa); var found: std.StringArrayHashMapUnmanaged(struct { n: usize, first: usize }) = .empty; try c.fresh(0); + // The window's size as the input's resizes leave it. + var size: [2]u16 = .{ 80, 24 }; const t0 = nowMs(); var ended: usize = 0; var ran: usize = 0; @@ -1399,7 +1504,7 @@ fn fuzz(gpa: Allocator, seed: u64, steps: usize, only: ?[]const usize, verbose: _ = step_arena.reset(.retain_capacity); const a = step_arena.allocator(); c.step = step; - const op = gen(r, a); + const op = if (run_mode == .rules) gen(r, a) else genInput(r, a, &size); if (only) |list| if (std.mem.indexOfScalar(usize, list, step) == null) continue; std.debug.print("mky step {d}\n", .{step}); ran += 1; @@ -1425,8 +1530,11 @@ fn fuzz(gpa: Allocator, seed: u64, steps: usize, only: ?[]const usize, verbose: const dt = @max(1, nowMs() - t0); std.debug.print("[seed {d}] {d} steps in {d} ms ({d}/s), {d} clean quit(s)\n", .{ seed, ran, dt, @divTrunc(@as(i64, @intCast(ran)) * 1000, dt), ended }); for (found.keys(), found.values()) |sig, v| std.debug.print(" {d}x {s} (first at step {d})\n", .{ v.n, sig[0..@min(sig.len, 200)], v.first }); - if (c.sess) |*s| s.deinit(); - return if (found.count() > 0) 1 else 0; + if (c.sess) |*s| { + s.deinit(); + c.replayed(steps); + } + return if (found.count() > 0 or c.diverged > 0) 1 else 0; } fn nowMs() i64 { @@ -1455,6 +1563,7 @@ fn spawn(gpa: Allocator, seed: u64, steps: usize, only: ?[]const usize, verbose: var argv: std.ArrayList(?[*:0]const u8) = .empty; for ([_][]const u8{ "pardes-monkey-session", "--seed", print(a, "{d}", .{seed}), "--steps", print(a, "{d}", .{steps}) }) |arg| try argv.append(a, try a.dupeSentinel(u8, arg, 0)); if (verbose) try argv.append(a, "-v"); + if (run_mode != .rules) try argv.append(a, if (run_mode == .input) "--input-mode" else "--replay"); if (only) |list| { var text: std.ArrayList(u8) = .empty; for (list, 0..) |n, i| try text.print(a, "{s}{d}", .{ if (i > 0) "," else "", n }); @@ -1607,11 +1716,15 @@ fn shrink(gpa: Allocator, seed: u64, f: Found, budget: usize) !void { const small = try ddmin(gpa, body, &trial, Trial.fails); var text: std.ArrayList(u8) = .empty; for (small, 0..) |n, i| try text.print(gpa, "{s}{d}", .{ if (i > 0) "," else "", n }); - std.debug.print(" shrunk {d} -> {d} ops: zig build monkey-session -Dplatform=tui -- --seed {d} --steps {d} --only {s} -v\n", .{ body.len, small.len, seed, f.step + 1, text.items }); + std.debug.print(" shrunk {d} -> {d} ops: zig build behaviour-test -Dplatform=tui -- {s}--seed {d} --steps {d} --only {s} -v\n", .{ body.len, small.len, switch (run_mode) { + .rules => "", + .input => "--monkey 1 ", + .replay => "--replay ", + }, seed, f.step + 1, text.items }); } fn usage() noreturn { - std.debug.print("usage: pardes-monkey-session [--seed N]... [--steps M] [--only i,j,k] [--no-shrink] [--shrink-budget N] [--smoke] [-v]\n", .{}); + std.debug.print("usage: pardes-monkey-session [--seed N]... [--steps M] [--only i,j,k] [--no-shrink] [--shrink-budget N] [--monkey <seeds>] [--replay] [-v]\n", .{}); std.process.exit(2); } @@ -1623,8 +1736,11 @@ pub fn main(init: std.process.Init) !void { var only: ?[]const usize = null; var no_shrink = false; var budget: usize = 300; - var smoke = false; + // Bare, as behaviour-test runs it: a short fixed-seed run. + var smoke = args.len == 1; var verbose = false; + // --monkey's count of seeds, 1 to N, when none is named. + var monkey: usize = 0; var i: usize = 1; while (i < args.len) : (i += 1) { const arg = args[i]; @@ -1648,6 +1764,14 @@ pub fn main(init: std.process.Init) !void { no_shrink = true; } else if (std.mem.eql(u8, arg, "--smoke")) { smoke = true; + } else if (std.mem.eql(u8, arg, "--monkey")) { + if (run_mode == .rules) run_mode = .input; + monkey = std.fmt.parseInt(usize, value, 10) catch usage(); + i += 1; + } else if (std.mem.eql(u8, arg, "--input-mode")) { + run_mode = .input; + } else if (std.mem.eql(u8, arg, "--replay")) { + run_mode = .replay; } else if (std.mem.eql(u8, arg, "-v") or std.mem.eql(u8, arg, "--verbose")) { verbose = true; } else usage(); @@ -1671,6 +1795,11 @@ pub fn main(init: std.process.Init) !void { steps = steps orelse 800; no_shrink = true; } + // The input's seeds are 70 steps each, as the tty monkey's scripts were. + if (run_mode != .rules) { + if (seeds.items.len == 0) for (1..if (monkey > 0) monkey + 1 else 21) |n| try seeds.append(gpa, n); + steps = steps orelse 70; + } if (seeds.items.len == 0) try seeds.append(gpa, 1); var total: usize = 0; for (seeds.items) |seed| { @@ -1680,5 +1809,6 @@ pub fn main(init: std.process.Init) !void { var seen: std.StringHashMapUnmanaged(void) = .empty; for (found) |f| if (!(try seen.getOrPut(gpa, f.sig)).found_existing) try shrink(gpa, seed, f, budget); } + if (run_mode != .rules) std.debug.print("{s}: {d} seeds of {d} steps, {d} failure(s)\n", .{ @tagName(run_mode), seeds.items.len, steps.?, total }); if (total > 0) std.process.exit(1); } diff --git a/test/process_test.zig b/test/process_test.zig index bab80183..5876e005 100644 --- a/test/process_test.zig +++ b/test/process_test.zig @@ -5,7 +5,7 @@ //! its own instead (test/tty.zig), on the tty alone. //! //! pardes-process-test <pardes> [--backend=tui|gui] [--addon=<lib>]... -//! [--lspmock=<exe>] [--update] [filter] +//! [--lspmock=<exe>] [--update] [--replay [--replay-with=<pardes>]] [filter] const std = @import("std"); const process = @import("process.zig"); const tty = @import("tty.zig"); @@ -53,6 +53,10 @@ pub fn main(init: std.process.Init) !void { 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 (std.mem.eql(u8, a, "--replay")) { + tty.replay = true; + } else if (std.mem.startsWith(u8, a, "--replay-with=")) { + tty.replay_with = try std.Io.Dir.cwd().realPathFileAlloc(init.io, a["--replay-with=".len..], arena); } else if (n < args.len) { args[n] = a; n += 1; @@ -62,13 +66,13 @@ pub fn main(init: std.process.Init) !void { // 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); + tty.goldens = std.Io.Dir.cwd().realPathFileAlloc(init.io, "test/snapshots", arena) catch tty.goldens; const gpa = std.heap.page_allocator; const on = @tagName(process.backend); var failed: usize = 0; var skipped: usize = 0; var ran: usize = 0; - if (!tty.update) inline for (files) |file| inline for (file.cases) |case| { + if (!tty.update and !tty.replay) inline for (files) |file| inline for (file.cases) |case| { if (std.mem.indexOf(u8, case[0], filter) != null) { ran += 1; const t0 = process.nowMs(); diff --git a/test/session.zig b/test/session.zig index b35d08ad..136d34d1 100644 --- a/test/session.zig +++ b/test/session.zig @@ -190,6 +190,37 @@ pub const Session = struct { return .{ try std.fmt.parseInt(u32, it.next() orelse return error.NoRange, 10), try std.fmt.parseInt(u32, it.next() orelse return error.NoRange, 10) }; } + /// The window resized to `cols` by `rows`, as a terminal's SIGWINCH or + /// a window's resize tells its host. + pub fn resize(s: *Session, cols: u16, rows: u16) void { + pardesOf(s).update(.{ .resize = .{ .cols = cols, .rows = rows } }); + s.drain(); + } + + /// Every session started from here on records what it consumes as a + /// tape in memory, as PARDES_RECORD has a real one record it + /// (src/tape.zig); `replayTape` replays it once the session is gone. + pub fn recordTape(gpa: std.mem.Allocator) !void { + const t = try gpa.create(pardes.tape.Tape); + t.* = pardes.tape.memory(gpa); + pardes.tape.on = t; + } + + /// The tape `recordTape` started, replayed as `PARDES_REPLAY` replays a + /// real session's: into two replicas at different addresses and one + /// that never draws, every digest checked, and the session's dump at + /// its end loaded to its digest and dumped to its bytes again. False + /// when a replica diverged (said on stderr). After `deinit`. + pub fn replayTape(gpa: std.mem.Allocator) bool { + const t = pardes.tape.on orelse return true; + pardes.tape.on = null; + defer { + pardes.tape.release(t); + gpa.destroy(t); + } + return pardes.tape.replayBytes(gpa, t.buf.items, "session", true); + } + /// No frontend attached, as a detached session's daemon says. pub fn detach(s: *Session) void { pardesOf(s).unattended = true; diff --git a/test/snapshot.zig b/test/snapshot.zig deleted file mode 100644 index 51c81dd9..00000000 --- a/test/snapshot.zig +++ /dev/null @@ -1,1753 +0,0 @@ -// pardes-snap: drive a pardes binary with a scripted input trace in a pty and -// capture the rendered grid at named sync points. The same script run against -// the prototype and the rewrite must produce byte-identical captures — this is -// the old-vs-new parity oracle for the rewrite. -// -// zig build snap run all snapshots/*.snap, diff goldens -// zig build snap -- --update regenerate goldens serially -// zig build snap -- snapshots/boot.snap one script -// zig build snap -- --jobs=1 serial (default: 1.25 per cpu) -// zig build snap -- --trace-stable show what every `stable` waited on -// -// Scripts run one per forked child, in parallel; each child's report is held -// in a temp file and printed in script order at the end. The runner takes its -// own lockfile, so `zig build snap` never needs an `flock` wrapper: a second -// run waits for the first instead of trampling the fixed /tmp paths that the -// goldens record verbatim. A script that fails in the parallel pass is re-run -// alone before it counts as a failure. -// -// `stable` no longer burns its wall-clock window: it returns as soon as the -// app is provably done — screen unchanged, pty empty, and every process it -// forked asleep (see waitStable). That, the fan-out, and building the vendored -// C optimized (build.zig's c_optimize: 90% of a Debug startup used to be -// tree-sitter's query analyser at -O0) took the suite from 7m54s to ~4s. The -// app now reaches first paint in ~25ms, so what is left is mostly real work: -// bash spawns, their output, and the 40 `settle`s after `key esc`. -// -// Script commands (line-oriented, # comments): -// file <name> <content> create file in the script's cwd (before start) -// lines <name> <n> [tail] create file with n numbered lines, tail on each -// dirmk <name> create a subdirectory -// run <shell...> run a command in the script's cwd (NOT in a pane) -// start <rows> <cols> [arg] fork the app in a pty (optional extra CLI arg) -// wait <ms> <needle...> pump until needle appears on the grid (fails hard) -// settle <ms> pump for a fixed duration -// stable <quiet_ms> <timeout_ms> pump until the grid stops changing -// text <literal> send literal bytes -// send <escaped> send with \e \r \n \t \\ \xNN escapes -// key <names...> enter esc tab bs space up down left right home end -// pgup pgdn c-<ch> a-<ch> (after esc: settle, or -// vaxis reads the next byte in the same batch and -// parses it as alt-<ch>. The scripts said 700ms and -// it cost the suite 28s; there is no timer in vaxis -// to outlast — 20ms passes, they use 100ms) -// press|release <[ctrl-]left|middle|right> <col> <row> SGR mouse, 1-based -// drag <btn> <col> <row> motion with button held -// motion <col> <row> button-less motion (hover) -// wheel <up|down> <col> <row> -// resize <rows> <cols> -// snap <label> capture grid text + cursor -// snapstyle <label> capture per-cell style runs (fg,bg,attrs) -// snap9p <label> read core cells/styles over the child's 9P socket -// -// Any <col> above may be `@Word`, `@Word#2` or `@Word+4` instead of a number: -// the column of a word on that row of the live grid (see resolveCol). Chrome -// words move, and a frozen column silently clicks whatever moved into it. -// -// A capture is a DELTA against the previous capture of the same kind in the -// same script: the first one (and any after a resize) is the whole screen as -// `|<row>`, the rest are 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 (see Prev). -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"); - -// This harness parses the app's output with its OWN ghostty-vt, which narrates -// every sequence it does not implement — vaxis's startup capability probes -// alone cost four `debug(stream)`/`warning(stream)`/`debug(kitty_gfx)` lines -// per script, burying the PASS/FAIL report under 200 lines of chatter. Cut the -// libraries back to errors; the report itself goes through std.debug, so a -// failure stays loud either way. -pub const std_options: std.Options = .{ .log_level = .err }; - -extern "c" fn setenv(name: [*:0]const u8, value: [*:0]const u8, overwrite: c_int) c_int; -extern "c" fn unsetenv(name: [*:0]const u8) 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; -extern "c" fn mkdtemp(template: [*:0]u8) ?[*:0]u8; - -const SNAP_BASE = "/tmp/pardes-snap"; -var trace_stable = false; -/// set for the serial re-run pass; children widen their probes (see beCareful) -var careful = false; -/// abs path of the deterministic mock language server the build handed over -/// (--lspmock=); null leaves the protocol client fully disabled for the run -var lspmock_bin: ?[:0]const u8 = null; -/// abs paths of the addons the build made (--addon=, image and pdf), linked -/// into each script's data directory, where a session's start scan finds them -var addons: [4][:0]const u8 = undefined; -var naddons: usize = 0; -var record_dir: ?[]const u8 = null; -/// --tape=DIR: each session records its tape there (PARDES_RECORD, src/tape.zig) -/// and the script fails unless every tape replays without diverging. -var tape_dir: ?[]const u8 = null; -/// --replay-with=EXE (with --tape): each tape replayed by that build of -/// pardes too, a window's build replaying a terminal's sessions (a replica -/// of another build reads them so: docs/next-daemon.md). -var replay_with: ?[:0]const u8 = null; -/// --dump (with --tape): each replay also loads the session's dump at its -/// end, which must be the same session and dump to the same bytes -/// (PARDES_REPLAY_DUMP, src/tape.zig). -var dump_check = false; -const gpa = std.heap.page_allocator; - -pub fn main(init: std.process.Init) !void { - var arena_state = std.heap.ArenaAllocator.init(gpa); - defer arena_state.deinit(); - const arena = arena_state.allocator(); - const args = try init.minimal.args.toSlice(init.arena.allocator()); - if (args.len == 2 and std.mem.eql(u8, args[1], "--self-test")) return testCli(init); - - // argv: exe-under-test, then flags/scripts. All paths made absolute up - // front because runScript chdirs into a per-script workdir. - var cwd_buf: [4096]u8 = undefined; - const cwd_p = libc.getcwd(&cwd_buf, cwd_buf.len) orelse fatal("getcwd failed", .{}); - const orig_cwd = std.mem.span(@as([*:0]u8, @ptrCast(cwd_p))); - - var exe: ?[]const u8 = null; - var update = false; - var retry_failures = true; - // Slight oversubscription: a script spends most of its life waiting on a - // shell, not computing. Measured on 16 cores: 16 jobs 4.4s, 20 jobs 3.9s, - // 24 jobs 3.7s but losing the idle-probe bet often enough that the re-run - // pass costs more than the extra parallelism saves. - const cpus = std.Thread.getCpuCount() catch 4; - var jobs: usize = cpus + cpus / 4; - var script_count: usize = 0; - var lspmock: ?[]const u8 = null; - for (args[1..]) |a| { - if (std.mem.eql(u8, a, "--update")) { - update = true; - } else if (std.mem.eql(u8, a, "--no-retry")) { - retry_failures = false; - } else if (std.mem.eql(u8, a, "--trace-stable")) { - trace_stable = true; - } else if (std.mem.startsWith(u8, a, "--lspmock=")) { - lspmock = try absPath(arena, orig_cwd, a["--lspmock=".len..]); - } else if (std.mem.startsWith(u8, a, "--addon=")) { - if (naddons == addons.len) return error.TooManyAddons; - addons[naddons] = try arena.dupeSentinel(u8, try absPath(arena, orig_cwd, a["--addon=".len..]), 0); - naddons += 1; - } else if (std.mem.startsWith(u8, a, "--record=")) { - record_dir = try absPath(arena, orig_cwd, a["--record=".len..]); - } else if (std.mem.startsWith(u8, a, "--tape=")) { - tape_dir = try absPath(arena, orig_cwd, a["--tape=".len..]); - } else if (std.mem.eql(u8, a, "--dump")) { - dump_check = true; - } else if (std.mem.startsWith(u8, a, "--replay-with=")) { - replay_with = try arena.dupeSentinel(u8, try absPath(arena, orig_cwd, a["--replay-with=".len..]), 0); - } else if (std.mem.startsWith(u8, a, "--jobs=")) { - jobs = @max(1, try std.fmt.parseInt(usize, a["--jobs=".len..], 10)); - } else if (exe == null) { - exe = try absPath(arena, orig_cwd, a); - } else { - script_count += 1; - } - } - // Updating used to be serial, because update mode has no expected bytes and - // so cannot tell a transient capture from behaviour. Serial was a proxy for - // that, and an expensive one (77s against 6s). What it was reaching for is - // available directly: capture at the WIDEST probe settings the harness has - // (beCareful, as if every script had already failed once), then run the - // ordinary verify pass over what was just written. A golden that does not - // reproduce is reported instead of blessed, and the parallel pass keeps its - // retry machinery, which serial update never had. - var scripts = try arena.alloc([]const u8, script_count); - var script_i: usize = 0; - var saw_exe = false; - for (args[1..]) |a| { - if (std.mem.eql(u8, a, "--update") or - std.mem.eql(u8, a, "--no-retry") or - std.mem.eql(u8, a, "--trace-stable") or - std.mem.startsWith(u8, a, "--lspmock=") or - std.mem.startsWith(u8, a, "--addon=") or - std.mem.startsWith(u8, a, "--record=") or - std.mem.startsWith(u8, a, "--tape=") or - std.mem.eql(u8, a, "--dump") or - std.mem.startsWith(u8, a, "--replay-with=") or - std.mem.startsWith(u8, a, "--jobs=")) continue; - if (!saw_exe) { - saw_exe = true; - continue; - } - scripts[script_i] = try absPath(arena, orig_cwd, a); - script_i += 1; - } - if (exe == null) fatal("usage: pardes-snap <exe> [scripts...] [--update] [--jobs=N]", .{}); - const exe_z = try arena.dupeSentinel(u8, exe.?, 0); - lspmock_bin = if (lspmock) |p| try arena.dupeSentinel(u8, p, 0) else null; - - if (scripts.len == 0) { - scripts = try listSnaps(arena, try absPath(arena, orig_cwd, "test/snapshots")); - std.mem.sort([]const u8, scripts, {}, struct { - fn lt(_: void, x: []const u8, y: []const u8) bool { - return std.mem.lessThan(u8, x, y); - } - }.lt); - } - if (scripts.len == 0) fatal("no .snap scripts found", .{}); - for (scripts, 0..) |script, i| for (scripts[0..i]) |previous| { - if (std.mem.eql(u8, std.fs.path.stem(script), std.fs.path.stem(previous))) { - std.debug.print("snapshot scripts share a work directory: {s} and {s}\n", .{ previous, script }); - return error.DuplicateScriptName; - } - }; - if (record_dir) |dir| { - if (update) fatal("--record and --update are separate modes", .{}); - try mkdir(arena, dir, true); - } - if (tape_dir) |dir| try mkdir(arena, dir, true); - - try mkdir(arena, SNAP_BASE, true); - // one run at a time (this is the flock that used to be typed by hand) - _ = lockOrWait(SNAP_BASE ++ "/.run.lock", "another pardes-snap run"); - - const codes = try arena.alloc(u8, scripts.len); - if (update) { - careful = true; - try runBatch(arena, exe_z, try toBatch(arena, scripts), true, jobs, codes); - var update_failed = false; - for (scripts, codes) |script, code| if (code != 0) { - update_failed = true; - const report = readFileAlloc(arena, try reportPath(arena, script)) catch "child died without a report\n"; - std.debug.print("{s}", .{report}); - }; - if (update_failed) return error.SnapshotRegenerationFailed; - careful = false; - std.debug.print("verifying {d} regenerated golden(s)\n", .{scripts.len}); - } - try runBatch(arena, exe_z, try toBatch(arena, scripts), false, jobs, codes); - - const attempts = try arena.alloc(u8, scripts.len); - @memset(attempts, 0); - var retry_dir: ?[]const u8 = null; - if (jobs > 1 and retry_failures) { - var round: usize = 0; - while (round < 2) : (round += 1) { - var retry_count: usize = 0; - for (codes) |c| { - if (c != 0) retry_count += 1; - } - if (retry_count == 0 or retry_count > 10) break; - if (retry_dir == null) { - var template = "/tmp/pardes-snap-retry-XXXXXX".* ++ [_:0]u8{0}; - const path = mkdtemp(&template) orelse return error.TempDirectoryFailed; - retry_dir = try arena.dupe(u8, std.mem.span(path)); - std.debug.print("retry captures: {s}\n", .{retry_dir.?}); - } - const retry = try arena.alloc(usize, retry_count); - var retry_i: usize = 0; - for (codes, 0..) |c, i| { - if (c != 0) { - try archiveAttempt(init.io, arena, retry_dir.?, scripts[i], attempts[i]); - attempts[i] += 1; - retry[retry_i] = i; - retry_i += 1; - } - } - const paths = try arena.alloc(Idx, retry.len); - for (retry, paths, 0..) |i, *p, n| p.* = .{ .path = scripts[i], .code_idx = n }; - std.debug.print("re-running {d} failed script(s) serially{s}:", .{ - paths.len, - if (round == 0) "" else " with wider settle probes", - }); - for (paths) |p| std.debug.print(" {s}", .{std.fs.path.stem(p.path)}); - std.debug.print("\n", .{}); - careful = round > 0; - const recodes = try arena.alloc(u8, paths.len); - try runBatch(arena, exe_z, paths, false, 1, recodes); - for (retry, recodes) |i, c| codes[i] = c; - } - } - - var failed: usize = 0; - for (scripts, codes, attempts) |script_path, code, attempt| { - if (attempt != 0) { - try archiveAttempt(init.io, arena, retry_dir.?, script_path, attempt); - std.debug.print("{s} required {d} retr{s}\n", .{ std.fs.path.stem(script_path), attempt, if (attempt == 1) "y" else "ies" }); - } - const report = readFileAlloc(arena, reportPath(arena, script_path) catch "") catch ""; - std.debug.print("{s}", .{report}); - if (code != 0) { - failed += 1; - if (report.len == 0) - std.debug.print("FAIL {s}: child died with no report\n", .{std.fs.path.stem(script_path)}); - } - } - if (failed > 0) { - // In update mode the golden was written and then failed to reproduce: - // the capture is not stable, so it is not a baseline. - std.debug.print("{d}/{d} snapshot scripts {s}\n", .{ - failed, scripts.len, if (update) "UNSTABLE (regenerated, does not reproduce)" else "FAILED", - }); - std.process.exit(1); - } - // Every retry passed: the captures of the failed attempts explain - // nothing any more, and /tmp is not where they should pile up. - if (retry_dir) |d| std.Io.Dir.cwd().deleteTree(init.io, d) catch {}; - std.debug.print("all {d} snapshot scripts ok\n", .{scripts.len}); -} - -fn testCli(init: std.process.Init) !void { - const io = init.io; - const arena = init.arena.allocator(); - const exe = try std.process.executablePathAlloc(io, arena); - var template = "/tmp/pardes-snap-selftest-XXXXXX".* ++ [_:0]u8{0}; - const root = std.mem.span(mkdtemp(&template) orelse return error.TempDirectoryFailed); - const prefix = std.fs.path.basename(root); - var dir = try std.Io.Dir.cwd().openDir(io, root, .{}); - defer dir.close(io); - var archives: std.ArrayList([]const u8) = .empty; - var passed = false; - defer { - if (passed) { - for (archives.items) |path| std.Io.Dir.cwd().deleteTree(io, path) catch {}; - for ([_][]const u8{ "bad", "good", "error", "unwritable" }) |name| { - const work = std.fmt.allocPrint(arena, "{s}/{s}-{s}", .{ SNAP_BASE, prefix, name }) catch continue; - std.Io.Dir.cwd().deleteTree(io, work) catch {}; - const report = std.fmt.allocPrint(arena, "{s}.report", .{work}) catch continue; - std.Io.Dir.cwd().deleteFile(io, report) catch {}; - } - std.Io.Dir.cwd().deleteTree(io, root) catch {}; - } else std.debug.print("snapshot driver test evidence: {s}\n", .{root}); - } - var scripts: [4][]const u8 = undefined; - for ([_][]const u8{ "bad", "good", "error", "unwritable" }, 0..) |name, i| { - const path = try std.fmt.allocPrint(arena, "{s}-{s}.snap", .{ prefix, name }); - try dir.writeFile(io, .{ .sub_path = path, .data = if (i == 2) "run false\n" else "file marker content\n" }); - scripts[i] = try std.fmt.allocPrint(arena, "{s}/{s}", .{ root, path }); - const golden = try std.fmt.allocPrint(arena, "{s}-{s}.golden", .{ prefix, name }); - try dir.writeFile(io, .{ .sub_path = golden, .data = if (i == 0 or i == 3) "expected capture\n" else "" }); - } - try dir.createDir(io, "other", .default_dir); - const duplicate = try std.fmt.allocPrint(arena, "{s}/other/{s}", .{ root, std.fs.path.basename(scripts[1]) }); - try std.Io.Dir.cwd().writeFile(io, .{ .sub_path = duplicate, .data = "file marker content\n" }); - const stale_actual = try std.fmt.allocPrint(arena, "{s}/{s}-error.actual", .{ root, prefix }); - try std.Io.Dir.cwd().writeFile(io, .{ .sub_path = stale_actual, .data = "older verification evidence\n" }); - const unwritable = try std.fmt.allocPrint(arena, "{s}-unwritable.actual", .{prefix}); - try dir.createDir(io, unwritable, .default_dir); - const record_arg = try std.fmt.allocPrint(arena, "--record={s}/recorded", .{root}); - const fixtures = [_]struct { - name: []const u8, - args: []const []const u8, - status: u8 = 1, - message: []const u8, - archived: ?usize = null, - actual: bool = false, - }{ - .{ .name = "retry", .args = &.{ scripts[0], scripts[1], "--jobs=2" }, .message = "required 2 retries", .archived = 0, .actual = true }, - .{ .name = "no-retry", .args = &.{ scripts[0], scripts[1], "--jobs=2", "--no-retry" }, .message = "1/2 snapshot scripts FAILED" }, - .{ .name = "duplicate", .args = &.{ scripts[1], duplicate, "--jobs=2" }, .message = "DuplicateScriptName" }, - .{ .name = "record", .args = &.{ scripts[2], scripts[1], "--jobs=2", record_arg }, .message = "1/2 snapshot scripts FAILED", .archived = 2 }, - .{ .name = "update", .args = &.{ scripts[2], "--jobs=2", "--update", "--no-retry" }, .message = "SnapshotRegenerationFailed" }, - .{ .name = "actual-write", .args = &.{ scripts[3], "--no-retry" }, .message = "cannot write" }, - .{ .name = "pass", .args = &.{ scripts[1], "--jobs=2" }, .status = 0, .message = "all 1 snapshot scripts ok" }, - }; - for (fixtures) |fixture| { - const argv = try arena.alloc([]const u8, fixture.args.len + 2); - argv[0] = exe; - argv[1] = exe; - @memcpy(argv[2..], fixture.args); - const result = try std.process.run(arena, io, .{ - .argv = argv, - .stdout_limit = .limited(1024 * 1024), - .stderr_limit = .limited(1024 * 1024), - .timeout = .{ .duration = .{ .clock = .awake, .raw = .fromSeconds(30) } }, - }); - try dir.writeFile(io, .{ .sub_path = try std.fmt.allocPrint(arena, "{s}.log", .{fixture.name}), .data = result.stderr }); - if (result.term != .exited or result.term.exited != fixture.status or std.mem.indexOf(u8, result.stderr, fixture.message) == null) { - std.debug.print("snapshot CLI fixture {s}:\n{s}\n", .{ fixture.name, result.stderr }); - return error.SnapshotDriverTestFailed; - } - const archive_marker = "retry captures: "; - const archive_start = std.mem.indexOf(u8, result.stderr, archive_marker); - if (fixture.archived) |script| { - const rest = result.stderr[(archive_start orelse return error.MissingRetryArchive) + archive_marker.len ..]; - const archive = rest[0 .. std.mem.indexOfScalar(u8, rest, '\n') orelse return error.MissingRetryArchive]; - const archive_prefix = "/tmp/pardes-snap-retry-"; - if (!std.mem.startsWith(u8, archive, archive_prefix) or archive.len == archive_prefix.len or - std.mem.indexOfScalar(u8, archive[archive_prefix.len..], '/') != null) - return error.IncorrectRetryArchive; - try archives.append(arena, archive); - if (std.mem.count(u8, result.stderr, "re-running ") != 2) return error.IncorrectRetryCount; - for (0..3) |attempt| { - const report = try std.fmt.allocPrint(arena, "{s}/{s}.{d}.report", .{ archive, std.fs.path.stem(scripts[script]), attempt }); - const report_bytes = try std.Io.Dir.cwd().readFileAlloc(io, report, arena, .limited(1024 * 1024)); - const failure = try std.fmt.allocPrint(arena, "FAIL {s}:", .{std.fs.path.stem(scripts[script])}); - if (std.mem.indexOf(u8, report_bytes, failure) == null) return error.MissingAttemptReport; - const actual = try std.fmt.allocPrint(arena, "{s}/{s}.{d}.actual", .{ archive, std.fs.path.stem(scripts[script]), attempt }); - const actual_bytes = std.Io.Dir.cwd().readFileAlloc(io, actual, arena, .limited(1024 * 1024)) catch |err| { - if (err == error.FileNotFound and !fixture.actual) continue; - return err; - }; - if (!fixture.actual or actual_bytes.len != 0) return error.IncorrectAttemptActual; - } - } else if (archive_start != null or std.mem.indexOf(u8, result.stderr, "re-running ") != null) return error.UnexpectedRetry; - if (std.mem.eql(u8, fixture.name, "update") and std.mem.indexOf(u8, result.stderr, "verifying ") != null) - return error.VerifiedFailedRegeneration; - if (std.mem.eql(u8, fixture.name, "actual-write") and std.mem.indexOf(u8, result.stderr, "actual written") != null) - return error.FalseActualReport; - if (std.mem.eql(u8, fixture.name, "retry") or std.mem.eql(u8, fixture.name, "no-retry")) { - const good = try std.fmt.allocPrint(arena, "PASS {s}", .{std.fs.path.stem(scripts[1])}); - if (std.mem.indexOf(u8, result.stderr, good) == null) return error.OmittedPassingScript; - } - if (std.mem.eql(u8, fixture.name, "record")) { - const good = try std.fmt.allocPrint(arena, "RECORDED {s}", .{std.fs.path.stem(scripts[1])}); - if (std.mem.indexOf(u8, result.stderr, good) == null) return error.OmittedPassingScript; - const stale = try std.Io.Dir.cwd().readFileAlloc(io, stale_actual, arena, .limited(1024)); - if (!std.mem.eql(u8, stale, "older verification evidence\n")) return error.ChangedStaleActual; - } - } - passed = true; - std.debug.print("snapshot driver: {d} CLI regression fixtures passed\n", .{fixtures.len}); -} - -/// Run `scripts` `jobs` at a time, one forked child each, filling `codes` with -/// their exit codes. Forking rather than threading because runScript owns -/// process-global state — chdir into its workdir, HOME/TERM/PARDES_DUMP in the -/// environment — which siblings must not see. Each child's report goes to its -/// own file and is replayed in script order by the caller, so parallelism -/// never interleaves a diff. -// Scripts run in the order given — alphabetical. Sorting longest-first (from -// the durations the previous run left in its reports) is the textbook makespan -// fix and it measured WORSE here: 3.0s when clean, but bunching the heavy -// scripts at t=0 makes them contend, the idle probes lose their bet, and the -// re-run pass costs more than the tail ever did (13-20s runs). Left alone. -const Idx = struct { path: []const u8, code_idx: usize }; - -fn toBatch(arena: std.mem.Allocator, scripts: []const []const u8) ![]const Idx { - const out = try arena.alloc(Idx, scripts.len); - for (scripts, out, 0..) |path, *o, i| o.* = .{ .path = path, .code_idx = i }; - return out; -} - -fn runBatch( - arena: std.mem.Allocator, - exe_z: [:0]const u8, - scripts: []const Idx, - update: bool, - jobs: usize, - codes: []u8, -) !void { - const Job = struct { pid: libc.pid_t, idx: usize }; - const running = try arena.alloc(Job, @min(jobs, scripts.len)); - var running_len: usize = 0; - var next: usize = 0; - while (next < scripts.len or running_len > 0) { - while (next < scripts.len and running_len < running.len) : (next += 1) { - const idx = next; - const pid = libc.fork(); - if (pid == 0) std.process.exit(runOne(arena, exe_z, scripts[idx].path, update)); - if (pid < 0) fatal("fork failed", .{}); - running[running_len] = .{ .pid = pid, .idx = scripts[idx].code_idx }; - running_len += 1; - } - var status: c_int = 0; - const pid = libc.waitpid(-1, &status, 0); - for (running[0..running_len], 0..) |j, i| { - if (j.pid != pid) continue; - // a killed child (crash in the harness itself) counts as a failure - codes[j.idx] = if (status == 0) 0 else 1; - running_len -= 1; - running[i] = running[running_len]; - break; - } - } -} - -/// One script, in its own process: run it, then diff or update its golden. -/// Everything it prints lands in its report file (dup2'd over stdout/stderr). -/// Returns the child's exit code. -fn runOne(arena: std.mem.Allocator, exe_z: [:0]const u8, script_path: []const u8, update: bool) u8 { - if (careful) beCareful(); - const stem = std.fs.path.stem(script_path); - const report_z = arena.dupeSentinel(u8, reportPath(arena, script_path) catch return 1, 0) catch return 1; - const fd = libc.open(report_z, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true }, @as(libc.mode_t, 0o644)); - if (fd >= 0) { - _ = libc.dup2(fd, 1); - _ = libc.dup2(fd, 2); - _ = libc.close(fd); - } - const base_path = script_path[0 .. script_path.len - ".snap".len]; - const golden_path = std.fmt.allocPrint(arena, "{s}.golden", .{base_path}) catch return 1; - // `.actual` means THIS invocation failed. Passing runs used to leave an - // ignored file from an older failure behind, making a clean suite look - // dirty to every manual `cmp` audit. Unlink only this script's exact path - // before it starts; a new mismatch below writes it back. - const actual_path = std.fmt.allocPrint(arena, "{s}.actual", .{base_path}) catch return 1; - const actual_path_z = arena.dupeSentinel(u8, actual_path, 0) catch return 1; - if (record_dir == null) _ = libc.unlink(actual_path_z); - const golden: ?[]u8 = if (record_dir == null) readFileAlloc(arena, golden_path) catch null else null; - const started = eh.nowMs(); - const out = runScript(arena, exe_z, script_path, stem) catch |e| { - std.debug.print("FAIL {s}: script error {s} ({d}ms)\n", .{ stem, @errorName(e), eh.nowMs() - started }); - // What the session did before the script gave up replays all the same. - if (tape_dir != null) if (replayTapes(arena, exe_z, stem)) |why| std.debug.print("DIVERGED {s}: {s}\n", .{ stem, why }); - return 1; - }; - const took = eh.nowMs() - started; - if (tape_dir != null) if (replayTapes(arena, exe_z, stem)) |why| { - std.debug.print("DIVERGED {s}: {s}\n", .{ stem, why }); - return 1; - }; - if (record_dir) |dir| { - const path = std.fmt.allocPrintSentinel(arena, "{s}/{s}.snapshot", .{ dir, stem }, 0) catch return 1; - eh.writeFile(path, out) catch return 1; - std.debug.print("RECORDED {s}\n", .{stem}); - return 0; - } - if (update) { - eh.writeFile(arena.dupeSentinel(u8, golden_path, 0) catch return 1, out) catch return 1; - std.debug.print("UPDATED {s} ({d} bytes)\n", .{ stem, out.len }); - return 0; - } - if (golden == null) { - std.debug.print("FAIL {s}: no golden (run with -- --update)\n", .{stem}); - return 1; - } - if (std.mem.eql(u8, golden.?, out)) { - std.debug.print("PASS {s} ({d}ms)\n", .{ stem, took }); - return 0; - } - eh.writeFile(arena.dupeSentinel(u8, actual_path, 0) catch return 1, out) catch |err| { - std.debug.print("FAIL {s}: differs from golden; cannot write {s}: {s} ({d}ms)\n", .{ stem, actual_path, @errorName(err), took }); - printFirstDiff(golden.?, out); - return 1; - }; - std.debug.print("FAIL {s}: differs from golden (actual written to {s}, {d}ms)\n", .{ stem, actual_path, took }); - printFirstDiff(golden.?, out); - return 1; -} - -/// Every tape the script's sessions wrote, replayed by the same build -/// (PARDES_REPLAY), and by --replay-with's: why the first that diverged -/// did, or null. Another build's replay need agree only in its replica that -/// draws nothing, as a replica client draws none of its session's frames: -/// the two that draw meet a window's drawing where the session had a -/// terminal's. -fn replayTapes(arena: std.mem.Allocator, exe_z: [:0]const u8, stem: []const u8) ?[]const u8 { - if (replayTapesWith(arena, exe_z, stem, false)) |why| return why; - const other = replay_with orelse return null; - return replayTapesWith(arena, other, stem, true); -} - -fn replayTapesWith(arena: std.mem.Allocator, exe_z: [:0]const u8, stem: []const u8, headless: bool) ?[]const u8 { - const dir = tape_dir.?; - const io = std.Io.Threaded.global_single_threaded.io(); - var d = std.Io.Dir.cwd().openDir(io, dir, .{ .iterate = true }) catch return "the tape directory cannot be read"; - defer d.close(io); - var it = d.iterate(); - var tapes: usize = 0; - while (it.next(io) catch return "the tape directory cannot be listed") |entry| { - if (!std.mem.startsWith(u8, entry.name, stem) or !std.mem.endsWith(u8, entry.name, ".tape")) continue; - const pid = entry.name[stem.len..][0 .. entry.name.len - stem.len - ".tape".len]; - if (pid.len < 2 or pid[0] != '-' or std.mem.indexOfNone(u8, pid[1..], "0123456789") != null) continue; - tapes += 1; - const cmd = std.fmt.allocPrintSentinel(arena, "PARDES_RECORD= PARDES_REPLAY='{s}/{s}' {s}timeout 300 '{s}' > '{s}/{s}.replay' 2>&1", .{ dir, entry.name, if (dump_check and !headless) "PARDES_REPLAY_DUMP=1 " else "", exe_z, dir, entry.name }, 0) catch return "out of memory"; - if (system(cmd) != 0) { - const why_path = std.fmt.allocPrint(arena, "{s}/{s}.replay", .{ dir, entry.name }) catch return "out of memory"; - const said = readFileAlloc(arena, why_path) catch return "the replay failed and said 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; - }; - return said; - } - } - if (tapes == 0) return "no session wrote a tape"; - return null; -} - -fn reportPath(arena: std.mem.Allocator, script_path: []const u8) ![]const u8 { - return std.fmt.allocPrint(arena, "{s}/{s}.report", .{ SNAP_BASE, std.fs.path.stem(script_path) }); -} - -fn archiveAttempt(io: std.Io, arena: std.mem.Allocator, dir: []const u8, script_path: []const u8, attempt: u8) !void { - const stem = std.fs.path.stem(script_path); - for ([_][]const u8{ "report", "actual" }) |suffix| { - if (record_dir != null and std.mem.eql(u8, suffix, "actual")) continue; - const source = if (std.mem.eql(u8, suffix, "report")) - try reportPath(arena, script_path) - else - try std.fmt.allocPrint(arena, "{s}.actual", .{script_path[0 .. script_path.len - ".snap".len]}); - const bytes = std.Io.Dir.cwd().readFileAlloc(io, source, arena, .limited(64 * 1024 * 1024)) catch |err| { - if (err == error.FileNotFound) continue; - return err; - }; - const path = try std.fmt.allocPrint(arena, "{s}/{s}.{d}.{s}", .{ dir, stem, attempt, suffix }); - const file = try std.Io.Dir.cwd().createFile(io, path, .{ .exclusive = true }); - defer file.close(io); - try file.writeStreamingAll(io, bytes); - } -} - -/// Exclusive flock on `path`, announcing the wait if someone else holds it. -/// The fd is deliberately leaked: the lock lives until the process exits. -/// -/// CLOEXEC is load-bearing. flock lives on the open file description, so an -/// inherited fd keeps the lock — and this process forks a pty full of app and -/// shell processes that can outlive it. Without CLOEXEC an orphaned bash holds -/// the lock forever and every later script blocks in flock(). -fn lockOrWait(path: [*:0]const u8, what: []const u8) libc.fd_t { - const fd = libc.open(path, .{ .ACCMODE = .WRONLY, .CREAT = true, .CLOEXEC = true }, @as(libc.mode_t, 0o644)); - if (fd < 0) fatal("cannot open lockfile {s}", .{path}); - if (libc.flock(fd, std.posix.LOCK.EX | std.posix.LOCK.NB) == 0) return fd; - // polled rather than a blocking flock so a stuck holder is reported instead - // of hanging the run until someone notices. The cap clears a full serial - // run (--jobs=1 is ~6 minutes) with room to spare. - std.debug.print("waiting for {s}...\n", .{what}); - var waited_ms: i64 = 0; - while (waited_ms < 600_000) : (waited_ms += 100) { - var none: [0]std.posix.pollfd = .{}; - _ = std.posix.poll(&none, 100) catch {}; - if (libc.flock(fd, std.posix.LOCK.EX | std.posix.LOCK.NB) == 0) return fd; - } - fatal("gave up after 10 minutes waiting for {s} ({s})", .{ what, path }); -} - -fn runScript(arena: std.mem.Allocator, exe_z: [:0]const u8, script_path: []const u8, stem: []const u8) ![]u8 { - const src = try readFileAlloc(arena, script_path); - - // Fixed, recreated-per-run workdir: its PATH shows up in pane tags, so it - // must be identical across runs and across old/new binaries. - const base = try std.fmt.allocPrint(arena, "{s}/{s}", .{ SNAP_BASE, stem }); - rmrf(base); - try mkdir(arena, SNAP_BASE, true); - 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); - // Keep startup configuration hermetic even when the developer exports an - // XDG directory that points outside this per-snapshot fake home. - const config_home = try std.fmt.allocPrintSentinel(arena, "{s}/.config", .{home}, 0); - _ = setenv("XDG_CONFIG_HOME", config_home, 1); - // ...and its data directory (dumps, the addons its start scan loads). - const data_home = try std.fmt.allocPrintSentinel(arena, "{s}/.local/share", .{home}, 0); - _ = setenv("XDG_DATA_HOME", data_home, 1); - if (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 (addons[0..naddons]) |lib| { - // libpdf.so as pdf.so: the name a build installs it as. - const file = std.fs.path.basename(lib); - const installed = if (std.mem.startsWith(u8, file, "lib")) file[3..] else file; - if (libc.symlink(lib, try std.fmt.allocPrintSentinel(arena, "{s}/pardes/addons/{s}", .{ data_home, installed }, 0)) != 0) return error.SymlinkFailed; - } - // ...and it is not empty: the DEFAULT shell is $SHELL, whatever this - // machine's user logs in with (fish's prompt carries a hostname and its - // greeting a version), so a golden taken - // against it would be a golden for this machine. Every script here runs - // bash — the .bashrc above pins its prompt to `$ ` — and the fish path is - // covered by host_io.Shell's unit tests instead. This is an ordinary - // config init going through the ordinary startup-config path, so it also - // proves `Shell <name>` is dispatchable from one. - try mkdir(arena, config_home, false); - const pardes_config = try std.fmt.allocPrint(arena, "{s}/pardes", .{config_home}); - try mkdir(arena, pardes_config, false); - // Messages leave the moment they are dismissed, as goldens have always - // recorded: a linger or a dissolve is time, and time cannot be a golden. - try eh.writeFile(try std.fmt.allocPrintSentinel(arena, "{s}/init", .{pardes_config}, 0), "Shell bash\nMessageLinger 0\n"); - _ = setenv("TERM", "xterm-256color", 1); - _ = setenv("LC_ALL", "C", 1); - // a wall clock cannot live in a golden; everything that would print one - // prints fixed characters instead when this is set — the lsp introspection - // views' durations and the transient message row's - // time of day (message.zig stamp) - _ = setenv("PARDES_NOTIME", "1", 1); - // A virtual core clock: animation moves a frame per timed-out wait, - // whatever the machine's load (host_io.testClock). - _ = setenv("PARDES_TEST_CLOCK", "1", 1); - // The protocol client must be HERMETIC under the harness: `.rs` files - // speak to the deterministic mock when the build handed one over, and - // every other spec is disabled outright — a script that opened a stray - // `.c` or `.ts` file must never spawn whatever clangd this machine has. - _ = setenv("PARDES_LSP_RS", lspmock_bin orelse "", 1); - _ = setenv("PARDES_LSP_C", "", 1); - _ = setenv("PARDES_LSP_GO", "", 1); - _ = setenv("PARDES_LSP_TS", "", 1); - _ = setenv("PARDES_LSP_PY", "", 1); - // Pin the dump path: live runs use a timestamped file under the user data - // dir (dump.outPath), which would make the dump/load/restore goldens - // nondeterministic. Per-SCRIPT, not one shared /tmp/pardes-dump.zon: four - // scripts write it and read it back, and sharing it meant they could only - // take turns — which cost more wall clock than the other 51 scripts put - // together. Scripts name it `$DUMP`. - const dump_path = try std.fmt.allocPrint(arena, "{s}/dump.zon", .{base}); - _ = setenv("PARDES_DUMP", try arena.dupeSentinel(u8, dump_path, 0), 1); - // Each session the script starts (and each pardes run inside one) - // writes its own tape, <stem>-<pid>.tape. - if (tape_dir) |dir| { - _ = system(try std.fmt.allocPrintSentinel(arena, "rm -f '{s}/{s}-'[0-9]*.tape '{s}/{s}-'[0-9]*.tape.replay", .{ dir, stem, dir, stem }, 0)); - _ = setenv("PARDES_RECORD", try std.fmt.allocPrintSentinel(arena, "{s}/{s}-", .{ dir, stem }, 0), 1); - } - if (chdirRc(try arena.dupeSentinel(u8, work, 0)) < 0) return error.ChdirFailed; - - const chunks = try arena.alloc([]const u8, countCaptures(src)); - var chunk_len: usize = 0; - var h: ?eh.Harness = null; - defer if (h) |*hp| hp.deinit(); - // captures are deltas against the previous one of the same kind (see Prev) - var prev: Prev = .{}; - - var lines_it = std.mem.splitScalar(u8, src, '\n'); - var lineno: usize = 0; - while (lines_it.next()) |raw_line| { - lineno += 1; - const trimmed = std.mem.trim(u8, raw_line, " \t\r"); - if (trimmed.len == 0 or trimmed[0] == '#') continue; - // `$DUMP` is the script's own PARDES_DUMP file (see above) - const line = if (std.mem.indexOf(u8, trimmed, "$DUMP") == null) trimmed else blk: { - const buf = try arena.alloc(u8, std.mem.replacementSize(u8, trimmed, "$DUMP", dump_path)); - _ = std.mem.replace(u8, trimmed, "$DUMP", dump_path, buf); - break :blk buf; - }; - var tok = std.mem.tokenizeScalar(u8, line, ' '); - const cmd = tok.next().?; - errdefer std.debug.print(" at {s}:{d}: {s}\n", .{ script_path, lineno, line }); - - if (std.mem.eql(u8, cmd, "config")) { - // Appended to the startup config this script's fake home already - // has, so a script can pin a setting instead of spelling out the - // screen geometry a default implies. Must precede `start`. - const setting = try std.fmt.allocPrint(arena, "{s}\n", .{tok.rest()}); - try eh.appendFile(try std.fmt.allocPrintSentinel(arena, "{s}/pardes/init", .{config_home}, 0), setting); - } else if (std.mem.eql(u8, cmd, "file")) { - const name = tok.next() orelse return error.BadScript; - try eh.writeFile(try arena.dupeSentinel(u8, name, 0), try unescape(arena, tok.rest())); - } else if (std.mem.eql(u8, cmd, "lines")) { - const name = tok.next() orelse return error.BadScript; - const n = try std.fmt.parseInt(usize, tok.next() orelse return error.BadScript, 10); - // anything after the count is glued onto every line (no separator: - // `rest` eats the delimiter, so spell one in the tail if you want - // one) — a file that is long AND wide, which is what a horizontal - // scroll test needs and `file` can only give as one huge script line - const tail = tok.rest(); - const buf = try numberedLines(arena, n, tail); - try eh.writeFile(try arena.dupeSentinel(u8, name, 0), buf); - } else if (std.mem.eql(u8, cmd, "ppmdiag")) { - // The diagonal-split test PPM from the old e2e (white over blue), - // grown to 512x512 with the white half filled by a fixed LCG - // noise. Both halves are load-bearing: the clean edge is what the - // block/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 image cannot show (its cells average - // down to flat color and a block always wins). - const name = tok.next() orelse return error.BadScript; - const ppm = try ppmDiag(arena); - try eh.writeFile(try arena.dupeSentinel(u8, name, 0), ppm); - } else if (std.mem.eql(u8, cmd, "dirmk")) { - try mkdir(arena, tok.next() orelse return error.BadScript, false); - } else if (std.mem.eql(u8, cmd, "run")) { - // A writer that is NOT a pardes pane. `file` mid-script is already - // one, but it cannot express the rename-over that is how a - // formatter actually replaces a file — and the difference is a - // different inotify event. This runs in the script's cwd, as a - // child of the RUNNER, so nothing it does reaches the app's ptys: - // whatever the app then shows, it woke up for by itself. - if (system(try arena.dupeSentinel(u8, tok.rest(), 0)) != 0) return error.RunFailed; - } else if (std.mem.eql(u8, cmd, "start")) { - const rows = try std.fmt.parseInt(u16, tok.next() orelse return error.BadScript, 10); - const cols = try std.fmt.parseInt(u16, tok.next() orelse return error.BadScript, 10); - var extra: [6]?[*:0]const u8 = @splat(null); - var nextra: usize = 0; - while (tok.next()) |a| { - if (nextra >= extra.len) return error.BadScript; - extra[nextra] = (try arena.dupeSentinel(u8, a, 0)).ptr; - nextra += 1; - } - if (h) |*hp| hp.deinit(); // scripts may restart (e.g. dump then -l) - // a new process is a new screen: capture it whole, or its first - // frame would be a delta against a dead instance's rows - prev = .{}; - h = try eh.Harness.initArgv(gpa, exe_z.ptr, rows, cols, extra[0..nextra]); - } else if (std.mem.eql(u8, cmd, "snapfile")) { - const label = tok.next() orelse return error.BadScript; - const contents = try readFileAlloc(arena, tok.rest()); - // Elide base64 payloads: they encode raw pty byte HISTORY, whose - // micro-timing (prompt redraw cycles) legitimately differs between - // implementations; the cleaned text fields are the contract. - try appendChunk(chunks, &chunk_len, try snapFile(arena, label, contents)); - } else if (std.mem.eql(u8, cmd, "wait")) { - const ms = try std.fmt.parseInt(i64, tok.next() orelse return error.BadScript, 10); - try live(&h).expectWaitFor(tok.rest(), ms, "snapshot wait"); - } else if (std.mem.eql(u8, cmd, "settle")) { - try live(&h).pump(try std.fmt.parseInt(i64, tok.next() orelse return error.BadScript, 10)); - } else if (std.mem.eql(u8, cmd, "stable")) { - const quiet = try std.fmt.parseInt(i64, tok.next() orelse return error.BadScript, 10); - const timeout = try std.fmt.parseInt(i64, tok.next() orelse return error.BadScript, 10); - try waitStable(live(&h), quiet, timeout); - } else if (std.mem.eql(u8, cmd, "text")) { - try live(&h).send(tok.rest()); - } else if (std.mem.eql(u8, cmd, "send")) { - try live(&h).send(try unescape(arena, tok.rest())); - } else if (std.mem.eql(u8, cmd, "key")) { - while (tok.next()) |name| try live(&h).send(keyBytes(name) orelse return error.BadKey); - } else if (std.mem.eql(u8, cmd, "press") or std.mem.eql(u8, cmd, "release") or std.mem.eql(u8, cmd, "drag")) { - const btn = buttonCode(tok.next() orelse return error.BadScript) orelse return error.BadScript; - const col_spec = tok.next() orelse return error.BadScript; - const row = try std.fmt.parseInt(u16, tok.next() orelse return error.BadScript, 10); - const col = try resolveCol(live(&h), col_spec, row); - const b: u16 = if (std.mem.eql(u8, cmd, "drag")) btn + 32 else btn; - const fin: u8 = if (std.mem.eql(u8, cmd, "release")) 'm' else 'M'; - try live(&h).send(try std.fmt.allocPrint(arena, "\x1b[<{d};{d};{d}{c}", .{ b, col, row, fin })); - } else if (std.mem.eql(u8, cmd, "motion")) { - const col_spec = tok.next() orelse return error.BadScript; - const row = try std.fmt.parseInt(u16, tok.next() orelse return error.BadScript, 10); - const col = try resolveCol(live(&h), col_spec, row); - try live(&h).send(try std.fmt.allocPrint(arena, "\x1b[<35;{d};{d}M", .{ col, row })); - } else if (std.mem.eql(u8, cmd, "wheel")) { - const dir = tok.next() orelse return error.BadScript; - const b: u16 = if (std.mem.eql(u8, dir, "up")) 64 else 65; - const col_spec = tok.next() orelse return error.BadScript; - const row = try std.fmt.parseInt(u16, tok.next() orelse return error.BadScript, 10); - const col = try resolveCol(live(&h), col_spec, row); - try live(&h).send(try std.fmt.allocPrint(arena, "\x1b[<{d};{d};{d}M", .{ b, col, row })); - } else if (std.mem.eql(u8, cmd, "resize")) { - const rows = try std.fmt.parseInt(u16, tok.next() orelse return error.BadScript, 10); - const cols = try std.fmt.parseInt(u16, tok.next() orelse return error.BadScript, 10); - try live(&h).resize(rows, cols); - // Another view's terminal is no one's controlling one: the app - // is told it changed, as a stub tells it of its own. - } else if (std.mem.eql(u8, cmd, "snap")) { - try appendChunk(chunks, &chunk_len, try snapText(arena, live(&h), tok.rest(), &prev)); - } else if (std.mem.eql(u8, cmd, "snapstyle")) { - try appendChunk(chunks, &chunk_len, try snapStyle(arena, live(&h), tok.rest(), &prev)); - } else if (std.mem.eql(u8, cmd, "snap9p")) { - try appendChunk(chunks, &chunk_len, try snap9p(arena, live(&h), tok.rest(), &prev)); - } else { - std.debug.print("unknown command {s}\n", .{cmd}); - return error.BadScript; - } - } - return concatChunks(arena, chunks[0..chunk_len]); -} - -fn countCaptures(src: []const u8) usize { - var count: usize = 0; - var lines = std.mem.splitScalar(u8, src, '\n'); - while (lines.next()) |raw_line| { - const line = std.mem.trim(u8, raw_line, " \t\r"); - if (line.len == 0 or line[0] == '#') continue; - var tok = std.mem.tokenizeScalar(u8, line, ' '); - const cmd = tok.next().?; - if (std.mem.eql(u8, cmd, "snap") or - std.mem.eql(u8, cmd, "snapstyle") or - std.mem.eql(u8, cmd, "snap9p") or - std.mem.eql(u8, cmd, "snapfile")) count += 1; - } - return count; -} - -fn appendChunk(chunks: [][]const u8, len: *usize, chunk: []const u8) !void { - if (len.* == chunks.len) return error.BadScript; - chunks[len.*] = chunk; - len.* += 1; -} - -fn concatChunks(arena: std.mem.Allocator, chunks: []const []const u8) ![]u8 { - var total: usize = 0; - for (chunks) |chunk| total += chunk.len; - const out = try arena.alloc(u8, total); - var pos: usize = 0; - for (chunks) |chunk| copyBytes(out, &pos, chunk); - return out; -} - -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 ppmDiag(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 snapFile(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; -} - -/// The terminal the script drives now (`view`). -fn live(h: *?eh.Harness) *eh.Harness { - if (h.*) |*v| return v; - fatal("script used the app before `start`", .{}); -} - -/// 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 old and new binaries are compared 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) { - if (trace_stable) std.debug.print("[stable q={d}] window: last change +{d}ms, cost {d}ms\n", .{ quiet, last_change - t0, now - t0 }); - return; - } - // Fast path: the screen has held still, the pty is empty in both - // directions (so the app has CONSUMED everything the script 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) { - if (trace_stable) std.debug.print("[stable q={d}] asleep: last change +{d}ms, cost {d}ms\n", .{ quiet, last_change - t0, now - t0 }); - 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; - if (trace_stable) std.debug.print("[stable q={d}] change at +{d}ms (gap {d}ms)\n", .{ quiet, eh.nowMs() - t0, eh.nowMs() - last_change }); - 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; - -/// Widen the probes for the re-run pass: nothing else is competing then, so the -/// extra wait is cheap, and its verdict is the one that gets reported. -fn beCareful() void { - probe_after_ms = 40; - probe_hold_ms = 300; -} - -/// 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 script 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 script, -/// 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 script 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 snap9p(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 script, 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 unescape(arena: std.mem.Allocator, s: []const u8) ![]const u8 { - var len: usize = 0; - var i: usize = 0; - while (i < s.len) : (i += 1) { - if (s[i] != '\\' or i + 1 >= s.len) { - len += 1; - continue; - } - i += 1; - switch (s[i]) { - 'e', 'r', 'n', 't', '\\' => len += 1, - 'x' => { - if (i + 2 >= s.len) return error.BadEscape; - _ = try std.fmt.parseInt(u8, s[i + 1 .. i + 3], 16); - len += 1; - i += 2; - }, - else => return error.BadEscape, - } - } - const out = try arena.alloc(u8, len); - var pos: usize = 0; - i = 0; - while (i < s.len) : (i += 1) { - if (s[i] != '\\' or i + 1 >= s.len) { - out[pos] = s[i]; - pos += 1; - continue; - } - i += 1; - out[pos] = switch (s[i]) { - 'e' => 0x1b, - 'r' => '\r', - 'n' => '\n', - 't' => '\t', - '\\' => '\\', - 'x' => value: { - const value = try std.fmt.parseInt(u8, s[i + 1 .. i + 3], 16); - i += 2; - break :value value; - }, - else => unreachable, - }; - pos += 1; - } - return out; -} - -fn absPath(arena: std.mem.Allocator, cwd: []const u8, p: []const u8) ![]const u8 { - if (p.len > 0 and p[0] == '/') return try arena.dupe(u8, p); - return try std.fmt.allocPrint(arena, "{s}/{s}", .{ cwd, p }); -} - -fn listSnaps(arena: std.mem.Allocator, dir_path: []const u8) ![][]const u8 { - const dir_z = try arena.dupeSentinel(u8, dir_path, 0); - const count = countSnapEntries(dir_z, dir_path); - const scripts = try arena.alloc([]const u8, count); - const dir = libc.opendir(dir_z) orelse fatal("no snapshots/ dir at {s}", .{dir_path}); - defer _ = libc.closedir(dir); - var i: usize = 0; - while (libc.readdir(dir)) |d| { - const name = std.mem.sliceTo(@as([*:0]const u8, @ptrCast(&d.name)), 0); - if (!std.mem.endsWith(u8, name, ".snap")) continue; - if (i == scripts.len) return error.DirectoryChanged; - scripts[i] = try std.fmt.allocPrint(arena, "{s}/{s}", .{ dir_path, name }); - i += 1; - } - if (i != scripts.len) return error.DirectoryChanged; - return scripts; -} - -fn countSnapEntries(dir_z: [:0]const u8, dir_path: []const u8) usize { - const dir = libc.opendir(dir_z) orelse fatal("no snapshots/ dir at {s}", .{dir_path}); - defer _ = libc.closedir(dir); - var count: usize = 0; - while (libc.readdir(dir)) |d| { - const name = std.mem.sliceTo(@as([*:0]const u8, @ptrCast(&d.name)), 0); - if (std.mem.endsWith(u8, name, ".snap")) count += 1; - } - return count; -} - -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 chdirRc(path_z: [:0]const u8) c_int { - return libc.chdir(path_z.ptr); -} - -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; - } -} - -fn fatal(comptime fmt: []const u8, args: anytype) noreturn { - std.debug.print(fmt ++ "\n", args); - std.process.exit(1); -} diff --git a/test/tty.zig b/test/tty.zig index d139cb6a..2fdf5952 100644 --- a/test/tty.zig +++ b/test/tty.zig @@ -45,6 +45,16 @@ 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; @@ -119,6 +129,10 @@ pub const Tty = struct { 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 }; } @@ -129,6 +143,13 @@ pub const Tty = struct { /// 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 ""; @@ -140,6 +161,30 @@ pub const Tty = struct { 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`. |
