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.zig381
1 files changed, 381 insertions, 0 deletions
diff --git a/test/process/window.zig b/test/process/window.zig
index 8d1afed8..e39e0963 100644
--- a/test/process/window.zig
+++ b/test/process/window.zig
@@ -7,6 +7,7 @@ const process = @import("../process.zig");
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 frame corpus, every kept frame and its sha256 into PARDES_GUI_CORPUS, to compare two builds on one machine", corpus },
};
fn envOr(name: [*:0]const u8, default: []const u8) []const u8 {
@@ -157,3 +158,383 @@ fn firstPane(f: *process.Files) !?u32 {
const end = std.mem.indexOfScalar(u8, index, ' ') orelse return null;
return std.fmt.parseInt(u32, index[0..end], 10) catch null;
}
+
+/// 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;
+}
+
+/// The serial of a pane /index did not list in `before`, waited for.
+fn paneSince(f: *process.Files, before: []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 head = row[0 .. std.mem.indexOfScalar(u8, row, ' ') orelse continue];
+ if (std.mem.indexOf(u8, before, f.at("{s} ", .{head})) == null) return std.fmt.parseInt(u32, head, 10);
+ }
+ }
+ return error.NoNewPane;
+}
+
+/// Until the body of pane `serial` holds `word`.
+fn bodyHas(f: *process.Files, serial: u32, word: []const u8) !void {
+ const deadline = process.nowMs() + 10_000;
+ while (!process.has(try f.read(f.at("/pane/{d}/body", .{serial})), word)) : (process.nap(50))
+ if (process.nowMs() > deadline) return error.NoOutput;
+}
+
+extern "c" fn system(cmd: [*:0]const u8) c_int;
+extern "c" fn ioctl(fd: c_int, request: c_ulong, ...) c_int;
+
+/// The frames a corpus keeps (`corpus`): numbered in the order kept, each
+/// with its sha256 (sha256sum's lines) and its scene.
+const Corpus = struct {
+ gpa: std.mem.Allocator,
+ a: std.mem.Allocator,
+ out: []const u8,
+ n: u32 = 0,
+ sums: std.ArrayList(u8) = .empty,
+ scenes: std.ArrayList(u8) = .empty,
+ /// The window's own series below this are read and gone: a frame is
+ /// megabytes, and /tmp is small.
+ pruned: u32 = 0,
+
+ /// The frames the window has captured, read from its status.
+ fn captured(k: *Corpus, d: *process.Detached) !u32 {
+ const text = try process.readWhole(k.a, k.at("{s}/status", .{d.captures()}));
+ var words = std.mem.tokenizeAny(u8, text, " \n");
+ _ = words.next();
+ return std.fmt.parseInt(u32, words.next() orelse return error.NoStatus, 10);
+ }
+
+ fn at(k: *Corpus, comptime fmt: []const u8, args: anytype) []const u8 {
+ return std.fmt.allocPrint(k.a, fmt, args) catch @panic("out of memory");
+ }
+
+ /// Once the window is idle, the frames it has captured: where a step's
+ /// own begin. What came before is let go.
+ fn mark(k: *Corpus, d: *process.Detached) !u32 {
+ try d.settle(k.a);
+ const to = try k.captured(d);
+ k.prune(d, to);
+ return to;
+ }
+
+ /// The step begun at `from`, once the window is idle again: every frame
+ /// it drew (a motion, one input on the virtual clock), or only the one
+ /// that stays (what more than one input or a worker's landing makes,
+ /// whose frames in between are the machine's timing).
+ fn keep(k: *Corpus, d: *process.Detached, from: u32, label: []const u8, every: bool) !void {
+ const to = try k.rest(d);
+ if (to == 0) return error.NoFrame;
+ try k.take(d, if (every and to > from) from else to - 1, to, label);
+ }
+
+ /// Idle, and still idle once a worker had time to land what it owes (a
+ /// PDF page, a highlighted file: their jobs are not the loop's, and the
+ /// window is idle while they run): the frames captured then.
+ fn rest(k: *Corpus, d: *process.Detached) !u32 {
+ try d.settle(k.a);
+ var last = try k.captured(d);
+ for (0..50) |_| {
+ process.nap(400);
+ try d.settle(k.a);
+ const now = try k.captured(d);
+ if (now == last) return now;
+ last = now;
+ }
+ return error.NeverRests;
+ }
+
+ /// The first `n` frames since `from` of a scene that never rests (the
+ /// pet, the snake: they animate while shown), as the virtual clock
+ /// steps them.
+ fn first(k: *Corpus, d: *process.Detached, from: u32, n: u32, label: []const u8) !void {
+ const deadline = process.nowMs() + 30_000;
+ while (try k.captured(d) < from + n) : (process.nap(5))
+ if (process.nowMs() > deadline) return error.NoFrames;
+ try k.take(d, from, from + n, label);
+ }
+
+ fn take(k: *Corpus, d: *process.Detached, lo: u32, hi: u32, label: []const u8) !void {
+ for (lo..hi) |i| {
+ const bytes = try process.readWhole(k.gpa, k.at("{s}/frame-{d:0>5}.ppm", .{ d.captures(), i }));
+ defer k.gpa.free(bytes);
+ var digest: [32]u8 = undefined;
+ std.crypto.hash.sha2.Sha256.hash(bytes, &digest, .{});
+ const name = k.at("frame-{d:0>5}.ppm", .{k.n});
+ try process.writeFile(k.a, k.at("{s}/{s}", .{ k.out, name }), bytes);
+ try k.sums.print(k.a, "{x} {s}\n", .{ digest, name });
+ try k.scenes.print(k.a, "{d:0>5} {s}\n", .{ k.n, label });
+ std.debug.print("{d:0>5} {x} {s}\n", .{ k.n, digest[0..6], label });
+ k.n += 1;
+ }
+ k.prune(d, hi);
+ }
+
+ fn prune(k: *Corpus, d: *process.Detached, below: u32) void {
+ while (k.pruned < below) : (k.pruned += 1) {
+ const path = std.fmt.allocPrintSentinel(k.a, "{s}/frame-{d:0>5}.ppm", .{ d.captures(), k.pruned }, 0) catch return;
+ _ = std.c.unlink(path);
+ }
+ }
+
+ fn finish(k: *Corpus) !void {
+ try process.writeFile(k.a, k.at("{s}/frames.sha256", .{k.out}), k.sums.items);
+ try process.writeFile(k.a, k.at("{s}/scenes.txt", .{k.out}), k.scenes.items);
+ }
+};
+
+/// The window's frame size in pixels, from the frame it last captured.
+fn frameSize(a: std.mem.Allocator, d: *process.Detached) ![2]u32 {
+ const bytes = try d.frame(a);
+ var words = std.mem.tokenizeAny(u8, bytes[0..@min(bytes.len, 32)], " \n");
+ _ = words.next();
+ return .{ try std.fmt.parseInt(u32, words.next().?, 10), try std.fmt.parseInt(u32, words.next().?, 10) };
+}
+
+/// The corpus's files, in a root of their own (fixed: its paths are drawn
+/// in the tags), made anew for each window.
+const root = "/tmp/pardes-gui-corpus";
+fn corpusRoot(a: std.mem.Allocator) !void {
+ _ = system("rm -rf -- /tmp/pardes-gui-corpus");
+ if (std.c.mkdir(root, 0o700) != 0) return error.NoRoot;
+ 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| {
+ \\ if (shape == .circle) {
+ \\
+ );
+ for (0..80) |n| try zig.print(a, " total += shape.area() * {d}; // line {d}\n", .{ n, n });
+ try zig.appendSlice(a, " }\n }\n std.debug.print(\"{d}\\n\", .{total});\n}\n");
+ try process.writeFile(a, root ++ "/shapes.zig", zig.items);
+ try process.writeFile(a, root ++ "/notes.md",
+ \\# Fallback faces and rules
+ \\
+ \\| name | glyphs |
+ \\|------|--------|
+ \\| cjk | 界面字 |
+ \\| nerd |
+ ++ "\u{e5ff} \u{f07b} \u{e0b0}" ++
+ \\ |
+ \\| sym | ∮ ≠ ★ ☃ ⚡ ⌘ |
+ \\
+ \\┌──┬──┐
+ \\│ a│ b│
+ \\├──┼──┤
+ \\│ c│ d│
+ \\└──┴──┘
+ \\
+ );
+ try process.writeFile(a, root ++ "/ligatures.zig",
+ \\const a = b -> c; // => != <= >= == === !== |> <| :: ++ --
+ \\const fi = "office flow staff"; // f|i f|l s|t stay apart
+ \\
+ );
+ 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);
+ try process.writeFile(a, root ++ "/doc.pdf", try process.readWhole(a, "docs/9p.pdf"));
+ // A face of the repo's with ligatures, where `Font` finds it by name.
+ for ([_][:0]const u8{ root ++ "/.local", root ++ "/.local/share", root ++ "/.local/share/fonts" }) |dir| _ = std.c.mkdir(dir, 0o755);
+ try process.writeFile(a, root ++ "/.local/share/fonts/MapleMono-NF-Regular.ttf", try process.readWhole(a, "assets/MapleMono-NF-Regular.ttf"));
+ try process.writeFile(a, root ++ "/sgr.sh",
+ \\printf '\033[1mbold\033[0m \033[2mdim\033[0m \033[7mreverse\033[0m [\033[8minvisible\033[0m]\n'
+ \\printf '\033[4:1msingle\033[0m \033[4:2mdouble\033[0m \033[4:3mcurly\033[0m \033[4:4mdotted\033[0m \033[4:5mdashed\033[0m \033[9mstrike\033[0m\n'
+ \\printf '\033[1;4:3;9mall\033[0m \033[38;2;255;128;0mrgb\033[0m \033[44mbg\033[0m\nEND\n'
+ \\
+ );
+ // A kitty image: 8x8 RGB, drawn 10 cells by 4.
+ var rgb: [8 * 8 * 3]u8 = undefined;
+ for (0..64) |i| rgb[i * 3 ..][0..3].* = .{ @intCast(i * 4), @intCast(255 - i * 4), @intCast((i % 8) * 32) };
+ var b64: [std.base64.standard.Encoder.calcSize(rgb.len)]u8 = undefined;
+ _ = std.base64.standard.Encoder.encode(&b64, &rgb);
+ try process.writeFile(a, root ++ "/kitty.sh", try std.fmt.allocPrint(a, "printf '\\033_Ga=T,f=24,s=8,v=8,c=10,r=4;{s}\\033\\\\'\nprintf '\\nKITTY\\n'\n", .{b64}));
+}
+
+/// S0 of the GPU move (.scratch/sketch/briefs/gpu-s0.md): the renderer's
+/// frame corpus. Twelve scenes on the hidden window under the virtual
+/// clock, each step one input (a 9P write, or one event on its terminal)
+/// and then idle; the frames a step keeps go to PARDES_GUI_CORPUS as
+/// frame-NNNNN.ppm, their sha256 in frames.sha256 (sha256sum's lines),
+/// their scenes in scenes.txt. Two builds' corpora on one machine are the
+/// same bytes, or the renderer changed: a GPU and its driver draw their own
+/// pixels, so it gates a build against a build, never a machine.
+/// PARDES_GUI_CORPUS_SNAKE is the snake_shader addon (`zig build
+/// snake-shader`). Skipped without PARDES_GUI_CORPUS.
+fn corpus(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ try process.only(.gui);
+ const out = std.mem.span(std.c.getenv("PARDES_GUI_CORPUS") orelse return error.SkipZigTest);
+ const snake = std.mem.span(std.c.getenv("PARDES_GUI_CORPUS_SNAKE") orelse {
+ std.debug.print("PARDES_GUI_CORPUS_SNAKE: the snake_shader addon's library\n", .{});
+ return error.NoSnakeAddon;
+ });
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ defer _ = system("rm -rf -- /tmp/pardes-gui-corpus");
+ const init = "Shell /bin/sh\nTheme forge\nMessageLinger 0\nCursorBlink off\n";
+ var k: Corpus = .{ .gpa = gpa, .a = a, .out = out };
+ {
+ try corpusRoot(a);
+ var d = try process.Detached.start(gpa, exe, "corpus", .{ .root = root, .file = root ++ "/shapes.zig", .init = init, .grid = .{ 100, 22 }, .env = &.{
+ .{ "PARDES_TEST_CLOCK", "1" }, .{ "PARDES_TEST_SERIES", "1" }, .{ "PARDES_TEST_PAD", "7" },
+ } });
+ defer d.deinit();
+ const f = &d.files;
+ const first = try paneWith(f, "shapes.zig");
+ // 1. A Zig file: tags, the block cursor, the scrollbar.
+ try k.keep(&d, 0, "01 zig file: tags, block cursor, scrollbar", false);
+ const size = try frameSize(a, &d);
+ const cell_w = (size[0] - 7) / 100;
+ const cell_h = (size[1] - 7) / 22;
+ var from = try k.mark(&d);
+ try f.write(f.at("/pane/{d}/dot", .{first}), "45\n");
+ try k.keep(&d, from, "01 zig file: the cursor at line 45, the thumb mid-track", false);
+ // 11. Motion on the virtual clock: a wheel's glide (rows shifted,
+ // the scroll scissor), a jump's trail and the caret's glide quad.
+ from = try k.mark(&d);
+ try d.mouse("wheel", -3, cell_w * 40, cell_h * 12);
+ try k.keep(&d, from, "11 a wheel's glide, every frame", true);
+ from = try k.mark(&d);
+ try d.mouse("down", 1, cell_w * 20, cell_h * 10);
+ try d.mouse("up", 1, cell_w * 20, cell_h * 10);
+ try k.keep(&d, from, "11 a click moves the caret, every frame", true);
+ from = try k.mark(&d);
+ try d.typeKeys("gg");
+ try k.keep(&d, from, "11 a jump's trail and the caret's glide, every frame", true);
+ from = try k.mark(&d);
+ try f.write("/ctl", "Pet cat\n");
+ try k.keep(&d, from, "11 the pet, every frame", true);
+ try f.write("/ctl", "Pet off\n");
+ // 6. Taglines at 80% and the tree-sitter context rows.
+ from = try k.mark(&d);
+ try f.write("/ctl", "TaglineSize 80\n");
+ try k.keep(&d, from, "06 TaglineSize 80", false);
+ from = try k.mark(&d);
+ try f.write(f.at("/pane/{d}/ctl", .{first}), "TreeContext\n");
+ try k.keep(&d, from, "06 TreeContext on", false);
+ from = try k.mark(&d);
+ try f.write(f.at("/pane/{d}/dot", .{first}), "70\n");
+ try k.keep(&d, from, "06 context rows over a deep line", false);
+ // 3. A terminal's SGR: bold, dim, reverse, invisible, the five
+ // underlines, strike; 10. a kitty image in it.
+ const before = try f.read("/index");
+ try f.write(f.at("/pane/{d}/exec", .{first}), "Term\n");
+ const term = try paneSince(f, before);
+ try f.write(f.at("/pane/{d}/pty/data", .{term}), "PS1='$ '; clear; sh " ++ root ++ "/sgr.sh\r");
+ try bodyHas(f, term, "END");
+ try k.keep(&d, 0, "03 a terminal's SGR styles", false);
+ try f.write(f.at("/pane/{d}/pty/data", .{term}), "clear; sh " ++ root ++ "/kitty.sh\r");
+ try bodyHas(f, term, "KITTY");
+ try k.keep(&d, 0, "10 a kitty image in a terminal pane", false);
+ try f.write(f.at("/pane/{d}/exec", .{term}), "Del\n");
+ // 5. Fallback faces (CJK, Nerd icons), a markdown table, box rules.
+ try f.write(f.at("/pane/{d}/look", .{first}), root ++ "/notes.md\n");
+ const notes = try paneWith(f, "notes.md");
+ try k.keep(&d, 0, "05 fallback glyphs, a markdown table, box rules", false);
+ // 9. An image pane; a PDF pane and the pointer's word highlighted
+ // (its dirty rows uploaded).
+ try f.write(f.at("/pane/{d}/look", .{notes}), root ++ "/ramp.ppm\n");
+ const image = try paneWith(f, "ramp.ppm");
+ try k.keep(&d, 0, "09 an image pane", false);
+ try f.write(f.at("/pane/{d}/exec", .{image}), "Del\n");
+ try f.write(f.at("/pane/{d}/exec", .{notes}), "Del\n");
+ try f.write(f.at("/pane/{d}/look", .{first}), root ++ "/doc.pdf\n");
+ _ = try paneWith(f, "doc.pdf");
+ try k.keep(&d, 0, "09 a PDF pane", false);
+ _, const tag_row = try f.where("doc.pdf");
+ for ([_][2]usize{ .{ 26, 8 }, .{ 26, 3 }, .{ 40, 8 } }) |off| {
+ from = try k.mark(&d);
+ try d.mouse("motion", 0, @intCast(cell_w * off[0] + cell_w / 2), @intCast(cell_h * (tag_row + off[1]) + cell_h / 2));
+ try k.keep(&d, from, "09 the PDF's hovered word, its rows painted again", false);
+ }
+ // 7. Three columns, five panes, focus and dirty grips, InactiveDim.
+ try f.write("/ctl", "Newcol\n");
+ try f.write("/ctl", "Newcol\n");
+ const scratch = try f.newPane();
+ try f.write(f.at("/pane/{d}/body", .{scratch}), "a dirty pane\n");
+ try f.write("/ctl", "InactiveDim 40\n");
+ try k.keep(&d, 0, "07 three columns, a dirty pane, InactiveDim 40", false);
+ // 8. WindowOpacity at 71 and 0.
+ try f.write("/ctl", "WindowOpacity 71\n");
+ try k.keep(&d, 0, "08 WindowOpacity 71", false);
+ try f.write("/ctl", "WindowOpacity 0\n");
+ try k.keep(&d, 0, "08 WindowOpacity 0", false);
+ try f.write("/ctl", "WindowOpacity 100\n");
+ // 4. Ligatures in a face that has them; 12. the font changed (the
+ // atlas reset).
+ try f.write(f.at("/pane/{d}/look", .{first}), root ++ "/ligatures.zig\n");
+ _ = try paneWith(f, "ligatures.zig");
+ try k.keep(&d, 0, "04 ligatures.zig in the default face", false);
+ try f.write("/ctl", "Font MapleMono-NF-Regular:16\n");
+ try k.keep(&d, 0, "04 12 Font MapleMono 16: ligatures, the atlas reset", false);
+ // The window resized: its terminal's size, which a test window follows.
+ var ws: std.posix.winsize = .{ .row = 20, .col = 70, .xpixel = 0, .ypixel = 0 };
+ if (ioctl(d.child.master, 0x5414, &ws) != 0) return error.NoResize; // TIOCSWINSZ
+ try k.keep(&d, 0, "12 the window resized to 70x20", false);
+ }
+ // 12. The snake: an addon's GPU scene and its CRT post-process,
+ // through the premultiplied pipeline. A window of its own: its picture
+ // breathes on the clock, and a long session's clock has seen the
+ // machine's timing (a timer an input cancelled, or not yet).
+ k.pruned = 0;
+ {
+ try corpusRoot(a);
+ var d = try process.Detached.start(gpa, exe, "corpus-snake", .{ .root = root, .file = root ++ "/shapes.zig", .init = init, .grid = .{ 80, 24 }, .env = &.{
+ .{ "PARDES_TEST_CLOCK", "1" }, .{ "PARDES_TEST_SERIES", "1" }, .{ "PARDES_TEST_PAD", "7" },
+ } });
+ defer d.deinit();
+ const f = &d.files;
+ const first = try paneWith(f, "shapes.zig");
+ _ = try k.rest(&d);
+ try f.write("/ctl", f.at("Addon load {s}\n", .{snake}));
+ try k.keep(&d, 0, "12 the snake addon loaded", false);
+ const from = try k.mark(&d);
+ try f.write(f.at("/pane/{d}/exec", .{first}), "SnakeShader\n");
+ try k.first(&d, from, 10, "12 SnakeShader's CRT scene, its first frames");
+ }
+ // 2. Scene 1 at a 2x display.
+ k.pruned = 0;
+ {
+ try corpusRoot(a);
+ var d = try process.Detached.start(gpa, exe, "corpus2x", .{ .root = root, .file = root ++ "/shapes.zig", .init = init, .grid = .{ 50, 14 }, .env = &.{
+ .{ "PARDES_TEST_CLOCK", "1" }, .{ "PARDES_TEST_SERIES", "1" }, .{ "PARDES_TEST_PAD", "7" }, .{ "PARDES_TEST_SCALE", "2" },
+ } });
+ defer d.deinit();
+ const f = &d.files;
+ const first = try paneWith(f, "shapes.zig");
+ try k.keep(&d, 0, "02 the zig file at a 2x display", false);
+ try f.write(f.at("/pane/{d}/dot", .{first}), "20,22\n");
+ try k.keep(&d, 0, "02 a selection at a 2x display", false);
+ }
+ try k.finish();
+}