summaryrefslogtreecommitdiff
path: root/test/monkey.zig
diff options
context:
space:
mode:
Diffstat (limited to 'test/monkey.zig')
-rw-r--r--test/monkey.zig51
1 files changed, 38 insertions, 13 deletions
diff --git a/test/monkey.zig b/test/monkey.zig
index dcea0b43..2e19cb21 100644
--- a/test/monkey.zig
+++ b/test/monkey.zig
@@ -1,6 +1,6 @@
// pardes-monkey: random snapshot scripts against the tty, hunting panics.
//
-// zig build monkey -Dplatform=tty -- <seeds> [steps] [--from=N] [--out=DIR] [--keep]
+// zig build monkey -Dplatform=tty -- <seeds> [steps] [--from=N] [--out=DIR] [--keep] [--views=N]
//
// Each seed makes one script (a fixed seed makes the same script, so a hit
// replays): keys and leader bursts, typing, mouse presses, drags and wheel,
@@ -9,7 +9,9 @@
// /tmp/pardes-monkey), and a panic is a record in the app's crash file
// (src/crash.zig, in the script's fake home: found even when the crash cut
// the script short) or a `.zig:N:N: 0x` stack frame in the report or the
-// grid it captured (a trace renders INTO the screen). A hit
+// grid it captured (a trace renders INTO the screen). --views=N gives the
+// session N terminals, each a view of it (views.zig), and types into and
+// sizes each in turn, a `view` switch among the steps. A hit
// keeps DIR/seed-N.snap, its captures and its report; the rest are deleted.
// A panic's trace can scroll off a small grid: replay the kept script, or
// run the app in a larger pty. Every hit gets a fix and a pinned regression
@@ -26,6 +28,9 @@ const Script = struct {
gpa: std.mem.Allocator,
rows: u16 = 24,
cols: u16 = 80,
+ /// Each terminal's size, and the one typed into (`--views`).
+ sizes: [4][2]u16 = @splat(.{ 24, 80 }),
+ view: usize = 0,
fn line(s: *Script, comptime fmt: []const u8, args: anytype) !void {
try s.out.print(s.gpa, fmt ++ "\n", args);
@@ -38,18 +43,24 @@ const commands = [_][]const u8{ "Newcol", "Find", "Grep", "Joincol", "Help", "Du
const leader_keys = "abcdefghijklmnopqrstuvwxyz0123456789$^";
const typed = "abcdefghijklmnopqrstuvwxyz0123456789 -_=+,:;()";
-fn generate(gpa: std.mem.Allocator, seed: u64, steps: usize) ![]u8 {
+fn generate(gpa: std.mem.Allocator, seed: u64, steps: usize, views: usize) ![]u8 {
var prng = std.Random.DefaultPrng.init(seed);
const random = prng.random();
var s: Script = .{ .gpa = gpa };
- try s.line("# pardes-monkey seed {d}, {d} steps", .{ seed, steps });
+ try s.line("# pardes-monkey seed {d}, {d} steps, {d} views", .{ seed, steps, views });
try s.line("file bad.txt hello \\xff\\xfe world\\nlatin-1 caf\\xe9 tail\\ntruncated \\xe6\\x97 here\\nend\\n", .{});
try s.line("file wide.txt {s}tail\\nsecond line\\n", .{std.mem.asBytes(&@as([8][37]u8, @splat("\\xe6\\x97\\xa5\\xe6\\x9c\\xac\\xe8\\xaa\\x9e ".*)))});
try s.line("lines long.txt 400 some words after the number, long enough to wrap in a narrow pane", .{});
- try s.line("start 24 80 bad.txt", .{});
+ if (views > 1) try s.line("start 24 80 views={d} bad.txt", .{views}) else try s.line("start 24 80 bad.txt", .{});
try s.line("wait 8000 Newcol Joincol", .{});
try s.line("stable 300 5000", .{});
for (0..steps) |step| {
+ if (views > 1 and random.uintLessThan(u8, 4) == 0) {
+ s.sizes[s.view] = .{ s.rows, s.cols };
+ s.view = random.uintLessThan(usize, views);
+ s.rows, s.cols = s.sizes[s.view];
+ try s.line("view {d}", .{s.view + 1});
+ }
const wide = s.cols >= 70 and s.rows >= 6;
switch (random.uintLessThan(u8, 12)) {
// A workspace word, run with a middle click: new columns make
@@ -150,9 +161,9 @@ test "a panic trace is found, and ordinary colons are not" {
}
test "a seed makes the same script every time" {
- const a = try generate(std.testing.allocator, 42, 50);
+ const a = try generate(std.testing.allocator, 42, 50, 3);
defer std.testing.allocator.free(a);
- const b = try generate(std.testing.allocator, 42, 50);
+ const b = try generate(std.testing.allocator, 42, 50, 3);
defer std.testing.allocator.free(b);
try std.testing.expectEqualStrings(a, b);
}
@@ -166,7 +177,7 @@ pub fn main(init: std.process.Init) !void {
const io = init.io;
const args = try init.minimal.args.toSlice(init.arena.allocator());
if (args.len < 4) {
- std.debug.print("usage: pardes-monkey <pardes-snap> <pardes> <seeds> [steps] [--from=N] [--out=DIR]\n", .{});
+ std.debug.print("usage: pardes-monkey <pardes-snap> <pardes> <seeds> [steps] [--from=N] [--out=DIR] [--keep] [--tape=DIR] [--views=N] [--dump]\n", .{});
std.process.exit(2);
}
const snap = args[1];
@@ -177,12 +188,25 @@ pub fn main(init: std.process.Init) !void {
var out: []const u8 = "/tmp/pardes-monkey";
// Keep every script and capture, not only a hit's: to see what it did.
var keep = false;
+ // --tape=DIR: each seed's sessions record their tapes there and the
+ // seed is a hit if one does not replay (pardes-snap --tape).
+ var tape: ?[]const u8 = null;
+ var views: usize = 1;
+ // --dump (with --tape): each replay loads the session's dump at its end
+ // too (pardes-snap --dump).
+ var dump = false;
var positional: usize = 0;
for (args[3..]) |a| {
- if (std.mem.startsWith(u8, a, "--from=")) {
+ if (std.mem.startsWith(u8, a, "--views=")) {
+ views = std.math.clamp(try std.fmt.parseInt(usize, a["--views=".len..], 10), 1, 4);
+ } else if (std.mem.startsWith(u8, a, "--from=")) {
from = try std.fmt.parseInt(u64, a["--from=".len..], 10);
} else if (std.mem.eql(u8, a, "--keep")) {
keep = true;
+ } else if (std.mem.startsWith(u8, a, "--tape=")) {
+ tape = a;
+ } else if (std.mem.eql(u8, a, "--dump")) {
+ dump = true;
} else if (std.mem.startsWith(u8, a, "--out=")) {
out = a["--out=".len..];
} else {
@@ -198,13 +222,13 @@ pub fn main(init: std.process.Init) !void {
var hits: usize = 0;
var seed = from;
while (seed < from + seeds) : (seed += 1) {
- const script = try generate(gpa, seed, steps);
+ const script = try generate(gpa, seed, steps, views);
defer gpa.free(script);
var path_buf: [4096]u8 = undefined;
const path = try std.fmt.bufPrint(&path_buf, "{s}/seed-{d}.snap", .{ out, seed });
try std.Io.Dir.cwd().writeFile(io, .{ .sub_path = path, .data = script });
const run = std.process.run(gpa, io, .{
- .argv = &.{ snap, app, "--update", "--no-retry", "--jobs=1", path },
+ .argv = if (tape) |t| (if (dump) &.{ snap, app, "--update", "--no-retry", "--jobs=1", t, "--dump", path } else &.{ snap, app, "--update", "--no-retry", "--jobs=1", t, path }) else &.{ snap, app, "--update", "--no-retry", "--jobs=1", path },
.stdout_limit = .limited(64 << 20),
.stderr_limit = .limited(64 << 20),
}) catch |err| {
@@ -223,14 +247,15 @@ pub fn main(init: std.process.Init) !void {
const crash_path = try std.fmt.bufPrint(&crash_buf, "/tmp/pardes-snap/seed-{d}/home/.config/pardes/crashes", .{seed});
const crashes = readAll(gpa, io, crash_path);
defer gpa.free(crashes);
- if (crashes.len != 0 or hasTrace(run.stdout) or hasTrace(run.stderr) or hasTrace(golden)) {
+ const diverged = tape != null and (std.mem.indexOf(u8, run.stdout, "DIVERGED") != null or std.mem.indexOf(u8, run.stderr, "DIVERGED") != null);
+ if (crashes.len != 0 or diverged or hasTrace(run.stdout) or hasTrace(run.stderr) or hasTrace(golden)) {
hits += 1;
var log_buf: [4096]u8 = undefined;
const log_path = try std.fmt.bufPrint(&log_buf, "{s}/seed-{d}.log", .{ out, seed });
const both = try std.mem.concat(gpa, u8, &.{ crashes, run.stdout, run.stderr });
defer gpa.free(both);
try std.Io.Dir.cwd().writeFile(io, .{ .sub_path = log_path, .data = both });
- std.debug.print("PANIC seed {d}: {s}\n", .{ seed, path });
+ std.debug.print("{s} seed {d}: {s}\n", .{ if (diverged) "DIVERGED" else "PANIC", seed, path });
} else if (!keep) {
std.Io.Dir.cwd().deleteFile(io, path) catch {};
std.Io.Dir.cwd().deleteFile(io, golden_path) catch {};