summaryrefslogtreecommitdiff
path: root/test/behaviour
diff options
context:
space:
mode:
Diffstat (limited to 'test/behaviour')
-rw-r--r--test/behaviour/modes.zig219
1 files changed, 219 insertions, 0 deletions
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);
+}