diff options
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; +} |
