summaryrefslogtreecommitdiff
path: root/test/process/window.zig
diff options
context:
space:
mode:
Diffstat (limited to 'test/process/window.zig')
-rw-r--r--test/process/window.zig364
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;
+}