From 273cbd0df9d8edf4725fdff5f9da560b35b63058 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Wed, 4 Nov 2026 10:52:01 -0300 Subject: test: src/pardes.zig's jump tests through the 9P tree alone, in test/behaviour/modes.zig (guide.typ's Modes, Ctrl-o and Ctrl-i): a jumplist made as a user makes one (each place a pane's dot moved there and the keyboard given it; A and B files, C a Zerox twin, O the +Help output; the starting shell deleted, its places with it), walked by Ctrl-o, Ctrl-i (Kctl i), SPC j o and SPC j i, and the Back and Forward builtins, read from /focus and the dot's line, each walk's end said on screen: JumpScope file keeping to the focused file and leaving it only once it runs out, Ctrl-i its mirror and retracing a run of Ctrl-o, JumpScope all in jump order (bare JumpScope file again), a pane with no file stepping globally, a file in two panes keeping to its own pane first, every way taking the same steps, a step dropping the selections, select mode and the extra cursors and landing on the cursor the place was left with (nothing further on leaving the selection), and hopping two panes by Esc, window mode and clicks making no places; the old test of a missing entry's skip kept trimmed (its entries injected), and the side-button and jumpBy one kept, /mousein having no side buttons; each checked to fail against a break (JumpScope file off, JumpScope all ignored, a pane's own places not first, an output pane keeping to itself, Forward always global, Forward stepping back, the hop merge off, the source's selection not cleared) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge --- test/behaviour/modes.zig | 219 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 219 insertions(+) (limited to 'test/behaviour/modes.zig') diff --git a/test/behaviour/modes.zig b/test/behaviour/modes.zig index f29a4b56..b1641c6f 100644 --- a/test/behaviour/modes.zig +++ b/test/behaviour/modes.zig @@ -259,3 +259,222 @@ test "modes: window keys walk from a pane up through its column's tag and the wo try expectEqual((try s.where("body"))[1], (try s.cursor()).?[1]); try s.expect(s.at("/pane/{d}/body", .{a}), "body\n"); } + +/// The jump tests' session: a pane a letter of `order`, A and B each a file +/// of 100 lines, C a Zerox of A, O the +Help output (no file behind it), +/// and the jumplist `order`, a letter a place, each letter's n-th place its +/// line 1 + 40n ("ABABA" is A1 B1 A41 B41 A81): each made by moving its +/// pane's dot there and giving it the keyboard, as a jump does (a new +/// pane's first, where it opens). The shell the session started with is +/// closed after, its places with it. +const Jumps = struct { + s: Session, + ids: [4]u32 = @splat(0), + + const letters = "ABCO"; + + fn init(order: []const u8) !Jumps { + var t: Jumps = .{ .s = try Session.initTerm(std.testing.allocator) }; + errdefer t.s.deinit(); + const s = &t.s; + const shell = try s.focused(); + var seen: [4]u32 = @splat(0); + for (order) |letter| { + const which = std.mem.indexOfScalar(u8, letters, letter).?; + if (t.ids[which] == 0) t.ids[which] = switch (letter) { + 'O' => o: { + try s.write(s.at("/pane/{d}/exec", .{shell}), "Help\n"); + break :o try s.focused(); + }, + else => made: { + // C is A's twin, and A C's when C came first. + const twin = t.ids[if (letter == 'A') 2 else if (letter == 'C') 0 else 1]; + if (letter != 'B' and twin != 0) { + try s.write(s.at("/pane/{d}/exec", .{twin}), "Zerox\n"); + break :made try s.focused(); + } + const n = try s.newPane(); + try s.write(s.at("/pane/{d}/name", .{n}), if (letter == 'B') "/b.txt\n" else "/a.txt\n"); + try s.write(s.at("/pane/{d}/body", .{n}), std.mem.asBytes(&@as([100][4]u8, @splat("row\n".*)))); + break :made n; + }, + }; + const n = t.ids[which]; + try s.write(s.at("/pane/{d}/addr", .{n}), s.at("{d}\n", .{1 + 40 * seen[which]})); + try s.write(s.at("/pane/{d}/ctl", .{n}), "dot=addr\n"); + try s.write("/focus", s.at("{d}\n", .{n})); + seen[which] += 1; + } + try s.write(s.at("/pane/{d}/ctl", .{shell}), "delete\n"); + return t; + } + + /// Where the keyboard is: its pane's letter and the dot's line, `A50`. + fn here(t: *Jumps) ![]const u8 { + const s = &t.s; + const n = try s.focused(); + const at, _ = try s.range(s.at("/pane/{d}/dot", .{n})); + const body = try s.read(s.at("/pane/{d}/body", .{n})); + const which = std.mem.indexOfScalar(u32, &t.ids, n).?; + return s.at("{c}{d}", .{ letters[which], std.mem.count(u8, body[0..at], "\n") + 1 }); + } + + const Way = enum { key, leader, builtin }; + + /// Steps back or on until the list ends that way, as it says; the + /// places landed on, "A50 A10 B10". + fn walk(t: *Jumps, way: Way, back: bool) ![]const u8 { + const s = &t.s; + var out: []const u8 = ""; + for (0..64) |_| { + const before = try t.here(); + switch (way) { + .key => try s.keys(if (back) "\x0f" else "\u{F017}i"), + .leader => try s.keys(if (back) " jo" else " ji"), + .builtin => try s.write("/exec", if (back) "Back\n" else "Forward\n"), + } + const now = try t.here(); + if (std.mem.eql(u8, before, now)) break; + out = if (out.len == 0) now else s.at("{s} {s}", .{ out, now }); + } else return error.NoEnd; + try std.testing.expect(std.mem.indexOf(u8, try s.screen(), if (back) "nothing further back" else "nothing further on") != null); + return out; + } +}; + +test "modes: Ctrl-o keeps to the focused file (JumpScope file), A41 then A1, and leaves it only once it runs out that way; Ctrl-i mirrors it" { + var t = try Jumps.init("BABABA"); + defer t.s.deinit(); + try std.testing.expect(std.mem.indexOf(u8, try t.s.read("/ctl"), "\nJumpScope file\n") != null); + // B81, B41 passed over, kept in their places: A has nothing older than + // A1, so the step after it is the nearest place of any file, B1. + try std.testing.expectEqualStrings("A41 A1 B1", try t.walk(.key, true)); + // Forward is the mirror, from B1 in B: B's own places first, then A81, + // the newest, where the Backs started. + try std.testing.expectEqualStrings("B41 B81 A81", try t.walk(.key, false)); +} + +test "modes: Ctrl-i retraces a run of Ctrl-o inside one file step for step, back to where it began" { + var t = try Jumps.init("ABABA"); + defer t.s.deinit(); + // A1 B1 A41 B41 A81 from A81: nothing older than A1 at all. + try std.testing.expectEqualStrings("A41 A1", try t.walk(.key, true)); + try std.testing.expectEqualStrings("A41 A81", try t.walk(.key, false)); + // One back, one on: the same place, whichever were passed over. + try t.s.keys("\x0f"); + try std.testing.expectEqualStrings("A41", try t.here()); + try t.s.keys("\u{F017}i"); + try std.testing.expectEqualStrings("A81", try t.here()); + // And the steps made no places of their own. + try std.testing.expectEqualStrings("A41 A1", try t.walk(.key, true)); +} + +test "modes: with JumpScope all, Ctrl-o and Ctrl-i take every place in the order it was jumped to, and bare JumpScope is file again" { + var t = try Jumps.init("ABABA"); + defer t.s.deinit(); + try t.s.write("/ctl", "JumpScope all\n"); + try std.testing.expectEqualStrings("B41 A41 B1 A1", try t.walk(.key, true)); + try std.testing.expectEqualStrings("B1 A41 B41 A81", try t.walk(.key, false)); + try t.s.write("/ctl", "JumpScope\n"); + try std.testing.expect(std.mem.indexOf(u8, try t.s.read("/ctl"), "\nJumpScope file\n") != null); +} + +test "modes: from a pane with no file, Ctrl-o and Ctrl-i step through every place" { + var t = try Jumps.init("OAOBO"); + defer t.s.deinit(); + // O81 keeps to nothing: B1, the next older of all. From B, nothing of + // B is older, so O41; from O, A1; from A, O1. + try std.testing.expectEqualStrings("B1 O41 A1 O1", try t.walk(.key, true)); + try std.testing.expectEqualStrings("A1 O41 B1 O81", try t.walk(.key, false)); +} + +test "modes: Ctrl-o in a file shown in two panes keeps to its own pane first, then the file in the other" { + // C is A's file in a second pane: C1 B1 A1 C41 A41. + var t = try Jumps.init("CBACA"); + defer t.s.deinit(); + // From A41: A1 in this pane, over the nearer C41; then none of A's own + // is older, so the file's in C, C1, over B1. + try std.testing.expectEqualStrings("A1 C1", try t.walk(.key, true)); + // From C1 in C: C41, its own, then the file's newest, A41. + try std.testing.expectEqualStrings("C41 A41", try t.walk(.key, false)); +} + +test "modes: Back and Forward take the same steps from Ctrl-o and Ctrl-i, SPC j o and SPC j i, and the builtins" { + for ([_]Jumps.Way{ .key, .leader, .builtin }) |way| { + var t = try Jumps.init("BABABA"); + defer t.s.deinit(); + try std.testing.expectEqualStrings("A41 A1 B1", try t.walk(way, true)); + try std.testing.expectEqualStrings("B41 B81 A81", try t.walk(way, false)); + } +} + +test "modes: Ctrl-o and Ctrl-i drop the selections, select mode and the extra cursors, and land where the place was left" { + const rows = std.mem.asBytes(&@as([97][4]u8, @splat("row\n".*))); + var s = try Session.initFile(std.testing.allocator, "alpha beta\ngamma delta\nepsilon zeta\n" ++ rows); + defer s.deinit(); + const n = try s.focused(); + const dot = s.at("/pane/{d}/dot", .{n}); + // A place on line 3, at its eighth column (byte 30), then line 60. + try s.write(s.at("/pane/{d}/addr", .{n}), "#30\n"); + try s.write(s.at("/pane/{d}/ctl", .{n}), "dot=addr\n"); + try s.keys("60G"); + // Each step lands on the cursor the place was left with. + var back_to: u32 = 30; + for ([_][]const u8{ "\x0f", "\u{F017}i" }) |key| { + // A line selected, a second cursor under it, select mode on. + try s.keys("xCv"); + try std.testing.expectEqualStrings("select", try mode(&s, n)); + const leaving = (try s.range(dot))[1] - 1; // the cursor: its last character + try s.keys(key); + try std.testing.expectEqualStrings("normal", try mode(&s, n)); + try std.testing.expectEqual(back_to, (try s.range(dot))[0]); + back_to = leaving; + try s.expect(s.at("/pane/{d}/sel", .{n}), ""); + // One cursor: a Z typed goes in once. + try s.keys("iZ\x1b"); + try expectEqual(@as(usize, 1), std.mem.count(u8, try s.read(s.at("/pane/{d}/body", .{n})), "Z")); + try s.keys("u"); + } + // No place further on: said, and the selection left as it was. + try s.keys("x"); + const sel = try s.read(s.at("/pane/{d}/sel", .{n})); + try s.keys("\u{F017}i"); + try std.testing.expect(std.mem.indexOf(u8, try s.screen(), "nothing further on") != null); + try s.expect(s.at("/pane/{d}/sel", .{n}), sel); +} + +test "modes: hopping between two panes by Esc, window mode or a click makes no places, so one Ctrl-o goes back across and the next has nowhere to go" { + var s = try Session.initFile(std.testing.allocator, std.mem.asBytes(&@as([100][4]u8, @splat("row\n".*)))); + defer s.deinit(); + // Two panes of room, not acme's fit to the doc. + try s.write("/ctl", "Placement pardes\n"); + const doc = try s.focused(); + try s.keys("\u{F015}n"); // a shell under the doc + const shell = try s.focused(); + if (std.mem.indexOf(u8, try s.read(s.at("/pane/{d}/ctl", .{shell})), "mode:tty") != null) try s.keys("\x02"); + for (0..8) |_| { + const was = try s.focused(); + try s.keys("\x1b"); + try expectEqual(if (was == doc) shell else doc, try s.focused()); + } + for (0..8) |_| { + const want = if (try s.focused() == doc) shell else doc; + try s.keys(if (want == shell) " wj\n" else " wk\n"); + try expectEqual(want, try s.focused()); + } + const doc_row = (try s.where("row"))[1]; + const shell_row = (try s.where("Tty Save Mode"))[1] + 1; + for (0..8) |_| { + const other = if (try s.focused() == doc) shell else doc; + const row = if (other == doc) doc_row else shell_row; + try s.write("/mousein", s.at("m 10 {d} 1\nm 10 {d} 0\n", .{ row, row })); + try expectEqual(other, try s.focused()); + } + const before = try s.focused(); + try s.keys("\x0f"); + try std.testing.expect(before != try s.focused()); + const after = try s.focused(); + try s.keys("\x0f"); + try expectEqual(after, try s.focused()); + try std.testing.expect(std.mem.indexOf(u8, try s.screen(), "nothing further back") != null); +} -- cgit v1.3