diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-04 21:29:23 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-04 21:29:23 -0300 |
| commit | 528a66cc720b25252a497adeb358e729dc8f3a62 (patch) | |
| tree | 872890f4f70d8a1ef07eba9a0f6fe72b491ee883 /test/process/window.zig | |
| parent | e67a1a561d9a9a7269bcc7c9af5678d3f50a95cb (diff) | |
| download | pardes-528a66cc720b25252a497adeb358e729dc8f3a62.tar.gz pardes-528a66cc720b25252a497adeb358e729dc8f3a62.zip | |
test: the window's own tests in Zig (T4, test/process/window.zig), gui_monkey.py and gui_golden.py gone: the monkey drives the hidden window's own input (Detached.typeKeys into its pty, Detached.mouse's OSC 777 events) with clicks, drags, wheels, hovers and keys, and columns, looks, Joincol, Collapse, Delcol and themes over 9P, then the window must settle, alive, with no crash record (two combinations of 30 steps in process-test, all 40 Motion x Lift x Bloom with zig build monkey-gui -Dplatform=gui); the goldens hash the 17 scenes' frames (Detached.capture, a transition's frame 6 too) against test/gui-goldens.txt, regenerated for the offscreen window and twice reproduced, run when asked (zig build gui-golden -Dplatform=gui, PARDES_GUI_GOLDEN=update); Detached's init file, settle and capture; no Python step left in the build
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'test/process/window.zig')
| -rw-r--r-- | test/process/window.zig | 364 |
1 files changed, 364 insertions, 0 deletions
diff --git a/test/process/window.zig b/test/process/window.zig new file mode 100644 index 00000000..63247122 --- /dev/null +++ b/test/process/window.zig @@ -0,0 +1,364 @@ +//! The window's own (T4 of docs/next-tests.md): what only its pixels and +//! its own input show, on the hidden window `zig build process-test +//! -Dplatform=gui` drives. test/gui_monkey.py and test/gui_golden.py, here. +const std = @import("std"); +const process = @import("../process.zig"); +extern "c" fn system(cmd: [*:0]const u8) c_int; + +pub const cases = .{ + .{ "window: a monkey over the effects: random clicks, drags, wheels, keys, columns, looks and themes, then it settles, alive, with no crash record", monkey }, + .{ "window: its scenes are the frames test/gui-goldens.txt hashes (PARDES_GUI_GOLDEN=check|update, this machine's)", goldens }, +}; + +fn envOr(name: [*:0]const u8, default: []const u8) []const u8 { + return if (std.c.getenv(name)) |v| std.mem.span(v) else default; +} + +/// The serial of the first pane whose tag holds `word`, waited for. +fn paneWith(f: *process.Files, word: []const u8) !u32 { + const deadline = process.nowMs() + 10_000; + while (process.nowMs() < deadline) : (process.nap(50)) { + var rows = std.mem.tokenizeScalar(u8, try f.read("/index"), '\n'); + while (rows.next()) |row| { + const serial = std.fmt.parseInt(u32, row[0 .. std.mem.indexOfScalar(u8, row, ' ') orelse continue], 10) catch continue; + if (process.has(try f.read(f.at("/pane/{d}/tag", .{serial})), word)) return serial; + } + } + std.debug.print("no pane's tag holds {s}\n", .{word}); + return error.NoSuchPane; +} + +const motions = [_][]const u8{ "off", "crisp", "smooth", "bouncy", "playful" }; +const lifts = [_][]const u8{ "off", "shadow", "rim", "auto" }; +const blooms = [_][]const u8{ "0", "2" }; +const themes = [_][]const u8{ "lapis", "lapis_plain", "forge", "acme", "dusk", "daybreak" }; + +/// test/gui_monkey.py's: each Motion x Lift x Bloom gets a random burst, +/// then must settle with its process alive and no crash record. Two +/// combinations and 30 steps in process-test; PARDES_GUI_MONKEY=all runs +/// all 40 (`zig build monkey-gui`), PARDES_GUI_MONKEY_SEED and _STEPS +/// choose the rest. +fn monkey(gpa: std.mem.Allocator, exe: [:0]const u8) !void { + try process.only(.gui); + const all = std.mem.eql(u8, envOr("PARDES_GUI_MONKEY", ""), "all"); + const seed = try std.fmt.parseInt(u64, envOr("PARDES_GUI_MONKEY_SEED", "1"), 10); + const steps = try std.fmt.parseInt(usize, envOr("PARDES_GUI_MONKEY_STEPS", if (all) "60" else "30"), 10); + var failed: usize = 0; + var n: usize = 0; + for (motions) |m| for (lifts) |l| for (blooms) |b| { + defer n += 1; + // The smoke run: the quietest combination and the busiest. + if (!all and n != 0 and n != motions.len * lifts.len * blooms.len - 1) continue; + if (!try monkeyOne(gpa, exe, m, l, b, seed * 1000 + n, steps)) failed += 1; + }; + if (failed > 0) return error.MonkeyFailed; +} + +fn monkeyOne(gpa: std.mem.Allocator, exe: [:0]const u8, motion: []const u8, lift: []const u8, bloom: []const u8, seed: u64, steps: usize) !bool { + var arena = std.heap.ArenaAllocator.init(gpa); + defer arena.deinit(); + const a = arena.allocator(); + const init = try std.fmt.allocPrint(a, "Shell /bin/sh\nMessageLinger 0\nMotion {s}\nLift {s}\nBloom {s}\nPanelSlide\nSelectionGlow on\nHoverGlow on\n", .{ motion, lift, bloom }); + var d = try process.Detached.start(gpa, exe, "monkey", .{ .init = init, .env = &.{ + .{ "PARDES_TEST_CLOCK", "1" }, .{ "PARDES_TEST_COLS", "80" }, .{ "PARDES_TEST_ROWS", "28" }, .{ "PARDES_TEST_PAD", "0" }, + } }); + defer d.deinit(); + const f = &d.files; + var src: std.ArrayList(u8) = .empty; + for (0..200) |k| try src.print(a, "pub fn f{d}(x: u32) u32 {{ return x * {d}; }} // a line\n", .{ k, k }); + try d.put("a.zig", src.items); + for ([_][]const u8{ "b.txt", "c.txt" }) |name| { + var text: std.ArrayList(u8) = .empty; + for (0..80) |k| try text.print(a, "{s} line {d} with some words\n", .{ name, k }); + try d.put(name, text.items); + } + const names = [_][]const u8{ "b.txt", "c.txt", "a.zig" }; + var prng = std.Random.DefaultPrng.init(seed); + const r = prng.random(); + const w: u32 = 1280; + const h: u32 = 840; + var log: std.ArrayList(u8) = .empty; + for (0..steps) |_| { + const x = r.uintLessThan(u32, w); + const y = r.uintLessThan(u32, h); + const action = r.uintLessThan(u32, 12); + // A refusal is part of the burst (a Delcol of the last column, a + // look at a moved pane): logged, never the verdict. + step(&d, f, a, r, action, x, y, &names, &log) catch |err| try log.print(a, "refused {t}\n", .{err}); + process.nap(30); + } + var verdict: []const u8 = "ok"; + d.settle(gpa) catch { + verdict = "never settled"; + }; + if (d.exited(0) != null) verdict = "process gone"; + _ = f.read("/index") catch { + verdict = "no /index"; + }; + const config = try std.fmt.allocPrint(a, "{s}/config/pardes", .{d.root()}); + if (process.entries(a, config)) |listed| { + for (listed) |name| if (process.has(name, "crash")) { + verdict = try std.fmt.allocPrint(a, "crash record {s}", .{name}); + }; + } else |_| {} + const ok = std.mem.eql(u8, verdict, "ok"); + if (!ok) std.debug.print("monkey {s}-{s}-bloom{s} (seed {d}): {s}\n{s}", .{ motion, lift, bloom, seed, verdict, log.items }); + return ok; +} + +fn step(d: *process.Detached, f: *process.Files, a: std.mem.Allocator, r: std.Random, action: u32, x: u32, y: u32, names: []const []const u8, log: *std.ArrayList(u8)) !void { + switch (action) { + 0, 1 => { + try d.mouse("down", 1, x, y); + try d.mouse("up", 1, x, y); + try log.print(a, "click {d},{d}\n", .{ x, y }); + }, + 2 => { + const x2 = r.uintLessThan(u32, 1280); + const y2 = r.uintLessThan(u32, 840); + try d.mouse("down", 1, x, y); + for (1..6) |i| { + const k: i64 = @intCast(i); + try d.mouse("motion", 1, @intCast(@as(i64, x) + @divTrunc((@as(i64, x2) - x) * k, 5)), @intCast(@as(i64, y) + @divTrunc((@as(i64, y2) - y) * k, 5))); + } + try d.mouse("up", 1, x2, y2); + try log.print(a, "drag {d},{d}->{d},{d}\n", .{ x, y, x2, y2 }); + }, + 3 => { + const amount = ([_]i32{ -6, -2, 2, 6 })[r.uintLessThan(usize, 4)]; + try d.mouse("wheel", amount, x, y); + try log.print(a, "wheel {d}\n", .{amount}); + }, + 4 => { + try d.mouse("motion", 0, x, y); + try log.print(a, "hover {d},{d}\n", .{ x, y }); + }, + 5 => { + try log.print(a, "Newcol\n", .{}); + try f.write("/ctl", "Newcol\n"); + }, + 6 => if (try firstPane(f)) |serial| { + const target = names[r.uintLessThan(usize, names.len)]; + try log.print(a, "look {s}\n", .{target}); + try f.write(f.at("/pane/{d}/look", .{serial}), f.at("{s}/{s}\n", .{ d.root(), target })); + }, + 7 => if (try firstPane(f)) |serial| { + // Delcol too: the last column's going leaves an empty window + // (acme's), not a quit. + const word = ([_][]const u8{ "Joincol", "Collapse", "Delcol" })[r.uintLessThan(usize, 3)]; + try log.print(a, "{s}\n", .{word}); + try f.write(f.at("/pane/{d}/exec", .{serial}), f.at("{s}\n", .{word})); + } else { + // An empty window: pane/new makes its column and a pane. + try log.print(a, "pane/new (empty window)\n", .{}); + _ = try f.newPane(); + }, + 8 => { + const keys = ([_][]const u8{ "j", "k", "10j", "gg", "w", "%", "v5j", "\x1b" })[r.uintLessThan(usize, 8)]; + try log.print(a, "keys\n", .{}); + try d.typeKeys(keys); + }, + 9 => { + const theme = themes[r.uintLessThan(usize, themes.len)]; + try log.print(a, "Theme {s}\n", .{theme}); + try f.write("/ctl", f.at("Theme {s}\n", .{theme})); + }, + 10 => { + try d.mouse("down", 3, x, y); + try d.mouse("up", 3, x, y); + try log.print(a, "look-click {d},{d}\n", .{ x, y }); + }, + else => { + process.nap(([_]u32{ 0, 50, 200 })[r.uintLessThan(usize, 3)]); + try log.print(a, "pause\n", .{}); + }, + } +} + +fn firstPane(f: *process.Files) !?u32 { + const index = try f.read("/index"); + const end = std.mem.indexOfScalar(u8, index, ' ') orelse return null; + return std.fmt.parseInt(u32, index[0..end], 10) catch null; +} + +/// test/gui_golden.py's scenes, each frame's sha256 against +/// test/gui-goldens.txt: an exact gate for one machine (a GPU, a driver, +/// software rendering here draw their own pixels), never a CI one, so it +/// runs only when asked: PARDES_GUI_GOLDEN=check, or =update to rewrite the +/// goldens; PARDES_GUI_GOLDEN_KEEP=<dir> keeps each frame as <scene>.ppm. +/// The root is fixed: its paths are drawn in the tags. +fn goldens(gpa: std.mem.Allocator, exe: [:0]const u8) !void { + try process.only(.gui); + const mode = envOr("PARDES_GUI_GOLDEN", ""); + if (!std.mem.eql(u8, mode, "check") and !std.mem.eql(u8, mode, "update")) return error.SkipZigTest; + var arena = std.heap.ArenaAllocator.init(gpa); + defer arena.deinit(); + const a = arena.allocator(); + const root = "/tmp/pardes-gui-golden"; + _ = system("rm -rf -- /tmp/pardes-gui-golden"); + if (std.c.mkdir(root, 0o700) != 0) return error.NoRoot; + defer _ = system("rm -rf -- /tmp/pardes-gui-golden"); + var zig: std.ArrayList(u8) = .empty; + try zig.appendSlice(a, + \\const std = @import("std"); + \\ + \\pub const Shape = union(enum) { + \\ circle: f32, + \\ square: f32, + \\ + \\ pub fn area(shape: Shape) f32 { + \\ return switch (shape) { + \\ .circle => |r| std.math.pi * r * r, + \\ .square => |s| s * s, + \\ }; + \\ } + \\}; + \\ + \\pub fn main() void { + \\ var total: f32 = 0; + \\ const shapes = [_]Shape{ .{ .circle = 1 }, .{ .square = 2 } }; + \\ for (shapes) |shape| { + \\ + ); + for (0..60) |n| try zig.print(a, " total += shape.area() * {d}; // line {d}\n", .{ n, n }); + try zig.appendSlice(a, " }\n std.debug.print(\"{d}\\n\", .{total});\n}\n"); + try process.writeFile(a, root ++ "/shapes.zig", zig.items); + var notes: std.ArrayList(u8) = .empty; + for (0..4) |_| try notes.appendSlice(a, "Pardes GUI golden\n\nA second document, opened by Look.\n"); + try process.writeFile(a, root ++ "/notes.txt", notes.items); + // One of the two alignments puts a wide glyph across the body's right edge. + var wide: std.ArrayList(u8) = .empty; + try wide.append(a, 'x'); + for (0..80) |_| try wide.appendSlice(a, "\u{754c}"); + try wide.append(a, '\n'); + for (0..80) |_| try wide.appendSlice(a, "\u{754c}"); + try wide.append(a, '\n'); + try process.writeFile(a, root ++ "/wide.txt", wide.items); + var ppm: std.ArrayList(u8) = .empty; + try ppm.print(a, "P6\n{d} {d}\n255\n", .{ 96, 64 }); + for (0..64) |yy| for (0..96) |xx| try ppm.appendSlice(a, &.{ @intCast(xx * 255 / 96), @intCast(yy * 255 / 64), 128 }); + try process.writeFile(a, root ++ "/ramp.ppm", ppm.items); + + var d = try process.Detached.start(gpa, exe, "gui-golden", .{ + .root = root, + .file = root ++ "/shapes.zig", + .init = "Shell /bin/sh\nTheme forge\nMessageLinger 0\n", + // The virtual clock: a transition's frames are the same frames on + // any machine, so one partway through can be hashed too. + .env = &.{ .{ "PARDES_TEST_CLOCK", "1" }, .{ "PARDES_TEST_COLS", "120" }, .{ "PARDES_TEST_ROWS", "40" }, .{ "PARDES_TEST_PAD", "7" } }, + }); + defer d.deinit(); + const f = &d.files; + var results: std.ArrayList(u8) = .empty; + const keep = std.c.getenv("PARDES_GUI_GOLDEN_KEEP"); + const Scene = struct { + fn shot(dd: *process.Detached, al: std.mem.Allocator, out: *std.ArrayList(u8), kept: ?[*:0]const u8, label: []const u8, file: []const u8) !void { + const bytes = try dd.capture(al, file); + var digest: [32]u8 = undefined; + std.crypto.hash.sha2.Sha256.hash(bytes, &digest, .{}); + try out.print(al, "{s} {x}\n", .{ label, digest }); + if (kept) |dir| try process.writeFile(al, try std.fmt.allocPrint(al, "{s}/{s}.ppm", .{ std.mem.span(dir), label }), bytes); + std.debug.print("{s} {x}\n", .{ label, digest[0..8] }); + } + }; + const shot = Scene.shot; + const first = try paneWith(f, "shapes.zig"); + try shot(&d, a, &results, keep, "01-boot", "latest.ppm"); + try f.write(f.at("/pane/{d}/look", .{first}), root ++ "/notes.txt\n"); + const notes_pane = try paneWith(f, "notes.txt"); + try shot(&d, a, &results, keep, "02-second-document", "latest.ppm"); + try f.write(f.at("/pane/{d}/ctl", .{first}), "Msg a golden notice\n"); + try shot(&d, a, &results, keep, "03-notice", "latest.ppm"); + try f.write(f.at("/pane/{d}/ctl", .{first}), "TreeContext\n"); + try f.write(f.at("/pane/{d}/dot", .{first}), "45\n"); + try shot(&d, a, &results, keep, "04-context-rows-mid-thumb", "latest.ppm"); + try f.write(f.at("/pane/{d}/dot", .{first}), "40,43\n"); + try shot(&d, a, &results, keep, "05-body-selection", "latest.ppm"); + // A press and a drag along the source's tag: the tag takes the keyboard + // with a selection and a caret. The pointer then rests on empty body + // space, far right. + for ([_]struct { []const u8, i32, u32, u32 }{ .{ "down", 1, 500, 87 }, .{ "motion", 1, 620, 87 }, .{ "up", 1, 620, 87 }, .{ "motion", 0, 1880, 1300 } }) |ev| { + try d.mouse(ev[0], ev[1], ev[2], ev[3]); + process.nap(100); + } + try shot(&d, a, &results, keep, "06-tag-focus-selection", "latest.ppm"); + try d.typeKeys("\x1b"); + process.nap(200); + const scratch = try f.newPane(); + try f.write(f.at("/pane/{d}/exec", .{scratch}), "Save\n"); + try shot(&d, a, &results, keep, "07-prompt-notice", "latest.ppm"); + try d.typeKeys("\x1b"); + process.nap(200); + try f.write(f.at("/pane/{d}/exec", .{scratch}), "Del\n"); + try f.write(f.at("/pane/{d}/look", .{first}), root ++ "/wide.txt\n"); + const wide_pane = try paneWith(f, "wide.txt"); + var name: std.ArrayList(u8) = .empty; + try name.append(a, 'x'); + for (0..70) |_| try name.appendSlice(a, "\u{754c}"); + try name.append(a, '\n'); + try f.write(f.at("/pane/{d}/name", .{wide_pane}), name.items); + try f.write("/ctl", "Wrap off\n"); + try shot(&d, a, &results, keep, "08-wide-glyph-edges", "latest.ppm"); + try f.write("/ctl", "Wrap on\n"); + try f.write(f.at("/pane/{d}/exec", .{wide_pane}), "Del\n"); + try f.write("/ctl", "FocusTint on\n"); + try f.write(f.at("/pane/{d}/ctl", .{notes_pane}), "Collapse\n"); + try shot(&d, a, &results, keep, "09-collapsed-focus-tint", "latest.ppm"); + try f.write(f.at("/pane/{d}/ctl", .{notes_pane}), "Collapse\n"); + try f.write("/ctl", "Tagbottom\n"); + try shot(&d, a, &results, keep, "10-tagbottom", "latest.ppm"); + try f.write("/ctl", "Tagbottom\n"); + try f.write(f.at("/pane/{d}/tag", .{first}), " Second\nthird line of the tag"); + try shot(&d, a, &results, keep, "12-multiline-tag", "latest.ppm"); + try f.write(f.at("/pane/{d}/look", .{first}), root ++ "/ramp.ppm\n"); + _ = try paneWith(f, "ramp.ppm"); + try shot(&d, a, &results, keep, "13-image", "latest.ppm"); + try f.write("/ctl", "Theme ink\n"); + try shot(&d, a, &results, keep, "14-theme-ink", "latest.ppm"); + try f.write("/ctl", "Theme acme\n"); + try shot(&d, a, &results, keep, "15-theme-acme-light", "latest.ppm"); + try f.write("/ctl", "Debug\n"); + try shot(&d, a, &results, keep, "16-debug", "latest.ppm"); + try f.write("/ctl", "Debug\n"); + // A terminal pane: raw rows, ANSI colours, a hidden prompt. + const before = try f.read("/index"); + try f.write(f.at("/pane/{d}/exec", .{first}), "Term\n"); + const terminal = blk: { + const deadline = process.nowMs() + 10_000; + while (process.nowMs() < deadline) : (process.nap(50)) { + var rows = std.mem.tokenizeScalar(u8, try f.read("/index"), '\n'); + while (rows.next()) |row| { + const head = row[0 .. std.mem.indexOfScalar(u8, row, ' ') orelse continue]; + if (std.mem.indexOf(u8, before, f.at("{s} ", .{head})) == null) break :blk try std.fmt.parseInt(u32, head, 10); + } + } + return error.NoTerminal; + }; + try f.write(f.at("/pane/{d}/pty/data", .{terminal}), "PS1='$ '; clear; printf '\\033[1;36mcolour\\033[0m plain \\033[32mgreen\\033[0m\\n'\r"); + { + const deadline = process.nowMs() + 10_000; + while (!process.has(try f.read(f.at("/pane/{d}/body", .{terminal})), "green")) : (process.nap(50)) + if (process.nowMs() > deadline) return error.NoTerminalOutput; + } + try shot(&d, a, &results, keep, "17-terminal", "latest.ppm"); + // Partway through a transition: the panes, the picture among them, + // sliding over for a new column, frame 6 of PanelSlide's 12. + try f.write("/ctl", "PanelSlide\n"); + try f.write(f.at("/pane/{d}/exec", .{first}), "Newcol\n"); + try shot(&d, a, &results, keep, "18-mid-transition", "transition-6.ppm"); + + const goldens_path = "test/gui-goldens.txt"; + if (std.mem.eql(u8, mode, "update")) { + try process.writeFile(a, goldens_path, results.items); + std.debug.print("updated {s}\n", .{goldens_path}); + return; + } + const want = try process.readWhole(a, goldens_path); + var bad: usize = 0; + var got = std.mem.tokenizeScalar(u8, results.items, '\n'); + while (got.next()) |line| if (std.mem.indexOf(u8, want, line) == null) { + bad += 1; + std.debug.print("frame changed: {s}\n", .{line[0..std.mem.indexOfScalar(u8, line, ' ').?]}); + }; + if (bad > 0) return error.FramesChanged; +} |
