//! The window's own (T4 of docs/next-tests.md): its own input, on the //! hidden window `zig build process-test -Dplatform=gui` drives, settling //! alive. Its pixels are its unit tests' (`unit-test -Dplatform=gui`) and //! the image and kitty harnesses'; what the core draws, the tty cases'. const std = @import("std"); 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 { return if (std.c.getenv(name)) |v| std.mem.span(v) else default; } const themes = [_][]const u8{ "lapis", "forge", "acme", "dusk", "daybreak" }; /// test/gui_monkey.py's: random bursts, each run then settling with its /// process alive and no crash record. Two runs of 30 steps in /// process-test; PARDES_GUI_MONKEY=all runs 5 (`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; for (0..@as(usize, if (all) 5 else 2)) |n| { if (!try monkeyOne(gpa, exe, seed * 1000 + n, steps)) failed += 1; } if (failed > 0) return error.MonkeyFailed; } fn monkeyOne(gpa: std.mem.Allocator, exe: [:0]const u8, seed: u64, steps: usize) !bool { var arena = std.heap.ArenaAllocator.init(gpa); defer arena.deinit(); const a = arena.allocator(); const init = "Shell /bin/sh\nMessageLinger 0\n"; var d = try process.Detached.start(gpa, exe, "monkey", .{ .init = init, .grid = .{ 80, 28 }, .env = &.{ .{ "PARDES_TEST_CLOCK", "1" }, .{ "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 (seed {d}): {s}\n{s}", .{ 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; } /// 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(); }