summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--build.zig3
-rw-r--r--docs/next-tests.md38
-rw-r--r--src/pardes.zig626
-rw-r--r--test/behaviour.zig7
-rw-r--r--test/behaviour/columns_and_tags.zig168
-rw-r--r--test/behaviour/keys.zig227
-rw-r--r--test/behaviour/limits.zig18
-rw-r--r--test/behaviour/look_and_exec.zig160
-rw-r--r--test/behaviour/modes.zig104
-rw-r--r--test/behaviour/mouse.zig133
-rw-r--r--test/behaviour/other_files.zig10
-rw-r--r--test/behaviour/panes.zig197
-rw-r--r--test/behaviour/placement.zig61
-rw-r--r--test/behaviour/settings.zig62
-rw-r--r--test/behaviour/tags.zig399
-rw-r--r--test/behaviour/terminals.zig46
-rw-r--r--test/output.zig141
-rw-r--r--test/panes.zig1017
-rw-r--r--test/pdf.zig305
-rw-r--r--test/session.zig77
20 files changed, 1703 insertions, 2096 deletions
diff --git a/build.zig b/build.zig
index 8a9451eb..c90485b6 100644
--- a/build.zig
+++ b/build.zig
@@ -1880,6 +1880,9 @@ pub fn build(b: *std.Build) void {
.link_libc = true,
});
behaviour_module.addImport("session", session_module);
+ // The build's options alone (platform), never the core: a test of a
+ // window's word knows which build it runs in.
+ behaviour_module.addImport("pardes_config", core_module.import_table.get("pardes_config").?);
const behaviour_tests = b.addTest(.{ .root_module = behaviour_module, .filters = test_filters });
if (test_nonce) |nonce| behaviour_tests.root_module.addImport("test_rebuild_nonce", nonce);
test_build.dependOn(&behaviour_tests.step);
diff --git a/docs/next-tests.md b/docs/next-tests.md
index 9e234dfa..3f85e030 100644
--- a/docs/next-tests.md
+++ b/docs/next-tests.md
@@ -101,20 +101,38 @@ What the M tests reach into, and the public surface for it:
## Progress
-Left to migrate, a file a row (`grep -c '^test "' <file>` before and
-after; M as the inventory classed them):
+After the first fan-out (2026-11-03: four migrators, each followed by a
+reviewer that ran its own breaks; 108 tests in test/behaviour/):
-| file | M at the start | moved | checked against |
+| area | moved | M left | X kept |
|---|---|---|---|
-| src/ninep/ctl.zig | 82 | 9, 1 X kept | `collapsed ` left off the ctl read; Putall saving nothing; a look's blanks trimmed; size taking a screen too small |
+| src/ninep/ctl.zig, pane.zig | 38 (9 by hand) | about 72 | 6 |
+| test/panes.zig | 30 | 15 | 16 |
+| src/pardes.zig | 28 | 17 | 36 |
+| test/pdf.zig, test/output.zig | 14 | 28 | 13 |
-Migrated so far, in test/behaviour/: other_files (kbdin, mousein), panes
-(collapsed, name's leading blank, Putall), edit (an Edit block to a pane's
-ctl, the root's and exec, one left open at its clunk an err in the log),
-look_and_exec (a look's leading blanks, a bare :N), columns_and_tags (a
-look after Newcol), root_ctl (size). X, left where it is: a failure said
-while a 9P write waits (it checks the 9P server's own flags).
+What the M left need, most first:
+- **Effects performed:** Session counts a save and drops it; a save
+ record, /recent after a save, and a terminal's pty bytes come only once
+ a host performs the effect. A Session option that performs saves (and
+ keeps pty writes) unlocks a group in each area.
+- **A real host (T2):** terminals' output and shells, command panes
+ finishing, Tty and pty/ctl exec, a missing interpreter.
+- **Image panes:** they need the decoder worker Session does not start.
+- **LSP:** a fake language server.
+- **Not reached yet:** jumps and Back/Forward, Zerox, Get, Restore,
+ DumpConfig, ThemeFile, and name edge cases.
+Traps the migrators found in Session, each now in its tests' code:
+- **It never ticks the core,** so a record a step makes (a pane's `new`)
+ shows in /log only at the next request.
+- **A last line with no newline is held until the clunk;** its failure
+ goes to /log only, and the write reports success. End ctl lines with
+ `\n`.
+- **`write` appends (`>>`); `replace` truncates first (`>`).**
+- **`read` sets no `said`.**
+
+## Phases
## Phases
0. Inventory. Done, above.
diff --git a/src/pardes.zig b/src/pardes.zig
index ff64cb9f..b47119c4 100644
--- a/src/pardes.zig
+++ b/src/pardes.zig
@@ -710,34 +710,6 @@ test "pane-tag Exec prefers Tty and argument builtins before shell fallback" {
try std.testing.expectEqualStrings("DefinitelyNotABuiltin\r", sent[0..sent_len]);
}
-test "Collapse builtin keeps content and restores the pane from its default tag" {
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 100, .rows = 24, .tty_only = true });
- defer p.deinit();
- const pane = try p.setTestFile("keep this text\n");
- p.sync();
- const height = p.rects[0].h;
- const revision = pane.file.?.revision;
- for ([_][]const u8{ tagline.pane_tail, tagline.file_pane_tail, tagline.pdf_pane_tail, tagline.terminal_pane_tail }) |tail|
- try std.testing.expect(std.mem.endsWith(u8, tail, " Collapse Del"));
-
- try std.testing.expect(p.executeBuiltinLine(0, "Collapse"));
- p.sync();
- try std.testing.expect(pane.collapsed);
- try std.testing.expectEqual(@as(u16, BOX_H), p.rects[0].h);
- try std.testing.expectEqual(@as(f32, @floatFromInt(height)), pane.vweight);
- try std.testing.expectEqual(revision, pane.file.?.revision);
- try std.testing.expectEqualStrings("keep this text\n", pane.file.?.content);
- try std.testing.expect((try p.render(p.scratch.allocator())).cursor == null);
- tagline.enterTag(p, pane);
- const tag_cursor = (try p.render(p.scratch.allocator())).cursor orelse return error.MissingTagCursor;
- try std.testing.expectEqual(p.rects[0].y, tag_cursor.y);
- pane.focus = .body;
- try std.testing.expect(p.executeBuiltinLine(0, "Collapse"));
- p.sync();
- try std.testing.expect(!pane.collapsed);
- try std.testing.expectEqual(height, p.rects[0].h);
-}
-
test "LocationsConfig command reports partial updates and survives restore" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
@@ -851,42 +823,6 @@ test "TreeContext command and custom tag survive a workspace round trip" {
try std.testing.expectEqualStrings(" Save Keep Del", tagline.curTail(saved));
}
-test "Togglettymode builtin and keyboard chord share mode transitions including edited tags" {
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 120, .rows = 20, .tty_only = true });
- defer p.deinit();
- const pane = p.panes[0].?;
- try std.testing.expect(std.mem.indexOf(u8, tagline.curTail(pane), " Mode ") != null);
- try pane.appendTag(" Togglettymode");
- try std.testing.expectEqual(Text.Mode.tty, pane.body.mode);
- try std.testing.expect(p.executeBuiltinLine(0, "Togglettymode"));
- try std.testing.expectEqual(Text.Mode.normal, pane.body.mode);
- p.update(.{ .key = .{ .cp = p.tty_toggle, .ctrl = true } });
- try std.testing.expectEqual(Text.Mode.tty, pane.body.mode);
- // The tag has its own mode: the body keeps tty while the tag is typed into.
- tagline.enterTag(p, pane);
- try std.testing.expect(pane.focus == .tag);
- try std.testing.expectEqual(Text.Mode.tty, pane.body.mode);
- try std.testing.expect(p.executeBuiltinLine(0, "Togglettymode"));
- try std.testing.expectEqual(Text.Mode.normal, pane.body.mode);
- try std.testing.expect(pane.focus == .body);
- tagline.enterTag(p, pane);
- p.update(.{ .key = .{ .cp = p.tty_toggle, .ctrl = true } });
- try std.testing.expectEqual(Text.Mode.tty, pane.body.mode);
- try std.testing.expect(pane.focus == .body);
-
- p.acknowledgePanelPresentation(&.{});
- const tag = try tagline.tagText(p, p.scratch.allocator(), pane);
- const x = p.rects[0].x + TAG_TEXT_INSET + @as(u16, @intCast(std.mem.indexOf(u8, tag, "Togglettymode").?));
- const y = p.rects[0].y;
- p.update(.{ .mouse = .{ .button = .middle, .kind = .press, .col = x, .row = y } });
- p.update(.{ .mouse = .{ .button = .middle, .kind = .release, .col = x, .row = y } });
- try std.testing.expectEqual(Text.Mode.normal, pane.body.mode);
- const file = try p.setTestFile("unchanged\n");
- try std.testing.expect(p.executeBuiltinLine(0, "Togglettymode"));
- try std.testing.expectEqual(Text.Mode.normal, file.body.mode);
- try std.testing.expectEqualStrings("unchanged\n", file.file.?.content);
-}
-
test "Filter is ordered after Del and toggles only its terminal or +Pager pane" {
const testing = std.testing;
const del = std.meta.stringToEnum(Builtin, "Del") orelse return error.MissingDelBuiltin;
@@ -978,29 +914,6 @@ test "compact tag commands stay beside their own prefix across layout changes" {
try std.testing.expectEqualStrings(above_tag, try tagline.tagText(p, p.scratch.allocator(), above));
}
-test "Joincol folds the active column into its right neighbor, keeping its panes" {
- const gpa = std.testing.allocator;
- const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 100, .rows = 30 });
- defer p.deinit();
- while (p.nextEffect()) |_| {}
-
- const right = p.freeSlot().?;
- _ = try p.newShell(right, "");
- try std.testing.expect(layout.splitColumn(p, 0, right, false));
- while (p.nextEffect()) |_| {}
- try std.testing.expectEqual(@as(usize, 2), p.ncol);
-
- p.active = 0; // the left column is current
- layout.joinCol(p, 0);
- try std.testing.expectEqual(@as(usize, 1), p.ncol);
- const lf = layout.findPane(p, 0) orelse return error.LostLeftPane;
- const rf = layout.findPane(p, right) orelse return error.LostRightPane;
- try std.testing.expectEqual(lf.col, rf.col);
-
- layout.joinCol(p, 0); // no right neighbor left: inert
- try std.testing.expectEqual(@as(usize, 1), p.ncol);
-}
-
test "Tty spawns a raw shell in the caller's directory" {
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 100, .rows = 30 });
@@ -1282,24 +1195,6 @@ test "first document keeps its originating shell and only opens a column when it
}
}
-test "acme placement: an empty active column takes the new pane whole" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 160, .rows = 32 });
- defer p.deinit();
- try std.testing.expectEqual(config.Runtime.Placement.acme, p.settings.placement);
- p.newColumn(0); // its tag has the keyboard: it is the active column
- tagline.exitHeader(p);
- p.sync();
- // A Look from the shell's text still lands in the active column, as
- // acme's makenewwindow puts it in activecol first (util.c:456).
- _ = try p.openTutorView(1);
- exec.placeNew(p, 0, 0, 1, .doc);
- try std.testing.expectEqualSlices(usize, &.{1}, p.col_panes[1][0..p.col_n[1]]);
- try std.testing.expectEqual(@as(usize, 1), p.active);
- try std.testing.expectEqual(@as(?usize, 1), p.activeColumn());
- // Never a new column.
- try std.testing.expectEqual(@as(usize, 2), p.ncol);
-}
-
test "acme placement: under a pane's text when it has many blank rows, else halving the biggest" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 60 });
defer p.deinit();
@@ -1373,38 +1268,6 @@ test "acme placement: a pane made from the middle of a column moves only the one
try std.testing.expectEqual(was_bottom.h, p.rects[bottom].h);
}
-test "acme placement: New and 9P's new take the bottom half of the last pane" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 40 });
- defer p.deinit();
- p.newScratchBelow(p.active);
- const last = p.active;
- p.sync();
- const was = p.rects[last];
- p.newScratchFor(last, .fs);
- const made = p.active;
- p.sync();
- try std.testing.expectEqual(layout.findPane(p, last).?.idx + 1, layout.findPane(p, made).?.idx);
- try std.testing.expectEqual(was.y + was.h, p.rects[made].y + p.rects[made].h);
- try std.testing.expect(p.rects[made].y > was.y + BOX_H);
-}
-
-test "Placement pardes brings back the old rules, and says so in DumpConfig" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 40 });
- defer p.deinit();
- try std.testing.expect(p.executeBuiltinLine(p.active, "Placement pardes"));
- try std.testing.expectEqual(config.Runtime.Placement.pardes, p.settings.placement);
- const top = p.active;
- p.sync();
- const was = p.rects[top];
- p.newScratchBelow(top);
- p.sync();
- // Directly under the asking pane, as New always put it.
- try std.testing.expectEqual(@as(usize, 1), layout.findPane(p, p.active).?.idx);
- try std.testing.expectEqual(was.y + was.h, p.rects[p.active].y + p.rects[p.active].h);
- try std.testing.expect(p.executeBuiltinLine(p.active, "Placement"));
- try std.testing.expectEqual(config.Runtime.Placement.acme, p.settings.placement);
-}
-
test "an empty column shows its theme's empty_col under its tag: acme's white, else the border" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 120, .rows = 20 });
defer p.deinit();
@@ -1442,24 +1305,6 @@ test "BootShell keep leaves the untouched boot shell a dragged document joins; r
}
}
-test "a pane its whole text fits in never scrolls to keep a margin" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 30 });
- defer p.deinit();
- const pane = try p.setTestFile("one\ntwo\nthree\n");
- // A second pane under it, as acme's placement puts one: right under the
- // three lines, which leaves the file exactly three body rows.
- const below = p.freeSlot().?;
- _ = try p.openTutorView(below);
- exec.placeNew(p, 0, 0, below, .doc);
- p.active = 0;
- p.sync();
- try std.testing.expectEqual(@as(u16, 3), p.rects[0].h - pane.tag_rows);
- for ("jj") |c| p.update(.{ .key = .{ .cp = c, .text = &.{c} } });
- p.sync();
- try std.testing.expectEqual(@as(i32, 2), pane.body.cur_row);
- try std.testing.expectEqual(@as(i32, 0), pane.scroll());
-}
-
test "dragging a column's only pane to another leaves that column in place, empty" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 160, .rows = 32 });
defer p.deinit();
@@ -1485,31 +1330,6 @@ test "dragging a column's only pane to another leaves that column in place, empt
try std.testing.expectEqual(@as(usize, 1), p.col_n[0]);
}
-test "pane defaults keep creation of scratch panes in column tags" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
- defer p.deinit();
- for ([_][]const u8{ tagline.pane_tail, tagline.file_pane_tail, tagline.pdf_pane_tail, tagline.terminal_pane_tail, config.topbar_str }) |tag| {
- var words = std.mem.tokenizeScalar(u8, tag, ' ');
- while (words.next()) |word| try std.testing.expect(!std.mem.eql(u8, word, "New"));
- }
- try std.testing.expectEqualStrings("New Tty Find Grep Joincol Delcol", tagline.columnTag(p, 0));
-}
-
-test "an unsaved file's tag is its name alone: the grip, not a mark, says it is unsaved" {
- const gpa = std.testing.allocator;
- const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 100, .rows = 30 });
- defer p.deinit();
- while (p.nextEffect()) |_| {}
- const pane = try p.setTestFile("before\n");
- const clean = try tagline.tagText(p, p.scratch.allocator(), pane);
- panes.File.setContent(p, &pane.file.?, try gpa.dupe(u8, "after\n"));
- const dirty = try tagline.tagText(p, p.scratch.allocator(), pane);
- try std.testing.expectEqualStrings(clean, dirty);
- try std.testing.expect(std.mem.indexOf(u8, dirty, " *") == null);
- // The dirty file and index's flag still say it.
- try std.testing.expect(ctlfs.pane.dirtyOf(pane));
-}
-
test "unknown Exec from a document runs as a command pane in its directory, typed into no terminal" {
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{});
@@ -2766,18 +2586,6 @@ test "a host with no methods at all is a complete in-process pardes" {
try std.testing.expect(p.quit);
}
-test "a builtin that needs a pane reports capacity failure when every slot is full" {
- const p = try Pardes.init(std.testing.allocator, .{ .shells = 3, .cols = 100, .rows = 30 });
- defer p.deinit();
- while (p.nextEffect()) |_| {}
- for (0..MAX_PANES) |id| if (p.panes[id] == null) {
- _ = try p.newDocPane(id);
- };
- const help = std.meta.stringToEnum(Builtin, "Help") orelse return error.MissingHelpBuiltin;
- exec.runBuiltin(p, help, 0, "", null);
- try std.testing.expect(std.mem.indexOf(u8, p.panes[0].?.msg[0..p.panes[0].?.msg_len], "help: no space for a pane") != null);
-}
-
test "Font keeps requested and acknowledged faces as separate plain state" {
if (comptime !font_picker) return; // there is no Font builtin on tty or web
const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
@@ -2866,26 +2674,6 @@ test "Font size suffix reaches native request and invalid input leaves it intact
try std.testing.expectEqual(@as(u16, 1850), p.settings.font.effective_size_hundredths);
}
-test "Pet command is SDL-only optional and validates its argument" {
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
- defer p.deinit();
- try std.testing.expectEqual(.off, p.settings.pet);
- if (comptime platform != .gui) {
- // A terminal's view has the word and takes it not.
- try std.testing.expect(p.executeBuiltinLine(p.active, "Pet cat"));
- try std.testing.expectEqual(.off, p.settings.pet);
- return;
- }
- try std.testing.expect(p.executeBuiltinLine(p.active, "Pet cat"));
- try std.testing.expectEqual(.cat, p.settings.pet);
- try std.testing.expect(p.executeBuiltinLine(p.active, "Pet dog"));
- try std.testing.expectEqual(.cat, p.settings.pet);
- try std.testing.expect(p.executeBuiltinLine(p.active, "Pet frog"));
- try std.testing.expectEqual(.frog, p.settings.pet);
- try std.testing.expect(p.executeBuiltinLine(p.active, "Pet off"));
- try std.testing.expectEqual(.off, p.settings.pet);
-}
-
test "startup config overrides restored styling before initFromDump returns" {
const source = try Pardes.init(std.testing.allocator, .{ .startup_config = "Theme dark\n" });
defer source.deinit();
@@ -3213,33 +3001,6 @@ fn pardes_ctlfs_ctlText(p: *Pardes, pane: *Pane) []const u8 {
return th.rd(p, ctlfs.Node.of(pane.serial, .ctl), 0, 4096).bytes;
}
-test "a name typed into the tag's path survives Esc, pending, and the next Enter renames; a second Esc drops it" {
- const gpa = std.testing.allocator;
- const p = try Pardes.init(gpa, .{ .tty_only = true });
- defer p.deinit();
- const pane = try p.setTestFile("x\n");
- for ([_]bool{ true, false }) |enter| {
- tagline.enterTag(p, pane);
- pane.tag.mode = .insert;
- pane.tag.cur_row = 0;
- pane.tag.cur_col = 1;
- p.update(.{ .key = .{ .cp = 'z', .text = "z" } });
- try std.testing.expect(pane.prompt == .name);
- p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expect(pane.prompt == .name);
- // A stray key changes nothing while it waits.
- p.update(.{ .key = .{ .cp = 'q', .text = "q" } });
- if (enter) {
- p.update(.{ .key = .{ .cp = Key.enter } });
- try std.testing.expectEqualStrings("/ztest.txt", pane.file.?.path);
- } else {
- p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expect(pane.prompt != .name);
- try std.testing.expectEqualStrings("/ztest.txt", pane.file.?.path);
- }
- }
-}
-
test "tabbed file aligns syntax cursor and mouse at the nearest insertion gap" {
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .cols = 60, .rows = 12 });
@@ -3345,21 +3106,6 @@ test "editable workspace and column tags are typed into and persist" {
try std.testing.expectEqualStrings("", tagline.columnTag(empty, 0));
}
-test "column tags follow their column through split and close" {
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 120, .rows = 20, .tty_only = true });
- defer p.deinit();
- _ = try p.setTestFile("left\n");
- p.col_tags[0].own = try p.gpa.dupe(u8, "Left Find");
- _ = exec.execute(p, 0, "Newcol");
- try std.testing.expectEqual(@as(usize, 2), p.ncol);
- try std.testing.expectEqualStrings("Left Find", tagline.columnTag(p, 0));
- p.col_tags[1].own = try p.gpa.dupe(u8, "Right Grep");
- p.active = p.col_panes[0][0];
- layout.joinCol(p, 0);
- try std.testing.expectEqual(@as(usize, 1), p.ncol);
- try std.testing.expectEqualStrings("Right Grep", tagline.columnTag(p, 0));
-}
-
test "column tags render edit hover and scroll from the column edge" {
const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 20, .tty_only = true });
defer p.deinit();
@@ -3437,43 +3183,6 @@ test "column tag first-cell execution keeps New local to the clicked column" {
try std.testing.expectEqualStrings("untouched\n", p.panes[0].?.file.?.content);
}
-test "header clicks beyond text append and long UTF-8 tags reveal their caret" {
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 50, .rows = 12, .tty_only = true });
- defer p.deinit();
- _ = try p.setTestFile("body\n");
- p.col_tags[0].own = try p.gpa.dupe(u8, "New");
- p.acknowledgePanelPresentation(&.{});
- p.update(.{ .mouse = .{ .button = .left, .kind = .press, .col = 40, .row = TOPBAR_H } });
- p.update(.{ .mouse = .{ .button = .left, .kind = .release, .col = 40, .row = TOPBAR_H } });
- p.update(.{ .key = .{ .cp = 'x', .text = " extended" } });
- try std.testing.expectEqualStrings("New extended", tagline.columnTag(p, 0));
- p.update(.{ .paste = " 界界界界界界界界界界界界界界界界界界界界界界界界界界界界界界" });
- const frame = try p.render(p.scratch.allocator());
- try std.testing.expect(p.header_scroll > 0);
- try std.testing.expect(frame.cursor != null);
- try std.testing.expectEqual(TOPBAR_H, frame.cursor.?.y);
- try std.testing.expect(frame.cursor.?.x < p.screen_w);
- p.update(.{ .key = .{ .cp = Key.home } });
- _ = try p.render(p.scratch.allocator());
- try std.testing.expectEqual(@as(usize, 0), p.header_scroll);
-}
-
-test "a newline typed into a column tag is a space: the tag stays one row" {
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 50, .rows = 12, .tty_only = true });
- defer p.deinit();
- _ = try p.setTestFile("body\n");
- p.col_tags[0].own = try p.gpa.dupe(u8, "New");
- p.acknowledgePanelPresentation(&.{});
- p.update(.{ .mouse = .{ .button = .left, .kind = .press, .col = 40, .row = TOPBAR_H } });
- p.update(.{ .mouse = .{ .button = .left, .kind = .release, .col = 40, .row = TOPBAR_H } });
- p.update(.{ .key = .{ .cp = Key.enter } });
- p.update(.{ .key = .{ .cp = 'S', .text = "Snarf" } });
- _ = try p.render(p.scratch.allocator());
- try std.testing.expectEqualStrings("New Snarf", tagline.columnTag(p, 0));
- try std.testing.expectEqual(COLBAR_H, p.columnBarHeight());
- try std.testing.expectEqual(TOPBAR_H + COLBAR_H, p.rects[0].y);
-}
-
test "tiny screens keep pane space before adding a column tag" {
const p = try Pardes.init(std.testing.allocator, .{ .cols = 8, .rows = 2, .tty_only = true });
defer p.deinit();
@@ -3504,18 +3213,6 @@ test "a screen too short for the column row releases a column tag's focus withou
try std.testing.expectEqualStrings("unchanged body\n", pane.file.?.content);
}
-test "a header's execute key runs the word under its cursor and lets go of the keyboard first" {
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 100, .rows = 12, .tty_only = true });
- defer p.deinit();
- _ = try p.setTestFile("body\n");
- tagline.enterHeader(p, null);
- p.global_tag.cur_col = @intCast(std.mem.indexOf(u8, config.topbar_str, "Dump").?);
- p.update(.{ .key = .{ .cp = Key.tab } });
- try std.testing.expect(!p.header_focus);
- try std.testing.expect(p.dump_out != null);
- try std.testing.expectEqual(@as(usize, 1), p.col_n[0]);
-}
-
test "s in a header selects in the header's own text" {
const p = try Pardes.init(std.testing.allocator, .{ .cols = 100, .rows = 12, .tty_only = true });
defer p.deinit();
@@ -3535,20 +3232,6 @@ test "s in a header selects in the header's own text" {
try std.testing.expectEqual(@as(u16, 0), pane.body.nsel);
}
-test "Enter in a header runs the word under its cursor, as the execute key does" {
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 100, .rows = 12, .tty_only = true });
- defer p.deinit();
- _ = try p.setTestFile("body\n");
- try std.testing.expectEqual(@as(usize, 1), p.ncol);
- tagline.enterHeader(p, null);
- p.global_tag.cur_col = @intCast(std.mem.indexOf(u8, config.topbar_str, "Newcol").?);
- p.update(.{ .key = .{ .cp = Key.enter } });
- try std.testing.expectEqual(@as(usize, 2), p.ncol);
- // and the workspace tag lets go of the keyboard: the new, empty
- // column's tag has it
- try std.testing.expect(p.header_focus and p.header_column.? == 1);
-}
-
test "window keys walk from a pane up through the column and workspace tags and back" {
const p = try Pardes.init(std.testing.allocator, .{ .cols = 100, .rows = 20, .tty_only = true });
defer p.deinit();
@@ -8320,31 +8003,6 @@ pub const Pardes = struct {
}
};
-test "Esc alternates between two panes of the SAME kind" {
- if (platform == .web) return;
- const gpa = std.testing.allocator;
- var cwdbuf: [4096]u8 = undefined;
- const cwd = std.mem.span(@as([*:0]u8, @ptrCast(std.c.getcwd(&cwdbuf, cwdbuf.len) orelse return)));
- var pathbuf: [4096]u8 = undefined;
- const boot = try std.fmt.bufPrint(&pathbuf, "{s}/mise.toml", .{cwd});
-
- const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 40, .file = boot });
- defer p.deinit();
- p.update(.{ .resize = .{ .cols = 80, .rows = 40 } });
- const a = p.active;
- exec.runBuiltin(p, .Look, a, "", "build.zig");
- p.sync();
- const b = p.active;
- try std.testing.expect(b != a);
- try std.testing.expect(!p.panes[a].?.isTerminal() and !p.panes[b].?.isTerminal());
-
- for (0..6) |_| {
- const was = p.active;
- p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expectEqual(if (was == a) b else a, p.active);
- }
-}
-
test "a boot file that will not open boots an errors pane rather than failing the launch" {
if (platform == .web) return;
const gpa = std.testing.allocator;
@@ -8609,62 +8267,6 @@ test "a prompt is typed on its own line in the notice band and leaves the tag ro
try std.testing.expect(pane.prompt == .none and pane.input.own == null);
}
-test "Newcol makes an empty column, and the next pane made from its tag fills it" {
- if (platform == .web) return;
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 160, .rows = 40 });
- defer p.deinit();
- const first = p.active;
- const panes_before = p.col_n[0];
- try std.testing.expect(p.executeBuiltinLine(first, "Newcol"));
- try std.testing.expectEqual(@as(usize, 2), p.ncol);
- try std.testing.expectEqual(@as(usize, 0), p.col_n[1]);
- try std.testing.expectEqual(panes_before, p.col_n[0]);
- // The keyboard is on the new column's tag; no pane has it.
- try std.testing.expect(p.header_focus and p.header_column.? == 1);
- try std.testing.expectEqual(first, p.active);
- p.sync();
- try std.testing.expect(p.executeBuiltinLine(first, "Tty"));
- const shell = p.active;
- try std.testing.expect(shell != first);
- try std.testing.expectEqual(@as(usize, 1), p.col_n[1]);
- try std.testing.expectEqual(shell, p.col_panes[1][0]);
- try std.testing.expect(!p.header_focus);
-
- // The next Tty splits as it always has: nothing is empty any more.
- p.sync();
- try std.testing.expect(p.executeBuiltinLine(shell, "Tty"));
- try std.testing.expectEqual(@as(usize, 2), p.col_n[1]);
-}
-
-test "a column tag's command acts on that column" {
- if (platform == .web) return;
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 160, .rows = 40 });
- defer p.deinit();
- const first = p.active;
- try std.testing.expect(p.executeBuiltinLine(first, "Newcol"));
- try std.testing.expect(p.executeBuiltinLine(first, "Newcol"));
- try std.testing.expectEqual(@as(usize, 3), p.ncol);
- p.sync();
- // New from the middle column's tag lands in it, not below `first`.
- p.exec_column = 1;
- try std.testing.expect(p.executeBuiltinLine(first, "New"));
- p.exec_column = null;
- try std.testing.expectEqual(@as(usize, 1), p.col_n[1]);
- try std.testing.expectEqual(p.active, p.col_panes[1][0]);
- // Delcol from the empty right column's tag closes that one.
- p.exec_column = 2;
- try std.testing.expect(p.executeBuiltinLine(first, "Delcol"));
- p.exec_column = null;
- try std.testing.expectEqual(@as(usize, 2), p.ncol);
- try std.testing.expectEqual(@as(usize, 1), p.col_n[1]);
- // A pane's own Delcol closes its column whatever tag has the keyboard.
- try std.testing.expect(p.executeBuiltinLine(first, "Newcol"));
- try std.testing.expect(p.header_focus);
- try std.testing.expect(p.executeBuiltinLine(p.col_panes[1][0], "Delcol"));
- try std.testing.expectEqual(@as(usize, 2), p.ncol);
- try std.testing.expectEqual(@as(usize, 0), p.col_n[1]);
-}
-
test "Del from a key asks which neighbour takes the rows; nothing else asks" {
if (platform == .web) return;
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 40 });
@@ -8780,101 +8382,6 @@ test "Del from a key asks which neighbour takes the rows; nothing else asks" {
try std.testing.expect(p.panes[low] == null);
}
-test "a Look that finds nothing says so" {
- if (platform == .web) return;
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 });
- defer p.deinit();
- p.newScratchBelow(p.active);
- const id = p.active;
- p.sync();
- look.lookAt(p, id, "/no/such/zzqq");
- try std.testing.expectEqualStrings("Look: no match for \"/no/such/zzqq\"", p.panes[id].?.msg[0..p.panes[id].?.msg_len]);
-}
-
-test "focus on a closed pane goes to the pane that takes its place, not the one focused before" {
- if (platform == .web) return;
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 120, .rows = 40 });
- defer p.deinit();
- const shell = p.active;
- p.newColumn(shell);
- p.newScratchIn(shell, p.activeColumn().?);
- const right = p.active;
- p.sync();
- p.newScratchBelow(shell);
- const low = p.active;
- p.sync();
- // The dogfood case: `right` was focused just before `low`, but `shell`
- // grows into `low`'s rows, so `shell` gets the focus.
- try std.testing.expect(p.executeBuiltinLine(low, "Del"));
- p.sync();
- try std.testing.expect(p.panes[low] == null);
- try std.testing.expectEqual(shell, p.active);
-
- // Closing a pane that has no focus leaves the focus where it is.
- p.newScratchBelow(shell);
- const other = p.active;
- p.sync();
- p.active = right;
- p.sync();
- try std.testing.expect(p.executeBuiltinLine(other, "Del"));
- try std.testing.expectEqual(right, p.active);
-
- // Delcol: the column that takes the width holds, level with the closed
- // pane, the pane that takes its place; `right` was focused just before.
- p.newScratchBelow(right);
- const right_low = p.active;
- p.newScratchBelow(shell);
- const left_low = p.active;
- p.active = right;
- p.sync();
- p.active = left_low;
- p.sync();
- try p.removeColumn(layout.findPane(p, left_low).?.col);
- p.sync();
- try std.testing.expectEqual(right_low, p.active);
-}
-
-test "closing the last pane in a column leaves the column empty, its tag focused" {
- if (platform == .web) return;
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 120, .rows = 24 });
- defer p.deinit();
- const shell = p.active;
- p.newColumn(shell);
- p.newScratchIn(shell, p.activeColumn().?);
- const lone = p.active;
- try std.testing.expect(lone != shell);
- try std.testing.expectEqual(@as(usize, 2), p.ncol);
- const at = layout.findPane(p, lone).?;
- try std.testing.expectEqual(@as(usize, 1), p.col_n[at.col]);
- p.sync();
-
- try p.removePane(lone, null);
- p.sync();
-
- // The column outlives the pane, as acme's does: still two columns, the
- // emptied one with no pane and the keyboard on its tag.
- try std.testing.expectEqual(@as(usize, 2), p.ncol);
- try std.testing.expectEqual(@as(usize, 0), p.col_n[at.col]);
- try std.testing.expect(p.panes[lone] == null);
- try std.testing.expect(p.header_focus and p.header_column.? == at.col);
- try std.testing.expectEqual(shell, p.active);
- try std.testing.expect(!p.quit);
-
- // Down from it goes nowhere: nothing is below.
- try std.testing.expect(p.executeBuiltinLine(shell, "Down"));
- try std.testing.expect(p.header_focus and p.header_column.? == at.col);
-
- // ...and Delcol is what actually takes the column away.
- try p.removeColumn(at.col);
- p.sync();
- try std.testing.expectEqual(@as(usize, 1), p.ncol);
- try std.testing.expectEqual(shell, p.active);
-
- // The session's last pane closing ends it.
- try p.removePane(shell, null);
- try std.testing.expect(p.quit);
-}
-
test "the bare tty startup opens a text pane under the shell, unfocused" {
if (platform == .web) return;
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .boot = .tty });
@@ -8944,53 +8451,6 @@ test "tty output follows only from the bottom" {
try std.testing.expect(panes.terminal.scrollbar(sp).offset > live);
}
-test "Esc back into a file leaves its view where it was" {
- if (platform == .web) return;
- const gpa = std.testing.allocator;
- const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "src/memory.zig" });
- defer p.deinit();
- // Rows are lines: the centring below counts lines, and a wrapped line
- // above the cursor would push it out of the view it centres.
- p.settings.wrap = false;
- p.update(.{ .resize = .{ .cols = 80, .rows = 24 } });
- p.update(.{ .key = .{ .cp = 'n', .alt = true } }); // a shell under the doc
- const shell = p.active;
- p.update(.{ .key = .{ .cp = Key.escape } }); // back onto the doc
- p.sync();
- const doc = p.active;
- try std.testing.expect(doc != shell);
- const dp = p.panes[doc].?;
- try std.testing.expect(dp.file != null);
-
- // Ride the cursor down until the view has scrolled: it now sits in the
- // bottom band, which is exactly where a recenter is visible.
- for (0..20) |_| p.update(.{ .key = .{ .cp = 'j' } });
- p.sync();
- const view = dp.file.?.scroll;
- const row = dp.body.cur_row;
- try std.testing.expect(view > 0);
-
- p.update(.{ .key = .{ .cp = Key.escape } }); // out to the shell
- p.sync();
- try std.testing.expectEqual(shell, p.active);
- p.update(.{ .key = .{ .cp = Key.escape } }); // ...and back
- p.sync();
- try std.testing.expectEqual(doc, p.active);
-
- // Nothing moved. The old landing recentred the line under the cursor, so
- // coming back repainted the whole screen to show what was already on it.
- try std.testing.expectEqual(view, dp.file.?.scroll);
- try std.testing.expectEqual(row, dp.body.cur_row);
- // ...and the cursor is still on screen, which is all `.nearest` promises.
- try std.testing.expect(dp.body.cur_row >= @as(i32, @intCast(view)));
- try std.testing.expect(dp.body.cur_row < @as(i32, @intCast(view)) + @as(i32, dp.rows));
-
- // The other arm still centres: a look target, a `:NN`, a search hit.
- look.focusPaneLine(p, doc, .{ .line = @intCast(row + 1), .col = 1 }, .center);
- try std.testing.expect(dp.file.?.scroll != view);
- try std.testing.expectEqual(@as(usize, @intCast(row)) -| @as(usize, dp.rows) / 2, dp.file.?.scroll);
-}
-
test "raw tty Esc backs out and Shift-Esc is the program's Esc" {
if (platform == .web) return;
const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24, .file = "mise.toml" });
@@ -9048,43 +8508,6 @@ test "with ProgramEsc raw tty Escape only leaves at a shell prompt" {
try std.testing.expectEqual(Text.Mode.tty, pane.body.mode);
}
-test "Shift-Esc backs out to the previous pane in every mode, never into raw" {
- if (platform == .web) return;
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24, .file = "mise.toml" });
- defer p.deinit();
- p.update(.{ .key = .{ .cp = 'n', .alt = true } }); // a shell under the doc
- const shell = p.active;
- const sp = p.panes[shell].?;
- // A terminal in normal mode: out, still normal, never raw.
- if (sp.body.mode == .tty) p.update(.{ .key = .{ .cp = 'b', .ctrl = true } });
- try std.testing.expectEqual(Text.Mode.normal, sp.body.mode);
- p.update(.{ .key = .{ .cp = Key.escape, .shift = true } });
- try std.testing.expectEqual(@as(usize, 0), p.active);
- try std.testing.expectEqual(Text.Mode.normal, sp.body.mode);
- // A text pane in insert mode: out of insert, and out of the pane.
- const doc = p.panes[0].?;
- p.update(.{ .key = .{ .cp = 'i', .text = "i" } });
- try std.testing.expectEqual(Text.Mode.insert, doc.body.mode);
- p.update(.{ .key = .{ .cp = Key.escape, .shift = true } });
- try std.testing.expectEqual(Text.Mode.normal, doc.body.mode);
- try std.testing.expect(p.active != 0);
-}
-
-test "Esc in a column or the workspace tag gives the keyboard back to a pane, as Shift-Esc does" {
- if (platform == .web) return;
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24, .file = "mise.toml" });
- defer p.deinit();
- p.update(.{ .key = .{ .cp = 'n', .alt = true } }); // a pane to go back to
- for ([_]?usize{ 0, null }) |column| {
- tagline.enterHeader(p, column);
- try std.testing.expect(tagline.focusedHeader(p) != null);
- const was = p.active;
- p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expect(tagline.focusedHeader(p) == null);
- try std.testing.expect(p.active != was);
- }
-}
-
test "window mode moves an outline and focuses it on Enter, Esc or a label" {
const p = try Pardes.init(std.testing.allocator, .{ .cols = 120, .rows = 30 });
defer p.deinit();
@@ -10026,27 +9449,6 @@ test "core animation keeps wall time at 60, 120 and 144 Hz and across a stall" {
try std.testing.expectEqual(@as(?u64, null), p.nextWake());
}
-test "a pane closed while its question stands ends the question in the log" {
- const th = @import("ninep/testing.zig");
- const p = try th.withFile(std.testing.allocator, "x\n");
- defer p.deinit();
- p.settings.placement = .pardes;
- p.newScratchBelow(0);
- const closing = p.active;
- p.newScratchBelow(closing);
- p.sync();
- p.active = closing; // a middle pane: Del from a key asks which side
- const serial = p.panes[closing].?.serial;
- p.update(.{ .key = .{ .cp = ' ' } });
- p.update(.{ .key = .{ .cp = 'd' } });
- try std.testing.expectEqual(Pane.Prompt.del_side, p.panes[closing].?.prompt);
- // A bare answer says what this question takes.
- try std.testing.expectEqualStrings("answer takes k j or -", th.wr(p, ctlfs.Node.of(serial, .ctl), "answer\n").reply.ename);
- try p.removePane(closing, null);
- var want: [64]u8 = undefined;
- try std.testing.expect(th.logHas(p, try std.fmt.bufPrint(&want, "answer {d} -\ndel {d}", .{ serial, serial })));
-}
-
test "a Save the host could not do logs no save record" {
const th = @import("ninep/testing.zig");
const p = try th.withFile(std.testing.allocator, "x\n");
@@ -10070,31 +9472,3 @@ test "a Save the host could not do logs no save record" {
p.perform(.{ .save_file = .{ .pane = 0 } });
try std.testing.expect(th.logHas(p, "\nsave "));
}
-
-test "Delcol on the last column leaves the window, drawn and typed into, and Newcol starts it again" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 });
- defer p.deinit();
- while (p.nextEffect()) |_| {}
- while (p.ncol > 0) {
- p.exec_column = 0;
- _ = p.executeBuiltinLine(p.active, "Delcol");
- p.exec_column = null;
- p.sync();
- }
- try std.testing.expect(!p.quit);
- try std.testing.expect(p.anyPane() == null);
- // Drawn, and keys go to the workspace tag.
- _ = try p.render(p.frame_arena.allocator());
- p.update(.{ .key = .{ .cp = 'x', .text = "x" } });
- p.update(.{ .key = .{ .cp = Key.enter } });
- p.sync();
- _ = try p.render(p.frame_arena.allocator());
- try std.testing.expect(!p.quit);
- _ = p.executeBuiltinLine(p.active, "Newcol");
- p.sync();
- try std.testing.expectEqual(@as(usize, 1), p.ncol);
- _ = p.executeBuiltinLine(p.active, "New");
- p.sync();
- try std.testing.expect(p.anyPane() != null);
- _ = try p.render(p.frame_arena.allocator());
-}
diff --git a/test/behaviour.zig b/test/behaviour.zig
index a272d0f6..d9b15183 100644
--- a/test/behaviour.zig
+++ b/test/behaviour.zig
@@ -8,13 +8,20 @@ test {
_ = @import("behaviour/edit.zig");
_ = @import("behaviour/event.zig");
_ = @import("behaviour/flags.zig");
+ _ = @import("behaviour/keys.zig");
+ _ = @import("behaviour/limits.zig");
_ = @import("behaviour/log.zig");
_ = @import("behaviour/look_and_exec.zig");
+ _ = @import("behaviour/modes.zig");
_ = @import("behaviour/mounts.zig");
+ _ = @import("behaviour/mouse.zig");
_ = @import("behaviour/other_files.zig");
_ = @import("behaviour/panes.zig");
+ _ = @import("behaviour/placement.zig");
_ = @import("behaviour/root_ctl.zig");
_ = @import("behaviour/rules.zig");
_ = @import("behaviour/settings.zig");
+ _ = @import("behaviour/tags.zig");
+ _ = @import("behaviour/terminals.zig");
_ = @import("behaviour/tree.zig");
}
diff --git a/test/behaviour/columns_and_tags.zig b/test/behaviour/columns_and_tags.zig
index fa3baf48..d485ee6e 100644
--- a/test/behaviour/columns_and_tags.zig
+++ b/test/behaviour/columns_and_tags.zig
@@ -1,6 +1,7 @@
//! docs/typ/reference.typ, Columns and tags <columns-and-tags>.
const std = @import("std");
const Session = @import("session").Session;
+const expectEqualStrings = std.testing.expectEqualStrings;
/// /layout's line for the last column.
fn lastColumn(s: *Session) ![]const u8 {
@@ -32,6 +33,173 @@ test "columns-and-tags: a look after Newcol fills the empty column the keyboard
try std.testing.expect(std.mem.endsWith(u8, col, s.at(" {d}", .{try s.focused()})));
}
+test "columns-and-tags: Joincol folds a column into its right neighbour, keeping its panes, and with none it is inert" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const left = try s.focused();
+ const left_col = try s.column(0);
+ try s.write("/ctl", "Newcol\n");
+ const right_col = try s.column(1);
+ try s.write(s.at("/col/{d}/ctl", .{right_col}), "New\n");
+ const right = try s.focused();
+ try s.write(s.at("/col/{d}/ctl", .{left_col}), "Joincol\n");
+ try expectEqualStrings(s.at("{d}:{d},{d}", .{ right_col, right, left }), try s.columns());
+ _ = try s.refused(s.at("/col/{d}/ctl", .{right_col}), "Joincol\n");
+ try expectEqualStrings("Joincol: no column to the right", s.said);
+ try expectEqualStrings(s.at("{d}:{d},{d}", .{ right_col, right, left }), try s.columns());
+}
+
+test "columns-and-tags: Newcol makes an empty column with the keyboard on its tag, and the next pane made fills it" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const first = try s.focused();
+ try s.write("/ctl", "Newcol\n");
+ const left, const col = .{ try s.column(0), try s.column(1) };
+ try expectEqualStrings(s.at("{d}:{d} {d}:", .{ left, first, col }), try s.columns());
+ try s.expect("/focus", "");
+ try s.write(s.at("/pane/{d}/exec", .{first}), "Tty\n");
+ const shell = try s.focused();
+ try expectEqualStrings(s.at("{d}:{d} {d}:{d}", .{ left, first, col, shell }), try s.columns());
+ // The next Tty splits as it always has: nothing is empty any more.
+ try s.write(s.at("/pane/{d}/exec", .{shell}), "Tty\n");
+ try expectEqualStrings(s.at("{d}:{d} {d}:{d},{d}", .{ left, first, col, shell, try s.focused() }), try s.columns());
+}
+
+test "columns-and-tags: a column's exec acts on that column, and a pane's Delcol on its own" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const first = try s.focused();
+ try s.write("/ctl", "Newcol\n");
+ try s.write("/ctl", "Newcol\n");
+ const left, const middle = .{ try s.column(0), try s.column(1) };
+ // New from the middle column's tag lands in it, not below the pane
+ // with the keyboard.
+ try s.write(s.at("/col/{d}/exec", .{middle}), "New\n");
+ const made = try s.focused();
+ try expectEqualStrings(s.at("{d}:{d} {d}:{d} {d}:", .{ left, first, middle, made, try s.column(2) }), try s.columns());
+ // Delcol from the empty right column's tag closes that one.
+ try s.write(s.at("/col/{d}/exec", .{try s.column(2)}), "Delcol\n");
+ try expectEqualStrings(s.at("{d}:{d} {d}:{d}", .{ left, first, middle, made }), try s.columns());
+ // A pane's own Delcol closes its column whatever tag has the keyboard.
+ try s.write("/ctl", "Newcol\n");
+ try s.expect("/focus", "");
+ const right = try s.column(2);
+ try s.write(s.at("/pane/{d}/exec", .{made}), "Delcol\n");
+ try expectEqualStrings(s.at("{d}:{d} {d}:", .{ left, first, right }), try s.columns());
+}
+
+test "columns-and-tags: closing a column's last pane leaves it empty, its tag with the keyboard; Delcol takes it away" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const first = try s.focused();
+ try s.write("/ctl", "Newcol\n");
+ const left, const col = .{ try s.column(0), try s.column(1) };
+ try s.write(s.at("/col/{d}/ctl", .{col}), "New\n");
+ try s.write(s.at("/pane/{d}/ctl", .{try s.focused()}), "Del\n");
+ // The column outlives the pane, as acme's does.
+ try expectEqualStrings(s.at("{d}:{d} {d}:", .{ left, first, col }), try s.columns());
+ try s.expect("/focus", "");
+ // Down from it goes nowhere: nothing is below.
+ try s.write(s.at("/pane/{d}/exec", .{first}), "Down\n");
+ try s.expect("/focus", "");
+ // The tag with the keyboard is the emptied column's: what is typed lands there.
+ try s.keys("iMine\x1b");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read(s.at("/col/{d}/tag", .{col})), "Mine") != null);
+ try s.write(s.at("/col/{d}/ctl", .{col}), "Delcol\n");
+ try expectEqualStrings(s.at("{d}:{d}", .{ left, first }), try s.columns());
+ try std.testing.expectEqual(first, try s.focused());
+}
+
+test "columns-and-tags: a column's tag follows its column through Newcol and Joincol" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ try s.write(s.at("/col/{d}/tag", .{try s.column(0)}), " Left");
+ try s.write(s.at("/pane/{d}/exec", .{try s.focused()}), "Newcol\n");
+ try std.testing.expect(std.mem.endsWith(u8, try s.read(s.at("/col/{d}/tag", .{try s.column(0)})), " Left"));
+ try s.write(s.at("/col/{d}/tag", .{try s.column(1)}), " Right");
+ try s.write(s.at("/col/{d}/ctl", .{try s.column(0)}), "Joincol\n");
+ try std.testing.expect(std.mem.endsWith(u8, try s.read(s.at("/col/{d}/tag", .{try s.column(0)})), " Right"));
+}
+
+test "columns-and-tags: Delcol on the last column leaves the window, drawn and typed into, and Newcol starts it again" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ try s.write(s.at("/col/{d}/ctl", .{try s.column(0)}), "Delcol\n");
+ try expectEqualStrings("", try s.columns());
+ try s.expect("/index", "");
+ // Drawn, and keys go to the workspace tag.
+ try s.keys("x\n");
+ try std.testing.expect(std.mem.startsWith(u8, try s.screen(), " Newcol "));
+ try s.write("/ctl", "Newcol\n");
+ try s.write(s.at("/col/{d}/ctl", .{try s.column(0)}), "New\n");
+ try expectEqualStrings(s.at("{d}:{d}", .{ try s.column(0), try s.focused() }), try s.columns());
+}
+
+test "columns-and-tags: New is a column tag's word, in no pane's tag nor the workspace's" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ var t = try Session.initTerm(std.testing.allocator);
+ defer t.deinit();
+ // The file pane's, read before 9P's new takes the keyboard; a scratch
+ // made by New, and 9P's new (a +New file pane).
+ const file = try s.read(s.at("/pane/{d}/tag", .{try s.focused()}));
+ const made = try s.newPane();
+ try s.write(s.at("/col/{d}/exec", .{try s.column(0)}), "New\n");
+ const scratch = try s.focused();
+ try std.testing.expect(made != scratch);
+ for ([_][]const u8{
+ try s.read("/tag"),
+ file,
+ try s.read(s.at("/pane/{d}/tag", .{made})),
+ try s.read(s.at("/pane/{d}/tag", .{scratch})),
+ try t.read(t.at("/pane/{d}/tag", .{try t.focused()})),
+ }) |tag| {
+ var words = std.mem.tokenizeScalar(u8, tag, ' ');
+ while (words.next()) |word| try std.testing.expect(!std.mem.eql(u8, word, "New"));
+ }
+ try expectEqualStrings("New Tty Find Grep Joincol Delcol", try s.read(s.at("/col/{d}/tag", .{try s.column(0)})));
+}
+
+test "columns-and-tags: a click past a column tag's text types after it, a newline typed there a space, and a long tag scrolls to its caret" {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ const tag = s.at("/col/{d}/tag", .{try s.column(0)});
+ // Its row, then the pane's tag: the column's stays one row.
+ const rows = " New Tty Find Grep Joincol Delcol";
+ try std.testing.expect(std.mem.indexOf(u8, try s.screen(), rows ++ " ") != null);
+ try s.click("Delcol", 20, 1);
+ try s.keys("\nSnarf");
+ try expectEqualStrings("New Tty Find Grep Joincol Delcol Snarf", try s.read(tag));
+ try std.testing.expect(std.mem.indexOf(u8, try s.screen(), rows ++ " Snarf ") != null);
+ // The pane's tag on the row right under it: the column's is one row.
+ try std.testing.expectEqual((try s.where(rows))[1] + 1, (try s.where("/test.txt Save"))[1]);
+ // Wider than the screen: the tag scrolls to keep its caret drawn.
+ try s.keys(" 界界界界界界界界界界界界界界界界界界界界界界界界界界界界界界");
+ const col, const row = (try s.cursor()).?;
+ try std.testing.expectEqual(@as(usize, 1), row);
+ try std.testing.expect(col < 80);
+ try std.testing.expect(std.mem.indexOf(u8, try s.screen(), rows) == null);
+ try s.keys("\u{F00D}");
+ try std.testing.expect(std.mem.indexOf(u8, try s.screen(), rows) != null);
+}
+
+test "columns-and-tags: Enter in a tag in normal mode runs the word under its cursor, and Tab does too, letting go of the keyboard first" {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ const first = try s.focused();
+ try s.click("Newcol", 1, 1);
+ try s.keys("\x1b\n");
+ try expectEqualStrings(s.at("{d}:{d} {d}:", .{ try s.column(0), first, try s.column(1) }), try s.columns());
+ // The workspace tag lets go of the keyboard: the new, empty column's
+ // tag has it.
+ try s.expect("/focus", "");
+ try s.keys("iMine\x1b");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read(s.at("/col/{d}/tag", .{try s.column(1)})), "Mine") != null);
+ try s.click("Tutor", 1, 1);
+ try s.keys("\x1b\t");
+ try std.testing.expect(std.mem.endsWith(u8, try s.read(s.at("/pane/{d}/name", .{try s.focused()})), "/+Tutor\n"));
+}
+
test "columns-and-tags: a tag write refuses NUL and the other control characters, the workspace's, a column's and a pane's" {
var s = try Session.initFile(std.testing.allocator, "x\n");
defer s.deinit();
diff --git a/test/behaviour/keys.zig b/test/behaviour/keys.zig
new file mode 100644
index 00000000..41a2821a
--- /dev/null
+++ b/test/behaviour/keys.zig
@@ -0,0 +1,227 @@
+
+
+const std = @import("std");
+const Session = @import("session").Session;
+
+const alt = "\u{F015}";
+const window = "\x17"; // Ctrl-w
+
+test "keys: a prompt's entry and cancellation leave the tag, the body and its cursor as they were" {
+ var s = try Session.initFile(std.testing.allocator, "one\ntwo\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const tag = s.at("/pane/{d}/tag", .{n});
+ const dot = s.at("/pane/{d}/dot", .{n});
+ try s.replace(tag, " keep");
+ for ([_]struct { keys: []const u8, shown: []const u8 }{
+ .{ .keys = "s", .shown = " /zq" },
+ .{ .keys = "|", .shown = " |zq" },
+ .{ .keys = alt ++ "|", .shown = " |-zq" },
+ .{ .keys = "!", .shown = " !zq" },
+ .{ .keys = alt ++ "!", .shown = " !+zq" },
+ }) |case| {
+ try s.write(dot, "6 6");
+ try s.keys(case.keys);
+ // The answer is typed into the prompt's own line, never the tag.
+ try s.keys("zq");
+ _ = try s.where(case.shown);
+ try std.testing.expectEqualStrings("/test.txt keep", try s.read(tag));
+ try s.keys("\x1b");
+ try std.testing.expectError(error.NotOnScreen, s.where(case.shown));
+ try std.testing.expect(std.mem.endsWith(u8, try s.read(s.at("/pane/{d}/ctl", .{n})), " mode:normal "));
+ try std.testing.expectEqualStrings("/test.txt keep", try s.read(tag));
+ try std.testing.expectEqual(.{ 6, 6 }, try s.range(dot));
+ try s.expect(s.at("/pane/{d}/body", .{n}), "one\ntwo\n");
+ }
+ // Save on a scratch asks for a path, starting from its directory.
+ const scratch = try s.newPane();
+ const scratch_tag = try s.read(s.at("/pane/{d}/tag", .{scratch}));
+ try s.keys(":\tzq");
+ _ = try s.where("/zq");
+ try s.expect(s.at("/pane/{d}/tag", .{scratch}), scratch_tag);
+ try s.keys("\x1b");
+ try std.testing.expectError(error.NotOnScreen, s.where("/zq"));
+ try s.expect(s.at("/pane/{d}/tag", .{scratch}), scratch_tag);
+ try std.testing.expectEqual(@as(usize, 0), s.saved);
+}
+
+test "keys: a prompt opens whatever the tag already holds" {
+ var s = try Session.initFile(std.testing.allocator, "one\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const tag = s.at("/pane/{d}/tag", .{n});
+ try s.replace(tag, &@as([4096]u8, @splat('x')));
+ const full = try s.read(tag);
+ for ([_][]const u8{ "s", "|" }) |key| {
+ try s.keys(key);
+ try s.keys("zq");
+ _ = try s.where("zq");
+ try std.testing.expectEqualStrings(full, try s.read(tag));
+ try s.keys("\x1b");
+ }
+}
+
+test "keys: generated output refuses every pipe prompt before seeding the tag" {
+ var s = try Session.initFile(std.testing.allocator, "one\n");
+ defer s.deinit();
+ try s.write("/ctl", "Help\n");
+ const n = try s.focused();
+ const tag = try s.read(s.at("/pane/{d}/tag", .{n}));
+ const body = try s.read(s.at("/pane/{d}/body", .{n}));
+ for ([_][]const u8{ "|", alt ++ "|", "!", alt ++ "!" }) |key| {
+ try s.keys(key);
+ try std.testing.expectError(error.NotOnScreen, s.where(" |"));
+ try std.testing.expectError(error.NotOnScreen, s.where(" !"));
+ try s.expect(s.at("/pane/{d}/tag", .{n}), tag);
+ try s.expect(s.at("/pane/{d}/body", .{n}), body);
+ }
+}
+
+test "keys: a cancelled prompt restores the selection its regex previews changed" {
+ var s = try Session.initFile(std.testing.allocator, "one two one");
+ defer s.deinit();
+ const n = try s.focused();
+ const dot = s.at("/pane/{d}/dot", .{n});
+ for ([_][]const u8{ "sone", "S " }) |typed| {
+ try s.write(dot, "0 11");
+ try s.keys(typed);
+ try s.keys("\x1b");
+ try std.testing.expectEqual(.{ 0, 11 }, try s.range(dot));
+ try s.expect(s.at("/pane/{d}/sel", .{n}), "one two one");
+ try s.expect(s.at("/pane/{d}/body", .{n}), "one two one");
+ }
+}
+
+test "keys: a counted paste of nothing leaves no count for the next motion" {
+ var s = try Session.initFile(std.testing.allocator, "abcdefgh\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try s.keys("3pl");
+ try std.testing.expectEqual(.{ 1, 1 }, try s.range(s.at("/pane/{d}/dot", .{n})));
+ try s.expect(s.at("/pane/{d}/body", .{n}), "abcdefgh\n");
+}
+
+test "keys: a count or a prefix a click or a change of pane cancels leaves nothing for the next motion" {
+ const Gesture = enum { body, tag, focus, last };
+ for ([_][]const u8{ "3", "3g", "mr(" }) |typed| {
+ for ([_]Gesture{ .body, .tag, .focus, .last }) |gesture| {
+ errdefer std.debug.print("\nkeys={s} gesture={s}\n", .{ typed, @tagName(gesture) });
+ var s = try Session.initFile(std.testing.allocator, "abcdefghij\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try s.write("/ctl", "Newcol\n");
+ const other = try s.newPane();
+ try s.write("/focus", s.at("{d}", .{n}));
+ try s.keys(typed);
+ switch (gesture) {
+ .body => try s.click("abcdefghij", 3, 1),
+ .tag => {
+ try s.click("/test.txt Save", "/test.txt ".len + 3, 1);
+ try s.keys("\x1b:");
+ },
+ .focus, .last => {
+ try s.keys(window ++ "l\n");
+ try std.testing.expectEqual(other, try s.focused());
+ try s.keys(if (gesture == .last) "\x1b" else window ++ "h\n");
+ try std.testing.expectEqual(n, try s.focused());
+ },
+ }
+ const dot = s.at("/pane/{d}/dot", .{n});
+ const at = (try s.range(dot))[0];
+ try s.keys("l");
+ try std.testing.expectEqual(at + 1, (try s.range(dot))[0]);
+ try s.expect(s.at("/pane/{d}/body", .{n}), "abcdefghij\n");
+ }
+ }
+}
+
+test "keys: a PDF shown as text turns pages for the moving keys, counted, and the editing keys do nothing" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.lookFile("docs/design.pdf");
+ const pages = (try s.pdfPage(n))[1];
+ try std.testing.expect(pages > 3);
+ // j k, Ctrl-d Ctrl-u, Ctrl-f Ctrl-b: a page each, counted.
+ for ([_][]const u8{ "2j", "2k", "2\x04", "2\x15", "2\x06", "2\x02" }, 0..) |keys, i| {
+ try s.keys(keys);
+ try std.testing.expectEqual(@as(u32, if (i % 2 == 0) 3 else 1), (try s.pdfPage(n))[0]);
+ }
+ for ([_]struct { []const u8, u32 }{ .{ "ge", pages }, .{ "gg", 1 }, .{ "3gg", 3 }, .{ "2G", 2 } }) |step| {
+ try s.keys(step[0]);
+ try std.testing.expectEqual(step[1], (try s.pdfPage(n))[0]);
+ }
+ // Consumed, with their count: the page stays, no selection begins, and
+ // the next j is one page.
+ try s.keys("4dv|");
+ try std.testing.expectEqual(@as(u32, 2), (try s.pdfPage(n))[0]);
+ try std.testing.expect(std.mem.endsWith(u8, try s.read(s.at("/pane/{d}/ctl", .{n})), " mode:normal "));
+ try s.keys("j");
+ try std.testing.expectEqual(@as(u32, 3), (try s.pdfPage(n))[0]);
+}
+
+test "keys: SPC j n and SPC j p in plain text select its places, never a comment's slashes, round the end, opening nothing" {
+ var s = try Session.initFile(std.testing.allocator, "// ordinary comment\n/// documentation comment\n(//) [///] punctuation\n/\n// /tmp\n//tmp\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const index = try s.read("/index");
+ for ([_]struct { []const u8, []const u8, u32 }{
+ .{ " jn", "/", 69 }, .{ " jn", "/tmp", 74 }, .{ " jn", "//tmp", 79 }, .{ " jn", "/", 69 },
+ .{ " jp", "//tmp", 79 }, .{ " jp", "/tmp", 74 }, .{ " jp", "/", 69 },
+ }) |step| {
+ try s.keys(step[0]);
+ try std.testing.expectEqual(n, try s.focused());
+ try s.expect(s.at("/pane/{d}/sel", .{n}), step[1]);
+ try std.testing.expectEqual(step[2], (try s.range(s.at("/pane/{d}/dot", .{n})))[0]);
+ try s.expect("/index", index);
+ }
+}
+
+/// The value the root ctl's read gives `word`.
+fn setting(s: *Session, word: []const u8) ![]const u8 {
+ var lines = std.mem.splitScalar(u8, try s.read("/ctl"), '\n');
+ while (lines.next()) |line| if (std.mem.startsWith(u8, line, word) and line.len > word.len and line[word.len] == ' ') return line[word.len + 1 ..];
+ return error.NoSuchSetting;
+}
+
+test "keys: SPC j n and SPC j p walk Themes' rows, whole, never its section headings, and Tab sets the one selected" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const text = try s.focused();
+ // An imported theme's, the list still begins with the natives.
+ try s.write("/ctl", "Theme dark\n");
+ try s.write(s.at("/pane/{d}/exec", .{text}), "Themes\n");
+ // Listed beside the text, which keeps the keyboard.
+ try std.testing.expectEqual(text, try s.focused());
+ const list = text + 1;
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/index"), s.at("{d} text 0 /+Themes ", .{list})) != null);
+ const body = try s.read(s.at("/pane/{d}/body", .{list}));
+ // A heading, then a row a theme; each section after the first a blank
+ // line and its heading.
+ var lines = std.mem.splitScalar(u8, body, '\n');
+ try std.testing.expectEqualStrings("# Pardes themes", lines.next().?);
+ var names: std.ArrayList([]const u8) = .empty;
+ var first_break: ?usize = null;
+ while (lines.next()) |line| {
+ if (line.len == 0) {
+ const heading = lines.next() orelse break; // the newline ending the last row
+ try std.testing.expect(std.mem.startsWith(u8, heading, "# "));
+ first_break = first_break orelse names.items.len;
+ continue;
+ }
+ try std.testing.expect(std.mem.startsWith(u8, line, "Theme "));
+ try names.append(s.arena.allocator(), line);
+ }
+ const brk = first_break orelse return error.NoSections;
+ try std.testing.expect(std.mem.indexOf(u8, body[0..std.mem.indexOf(u8, body, "\n\n").?], "\nTheme acme\n") != null);
+ // Across the first section's end and back, the theme as it was.
+ for (names.items[0 .. brk + 1]) |row| {
+ try s.keys(" jn");
+ try std.testing.expectEqual(list, try s.focused());
+ try s.expect(s.at("/pane/{d}/sel", .{list}), row);
+ try std.testing.expectEqualStrings("dark", try setting(&s, "Theme"));
+ }
+ try s.keys(" jp");
+ try s.expect(s.at("/pane/{d}/sel", .{list}), names.items[brk - 1]);
+ try s.keys("\t");
+ try std.testing.expectEqualStrings(names.items[brk - 1]["Theme ".len..], try setting(&s, "Theme"));
+}
diff --git a/test/behaviour/limits.zig b/test/behaviour/limits.zig
new file mode 100644
index 00000000..08c864eb
--- /dev/null
+++ b/test/behaviour/limits.zig
@@ -0,0 +1,18 @@
+//! docs/typ/reference.typ, Limits <limits>.
+const std = @import("std");
+const Session = @import("session").Session;
+
+test "limits: a builtin that needs a pane says so when every slot is taken" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.focused();
+ // Room on the screen for every pane, so the slots run out first.
+ s.detach();
+ try s.write("/ctl", "size 100 400\n");
+ var made: usize = 1;
+ while (s.newPane()) |_| made += 1 else |_| {}
+ try std.testing.expectEqual(@as(usize, 64), made);
+ _ = try s.refused(s.at("/pane/{d}/exec", .{n}), "Help\n");
+ try std.testing.expectEqualStrings("help: no space for a pane: 64 max", s.said);
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), "help: no space for a pane") != null);
+}
diff --git a/test/behaviour/look_and_exec.zig b/test/behaviour/look_and_exec.zig
index 72052f7d..98cab342 100644
--- a/test/behaviour/look_and_exec.zig
+++ b/test/behaviour/look_and_exec.zig
@@ -163,3 +163,163 @@ test "look-and-exec: a line starting with # runs as nothing at an exec or a ctl,
try s.expect("/index", index);
try s.expect("/log", log);
}
+
+test "look-and-exec: a look replaces the selection it was made from, for an address, a range and text found" {
+ var s = try Session.initFile(std.testing.allocator, "alpha\nbravo\ncharlie\nneedle\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const dot = s.at("/pane/{d}/dot", .{n});
+ const look = s.at("/pane/{d}/look", .{n});
+ const ctl = s.at("/pane/{d}/ctl", .{n});
+ const body = s.at("/pane/{d}/body", .{n});
+ try s.write(dot, "0 5");
+ // A second cursor on the line below, and select mode.
+ try s.keys("Cv");
+ try std.testing.expect(std.mem.endsWith(u8, try s.read(ctl), " mode:select "));
+ try s.write(look, "/test.txt:3:2\n");
+ try expectEqual(.{ @as(u32, 13), @as(u32, 13) }, try s.range(dot));
+ // Both are gone with it: normal mode, and what is typed goes in once.
+ try std.testing.expect(std.mem.endsWith(u8, try s.read(ctl), " mode:normal "));
+ try s.keys("iZ\x1b");
+ try s.expect(body, "alpha\nbravo\ncZharlie\nneedle\n");
+ try s.write(ctl, "Undo\n");
+ try s.expect(body, "alpha\nbravo\ncharlie\nneedle\n");
+ try s.write(dot, "0 5");
+ try s.write(look, "/test.txt:2:2-4\n");
+ try s.expect(s.at("/pane/{d}/sel", .{n}), "rav");
+ try s.write(s.at("/pane/{d}/name", .{n}), "/tmp/look-selection-source.txt");
+ try s.write(dot, "0 5");
+ // A count typed before it is gone after it.
+ try s.keys("5");
+ try s.write(look, "needle\n");
+ try s.expect(s.at("/pane/{d}/sel", .{n}), "needle");
+ try s.keys("l");
+ try expectEqual(.{ @as(u32, 26), @as(u32, 26) }, try s.range(dot));
+ try expectEqual(n, try s.focused());
+}
+
+test "look-and-exec: a look into another pane leaves the source's dot and replaces the destination's selection" {
+ var s = try Session.initFile(std.testing.allocator, "source\nlines\n");
+ defer s.deinit();
+ const source = try s.focused();
+ const dest = try s.newPane();
+ try s.write(s.at("/pane/{d}/name", .{dest}), "/look-destination.txt");
+ try s.write(s.at("/pane/{d}/body", .{dest}), "alpha\nbravo\ncharlie\n");
+ const dest_dot = s.at("/pane/{d}/dot", .{dest});
+ for ([_]bool{ false, true }) |range| {
+ try s.write("/focus", s.at("{d}", .{source}));
+ try s.write(s.at("/pane/{d}/dot", .{source}), "0 6");
+ try s.write(dest_dot, "0 5");
+ try s.write(s.at("/pane/{d}/look", .{source}), if (range) "/look-destination.txt:2:2-4\n" else "/look-destination.txt:3:2\n");
+ try expectEqual(dest, try s.focused());
+ // The source keeps its dot, as acme's look leaves it.
+ try s.expect(s.at("/pane/{d}/sel", .{source}), "source");
+ if (range)
+ try s.expect(s.at("/pane/{d}/sel", .{dest}), "rav")
+ else
+ try expectEqual(.{ @as(u32, 13), @as(u32, 13) }, try s.range(dest_dot));
+ }
+}
+
+test "look-and-exec: a look that finds nothing says so" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.newPane();
+ try s.write(s.at("/pane/{d}/look", .{n}), "/no/such/zzqq\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), s.at("err {d} look: no match for \"/no/such/zzqq\"\n", .{n})) != null);
+}
+
+/// The log's `err` records, counted.
+fn errs(s: *Session) !usize {
+ return std.mem.count(u8, try s.read("/log"), "\nerr ");
+}
+
+/// The serial of the pane /index names with `suffix`.
+fn paneNamed(s: *Session, suffix: []const u8) !u32 {
+ var rows = std.mem.splitScalar(u8, try s.read("/index"), '\n');
+ while (rows.next()) |line| {
+ // serial kind dirty name column
+ const name = line[0 .. std.mem.lastIndexOfScalar(u8, line, ' ') orelse continue];
+ if (std.mem.endsWith(u8, name, suffix)) return std.fmt.parseInt(u32, line[0..std.mem.indexOfScalar(u8, line, ' ').?], 10);
+ }
+ return error.NoSuchPane;
+}
+
+test "look-and-exec: `:N` on a PDF turns to page N, from the pane and from the root's look, and `@pN:N` logs no err" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.lookFile("docs/design.pdf");
+ const look = s.at("/pane/{d}/look", .{n});
+ const pages = (try s.pdfPage(n))[1];
+ try std.testing.expect(pages >= 3);
+ try s.write(look, ":2\n");
+ try expectEqual(@as(u32, 2), (try s.pdfPage(n))[0]);
+ try s.write(look, s.at("@p{d}:1\n", .{n}));
+ try expectEqual(@as(u32, 1), (try s.pdfPage(n))[0]);
+ try s.write("/look", s.at("@p{d}:2\n", .{n}));
+ try expectEqual(@as(u32, 2), (try s.pdfPage(n))[0]);
+ try expectEqual(@as(usize, 0), try errs(&s));
+ // `:N:H` is hit H of its search on page N, as a search row's
+ // `file.pdf:N:H` is: with no search there is no hit 3, a miss that turns
+ // no page.
+ try s.write(look, ":1\n");
+ _ = try s.refused(look, ":2:3\n");
+ try expectEqual(@as(u32, 1), (try s.pdfPage(n))[0]);
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), "has no search hit 3 on page 2") != null);
+ try s.write(look, ":2\n");
+ _ = try s.refused(look, ":0\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), "has no page 0") != null);
+ // A byte offset or a pattern is no PDF address: refused with words.
+ _ = try s.refused(look, ":#3\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), "its address is a page, :N") != null);
+ const before = try errs(&s);
+ _ = try s.refused(look, s.at(":{d}\n", .{pages + 1}));
+ try expectEqual(before + 1, try errs(&s));
+ try expectEqual(@as(u32, 2), (try s.pdfPage(n))[0]);
+}
+
+test "look-and-exec: a look at a PDF's page past its last is a miss, never the last page, and opens nothing" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ var buf: [4096]u8 = undefined;
+ const dir = buf[0..try tmp.dir.realPath(std.testing.io, &buf)];
+ try std.Io.Dir.cwd().copyFile("docs/design.pdf", tmp.dir, "other.pdf", std.testing.io, .{});
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.lookFile("docs/design.pdf");
+ const look = s.at("/pane/{d}/look", .{n});
+ const name = std.mem.trimEnd(u8, try s.read(s.at("/pane/{d}/name", .{n})), "\n");
+ // Open: it stays on its page.
+ try s.write(look, ":2\n");
+ _ = try s.refused(look, s.at("{s}:999\n", .{name}));
+ try expectEqual(@as(u32, 2), (try s.pdfPage(n))[0]);
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), "has no page 999") != null);
+ // Not open: nothing opens.
+ const index = try s.read("/index");
+ _ = try s.refused(look, s.at("{s}/other.pdf:999\n", .{dir}));
+ try s.expect("/index", index);
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), "other.pdf has no page 999") != null);
+}
+
+test "look-and-exec: a +PdfSections row's first number is the page: a section not there, or on another page, is a miss said" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.lookFile("docs/design.pdf");
+ try s.write(s.at("/pane/{d}/exec", .{n}), "PdfSections\n");
+ const out = try paneNamed(&s, "/+PdfSections");
+ const body = try s.read(s.at("/pane/{d}/body", .{out}));
+ const row = body[0..std.mem.indexOfScalar(u8, body, '\n').?];
+ const place = row[0..std.mem.indexOfScalar(u8, row, ' ').?]; // design.pdf:P:S
+ var fields = std.mem.splitScalar(u8, place, ':');
+ _ = fields.next();
+ const page = try std.fmt.parseInt(u32, fields.next().?, 10);
+ const look = s.at("/pane/{d}/look", .{out});
+ // As listed: found, no miss.
+ try s.write(look, s.at("{s}\n", .{place}));
+ try expectEqual(@as(usize, 0), try errs(&s));
+ // The section on another page than the row says, and one not there.
+ _ = try s.refused(look, s.at("design.pdf:{d}:1\n", .{page + 1}));
+ try expectEqual(@as(usize, 1), try errs(&s));
+ _ = try s.refused(look, "design.pdf:1:999\n");
+ try expectEqual(@as(usize, 2), try errs(&s));
+}
diff --git a/test/behaviour/modes.zig b/test/behaviour/modes.zig
new file mode 100644
index 00000000..dde3ffb6
--- /dev/null
+++ b/test/behaviour/modes.zig
@@ -0,0 +1,104 @@
+//! docs/typ/guide.typ, Modes <modes>.
+const std = @import("std");
+const Session = @import("session").Session;
+const expectEqual = std.testing.expectEqual;
+
+fn mode(s: *Session, pane: u32) ![]const u8 {
+ const ctl = try s.read(s.at("/pane/{d}/ctl", .{pane}));
+ const at = std.mem.lastIndexOf(u8, ctl, " mode:").? + " mode:".len;
+ return std.mem.trimEnd(u8, ctl[at..], " ");
+}
+
+test "modes: Esc in normal mode alternates between two panes of the same kind" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "b.txt", .data = "b\n" });
+ var dir: [4096]u8 = undefined;
+ const at = dir[0..try tmp.dir.realPath(std.testing.io, &dir)];
+ var s = try Session.initFile(std.testing.allocator, "a\n");
+ defer s.deinit();
+ const a = try s.focused();
+ try s.write("/look", s.at("{s}/b.txt\n", .{at}));
+ const b = try s.focused();
+ try std.testing.expect(a != b);
+ for (0..6) |_| {
+ const was = try s.focused();
+ try s.keys("\x1b");
+ try expectEqual(if (was == a) b else a, try s.focused());
+ }
+}
+
+test "modes: Esc in a column or the workspace tag gives the keyboard back to a pane, as Shift-Esc does" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ _ = try s.newPane();
+ for ([_][]const u8{ "New Tty", "Newcol" }) |tag| {
+ const was = try s.focused();
+ // A click types into the tag; Esc is normal mode there, the next
+ // one is out of it.
+ try s.click(tag, 0, 1);
+ try s.keys("\x1b");
+ try s.expect("/focus", "");
+ try s.keys("\x1b");
+ try std.testing.expect(was != try s.focused());
+ }
+}
+
+test "modes: Shift-Esc backs out to the previous pane in every mode, never into raw" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const doc = try s.focused();
+ try s.keys("\u{F015}n"); // a shell under the doc
+ const shell = try s.focused();
+ if (std.mem.eql(u8, try mode(&s, shell), "tty")) try s.keys("\x02");
+ try std.testing.expectEqualStrings("normal", try mode(&s, shell));
+ // A terminal in normal mode: out, still normal, never raw.
+ try s.keys("\u{F016}\x1b");
+ try expectEqual(doc, try s.focused());
+ try std.testing.expectEqualStrings("normal", try mode(&s, shell));
+ // A text pane in insert mode: out of insert, and out of the pane.
+ try s.keys("i");
+ try std.testing.expectEqualStrings("insert", try mode(&s, doc));
+ try s.keys("\u{F016}\x1b");
+ try std.testing.expectEqualStrings("normal", try mode(&s, doc));
+ try std.testing.expect(doc != try s.focused());
+}
+
+/// The first line number drawn under the tag that starts with `tag`.
+fn topLine(s: *Session, tag: []const u8) !usize {
+ const row = (try s.where(tag))[1];
+ var rows = std.mem.splitScalar(u8, try s.screen(), '\n');
+ for (0..row + 1) |_| _ = rows.next();
+ var words = std.mem.tokenizeScalar(u8, rows.next().?, ' ');
+ return std.fmt.parseInt(usize, words.next().?, 10);
+}
+
+test "modes: Esc back into a file leaves its view where it was, and a look centres its line" {
+ var s = try Session.initFile(std.testing.allocator, std.mem.asBytes(&@as([100][4]u8, @splat("row\n".*))));
+ defer s.deinit();
+ const doc = try s.focused();
+ const dot = s.at("/pane/{d}/dot", .{doc});
+ try s.keys("\u{F015}n"); // a shell under the doc
+ const shell = try s.focused();
+ try s.keys("\x1b");
+ try expectEqual(doc, try s.focused());
+ // Ride the cursor down until the view has scrolled.
+ try s.keys(&@as([20]u8, @splat('j')));
+ const top = try topLine(&s, "/test.txt");
+ const at = try s.range(dot);
+ try std.testing.expect(top > 1);
+ try s.keys("\x1b");
+ try expectEqual(shell, try s.focused());
+ try s.keys("\x1b");
+ try expectEqual(doc, try s.focused());
+ // Nothing moved: the old landing recentred the line under the cursor.
+ try expectEqual(top, try topLine(&s, "/test.txt"));
+ try expectEqual(at, try s.range(dot));
+ // The other arm still centres: a look's `:NN`.
+ const line = 60;
+ try s.write(s.at("/pane/{d}/look", .{doc}), s.at(":{d}\n", .{line}));
+ const rows = (try s.where("Tty Save Mode"))[1] - (try s.where("/test.txt"))[1] - 1;
+ // Drawn mid-pane, a row either way.
+ const drawn_at = line - try topLine(&s, "/test.txt");
+ try std.testing.expect(drawn_at + 1 >= rows / 2 and drawn_at <= rows / 2 + 1);
+}
diff --git a/test/behaviour/mouse.zig b/test/behaviour/mouse.zig
new file mode 100644
index 00000000..0abe15dc
--- /dev/null
+++ b/test/behaviour/mouse.zig
@@ -0,0 +1,133 @@
+//! docs/typ/guide.typ, The mouse <mouse>.
+const std = @import("std");
+const Session = @import("session").Session;
+
+/// The mouse as `/mousein` lines say it, `m col row buttons` each.
+fn mouse(s: *Session, comptime lines: []const u8, args: anytype) !void {
+ try s.write("/mousein", s.at(lines, args));
+}
+
+test "mouse: a double-click selects a word, a line, a bracketed or quoted text, as acme's" {
+ var s = try Session.initFile(std.testing.allocator, "call foo_bar(a, b)\nsay \"hi there\"\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const sel = s.at("/pane/{d}/sel", .{n});
+ for ([_]struct { at: []const u8, into: usize, want: []const u8 }{
+ .{ .at = "foo_bar", .into = 2, .want = "foo_bar" },
+ .{ .at = "(a, b)", .into = 1, .want = "a, b" },
+ .{ .at = "call", .into = 0, .want = "call foo_bar(a, b)\n" },
+ .{ .at = "\"hi", .into = 1, .want = "hi there" },
+ }) |w| {
+ try s.click(w.at, w.into, 1);
+ try s.click(w.at, w.into, 1);
+ try s.expect(sel, w.want);
+ // A third click is a plain click again: the caret, no selection.
+ try s.click(w.at, w.into, 1);
+ try s.expect(sel, "");
+ }
+ // In the tag too: what it selected is what a yank takes.
+ try s.click("Collapse Del", "Collapse D".len, 1);
+ try s.click("Collapse Del", "Collapse D".len, 1);
+ try s.keys("\x1by:ggP");
+ try s.expect(s.at("/pane/{d}/body", .{n}), "Delcall foo_bar(a, b)\nsay \"hi there\"\n");
+}
+
+test "mouse: everything a B1 chord does while B1 is down is one undo step" {
+ var s = try Session.initFile(std.testing.allocator, "one two three\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const body = s.at("/pane/{d}/body", .{n});
+ const x, const y = try s.where("one two");
+ // B1-B2 then B1-B3: cut, then paste back: a copy, one step.
+ try mouse(&s, "m {d} {d} 1\nm {d} {d} 1\nm {d} {d} 3\nm {d} {d} 1\nm {d} {d} 5\nm {d} {d} 1\nm {d} {d} 0\n", .{ x + 4, y, x + 6, y, x + 6, y, x + 6, y, x + 6, y, x + 6, y, x + 6, y });
+ try s.expect(body, "one two three\n");
+ // Undone in one step, it is the text before the cut, not after it.
+ try s.write(s.at("/pane/{d}/ctl", .{n}), "Undo\n");
+ try s.expect(body, "one two three\n");
+ // A cut alone comes back with one Undo.
+ try mouse(&s, "m {d} {d} 1\nm {d} {d} 1\nm {d} {d} 3\nm {d} {d} 1\nm {d} {d} 0\n", .{ x + 4, y, x + 6, y, x + 6, y, x + 6, y, x + 6, y });
+ try s.expect(body, "one three\n");
+ try s.write(s.at("/pane/{d}/ctl", .{n}), "Undo\n");
+ try s.expect(body, "one two three\n");
+}
+
+test "mouse: a click past a line's or the file's end puts the caret where insertion types" {
+ for ([_]bool{ false, true }) |already_insert| {
+ for ([_]bool{ false, true }) |bottom_tag| {
+ for ([_]struct { text: []const u8, click_row: usize, dot: u32, col: usize, row: usize, result: []const u8 }{
+ .{ .text = "abc\nxy", .click_row = 0, .dot = 3, .col = 3, .row = 0, .result = "abcZ\nxy" },
+ .{ .text = "abc\nxy", .click_row = 5, .dot = 6, .col = 2, .row = 1, .result = "abc\nxyZ" },
+ .{ .text = "abc\n", .click_row = 5, .dot = 4, .col = 0, .row = 1, .result = "abc\nZ" },
+ .{ .text = "", .click_row = 5, .dot = 0, .col = 0, .row = 0, .result = "Z" },
+ }) |case| {
+ var s = try Session.initFile(std.testing.allocator, case.text);
+ defer s.deinit();
+ const n = try s.focused();
+ if (bottom_tag) try s.write("/ctl", "Tagbottom on\n");
+ if (already_insert) try s.keys("i");
+ // The first line's number, then a blank, then its text.
+ const x, const y = try s.where("1 ");
+ try mouse(&s, "m {d} {d} 1\nm {d} {d} 0\n", .{ x + 2 + 15, y + case.click_row, x + 2 + 15, y + case.click_row });
+ try std.testing.expectEqual(.{ case.dot, case.dot }, try s.range(s.at("/pane/{d}/dot", .{n})));
+ // The caret is drawn where it is, and insertion draws it there too.
+ try std.testing.expectEqual(.{ x + 2 + case.col, y + case.row }, (try s.cursor()).?);
+ if (!already_insert) try s.keys("i");
+ try std.testing.expect(std.mem.endsWith(u8, try s.read(s.at("/pane/{d}/ctl", .{n})), " mode:insert "));
+ try std.testing.expectEqual(.{ x + 2 + case.col, y + case.row }, (try s.cursor()).?);
+ try s.keys("Z");
+ try s.expect(s.at("/pane/{d}/body", .{n}), case.result);
+ }
+ }
+ }
+}
+
+test "mouse: a click on a tab's or a wrapped wide glyph's cells puts the caret on it" {
+ for ([_]bool{ false, true }) |already_insert| {
+ for ([_]bool{ false, true }) |wrap| {
+ const source = if (wrap) "012345678901234567890123456789界tail\n" else "\t界tail\n";
+ var s = try Session.initFile(std.testing.allocator, source);
+ defer s.deinit();
+ s.detach();
+ try s.write("/ctl", "size 24 12\n");
+ const n = try s.focused();
+ if (!wrap) try s.write("/ctl", "Wrap off\n");
+ if (already_insert) try s.keys("i");
+ const x, const y = try s.where("界");
+ if (wrap) try std.testing.expect(y > (try s.where("1 "))[1]);
+ // The glyph's second cell.
+ try mouse(&s, "m {d} {d} 1\nm {d} {d} 0\n", .{ x + 1, y, x + 1, y });
+ const at: u32 = @intCast(try std.unicode.utf8CountCodepoints(source[0..std.mem.indexOf(u8, source, "界").?]));
+ try std.testing.expectEqual(.{ at, at }, try s.range(s.at("/pane/{d}/dot", .{n})));
+ // Drawn on the glyph's first cell, in insert mode too.
+ try std.testing.expectEqual(.{ x, y }, (try s.cursor()).?);
+ if (!already_insert) try s.keys("i");
+ try std.testing.expectEqual(.{ x, y }, (try s.cursor()).?);
+ try s.keys("Z");
+ const byte = std.mem.indexOf(u8, source, "界").?;
+ try s.expect(s.at("/pane/{d}/body", .{n}), s.at("{s}Z{s}", .{ source[0..byte], source[byte..] }));
+ }
+ }
+}
+
+test "mouse: a B1 sweep over several lines is a stream, as acme's, in a body and a tag" {
+ var s = try Session.initFile(std.testing.allocator, "alpha\nbravo\ncharlie\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const body = s.at("/pane/{d}/body", .{n});
+ const x, const y = try s.where("alpha");
+ // From the press to the end of its line, the line between whole, the
+ // last from its start: no line numbers, no rectangle. B2 cuts it.
+ try mouse(&s, "m {d} {d} 1\nm {d} {d} 1\nm {d} {d} 3\nm {d} {d} 0\n", .{ x + 2, y, x + 1, y + 2, x + 1, y + 2, x + 1, y + 2 });
+ try s.expect(body, "alarlie\n");
+ try s.write(s.at("/pane/{d}/ctl", .{n}), "Undo\n");
+ // Upward, the same text.
+ try mouse(&s, "m {d} {d} 1\nm {d} {d} 1\nm {d} {d} 3\nm {d} {d} 0\n", .{ x + 1, y + 2, x + 2, y, x + 2, y, x + 2, y });
+ try s.expect(body, "alarlie\n");
+ // A tag of several rows sweeps the same way.
+ const tag = s.at("/pane/{d}/tag", .{n});
+ try s.write(tag, "\nLook Edit");
+ const tx, const ty = try s.where("Collapse");
+ const lx, const ly = try s.where("Look Edit");
+ try mouse(&s, "m {d} {d} 1\nm {d} {d} 1\nm {d} {d} 3\nm {d} {d} 0\n", .{ tx + 3, ty, lx + 1, ly, lx + 1, ly, lx + 1, ly });
+ try s.expect(tag, "/test.txt Save Tty Colok Edit");
+}
diff --git a/test/behaviour/other_files.zig b/test/behaviour/other_files.zig
index 8625df3b..ef1fab7e 100644
--- a/test/behaviour/other_files.zig
+++ b/test/behaviour/other_files.zig
@@ -70,3 +70,13 @@ test "other-files: pager answers its +Pager on the open that asked, whatever ano
try std.testing.expectEqual(@as(u16, 2), try s.refused("/pager", "/tmp/pardes-surely-missing-dir\n"));
try std.testing.expectEqual(@as(u16, 20), try s.refused("/pager", "/etc/passwd\n"));
}
+
+test "other-files: /recent keeps a PDF as it keeps a file: open, then closed" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.lookFile("docs/design.pdf");
+ const name = std.mem.trimEnd(u8, try s.read(s.at("/pane/{d}/name", .{n})), "\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/recent"), s.at("open {s}\n", .{name})) != null);
+ try s.write(s.at("/pane/{d}/ctl", .{n}), "Del\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/recent"), s.at("closed {s}\n", .{name})) != null);
+}
diff --git a/test/behaviour/panes.zig b/test/behaviour/panes.zig
index 4ea41693..a46f8432 100644
--- a/test/behaviour/panes.zig
+++ b/test/behaviour/panes.zig
@@ -166,3 +166,200 @@ test "panes: a second lock is refused until the holder unlocks or closes, and bi
try std.testing.expectEqual(@as(u16, 0), try s.writeFid(e, "lock\n"));
s.clunk(e);
}
+
+test "panes: an unsaved file's tag is its name alone, its dirty file says it is unsaved" {
+ var s = try Session.initFile(std.testing.allocator, "before\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const tag = s.at("/pane/{d}/tag", .{n});
+ const clean = try s.read(tag);
+ try s.write(s.at("/pane/{d}/body", .{n}), "after\n");
+ try std.testing.expectEqualStrings(clean, try s.read(tag));
+ try std.testing.expect(std.mem.indexOf(u8, clean, " *") == null);
+ try s.expect(s.at("/pane/{d}/dirty", .{n}), "1\n");
+}
+
+test "panes: a pane closed while its question stands ends the question in the log" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ try s.write("/ctl", "Placement pardes\n");
+ const top = try s.focused();
+ try s.write(s.at("/pane/{d}/exec", .{top}), "New\n");
+ const closing = try s.focused();
+ try s.write(s.at("/pane/{d}/exec", .{closing}), "New\n");
+ // A middle pane: Del from a key asks which side.
+ try s.write("/focus", s.at("{d}\n", .{closing}));
+ try s.keys(" d");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), s.at("ask {d} del k j\n", .{closing})) != null);
+ // A bare answer says what this question takes.
+ const ctl = s.at("/pane/{d}/ctl", .{closing});
+ _ = try s.refused(ctl, "answer\n");
+ try std.testing.expectEqualStrings("answer takes k j or -", s.said);
+ try s.write(ctl, "Del\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), s.at("answer {d} -\ndel {d}", .{ closing, closing })) != null);
+}
+
+test "panes: focus on a closed pane goes to the pane that takes its place, not the one focused before" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const left = try s.focused();
+ try s.write("/ctl", "Newcol\n");
+ try s.write(s.at("/col/{d}/ctl", .{try s.column(1)}), "New\n");
+ const right = try s.focused();
+ try s.write(s.at("/pane/{d}/exec", .{left}), "New\n");
+ const low = try s.focused();
+ // `right` was focused just before `low`, but `left` grows into `low`'s
+ // rows, so `left` gets the focus.
+ try s.write(s.at("/pane/{d}/ctl", .{low}), "Del\n");
+ try std.testing.expectEqual(left, try s.focused());
+ // Closing a pane that has no focus leaves the focus where it is.
+ try s.write(s.at("/pane/{d}/exec", .{left}), "New\n");
+ const other = try s.focused();
+ try s.write("/focus", s.at("{d}\n", .{right}));
+ try s.write(s.at("/pane/{d}/ctl", .{other}), "Del\n");
+ try std.testing.expectEqual(right, try s.focused());
+ // Delcol: the column that takes the width holds, level with the closed
+ // pane, the pane that takes its place; `right` was focused just before.
+ try s.write(s.at("/pane/{d}/exec", .{right}), "New\n");
+ const right_low = try s.focused();
+ try s.write(s.at("/pane/{d}/exec", .{left}), "New\n");
+ const left_low = try s.focused();
+ try s.write("/focus", s.at("{d}\n", .{right}));
+ try s.write("/focus", s.at("{d}\n", .{left_low}));
+ try s.write(s.at("/col/{d}/ctl", .{try s.column(0)}), "Delcol\n");
+ try std.testing.expectEqual(right_low, try s.focused());
+}
+
+test "panes: Collapse keeps the text and folds the pane to its tag, and again restores it" {
+ var s = try Session.initFile(std.testing.allocator, "keep this text\n");
+ defer s.deinit();
+ var t = try Session.initTerm(std.testing.allocator);
+ defer t.deinit();
+ const n = try s.focused();
+ for ([_][]const u8{
+ try s.read(s.at("/pane/{d}/tag", .{n})),
+ try s.read(s.at("/pane/{d}/tag", .{try s.newPane()})),
+ try t.read(t.at("/pane/{d}/tag", .{try t.focused()})),
+ }) |tag| try std.testing.expect(std.mem.endsWith(u8, tag, " Collapse Del"));
+ try s.write(s.at("/pane/{d}/ctl", .{try s.focused()}), "Del\n");
+ const ctl = s.at("/pane/{d}/ctl", .{n});
+ try s.write(ctl, "Collapse\n");
+ // Folded to its tag: no text drawn, no cursor in it, the text kept.
+ try std.testing.expect(std.mem.indexOf(u8, try s.read(ctl), " collapsed ") != null);
+ try std.testing.expect(std.mem.indexOf(u8, try s.screen(), "keep this text") == null);
+ try std.testing.expectEqual(null, try s.cursor());
+ try s.expect(s.at("/pane/{d}/body", .{n}), "keep this text\n");
+ try s.expect(s.at("/pane/{d}/dirty", .{n}), "0\n");
+ // Its tag still takes the keyboard, the cursor on the tag's row.
+ try s.keys(":");
+ try std.testing.expectEqual((try s.where("/test.txt"))[1], (try s.cursor()).?[1]);
+ try s.write(ctl, "Collapse\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read(ctl), " collapsed ") == null);
+ try std.testing.expectEqual((try s.where("/test.txt"))[1] + 1, (try s.where("1 keep this text"))[1]);
+}
+
+test "panes: a pane its whole text fits in never scrolls to keep a margin" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "f.txt", .data = "f\n" });
+ var dir: [4096]u8 = undefined;
+ const at = dir[0..try tmp.dir.realPath(std.testing.io, &dir)];
+ var s = try Session.initFile(std.testing.allocator, "one\ntwo\nthree\n");
+ defer s.deinit();
+ const n = try s.focused();
+ // A second pane under it, as acme's placement puts one: right under the
+ // three lines, which leaves the file exactly three body rows.
+ try s.write(s.at("/pane/{d}/look", .{n}), s.at("{s}/f.txt\n", .{at}));
+ try s.write("/focus", s.at("{d}\n", .{n}));
+ try s.keys("jj");
+ const top = (try s.where("/test.txt"))[1];
+ try std.testing.expectEqual(top + 4, (try s.where(at[0..@min(at.len, 20)]))[1]);
+ // On the last line, and line 1 still the first drawn.
+ try std.testing.expectEqual(.{ @as(u32, 8), @as(u32, 8) }, try s.range(s.at("/pane/{d}/dot", .{n})));
+ try std.testing.expectEqual(top + 1, (try s.where("1 one"))[1]);
+}
+
+/// `name` in `dir`: a one-page PDF with no outline and no text.
+fn plainPdf(dir: std.Io.Dir, name: []const u8) !void {
+ const objects = [_][]const u8{
+ "<< /Type /Catalog /Pages 2 0 R >>",
+ "<< /Type /Pages /Count 1 /Kids [3 0 R] >>",
+ "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 200 300] /Resources << >> >>",
+ };
+ var buf: [1024]u8 = undefined;
+ var w: std.Io.Writer = .fixed(&buf);
+ var at: [objects.len]usize = undefined;
+ try w.writeAll("%PDF-1.4\n");
+ for (objects, 0..) |object, i| {
+ at[i] = w.end;
+ try w.print("{d} 0 obj\n{s}\nendobj\n", .{ i + 1, object });
+ }
+ const xref = w.end;
+ try w.print("xref\n0 {d}\n0000000000 65535 f \n", .{objects.len + 1});
+ for (at) |off| try w.print("{d:0>10} 00000 n \n", .{off});
+ try w.print("trailer\n<< /Size {d} /Root 1 0 R >>\nstartxref\n{d}\n%%EOF\n", .{ objects.len + 1, xref });
+ try dir.writeFile(std.testing.io, .{ .sub_path = name, .data = w.buffered() });
+}
+
+test "panes: a PDF's body is the text of the page shown, each line of it a line, never a heading run into the text under it" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.lookFile("docs/design.pdf");
+ const body = s.at("/pane/{d}/body", .{n});
+ try std.testing.expect(std.mem.startsWith(u8, try s.read(body), "Pardes: A Text Environment\nArchitecture and implementation of the rewrite\n"));
+ try s.write(s.at("/pane/{d}/look", .{n}), ":2\n");
+ try std.testing.expect(!std.mem.startsWith(u8, try s.read(body), "Pardes: A Text Environment\n"));
+}
+
+test "panes: PdfTint steps a PDF's tint, read in its ctl and never in its tag, and only a PDF pane takes it" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const text = try s.focused();
+ const n = try s.lookFile("docs/design.pdf");
+ const ctl = s.at("/pane/{d}/ctl", .{n});
+ const tag = try s.read(s.at("/pane/{d}/tag", .{n}));
+ try std.testing.expect(std.mem.endsWith(u8, tag, " PdfSections PdfTint PdfFit Collapse Del"));
+ for ([_][]const u8{ "full", "disabled", "filtered" }) |want| {
+ try std.testing.expect(std.mem.indexOf(u8, try s.read(ctl), "fit:width ") != null);
+ try s.write(ctl, "PdfTint\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read(ctl), s.at(" tint:{s} ", .{want})) != null);
+ try s.expect(s.at("/pane/{d}/tag", .{n}), tag);
+ // Another pane's PdfTint is refused and leaves the PDF's alone.
+ try std.testing.expectEqual(@as(u16, 5), try s.refused(s.at("/pane/{d}/ctl", .{text}), "PdfTint\n"));
+ try std.testing.expect(std.mem.indexOf(u8, try s.read(ctl), s.at(" tint:{s} ", .{want})) != null);
+ }
+}
+
+test "panes: PdfSections on a PDF with no outline says so and opens nothing" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try plainPdf(tmp.dir, "plain.pdf");
+ var buf: [4096]u8 = undefined;
+ const dir = buf[0..try tmp.dir.realPath(std.testing.io, &buf)];
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.lookFile(s.at("{s}/plain.pdf", .{dir}));
+ try std.testing.expectEqual(@as(u32, 1), (try s.pdfPage(n))[1]);
+ const index = try s.read("/index");
+ for (0..2) |_| {
+ _ = try s.refused(s.at("/pane/{d}/exec", .{n}), "PdfSections\n");
+ try s.expect("/index", index);
+ }
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), "PdfSections: this PDF has no outline") != null);
+}
+
+test "panes: a Mini that cannot read its file leaves the panes, the last Mini's snapshot and the keyboard as they were" {
+ var s = try Session.initFile(std.testing.allocator, "abc\n");
+ defer s.deinit();
+ const text = try s.focused();
+ const exec = s.at("/pane/{d}/exec", .{text});
+ try s.write(exec, s.at("Mini /virtual/pane/{d}/body\n", .{text}));
+ const mini = try s.focused();
+ try std.testing.expect(mini != text);
+ const body = try s.read(s.at("/pane/{d}/body", .{mini}));
+ const index = try s.read("/index");
+ try std.testing.expectEqual(@as(u16, 2), try s.refused(exec, "Mini /virtual/does-not-exist\n"));
+ try std.testing.expectEqual(mini, try s.focused());
+ try s.expect("/index", index);
+ try s.expect(s.at("/pane/{d}/body", .{mini}), body);
+}
diff --git a/test/behaviour/placement.zig b/test/behaviour/placement.zig
new file mode 100644
index 00000000..079b5a5e
--- /dev/null
+++ b/test/behaviour/placement.zig
@@ -0,0 +1,61 @@
+//! docs/typ/reference.typ, Placement <placement>.
+const std = @import("std");
+const Session = @import("session").Session;
+
+test "placement: an empty active column takes the new pane whole, a look from another column's text too" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "f.txt", .data = "f\n" });
+ var dir: [4096]u8 = undefined;
+ const at = dir[0..try tmp.dir.realPath(std.testing.io, &dir)];
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const first = try s.focused();
+ // Its tag has the keyboard: it is the active column, and stays so
+ // when Esc gives the keyboard back.
+ try s.write("/ctl", "Newcol\n");
+ try s.keys("\x1b");
+ try std.testing.expectEqual(first, try s.focused());
+ // A look from the first pane's text still lands in the active column,
+ // as acme's makenewwindow puts it in activecol first (util.c:456).
+ try s.write(s.at("/pane/{d}/look", .{first}), s.at("{s}/f.txt\n", .{at}));
+ const made = try s.focused();
+ try std.testing.expectEqualStrings(s.at("{d}:{d} {d}:{d}", .{ try s.column(0), first, try s.column(1), made }), try s.columns());
+}
+
+/// The screen row the tag starting `name` is drawn on.
+fn tagRow(s: *Session, name: []const u8) !usize {
+ return (try s.where(s.at("{s} Save", .{name})))[1];
+}
+
+test "placement: New and 9P's new take the bottom half of the column's last pane" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const first = try s.focused();
+ try s.write(s.at("/pane/{d}/exec", .{first}), "New\n");
+ const last = try s.focused();
+ try s.write(s.at("/pane/{d}/name", .{last}), "/last\n");
+ const was = try tagRow(&s, "/last");
+ const made = try s.newPane();
+ try s.write(s.at("/pane/{d}/name", .{made}), "/made\n");
+ try std.testing.expectEqualStrings(s.at("{d}:{d},{d},{d}", .{ try s.column(0), first, last, made }), try s.columns());
+ // The last pane keeps its top and gives up its bottom half.
+ try std.testing.expectEqual(was, try tagRow(&s, "/last"));
+ const rows = std.mem.count(u8, try s.screen(), "\n") + 1;
+ try std.testing.expect(try tagRow(&s, "/made") >= was + (rows - was) / 2);
+}
+
+test "placement: Placement pardes puts a new pane right under the asking one, and bare it steps back to acme" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ try s.write("/ctl", "Placement pardes\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/ctl"), "\nPlacement pardes\n") != null);
+ const top = try s.focused();
+ try s.write(s.at("/pane/{d}/exec", .{top}), "New\n");
+ const below = try s.focused();
+ // Directly under the asking pane, as New always put it.
+ try s.write(s.at("/pane/{d}/exec", .{top}), "New\n");
+ try std.testing.expectEqualStrings(s.at("{d}:{d},{d},{d}", .{ try s.column(0), top, try s.focused(), below }), try s.columns());
+ try s.write("/ctl", "Placement\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/ctl"), "\nPlacement acme\n") != null);
+}
diff --git a/test/behaviour/settings.zig b/test/behaviour/settings.zig
index 5970e6b5..ff24704a 100644
--- a/test/behaviour/settings.zig
+++ b/test/behaviour/settings.zig
@@ -1,4 +1,5 @@
-//! docs/typ/reference.typ, Settings <settings>.
+
+
const std = @import("std");
const Session = @import("session").Session;
@@ -41,3 +42,62 @@ test "settings: Shell refuses a path that is no executable, and bare it goes bac
try std.testing.expect(has(try s.read("/log"), "Shell: the default again, "));
try std.testing.expectEqualStrings(default, try setting(&s, "Shell"));
}
+
+test "settings: Pet is the window's: a terminal's view refuses it, from a pane and the root; a window takes only its pets" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ // Which build, from its options, not from the answer: a terminal's view
+ // taking Pet must fail here, not pass as a window.
+ if (comptime @import("pardes_config").platform == .gui) {
+ try s.write("/ctl", "Pet cat\n");
+ // A window's: dog is no pet of its, and off is.
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/ctl"), "\nPet cat\n") != null);
+ _ = try s.refused("/ctl", "Pet dog\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/ctl"), "\nPet cat\n") != null);
+ try s.write("/ctl", "Pet frog\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/ctl"), "\nPet frog\n") != null);
+ try s.write("/ctl", "Pet off\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/ctl"), "\nPet off\n") != null);
+ return;
+ }
+ try std.testing.expectEqual(@as(u16, 22), try s.refused("/ctl", "Pet cat\n"));
+ try std.testing.expect(std.mem.startsWith(u8, s.said, "Pet is GUI-only, invalid here"));
+ try std.testing.expectEqual(@as(u16, 22), try s.refused(s.at("/pane/{d}/exec", .{try s.focused()}), "Pet cat\n"));
+ try std.testing.expectEqualStrings("Pet is GUI-only, invalid here", s.said);
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/ctl"), "Pet ") == null);
+}
+
+fn expectHas(text: []const u8, part: []const u8) !void {
+ if (std.mem.indexOf(u8, text, part) == null) {
+ std.debug.print("not in it: {s}\n", .{part});
+ return error.TestExpectedText;
+ }
+}
+
+test "settings: DumpConfig reports the settings in its one +DumpConfig pane, a second refreshing it" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const text = try s.focused();
+ const exec = s.at("/pane/{d}/exec", .{text});
+ try s.write(exec, "DumpConfig\n");
+ const out = try s.focused();
+ try std.testing.expect(out != text);
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/index"), s.at("{d} text 0 /+DumpConfig ", .{out})) != null);
+ const report = try s.read(s.at("/pane/{d}/body", .{out}));
+ for ([_][]const u8{ "Theme orchard\n", "Last shell spawned: (none)\n", "Shell change pending: on\n", "\nShell ", "LocationsConfig ", "no per-user config path" }) |line| try expectHas(report, line);
+ try s.write("/ctl", "Theme acme\n");
+ try s.write("/focus", s.at("{d}", .{text}));
+ try s.write(exec, "DumpConfig\n");
+ try std.testing.expectEqual(out, try s.focused());
+ try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, try s.read("/index"), "/+DumpConfig "));
+ try expectHas(try s.read(s.at("/pane/{d}/body", .{out})), "Theme acme\n");
+}
+
+test "settings: Config without a configuration directory says so and opens nothing" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const index = try s.read("/index");
+ try std.testing.expectEqual(@as(u16, 5), try s.refused(s.at("/pane/{d}/exec", .{try s.focused()}), "Config\n"));
+ try s.expect("/index", index);
+ try expectHas(try s.read("/log"), "Config: no startup file here: no configuration directory");
+}
diff --git a/test/behaviour/tags.zig b/test/behaviour/tags.zig
new file mode 100644
index 00000000..6c1c6fcd
--- /dev/null
+++ b/test/behaviour/tags.zig
@@ -0,0 +1,399 @@
+
+
+const std = @import("std");
+const Session = @import("session").Session;
+
+const home = "\u{F00D}";
+const right = "\u{F012}";
+const window = "\x17"; // Ctrl-w
+
+/// The pane's tag file.
+fn tag(s: *Session, n: u32) ![]const u8 {
+ return s.read(s.at("/pane/{d}/tag", .{n}));
+}
+
+/// The column of the screen's cursor in the tag drawn starting with
+/// `path`, which must be on its row.
+fn tagCol(s: *Session, path: []const u8) !usize {
+ const x, const y = try s.where(path);
+ const cx, const cy = (try s.cursor()).?;
+ try std.testing.expectEqual(y, cy);
+ return cx - x;
+}
+
+test "tags: s and S in a tag answer for the tag's own text; / still searches the body" {
+ var s = try Session.initFile(std.testing.allocator, "Some body\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try s.replace(s.at("/pane/{d}/tag", .{n}), " Save Del Snarf");
+ // The tag's line, its S's selected, then changed: both are the tag's.
+ try s.keys(":xsS\ncZ\x1b");
+ try std.testing.expectEqualStrings("/test.txt Zave Del Znarf", try tag(&s, n));
+ try s.expect(s.at("/pane/{d}/body", .{n}), "Some body\n");
+ // `/` from the tag is the body's search, as acme's Look from a tag is.
+ // Its places list the body's match.
+ try s.keys(",/body\n");
+ _ = try s.where("test.txt:1:6-9");
+}
+
+test "tags: ms and md edit a tag's own text, and the text the edit made is read back whole" {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try s.keys(":miwms(");
+ try std.testing.expectEqualStrings("/test.txt (Save) Tty Collapse Del", try tag(&s, n));
+ try s.keys("md(");
+ try std.testing.expectEqualStrings("/test.txt Save Tty Collapse Del", try tag(&s, n));
+}
+
+test "tags: the keyboard reaches a tag's path, which it can select and yank but not edit" {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const before = try tag(&s, n);
+ // `0` is the line's start, as in acme, where the name is ordinary text.
+ try s.keys(":0");
+ try std.testing.expectEqual(@as(usize, 0), try tagCol(&s, "/test.txt"));
+ // An edit that reaches into it is refused, the cursor with it.
+ try s.keys("Eyd");
+ try std.testing.expectEqualStrings(before, try tag(&s, n));
+ try std.testing.expectEqual(@as(usize, "/test.tx".len), try tagCol(&s, "/test.txt"));
+ // Typed into, the path drafts a name there, as a click on it does.
+ try s.keys(";0ix");
+ _ = try s.where("x/test.txt");
+ // Esc keeps the draft pending; a second drops it.
+ try s.keys("\x1b\x1b");
+ try s.expect(s.at("/pane/{d}/name", .{n}), "/test.txt\n");
+ // After the path, the text is the tag's own to edit.
+ try s.keys(":A!\x1b");
+ try std.testing.expectEqualStrings("/test.txt Save Tty Collapse Del!", try tag(&s, n));
+ // What it yanked was the path.
+ try s.keys(":P");
+ try s.expect(s.at("/pane/{d}/body", .{n}), "/test.txtbody\n");
+}
+
+test "tags: a tag remembers its cursor, starts on Save, and a click moves it" {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ const first = try s.focused();
+ try s.write("/ctl", "Newcol\n");
+ const second = try s.newPane();
+ try s.write(s.at("/pane/{d}/name", .{second}), "/second.txt");
+ const focus = s.at("{d}", .{first});
+ const other = s.at("{d}", .{second});
+ try s.write("/focus", focus);
+ // Nothing to remember yet: `:` lands on Save.
+ try s.keys(":");
+ try std.testing.expectEqual(@as(usize, "/test.txt ".len), try tagCol(&s, "/test.txt"));
+ // Home is the line's start, the path's: the keyboard reaches it.
+ try s.keys(home ++ right ++ right ++ right);
+ try std.testing.expectEqual(@as(usize, 3), try tagCol(&s, "/test.txt"));
+ // `:` in the tag's normal mode is the way back to the body.
+ try s.keys(":");
+ try std.testing.expect((try s.cursor()).?[1] != (try s.where("/test.txt"))[1]);
+ try s.write("/focus", other);
+ try s.keys(":" ++ home ++ right ++ right ++ right ++ right ++ right ++ ":");
+ try s.write("/focus", focus);
+ try s.keys(":");
+ try std.testing.expectEqual(@as(usize, 3), try tagCol(&s, "/test.txt"));
+ try s.keys(":");
+ try s.write("/focus", other);
+ try s.keys(":");
+ try std.testing.expectEqual(@as(usize, 5), try tagCol(&s, "/second.txt"));
+ try s.keys(":");
+ // A click in the tag puts its cursor there, the pane's keyboard with it.
+ try s.click("Save Tty", 6, 1);
+ try std.testing.expectEqual(first, try s.focused());
+ try std.testing.expectEqual(@as(usize, "/test.txt Save T".len), try tagCol(&s, "/test.txt"));
+ // A prompt opened and left from the body leaves it there.
+ try s.keys("\x1b:/\x1b:");
+ try std.testing.expectEqual(@as(usize, "/test.txt Save T".len), try tagCol(&s, "/test.txt"));
+ try s.keys(":");
+ try s.expect(s.at("/pane/{d}/body", .{first}), "body\n");
+}
+
+test "tags: executing a word from the tag runs it and gives the keyboard back to the body" {
+ for ([_][]const u8{ "\t", "\n" }) |chord| {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try s.keys("ix\x1b");
+ // `:` lands on Save; the execute key runs it, the look key looks
+ // it up. Either way the tag lets go of the keyboard first.
+ try s.keys(":");
+ try s.keys(chord);
+ try std.testing.expectEqual(@as(usize, if (chord[0] == '\t') 1 else 0), s.saved);
+ try s.keys("iQ\x1b");
+ try s.expect(s.at("/pane/{d}/body", .{n}), "xQbody\n");
+ // ...and the tag still knows where it was.
+ try s.keys(":");
+ try std.testing.expectEqual(@as(usize, "/test.txt ".len), try tagCol(&s, "/test.txt"));
+ }
+}
+
+test "tags: a renamed path moves the tag's cursor with the text after it and a shorter tag pulls it back" {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try s.keys("::"); // on Save, and back
+ try s.write(s.at("/pane/{d}/name", .{n}), "/界.zig");
+ try s.keys(":");
+ try std.testing.expectEqual(@as(usize, "/界.zig ".len - 1), try tagCol(&s, "/界"));
+ try s.keys(":");
+ try s.replace(s.at("/pane/{d}/tag", .{n}), "é");
+ try s.keys(":");
+ // `/界.zig é`: the cursor is pulled back onto the last character.
+ try std.testing.expectEqual(@as(usize, "/界.zig ".len - 1), try tagCol(&s, "/界"));
+ try s.expect(s.at("/pane/{d}/body", .{n}), "body\n");
+}
+
+test "tags: window keys move between panes from a tag and each tag keeps its cursor" {
+ for ([_]bool{ false, true }) |bottom| {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ if (bottom) try s.write("/ctl", "Tagbottom on\n");
+ const first = try s.focused();
+ const second = try s.newPane();
+ try s.write(s.at("/pane/{d}/name", .{second}), "/second.txt");
+ try s.write("/focus", s.at("{d}", .{first}));
+ try s.keys(":" ++ home ++ "ll" ++ window ++ "j\n");
+ try std.testing.expectEqual(second, try s.focused());
+ try s.keys(":" ++ home ++ "llll" ++ window ++ "k\n");
+ try std.testing.expectEqual(first, try s.focused());
+ try s.keys(":");
+ try std.testing.expectEqual(@as(usize, 2), try tagCol(&s, "/test.txt"));
+ try s.keys(window ++ "j\n:");
+ try std.testing.expectEqual(@as(usize, 4), try tagCol(&s, "/second.txt"));
+ }
+}
+
+test "tags: a tag's normal mode is the body's: motions stay in the tag and insert types into it" {
+ for ([_]bool{ false, true }) |bottom| {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ if (bottom) try s.write("/ctl", "Tagbottom on\n");
+ const first = try s.focused();
+ try s.write("/ctl", "Newcol\n");
+ const right_pane = try s.newPane();
+ try s.write("/focus", s.at("{d}", .{first}));
+ try s.keys(":" ++ home ++ "l");
+ try std.testing.expectEqual(@as(usize, 1), try tagCol(&s, "/test.txt"));
+ try s.keys("hkj");
+ try std.testing.expectEqual(@as(usize, 0), try tagCol(&s, "/test.txt"));
+ try std.testing.expectEqual(first, try s.focused());
+ try s.keys(window ++ "l\n");
+ try std.testing.expectEqual(right_pane, try s.focused());
+ try s.keys(window ++ "h\n");
+ try std.testing.expectEqual(first, try s.focused());
+ try s.keys(":i\u{F018}hjklHJKL:");
+ try std.testing.expectEqualStrings("/test.txt Save Tty Collapse DelhjklHJKL:", try tag(&s, first));
+ try std.testing.expect(std.mem.endsWith(u8, try s.read(s.at("/pane/{d}/ctl", .{first})), " mode:normal "));
+ try s.expect(s.at("/pane/{d}/body", .{first}), "body\n");
+ try std.testing.expectEqual(first, try s.focused());
+ }
+}
+
+test "tags: a tag with a newline in it is as tall as its lines, and each line is typed into and pointed at" {
+ for ([_]bool{ false, true }) |bottom| {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ const n = try s.focused();
+ if (bottom) try s.write("/ctl", "Tagbottom on\n");
+ // Insert mode in a tag is a body's: Enter is a new line.
+ try s.keys(":A\nSecond");
+ try std.testing.expectEqualStrings("/test.txt Save Tty Collapse Del\nSecond", try tag(&s, n));
+ const x, const y = try s.where("/test.txt");
+ try std.testing.expectEqual(.{ x, y + 1 }, try s.where("Second"));
+ // The caret is on the second line, after what was typed.
+ try std.testing.expectEqual(.{ x + 6, y + 1 }, (try s.cursor()).?);
+ // The body starts under (or over) the whole tag.
+ const by = (try s.where("1 body"))[1];
+ try std.testing.expect(if (bottom) by < y else by == y + 2);
+ // A click on the second line puts the tag's cursor on it.
+ try s.keys("\x1b:");
+ try s.write("/mousein", s.at("m {d} {d} 1\nm {d} {d} 0\n", .{ x + 2, y + 1, x + 2, y + 1 }));
+ try std.testing.expectEqual(.{ x + 2, y + 1 }, (try s.cursor()).?);
+ try s.keys("X");
+ try std.testing.expectEqualStrings("/test.txt Save Tty Collapse Del\nSeXcond", try tag(&s, n));
+ try s.expect(s.at("/pane/{d}/body", .{n}), "body\n");
+ }
+}
+
+test "tags: a tag with more lines than rows scrolls to keep its caret in view" {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ const n = try s.focused();
+ var many: std.ArrayList(u8) = .empty;
+ defer many.deinit(std.testing.allocator);
+ for (1..21) |i| try many.print(std.testing.allocator, "\nL{d}", .{i});
+ try s.write(s.at("/pane/{d}/tag", .{n}), many.items);
+ const x, const y = try s.where("/test.txt");
+ // To the last line: the tag scrolls so it is the bottom row, caret on it.
+ try s.keys(":ge");
+ const lx, const ly = try s.where("L20");
+ try std.testing.expectEqual(.{ lx, ly }, (try s.cursor()).?);
+ // What the pointer sees is what is shown: its first row is line 13.
+ try std.testing.expectEqual(.{ x, y }, try s.where("L13"));
+ try std.testing.expectError(error.NotOnScreen, s.where("L12"));
+ try s.write("/mousein", s.at("m {d} {d} 1\nm {d} {d} 0\n", .{ x + 1, y + 1, x + 1, y + 1 }));
+ try s.keys("X");
+ _ = try s.where("LX14");
+ // Back to the first line brings the prefix back into view.
+ try s.keys("\x1bgg");
+ try std.testing.expectEqual(.{ x, y }, try s.where("/test.txt"));
+ try std.testing.expectEqual(y, (try s.cursor()).?[1]);
+ // A column tag is one row, as acme's: its lines are joined.
+ var layout = std.mem.tokenizeScalar(u8, try s.read("/layout"), ' ');
+ const col_tag = s.at("/col/{s}/tag", .{layout.next().?});
+ try s.replace(col_tag, "New\nC1\nC2");
+ try std.testing.expect(std.mem.indexOfScalar(u8, try s.read(col_tag), '\n') == null);
+ try std.testing.expectEqual(y, (try s.where("/test.txt"))[1]);
+}
+
+test "tags: a long pane tag wraps onto rows, and a click on a wrapped row maps to the whole tag's address" {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ s.detach();
+ try s.write("/ctl", "size 50 12\n");
+ const n = try s.focused();
+ try s.write(s.at("/pane/{d}/name", .{n}), "/an/especially/deep/project/path/with/a/long/component/filename.zig");
+ try s.write(s.at("/pane/{d}/tag", .{n}), " SyntaxBold");
+ const before = try tag(&s, n);
+ try s.keys(":A");
+ try std.testing.expect((try s.cursor()).?[0] < 50);
+ // SyntaxBold is on a row of its own, below the path's.
+ try std.testing.expect((try s.where("SyntaxBold"))[1] > (try s.where("/an/"))[1]);
+ // Its last character, which a wrapped row's offset not mapped back misses.
+ try s.click("SyntaxBold", "SyntaxBol".len, 2);
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/ctl"), "SyntaxBold on\n") != null);
+ try std.testing.expectEqualStrings(before, try tag(&s, n));
+}
+
+test "tags: a word the tag's wrapping breaks across rows is still one word to a click" {
+ var s = try Session.initFile(std.testing.allocator, "body\n");
+ defer s.deinit();
+ s.detach();
+ try s.write("/ctl", "size 50 12\n");
+ const n = try s.focused();
+ // Lengthen the path until the wrap splits the word after "Synt" (a
+ // rename resets the tag's text, so it is written again each time).
+ var pad: usize = 1;
+ while (pad < 80) : (pad += 1) {
+ try s.write(s.at("/pane/{d}/name", .{n}), s.at("/{s}/f.zig", .{(&@as([80]u8, @splat('a')))[0..pad]}));
+ try s.write(s.at("/pane/{d}/tag", .{n}), " SyntaxBold");
+ var rows = std.mem.splitScalar(u8, try s.screen(), '\n');
+ const split = while (rows.next()) |row| {
+ if (std.mem.endsWith(u8, std.mem.trimEnd(u8, row, " "), "Synt")) break true;
+ } else false;
+ if (split) break;
+ } else return error.NoSplit;
+ try s.click("Synt", 1, 2);
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/ctl"), "SyntaxBold on\n") != null);
+}
+
+/// A click on the tag's path, at its last character: a name drafted
+/// there, its caret taken to its end.
+fn clickPathEnd(s: *Session, path: []const u8) !void {
+ try s.click(path, path.len - 1, 1);
+ try s.keys("\u{F018}");
+}
+
+test "tags: a name drafted in the tag commits with Enter, cancels with two Escs, and changes neither body nor tag text" {
+ var s = try Session.initFile(std.testing.allocator, "original body\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const name = s.at("/pane/{d}/name", .{n});
+ try s.write(s.at("/pane/{d}/tag", .{n}), " SyntaxBold");
+ for ([_]bool{ false, true }) |commit| {
+ const path = std.mem.trimEnd(u8, try s.read(name), "\n");
+ try clickPathEnd(&s, path);
+ try s.keys("\x15/new name.zig");
+ try s.expect(name, s.at("{s}\n", .{path}));
+ _ = try s.where("/new name.zig Save Tty Collapse Del SyntaxBold");
+ try s.expect(s.at("/pane/{d}/body", .{n}), "original body\n");
+ // Esc keeps the draft pending; a second drops it.
+ try s.keys(if (commit) "\n" else "\x1b\x1b");
+ try s.expect(name, if (commit) "/new name.zig\n" else "/test.txt\n");
+ try std.testing.expectEqualStrings(s.at("{s} Save Tty Collapse Del SyntaxBold", .{if (commit) "/new name.zig" else "/test.txt"}), try tag(&s, n));
+ // The keyboard is the body's again.
+ try std.testing.expect((try s.cursor()).?[1] != (try s.where("Save Tty"))[1]);
+ }
+ try std.testing.expectEqual(@as(usize, 0), s.saved);
+ // A name alone is no edit: the pane stays clean.
+ try s.expect(s.at("/pane/{d}/dirty", .{n}), "0\n");
+}
+
+test "tags: a drafted name's edits are by grapheme, and an empty one is not committed" {
+ var s = try Session.initFile(std.testing.allocator, "untouched\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try clickPathEnd(&s, "/test.txt");
+ try s.keys("\x15/café界\x08");
+ _ = try s.where("/café Save");
+ try s.keys("\x08");
+ _ = try s.where("/caf Save");
+ try s.keys("\x15\n");
+ try std.testing.expectError(error.NotOnScreen, s.where("/test.txt"));
+ try s.expect(s.at("/pane/{d}/name", .{n}), "/test.txt\n");
+ try s.expect(s.at("/pane/{d}/body", .{n}), "untouched\n");
+ // Esc keeps the draft pending; a second drops it.
+ try s.keys("\x1b");
+ try std.testing.expectError(error.NotOnScreen, s.where("/test.txt"));
+ try s.keys("\x1b");
+ _ = try s.where("/test.txt");
+}
+
+test "tags: leaving a pane or entering a header drops an uncommitted name" {
+ for ([_]bool{ false, true }) |header| {
+ var s = try Session.initFile(std.testing.allocator, "untouched\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try clickPathEnd(&s, "/test.txt");
+ try s.keys("\x15/draft");
+ _ = try s.where("/draft");
+ if (header) try s.click("Newcol", 1, 1) else _ = try s.newPane();
+ try std.testing.expectError(error.NotOnScreen, s.where("/draft"));
+ try s.expect(s.at("/pane/{d}/name", .{n}), "/test.txt\n");
+ }
+}
+
+test "tags: middle clicking Save commits the drafted name before saving" {
+ var s = try Session.initFile(std.testing.allocator, "untouched\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try clickPathEnd(&s, "/test.txt");
+ try s.keys("\x15/renamed.txt");
+ try s.click("Save Tty", 0, 2);
+ try s.expect(s.at("/pane/{d}/name", .{n}), "/renamed.txt\n");
+ try std.testing.expectEqualStrings("/renamed.txt Save Tty Collapse Del", try tag(&s, n));
+ try s.expect(s.at("/pane/{d}/body", .{n}), "untouched\n");
+ try std.testing.expectEqual(@as(usize, 1), s.saved);
+}
+
+test "tags: an oversized drafted name is refused at commit and the draft stays to correct" {
+ var s = try Session.initFile(std.testing.allocator, "untouched\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try clickPathEnd(&s, "/test.txt");
+ const excess = s.at("\x15/{s}\n", .{&@as([4999]u8, @splat('x'))});
+ try s.keys(excess);
+ try s.expect(s.at("/pane/{d}/name", .{n}), "/test.txt\n");
+ try s.expect(s.at("/pane/{d}/body", .{n}), "untouched\n");
+ _ = try s.where("/xxxx");
+}
+
+test "tags: a name typed into the tag's path survives Esc, pending, and the next Enter renames; a second Esc drops it" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const name = s.at("/pane/{d}/name", .{n});
+ // A click on the path types into it; a stray key while it waits
+ // changes nothing.
+ try s.click("/test.txt", 1, 1);
+ try s.keys("z\x1bq\n");
+ try s.expect(name, "/ztest.txt\n");
+ try s.click("/ztest.txt", 1, 1);
+ try s.keys("z\x1bq\x1b");
+ try s.expect(name, "/ztest.txt\n");
+ try std.testing.expect(std.mem.startsWith(u8, try s.read(s.at("/pane/{d}/tag", .{n})), "/ztest.txt "));
+}
diff --git a/test/behaviour/terminals.zig b/test/behaviour/terminals.zig
new file mode 100644
index 00000000..f6bbdfa0
--- /dev/null
+++ b/test/behaviour/terminals.zig
@@ -0,0 +1,46 @@
+//! docs/typ/guide.typ, Terminals <terminals>.
+const std = @import("std");
+const Session = @import("session").Session;
+
+fn mode(s: *Session, pane: u32) ![]const u8 {
+ const ctl = try s.read(s.at("/pane/{d}/ctl", .{pane}));
+ const at = std.mem.lastIndexOf(u8, ctl, " mode:").? + " mode:".len;
+ return std.mem.trimEnd(u8, ctl[at..], " ");
+}
+
+test "terminals: Togglettymode and Ctrl-B share the mode's transitions, from the body or its tag, and a text pane refuses it" {
+ var s = try Session.initTerm(std.testing.allocator);
+ defer s.deinit();
+ const n = try s.focused();
+ const ctl = s.at("/pane/{d}/ctl", .{n});
+ try std.testing.expect(std.mem.indexOf(u8, try s.read(s.at("/pane/{d}/tag", .{n})), " Mode ") != null);
+ try s.write(s.at("/pane/{d}/tag", .{n}), " Togglettymode");
+ try std.testing.expectEqualStrings("tty", try mode(&s, n));
+ try s.write(ctl, "Togglettymode\n");
+ try std.testing.expectEqualStrings("normal", try mode(&s, n));
+ try s.keys("\x02");
+ try std.testing.expectEqualStrings("tty", try mode(&s, n));
+ // The tag has its own mode: the body keeps tty while the tag is typed
+ // into, and either way of toggling gives the body the keyboard back.
+ const tag_row = (try s.where("Togglettymode"))[1];
+ try s.click("Togglettymode", 0, 1);
+ try std.testing.expectEqualStrings("tty", try mode(&s, n));
+ try std.testing.expectEqual(tag_row, (try s.cursor()).?[1]);
+ try s.write(ctl, "Togglettymode\n");
+ try std.testing.expectEqualStrings("normal", try mode(&s, n));
+ try std.testing.expect((try s.cursor()).?[1] > tag_row);
+ try s.click("Togglettymode", 0, 1);
+ try s.keys("\x02");
+ try std.testing.expectEqualStrings("tty", try mode(&s, n));
+ try std.testing.expect((try s.cursor()).?[1] > tag_row);
+ // A middle click on the word in the tag.
+ try s.click("Togglettymode", 0, 2);
+ try std.testing.expectEqualStrings("normal", try mode(&s, n));
+ // A text pane refuses it, normal, its text as it was.
+ const file = try s.newPane();
+ try s.write(s.at("/pane/{d}/body", .{file}), "unchanged\n");
+ _ = try s.refused(s.at("/pane/{d}/ctl", .{file}), "Togglettymode\n");
+ try std.testing.expectEqualStrings("Togglettymode: only a terminal pane takes it", s.said);
+ try std.testing.expectEqualStrings("normal", try mode(&s, file));
+ try s.expect(s.at("/pane/{d}/body", .{file}), "unchanged\n");
+}
diff --git a/test/output.zig b/test/output.zig
index 2b8bf1f5..3cfece45 100644
--- a/test/output.zig
+++ b/test/output.zig
@@ -495,60 +495,12 @@ test "Mini syntax colors survive toggles themes and rendering without source acc
}
}
-test "Mini failures leave its existing snapshot and focus unchanged" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
- defer p.deinit();
- const source = try p.setTestFile("abc\n");
- var path_buf: [128]u8 = undefined;
- const path = try std.fmt.bufPrint(&path_buf, "/virtual/pane/{d}/body", .{source.serial});
- try panes.mini.open(p, 0, path);
- const id = p.active;
- const mini = p.panes[id].?;
- const body = mini.file.?.content.ptr;
- const next = p.freeSlot();
- try std.testing.expectError(error.FileNotFound, panes.mini.open(p, 0, "/virtual/does-not-exist"));
- try std.testing.expectEqual(id, p.active);
- try std.testing.expectEqual(body, mini.file.?.content.ptr);
- try std.testing.expectEqual(next, p.freeSlot());
-}
-
-test "DumpConfig prints the startup path and refreshes its one output" {
+test "DumpConfig prints the startup path" {
const path = "/home/pardes-test/.config/pardes/init";
const p = try Pardes.init(std.testing.allocator, .{ .startup_config_path = path });
defer p.deinit();
-
- try std.testing.expect(p.executeBuiltinLine(0, "DumpConfig"));
- const opened = p.active;
- const out = p.panes[opened].?.file.?;
- for ([_][]const u8{
- "Startup config: " ++ path ++ "\n",
- "Theme orchard\n",
- "Last shell spawned: (none)\n",
- "Shell change pending: on\n",
- "LocationsConfig ",
- }) |line| try std.testing.expect(std.mem.indexOf(u8, out.content, line) != null);
- var default_line: [256]u8 = undefined;
- try std.testing.expect(std.mem.indexOf(u8, out.content, try std.fmt.bufPrint(&default_line, "Shell {s}\n", .{config.defaultShell()})) != null);
- try std.testing.expectEqualStrings(config.dump_config_buffer, std.fs.path.basename(out.path));
- try std.testing.expectEqual(panes.Output.Origin{ .cmd = .DumpConfig }, out.output.?.from);
-
- try std.testing.expect(p.executeBuiltinLine(0, "DumpConfig"));
- try std.testing.expectEqual(opened, p.active);
- var buffers: usize = 0;
- for (p.panes) |slot| {
- const f = (slot orelse continue).file orelse continue;
- const origin = (f.output orelse continue).from;
- buffers += @intFromBool(std.meta.eql(origin, panes.Output.Origin{ .cmd = .DumpConfig }));
- }
- try std.testing.expectEqual(@as(usize, 1), buffers);
-}
-
-test "DumpConfig reports the absence of a per-user config path" {
- const p = try Pardes.init(std.testing.allocator, .{});
- defer p.deinit();
try std.testing.expect(p.executeBuiltinLine(0, "DumpConfig"));
- const report = p.panes[p.active].?.file.?.content;
- try std.testing.expect(std.mem.indexOf(u8, report, "no per-user config path") != null);
+ try std.testing.expect(std.mem.indexOf(u8, p.panes[p.active].?.file.?.content, "Startup config: " ++ path ++ "\n") != null);
}
/// The file Config names, in a fresh temporary directory: `pardes/init`
@@ -621,14 +573,6 @@ test "Config with no startup file opens a pane of its name, and Save makes its d
try std.testing.expectEqual(std.Io.File.Kind.directory, made.kind);
}
-test "Config without a configuration directory says so and opens nothing" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
- defer p.deinit();
- const before = p.freeSlot();
- try std.testing.expect(p.executeBuiltinLine(p.active, "Config"));
- try std.testing.expectEqual(before, p.freeSlot());
-}
-
test "EffectCode lists readable virtual sources used by this backend" {
if (comptime !builtins.EffectCode.enabled) return;
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
@@ -771,31 +715,6 @@ fn selectedOutputText(pane: *const pardes.Pane) ?[]const u8 {
return line[lo..@min(line.len, hi + 1)];
}
-test "LookNext/LookPrev in ordinary text skips comment slashes and retains real paths" {
- if (platform == .web) return error.SkipZigTest;
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
- defer p.deinit();
- const pane = try p.setTestFile("// ordinary comment\n/// documentation comment\n(//) [///] punctuation\n/\n// /tmp\n//tmp\n");
- try std.testing.expect(pane.file.?.output == null);
- pardes.look.armLookWalk(p, 0);
- const available = p.freeSlot();
- for ([_]struct { key: u21, row: i32, text: []const u8 }{
- .{ .key = 'n', .row = 3, .text = "/" },
- .{ .key = 'n', .row = 4, .text = "/tmp" },
- .{ .key = 'n', .row = 5, .text = "//tmp" },
- .{ .key = 'n', .row = 3, .text = "/" },
- .{ .key = 'N', .row = 5, .text = "//tmp" },
- .{ .key = 'N', .row = 4, .text = "/tmp" },
- .{ .key = 'N', .row = 3, .text = "/" },
- }) |step| {
- lookKey(p, step.key);
- try std.testing.expectEqual(@as(usize, 0), p.active);
- try std.testing.expectEqual(step.row, pane.body.cur_row);
- try std.testing.expectEqualStrings(step.text, selectedOutputText(pane) orelse "");
- try std.testing.expectEqual(available, p.freeSlot());
- }
-}
-
test "LookNext/LookPrev skips formatted context and selects comment match locations" {
if (!pardes.syntax.enabled) return error.SkipZigTest;
for ([_]panes.Output.Origin{ .search, .{ .query = .references } }) |origin| {
@@ -1005,62 +924,6 @@ test "LookPrev exactly reverses LookNext across output panes and the ring seam"
try std.testing.expect(saw_first and saw_second);
}
-test "Themes lists the ring in sections and skips headings in both directions" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 40 });
- defer p.deinit();
- const source = try p.setTestFile("notes\n");
- pardes.colors.setThemeIndex(p, pardes.themes.len - 1);
- const original_theme = p.settings.theme;
- try std.testing.expect(p.executeBuiltinLine(0, "Themes"));
- const tid = source.search_pane orelse return error.MissingThemeList;
- const list = p.panes[tid].?;
- const content = list.file.?.content;
- try std.testing.expectEqual(@as(usize, 0), p.active);
- try std.testing.expectEqual(@as(i32, 0), list.body.cur_row);
- try std.testing.expectEqual(@as(usize, 0), list.file.?.scroll);
- try std.testing.expectEqualStrings("# Pardes themes", modal.lineSlice(content, 0));
- // Every theme in ring order, each section's heading after a blank line
- // where colors.groupAt says one starts.
- var row: usize = 1;
- var sections: usize = 1;
- var first_break: ?usize = null;
- for (pardes.themes, 0..) |theme, i| {
- if (i > 0) if (pardes.colors.groupAt(i)) |title| {
- try std.testing.expectEqualStrings("", modal.lineSlice(content, row));
- try std.testing.expect(std.mem.startsWith(u8, modal.lineSlice(content, row + 1), "# "));
- try std.testing.expectEqualStrings(title, modal.lineSlice(content, row + 1)["# ".len..]);
- row += 2;
- sections += 1;
- if (first_break == null) first_break = i;
- };
- const line = modal.lineSlice(content, row);
- try std.testing.expect(std.mem.startsWith(u8, line, "Theme "));
- try std.testing.expectEqualStrings(theme.name, line["Theme ".len..]);
- row += 1;
- }
- try std.testing.expectEqual(pardes.themes.len + 1 + 2 * (sections - 1), std.mem.count(u8, content, "\n"));
- // acme is a current theme: it is listed before any break.
- const acme = for (pardes.themes, 0..) |t, i| {
- if (std.mem.eql(u8, t.name, "acme")) break i;
- } else return error.MissingAcme;
- const brk = first_break orelse return error.NoSections;
- try std.testing.expect(acme < brk);
- // Opening an imported theme's selector must still begin with the natives.
- // Walk across the section break without selecting or executing a heading.
- for (pardes.themes[0 .. brk + 1]) |theme| {
- lookKey(p, 'n');
- try std.testing.expectEqual(tid, p.active);
- const selected = selectedOutputText(list) orelse return error.MissingThemeSection;
- try std.testing.expectEqualStrings(theme.name, selected["Theme ".len..]);
- try std.testing.expectEqual(original_theme, p.settings.theme);
- }
- lookKey(p, 'N');
- const previous = selectedOutputText(list) orelse return error.MissingThemeSection;
- try std.testing.expectEqualStrings(pardes.themes[brk - 1].name, previous["Theme ".len..]);
- p.update(.{ .key = .{ .cp = Key.tab } });
- try std.testing.expectEqual(brk - 1, p.settings.theme);
-}
-
test "LookNext/LookPrev selects command outputs by whole row" {
if (platform == .web) return;
var cwd_buf: [4096]u8 = undefined;
diff --git a/test/panes.zig b/test/panes.zig
index fc3f7804..db816d41 100644
--- a/test/panes.zig
+++ b/test/panes.zig
@@ -182,393 +182,6 @@ fn tagY(p: *Pardes, r: anytype) u16 {
return p.tagTop(paneAt(p, r), r);
}
-test "a tag with a newline in it is as tall as its lines, and each line is typed into and pointed at" {
- for ([_]bool{ false, true }) |bottom| {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 14 });
- defer p.deinit();
- const pane = try p.setTestFile("body\n");
- p.presentation.enabled = false;
- p.settings.tag_bottom = bottom;
- p.update(.tick);
- try std.testing.expectEqual(@as(u16, 1), pane.tag_rows);
- const height = p.rects[0].h;
- const body_rows = pane.rows;
- // Insert mode in a tag is a body's: Enter is a new line.
- p.update(.{ .key = .{ .cp = ':' } });
- p.update(.{ .key = .{ .cp = 'A' } });
- p.update(.{ .key = .{ .cp = Key.enter } });
- p.update(.{ .key = .{ .cp = 'S', .text = "Second" } });
- try std.testing.expect(std.mem.endsWith(u8, pardes.tagline.curTail(pane), "\nSecond"));
- try std.testing.expectEqual(@as(u16, 2), pane.tag_rows);
- // The pane keeps its height; the body gives the tag its row.
- try std.testing.expectEqual(height, p.rects[0].h);
- try std.testing.expectEqual(body_rows - 1, pane.rows);
- var frame = std.heap.ArenaAllocator.init(std.testing.allocator);
- defer frame.deinit();
- const surface = try p.render(frame.allocator());
- const r = p.rects[0];
- const tag_y = p.tagTop(pane, r);
- const x = r.x + pardes.TAG_TEXT_INSET;
- try std.testing.expectEqualStrings("/", surface.at(x, tag_y).grapheme());
- for ("Second", 0..) |byte, i| try std.testing.expectEqual(byte, surface.at(x + @as(u16, @intCast(i)), tag_y + 1).text[0]);
- try std.testing.expectEqual(pardes.FontRole.tagline, surface.at(x, tag_y + 1).style.font_role);
- // the caret is on the second line, after what was typed
- try std.testing.expectEqual(tag_y + 1, surface.cursor.?.y);
- try std.testing.expectEqual(x + 6, surface.cursor.?.x);
- // the body starts under (or over) the whole tag
- const body_y = p.bodyTop(pane, r);
- try std.testing.expectEqual(if (bottom) r.y else r.y + 2, body_y);
- try std.testing.expectEqualStrings("b", surface.at(r.x + config.GUTTER + panes.File.gutterWidth(pane), body_y).grapheme());
- // one layer, a row to each line, for a pixel shell
- var layers: usize = 0;
- for (p.surface.tagLayers()) |*layer| {
- if (layer.rows == 0 or layer.kind != .pane or layer.id != 0) continue;
- try std.testing.expectEqual(tag_y, layer.viewport.y);
- try std.testing.expectEqual(@as(u16, 2), layer.rows);
- try std.testing.expectEqual(@as(u16, 2), layer.viewport.h);
- layers += 1;
- }
- try std.testing.expectEqual(@as(usize, 1), layers);
- // a click on the second line puts the tag's cursor on it
- p.update(.{ .key = .{ .cp = Key.escape } });
- p.update(.{ .key = .{ .cp = ':' } });
- ClickCursorTests.click(p, .left, x + 2, tag_y + 1);
- try std.testing.expect(pane.focus == .tag);
- try std.testing.expectEqual(@as(i32, 1), pane.tag.cur_row);
- try std.testing.expectEqual(@as(i32, 2), pane.tag.cur_col);
- // and the pane's text, a row to a screen row, has both of its lines
- const text = try pardes.edit.paneText(p, pane);
- try std.testing.expect(std.mem.startsWith(u8, modal.lineSlice(text, 0), "/test.txt"));
- try std.testing.expectEqualStrings("Second", modal.lineSlice(text, 1));
- try std.testing.expectEqualStrings("body\n", pane.file.?.content);
- }
-}
-
-test "a tag with more lines than rows scrolls to keep its caret in view" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 30 });
- defer p.deinit();
- const pane = try p.setTestFile("body\n");
- p.presentation.enabled = false;
- var many: std.ArrayList(u8) = .empty;
- defer many.deinit(std.testing.allocator);
- for (1..21) |n| try many.print(std.testing.allocator, "\nL{d}", .{n});
- try pane.appendTag(many.items);
- p.update(.tick);
- try std.testing.expectEqual(@as(u16, pardes.MAX_TAG_ROWS), pane.tag_rows);
- var frame = std.heap.ArenaAllocator.init(std.testing.allocator);
- defer frame.deinit();
- const r = p.rects[0];
- const x = r.x + pardes.TAG_TEXT_INSET;
- // To the last line: the tag scrolls so it is the bottom row, caret on it.
- p.update(.{ .key = .{ .cp = ':' } });
- p.update(.{ .key = .{ .cp = 'g' } });
- p.update(.{ .key = .{ .cp = 'e' } });
- try std.testing.expectEqual(@as(i32, 20), pane.tag.cur_row);
- const bottom = try p.render(frame.allocator());
- const tag_y = p.tagTop(pane, r);
- const last_row = tag_y + pardes.MAX_TAG_ROWS - 1;
- try std.testing.expectEqual(last_row, bottom.cursor.?.y);
- try std.testing.expectEqualStrings("L", bottom.at(x, last_row).grapheme());
- try std.testing.expectEqualStrings("2", bottom.at(x + 1, last_row).grapheme());
- try std.testing.expectEqualStrings("0", bottom.at(x + 2, last_row).grapheme());
- // what the pointer sees is what is shown: its first row is line 13
- const text = try pardes.edit.paneText(p, pane);
- try std.testing.expectEqualStrings("L13", modal.lineSlice(text, 0));
- ClickCursorTests.click(p, .left, x + 1, tag_y + 1);
- try std.testing.expectEqual(@as(i32, 14), pane.tag.cur_row);
- try std.testing.expectEqual(@as(i32, 1), pane.tag.cur_col);
- // Back to the first line brings the prefix back into view.
- p.update(.{ .key = .{ .cp = Key.escape } });
- p.update(.{ .key = .{ .cp = 'g' } });
- p.update(.{ .key = .{ .cp = 'g' } });
- const top = try p.render(frame.allocator());
- try std.testing.expectEqual(@as(u16, 0), pane.tag_top);
- try std.testing.expectEqual(tag_y, top.cursor.?.y);
- try std.testing.expectEqualStrings("/", top.at(x, tag_y).grapheme());
-
- // A column tag is one row, as acme's: its lines are joined.
- many.clearRetainingCapacity();
- try many.appendSlice(std.testing.allocator, "New");
- for (1..21) |n| try many.print(std.testing.allocator, "\nC{d}", .{n});
- p.col_tags[0].own = try p.gpa.dupe(u8, many.items);
- p.update(.tick);
- try std.testing.expectEqual(pardes.COLBAR_H, p.columnBarHeight());
- try std.testing.expect(std.mem.indexOfScalar(u8, p.col_tags[0].own.?, '\n') == null);
-}
-
-const TagNavigationTests = struct {
- fn key(p: *Pardes, cp: u21) void {
- p.update(.{ .key = .{ .cp = cp } });
- }
-
- test "s, S and | in a tag answer for the tag's own text; / still searches the body" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
- defer p.deinit();
- const pane = try p.setTestFile("Some body\n");
- try setTag(pane, " Save Del Snarf");
- key(p, ':');
- key(p, 'x'); // the tag's line
- key(p, 's');
- try std.testing.expect(pane.prompt == .search and pane.prompt_for == .tag and pane.focus == .tag);
- p.update(.{ .key = .{ .cp = 'S', .text = "S" } });
- key(p, Key.enter);
- try std.testing.expect(pane.focus == .tag and pane.prompt == .none);
- var ranges: [panes.Text.max_selections]modal.Selection = undefined;
- const text = try pardes.edit.flatSurface(p, &pane.tag);
- const got = pane.tag.ranges(text, 0, &ranges);
- try std.testing.expectEqual(@as(usize, 2), got.n);
- for (ranges[0..got.n]) |range| try std.testing.expectEqualStrings("S", text[@min(range.anchor, range.head)..@max(range.anchor, range.head)]);
- // the body's selection is its own
- try std.testing.expectEqual(@as(u16, 0), pane.body.nsel);
- // `/` from the tag is the body's search, as acme's Look from a tag is
- key(p, ',');
- key(p, '/');
- try std.testing.expect(pane.prompt == .search and pane.prompt_for == .body and pane.focus == .body);
- key(p, Key.escape);
- try std.testing.expect(pane.prompt == .none and pane.focus == .body);
- }
-
- test "ms and md edit a tag's own text, and the text the edit made is read back whole" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
- defer p.deinit();
- const pane = try p.setTestFile("body\n");
- p.update(.tick);
- key(p, ':'); // the tag, on `Save` the first time
- for ("miwms(") |cp| key(p, cp);
- try std.testing.expect(std.mem.indexOf(u8, pardes.tagline.curTail(pane), "(Save)") != null);
- for ("md(") |cp| key(p, cp);
- try std.testing.expect(std.mem.indexOf(u8, pardes.tagline.curTail(pane), " Save ") != null);
- try std.testing.expect(std.mem.indexOf(u8, pardes.tagline.curTail(pane), "(") == null);
- }
-
- test "the keyboard reaches a tag's path, which it can select and yank but not edit" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
- defer p.deinit();
- const pane = try p.setTestFile("body\n");
- p.update(.tick);
- key(p, ':');
- // `0` is the line's start, as in acme, where the name is ordinary text
- key(p, '0');
- try std.testing.expectEqual(@as(i32, 0), pane.tag.cur_col);
- key(p, 'E');
- key(p, 'y');
- try std.testing.expectEqualStrings("/test.txt", p.registers.text(p.gpa, '"').?);
- // an edit that reaches into it is refused, the cursor with it
- const before = try std.testing.allocator.dupe(u8, try pardes.edit.flatSurface(p, &pane.tag));
- defer std.testing.allocator.free(before);
- const cursor = pane.tag.cur_col;
- key(p, 'd');
- try std.testing.expectEqualStrings(before, try pardes.edit.flatSurface(p, &pane.tag));
- try std.testing.expectEqual(cursor, pane.tag.cur_col);
- try std.testing.expect(pane.tag.vsel.active);
- // typed into, the path drafts a name there, as a click on it does
- key(p, ';');
- key(p, '0');
- key(p, 'i');
- p.update(.{ .key = .{ .cp = 'x', .text = "x" } });
- try std.testing.expect(pane.prompt == .name);
- try std.testing.expectEqualStrings("x/test.txt", pane.input.own.?);
- // Esc keeps the draft pending; a second drops it.
- key(p, Key.escape);
- key(p, Key.escape);
- try std.testing.expect(pane.prompt == .none);
- try std.testing.expectEqualStrings("/test.txt", pane.file.?.path);
- // after the path, the text is the tag's own to edit
- key(p, ':');
- key(p, 'A');
- p.update(.{ .key = .{ .cp = '!', .text = "!" } });
- try std.testing.expect(std.mem.endsWith(u8, pardes.tagline.curTail(pane), "!"));
- try std.testing.expectEqualStrings("body\n", pane.file.?.content);
- }
-
- fn window(p: *Pardes, letter: u21) void {
- p.update(.{ .key = .{ .cp = 'w', .ctrl = true } });
- key(p, letter);
- key(p, Key.enter);
- }
-
- test "a tag remembers its cursor, starts on Save, and a click moves it" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
- defer p.deinit();
- const first = try p.setTestFile("body\n");
- p.presentation.enabled = false;
- try std.testing.expect(p.executeBuiltinLine(0, "New"));
- const second_id = p.active;
- const second = p.panes[second_id].?;
- try std.testing.expect(layout.splitColumn(p, second_id, second_id, false));
- p.update(.tick);
- p.active = 0;
- // Nothing to remember yet: `:` lands on Save, in normal mode.
- key(p, ':');
- try std.testing.expect(first.focus == .tag and first.tag.mode == .normal);
- const shown = try pardes.edit.flatSurface(p, &first.tag);
- try std.testing.expectEqualStrings("Save", shown[@intCast(first.tag.cur_col)..][0..4]);
- // Home is the line's start, the path's: the keyboard reaches it.
- key(p, Key.home);
- for (0..3) |_| key(p, Key.right);
- try std.testing.expectEqual(@as(i32, 3), first.tag.cur_col);
- // `:` in the tag's normal mode is the way back to the body.
- key(p, ':');
- try std.testing.expect(first.focus == .body);
- p.active = second_id;
- key(p, ':');
- key(p, Key.home);
- for (0..5) |_| key(p, Key.right);
- key(p, ':');
- p.active = 0;
- key(p, ':');
- try std.testing.expectEqual(@as(i32, 3), first.tag.cur_col);
- key(p, ':');
- p.active = second_id;
- key(p, ':');
- try std.testing.expectEqual(@as(i32, 5), second.tag.cur_col);
- key(p, ':');
- var frame = std.heap.ArenaAllocator.init(p.gpa);
- defer frame.deinit();
- _ = try p.render(frame.allocator());
- const rect = p.rects[0];
- const y = tagY(p, rect);
- const prefix: u16 = @intCast(panes.File.displayWidth(try pardes.tagline.tagPrefix(p, first)));
- ClickCursorTests.click(p, .left, rect.x + pardes.TAG_TEXT_INSET + prefix + 6, y);
- try std.testing.expectEqual(@as(usize, 0), p.active);
- try std.testing.expect(first.focus == .tag and first.tag.mode == .insert);
- try std.testing.expectEqual(@as(i32, prefix + 6), first.tag.cur_col);
- key(p, Key.escape);
- key(p, ':');
- p.startPrompt(first, &first.body, .{ .search = config.search_marker });
- key(p, Key.escape);
- key(p, ':');
- try std.testing.expectEqual(@as(i32, prefix + 6), first.tag.cur_col);
- key(p, ':');
- try std.testing.expectEqualStrings("body\n", first.file.?.content);
- }
-
- test "executing a word from the tag runs it and gives the keyboard back to the body" {
- for ([_]u21{ Key.tab, Key.enter }) |chord| {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
- defer p.deinit();
- const pane = try p.setTestFile("body\n");
- p.update(.{ .key = .{ .cp = 'i' } });
- p.update(.{ .key = .{ .cp = 'x', .text = "x" } });
- p.update(.{ .key = .{ .cp = Key.escape } });
- while (p.nextEffect()) |_| {}
- // `:` lands on Save; the execute key runs it, the look key looks
- // it up. Either way the tag lets go of the keyboard first.
- key(p, ':');
- try std.testing.expect(pane.focus == .tag);
- key(p, chord);
- try std.testing.expect(pane.focus == .body);
- try std.testing.expectEqual(.normal, pane.body.mode);
- var saved = false;
- while (p.nextEffect()) |effect| {
- if (effect == .save_file) saved = true;
- }
- try std.testing.expectEqual(chord == Key.tab, saved);
- // ...and the tag still knows where it was.
- key(p, ':');
- try std.testing.expectEqualStrings("Save", (try pardes.edit.flatSurface(p, &pane.tag))[@intCast(pane.tag.cur_col)..][0..4]);
- }
- }
-
- test "a renamed path moves the tag's cursor with the text after it and a shorter tag pulls it back" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 14 });
- defer p.deinit();
- const pane = try p.setTestFile("body\n");
- key(p, ':'); // on Save
- key(p, ':');
- p.gpa.free(pane.file.?.path);
- pane.file.?.path = try p.gpa.dupe(u8, "/界.zig");
- p.update(.tick);
- key(p, ':');
- const shown = try pardes.edit.flatSurface(p, &pane.tag);
- try std.testing.expectEqualStrings("Save", shown[@intCast(pane.tag.cur_col)..][0..4]);
- key(p, ':');
- try setTag(pane, "é");
- p.update(.tick);
- key(p, ':');
- // `/界.zig é`: the cursor is pulled back onto the last character
- try std.testing.expectEqual(@as(i32, "/界.zig ".len), pane.tag.cur_col);
- try std.testing.expectEqualStrings("body\n", pane.file.?.content);
- }
-
- test "window keys move between panes from a tag and each tag keeps its cursor" {
- for ([_]bool{ false, true }) |bottom| {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 });
- defer p.deinit();
- const first = try p.setTestFile("body\n");
- p.presentation.enabled = false;
- p.settings.tag_bottom = bottom;
- try std.testing.expect(p.executeBuiltinLine(0, "New"));
- const second_id = p.active;
- const second = p.panes[second_id].?;
- p.update(.tick);
- p.active = 0;
- key(p, ':');
- key(p, Key.home);
- key(p, 'l');
- key(p, 'l');
- window(p, 'j');
- try std.testing.expectEqual(second_id, p.active);
- try std.testing.expect(first.focus == .body and second.focus == .body);
- key(p, ':');
- key(p, Key.home);
- for (0..4) |_| key(p, 'l');
- window(p, 'k');
- try std.testing.expectEqual(@as(usize, 0), p.active);
- try std.testing.expect(second.focus == .body);
- key(p, ':');
- try std.testing.expectEqual(@as(i32, 2), first.tag.cur_col);
- window(p, 'j');
- key(p, ':');
- try std.testing.expectEqual(@as(i32, 4), second.tag.cur_col);
- }
- }
-
- test "a tag's normal mode is the body's: motions stay in the tag and insert types into it" {
- for ([_]bool{ false, true }) |bottom| {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
- defer p.deinit();
- _ = try p.setTestFile("body\n");
- p.presentation.enabled = false;
- p.settings.tag_bottom = bottom;
- try std.testing.expect(p.executeBuiltinLine(0, "New"));
- const right = p.active;
- try std.testing.expect(layout.splitColumn(p, right, right, false));
- p.update(.tick);
- p.active = 0;
- key(p, ':');
- const pane = p.panes[0].?;
- key(p, Key.home);
- key(p, 'l');
- try std.testing.expectEqual(@as(i32, 1), pane.tag.cur_col);
- key(p, 'h');
- key(p, 'k');
- key(p, 'j');
- try std.testing.expectEqual(@as(i32, 0), pane.tag.cur_col);
- try std.testing.expectEqual(@as(usize, 0), p.active);
- try std.testing.expect(pane.focus == .tag and !p.header_focus);
- window(p, 'l');
- try std.testing.expectEqual(right, p.active);
- try std.testing.expect(pane.focus == .body and p.panes[right].?.focus == .body);
- window(p, 'h');
- try std.testing.expectEqual(@as(usize, 0), p.active);
- key(p, ':');
- key(p, 'i');
- key(p, Key.end);
- const before = pardes.tagline.curTail(pane).len;
- try std.testing.expect(pane.focus == .tag and pane.tag.mode == .insert and pane.body.mode == .normal);
- for ("hjklHJKL:") |letter| {
- const text = [_]u8{letter};
- p.update(.{ .key = .{ .cp = letter, .text = &text } });
- try std.testing.expect(pane.focus == .tag and pane.tag.mode == .insert);
- }
- try std.testing.expectEqualStrings("hjklHJKL:", pardes.tagline.curTail(pane)[before..]);
- try std.testing.expectEqualStrings("body\n", pane.file.?.content);
- try std.testing.expectEqual(@as(usize, 0), p.active);
- }
- }
-};
-
const BodyHitTests = struct {
fn mouse(layer: *const pardes.Layer, row: u16, col: u16, kind: pardes.Mouse.Kind) pardes.Mouse {
const width: f32 = if (row < layer.context_rows) 8 else 10;
@@ -1119,159 +732,6 @@ const ClickCursorTests = struct {
try std.testing.expect(std.mem.count(u8, got, "\n") > 20);
}
- test "everything a B1 chord does while B1 is down is one undo step" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 60, .rows = 12 });
- defer p.deinit();
- const pane = try p.setTestFile("one two three\n");
- var frame = std.heap.ArenaAllocator.init(p.gpa);
- defer frame.deinit();
- _ = try p.render(frame.allocator());
- const rect = p.rects[0];
- const x = rect.x + config.GUTTER + panes.File.gutterWidth(pane);
- const y = p.bodyTop(pane, rect);
- const M = struct {
- fn ev(pp: *Pardes, b: pardes.Mouse.Button, k: pardes.Mouse.Kind, cx: u16, cy: u16) void {
- pp.update(.{ .mouse = .{ .button = b, .kind = k, .col = cx, .row = cy } });
- }
- };
- // B1-B2 then B1-B3: cut, then paste back: a copy, one step.
- const before = pane.file.?.history.undo_len;
- M.ev(p, .left, .press, x + 4, y);
- M.ev(p, .left, .drag, x + 6, y);
- M.ev(p, .middle, .press, x + 6, y);
- M.ev(p, .middle, .release, x + 6, y);
- M.ev(p, .right, .press, x + 6, y);
- M.ev(p, .right, .release, x + 6, y);
- M.ev(p, .left, .release, x + 6, y);
- try std.testing.expectEqualStrings("one two three\n", pane.file.?.content);
- try std.testing.expectEqualStrings("two", p.registers.text(p.gpa, '"').?);
- try std.testing.expect(pane.file.?.history.undo_len <= before + 1);
- // A cut alone comes back with one Undo.
- M.ev(p, .left, .press, x + 4, y);
- M.ev(p, .left, .drag, x + 6, y);
- M.ev(p, .middle, .press, x + 6, y);
- M.ev(p, .middle, .release, x + 6, y);
- M.ev(p, .left, .release, x + 6, y);
- try std.testing.expectEqualStrings("one three\n", pane.file.?.content);
- try std.testing.expect(p.executeBuiltinLine(0, "Undo"));
- try std.testing.expectEqualStrings("one two three\n", pane.file.?.content);
- }
-
- test "a double-click selects a word, a line, a bracketed or quoted text, as acme's" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 60, .rows = 12 });
- defer p.deinit();
- const pane = try p.setTestFile("call foo_bar(a, b)\nsay \"hi there\"\n");
- var frame = std.heap.ArenaAllocator.init(p.gpa);
- defer frame.deinit();
- _ = try p.render(frame.allocator());
- const rect = p.rects[0];
- const x = rect.x + config.GUTTER + panes.File.gutterWidth(pane);
- const y = p.bodyTop(pane, rect);
- const Want = struct { col: u16, row: u16, text: []const u8 };
- for ([_]Want{
- .{ .col = 6, .row = 0, .text = "foo_bar" },
- .{ .col = 13, .row = 0, .text = "a, b" },
- .{ .col = 0, .row = 0, .text = "call foo_bar(a, b)\n" },
- .{ .col = 5, .row = 1, .text = "hi there" },
- }) |w| {
- click(p, .left, x + w.col, y + w.row);
- click(p, .left, x + w.col, y + w.row);
- try std.testing.expectEqualStrings(w.text, pardes.edit.currentSelText(p, pane).?);
- // A third click is a plain click again: the caret, no selection.
- click(p, .left, x + w.col, y + w.row);
- try std.testing.expect(!pane.body.vsel.active);
- }
- // In the tag too.
- const tag_text = try pardes.tagline.tagText(p, frame.allocator(), pane);
- const del: u16 = @intCast(std.mem.indexOf(u8, tag_text, "Del").? + 1);
- const tag_x = rect.x + pardes.TAG_TEXT_INSET + del;
- click(p, .left, tag_x, p.tagTop(pane, rect));
- click(p, .left, tag_x, p.tagTop(pane, rect));
- try std.testing.expect(pane.tag.vsel.active);
- const tag_now = try pardes.tagline.tagText(p, frame.allocator(), pane);
- const a = modal.offsetAt(tag_now, .{ .row = @intCast(pane.tag.vsel.row), .col = @intCast(pane.tag.vsel.col) });
- const h = modal.offsetAt(tag_now, .{ .row = @intCast(pane.tag.cur_row), .col = @intCast(pane.tag.cur_col) });
- try std.testing.expectEqualStrings("Del", tag_now[a .. h + 1]);
- }
-
- test "click cursor and insertion agree beyond line and file ends" {
- for ([_]bool{ false, true }) |already_insert| {
- for ([_]bool{ false, true }) |bottom_tag| {
- for ([_]struct { text: []const u8, click_row: u16, row: i32, col: i32, result: []const u8 }{
- .{ .text = "abc\nxy", .click_row = 0, .row = 0, .col = 3, .result = "abcZ\nxy" },
- .{ .text = "abc\nxy", .click_row = 5, .row = 1, .col = 2, .result = "abc\nxyZ" },
- .{ .text = "abc\n", .click_row = 5, .row = 1, .col = 0, .result = "abc\nZ" },
- .{ .text = "", .click_row = 5, .row = 0, .col = 0, .result = "Z" },
- }) |case| {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 12 });
- defer p.deinit();
- p.settings.tag_bottom = bottom_tag;
- const pane = try p.setTestFile(case.text);
- p.presentation.enabled = false;
- if (already_insert) p.update(.{ .key = .{ .cp = 'i' } });
- var frame = std.heap.ArenaAllocator.init(p.gpa);
- defer frame.deinit();
- _ = try p.render(frame.allocator());
- const rect = p.rects[0];
- const x = rect.x + config.GUTTER + panes.File.gutterWidth(pane);
- const y = bodyY(p, rect);
- click(p, .left, x + 15, y + case.click_row);
- try std.testing.expectEqual(case.row, pane.body.cur_row);
- try std.testing.expectEqual(case.col, pane.body.cur_col);
- const clicked = (try p.render(frame.allocator())).cursor orelse return error.MissingClickCursor;
- try std.testing.expectEqual(x + @as(u16, @intCast(case.col)), clicked.x);
- try std.testing.expectEqual(y + @as(u16, @intCast(case.row)), clicked.y);
- if (!already_insert) p.update(.{ .key = .{ .cp = 'i' } });
- try std.testing.expectEqual(panes.Text.Mode.insert, pane.body.mode);
- const insert = (try p.render(frame.allocator())).cursor orelse return error.MissingInsertCursor;
- try std.testing.expectEqual(clicked.x, insert.x);
- try std.testing.expectEqual(clicked.y, insert.y);
- p.update(.{ .key = .{ .cp = 'Z', .text = "Z" } });
- try std.testing.expectEqualStrings(case.result, pane.file.?.content);
- }
- }
- }
- }
-
- test "click cursor snaps tab and wrapped wide glyph cells before insertion" {
- for ([_]bool{ false, true }) |already_insert| {
- for ([_]bool{ false, true }) |wrap| {
- const source = if (wrap) "012345678901234567890123456789界tail\n" else "\t界tail\n";
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 24, .rows = 12 });
- defer p.deinit();
- const pane = try p.setTestFile(source);
- p.settings.wrap = wrap;
- p.presentation.enabled = false;
- if (already_insert) p.update(.{ .key = .{ .cp = 'i' } });
- var frame = std.heap.ArenaAllocator.init(p.gpa);
- defer frame.deinit();
- const surface = try p.render(frame.allocator());
- var target: ?struct { x: u16, y: u16 } = null;
- for (0..surface.rows) |row| for (0..surface.cols) |col| {
- if (std.mem.eql(u8, surface.at(@intCast(col), @intCast(row)).grapheme(), "界"))
- target = .{ .x = @intCast(col), .y = @intCast(row) };
- };
- const glyph = target orelse return error.MissingWideGlyph;
- if (wrap) try std.testing.expect(glyph.y > p.rects[0].y + pardes.BOX_H);
- click(p, .left, glyph.x + 1, glyph.y);
- const byte = std.mem.indexOf(u8, source, "界").?;
- try std.testing.expectEqual(@as(i32, @intCast(byte)), pane.body.cur_col);
- const clicked = (try p.render(frame.allocator())).cursor orelse return error.MissingClickCursor;
- try std.testing.expectEqual(glyph.x, clicked.x);
- try std.testing.expectEqual(glyph.y, clicked.y);
- if (!already_insert) p.update(.{ .key = .{ .cp = 'i' } });
- try std.testing.expectEqual(panes.Text.Mode.insert, pane.body.mode);
- const insert = (try p.render(frame.allocator())).cursor orelse return error.MissingInsertCursor;
- try std.testing.expectEqual(clicked.x, insert.x);
- try std.testing.expectEqual(clicked.y, insert.y);
- p.update(.{ .key = .{ .cp = 'Z', .text = "Z" } });
- const expected = try std.fmt.allocPrint(p.gpa, "{s}Z{s}", .{ source[0..byte], source[byte..] });
- defer p.gpa.free(expected);
- try std.testing.expectEqualStrings(expected, pane.file.?.content);
- }
- }
- }
-
test "click operands and hover follow the scrolled source selection" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 14 });
defer p.deinit();
@@ -1387,39 +847,6 @@ const JumpSelectionTests = struct {
try std.testing.expectEqual(@as(i32, 0), pane.body.cur_col);
}
- test "a B1 sweep over several lines is a stream, as acme's, in a body and a tag" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 60, .rows = 12 });
- defer p.deinit();
- const pane = try p.setTestFile("alpha\nbravo\ncharlie\n");
- var frame = std.heap.ArenaAllocator.init(p.gpa);
- defer frame.deinit();
- _ = try p.render(frame.allocator());
- const rect = p.rects[0];
- const x = rect.x + config.GUTTER + panes.File.gutterWidth(pane);
- const y = p.bodyTop(pane, rect);
- // From the press to the end of its line, the line between whole, the
- // last from its start: no line numbers, no rectangle.
- drag(p, x + 2, y, x + 1, y + 2);
- try std.testing.expectEqualStrings("pha\nbravo\nch", pardes.exec.heldSelection(p, 0).?);
- // Upward, the same text.
- drag(p, x + 1, y + 2, x + 2, y);
- try std.testing.expectEqualStrings("pha\nbravo\nch", pardes.exec.heldSelection(p, 0).?);
- // A tag of several rows sweeps the same way.
- if (pane.tag.own) |own| p.gpa.free(own);
- pane.tag.own = try p.gpa.dupe(u8, "Save Del\nLook Edit");
- p.sync();
- _ = try p.render(frame.allocator());
- p.sync();
- try std.testing.expectEqual(@as(u16, 2), pane.tag_rows);
- const sl: panes.Pane.Sel = .{ .state = .done, .r0 = 0, .c0 = 3, .r1 = 1, .c1 = 1 };
- const text = try pardes.edit.paneText(p, pane);
- const swept = try pardes.edit.selectionText(p, pane, sl);
- const first_line = text[0 .. std.mem.indexOfScalar(u8, text, '\n') orelse text.len];
- const second = std.mem.sliceTo(text[first_line.len + 1 ..], '\n');
- const want = try std.fmt.allocPrint(frame.allocator(), "{s}\n{s}", .{ first_line[3..], second[0..@min(2, second.len)] });
- try std.testing.expectEqualStrings(want, swept);
- }
-
test "jump selection clears copied sweeps in both history directions" {
for ([_]bool{ false, true }) |reverse|
try exercise("alpha\nbravo\n", false, reverse, 1, 3, "lpha\nbrav");
@@ -1606,138 +1033,6 @@ fn redraft(pane: *Pane, name: []const u8) void {
pane.input.cur_col = @intCast(name.len);
}
-/// Click the tagline at the end of the path: a name draft, caret there.
-fn clickPathEnd(p: *Pardes, pane: *Pane) void {
- const rect = p.rects[p.active];
- const y = tagY(p, rect);
- const x = rect.x + pardes.TAG_TEXT_INSET + @as(u16, @intCast(panes.File.displayWidth(pane.file.?.path) - 1));
- ClickCursorTests.click(p, .left, x, y);
- std.debug.assert(pane.prompt == .name);
- pane.input.cur_col = @intCast(pane.input.own.?.len);
-}
-
-test "pane filename drafts commit and cancel without changing body or command tail" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 70, .rows = 12 });
- defer p.deinit();
- const pane = try p.setTestFile("original body\n");
- const original = try p.gpa.dupe(u8, pane.file.?.path);
- defer p.gpa.free(original);
- try pane.appendTag(" SyntaxBold");
- const tail = try p.gpa.dupe(u8, pardes.tagline.curTail(pane));
- defer p.gpa.free(tail);
- for ([_]bool{ false, true }) |commit| {
- clickPathEnd(p, pane);
- p.update(.{ .key = .{ .cp = 'u', .ctrl = true } });
- p.update(.{ .paste = "/new name.zig" });
- try std.testing.expectEqualStrings(original, pane.file.?.path);
- try std.testing.expectEqualStrings("/new name.zig", pane.input.own.?);
- try std.testing.expectEqualStrings(tail, pardes.tagline.curTail(pane));
- try std.testing.expectEqualStrings("original body\n", pane.file.?.content);
- // Esc keeps the draft pending; a second drops it.
- p.update(.{ .key = .{ .cp = if (commit) Key.enter else Key.escape } });
- if (!commit) p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expect(pane.focus == .body);
- try std.testing.expect(pane.prompt == .none);
- try std.testing.expectEqualStrings(if (commit) "/new name.zig" else original, pane.file.?.path);
- try std.testing.expectEqualStrings(tail, pardes.tagline.curTail(pane));
- while (p.nextEffect()) |effect| try std.testing.expect(std.meta.activeTag(effect) != .save_file);
- }
- // A name alone is no edit: the pane stays clean.
- try std.testing.expect(pane.file.?.revision == pane.file.?.saved_revision);
-}
-
-test "pane filename grapheme edits and invalid empty commits preserve the buffer" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
- defer p.deinit();
- const pane = try p.setTestFile("untouched\n");
- clickPathEnd(p, pane);
- p.update(.{ .key = .{ .cp = 'u', .ctrl = true } });
- p.update(.{ .paste = "/café界" });
- p.update(.{ .key = .{ .cp = Key.backspace } });
- try std.testing.expectEqualStrings("/café", pane.input.own.?);
- p.update(.{ .key = .{ .cp = Key.backspace } });
- try std.testing.expectEqualStrings("/caf", pane.input.own.?);
- p.update(.{ .key = .{ .cp = 'u', .ctrl = true } });
- try std.testing.expectEqualStrings("", pane.input.own.?);
- p.update(.{ .key = .{ .cp = Key.enter } });
- try std.testing.expect(pane.prompt == .name);
- try std.testing.expectEqualStrings("/test.txt", pane.file.?.path);
- try std.testing.expectEqualStrings("untouched\n", pane.file.?.content);
- // Esc keeps the draft pending; a second drops it.
- p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expect(pane.prompt == .name);
- p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expect(pane.prompt == .none);
-}
-
-test "leaving a pane or entering a header cancels an uncommitted filename" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
- defer p.deinit();
- const pane = try p.setTestFile("untouched\n");
- for ([_]bool{ false, true }) |header| {
- p.active = 0;
- pardes.tagline.exitHeader(p);
- p.update(.tick);
- clickPathEnd(p, pane);
- p.update(.{ .paste = "/draft" });
- try std.testing.expect(pane.prompt == .name);
- if (header) {
- pardes.tagline.enterHeader(p, null);
- p.update(.tick);
- } else {
- try std.testing.expect(p.executeBuiltinLine(0, "New"));
- p.update(.tick);
- }
- try std.testing.expect(pane.prompt == .none);
- try std.testing.expect(pane.focus == .body);
- try std.testing.expectEqualStrings("/test.txt", pane.file.?.path);
- }
-}
-
-test "middle clicking Save commits the drafted filename before issuing a save" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 70, .rows = 12 });
- defer p.deinit();
- const pane = try p.setTestFile("untouched\n");
- clickPathEnd(p, pane);
- p.update(.{ .key = .{ .cp = 'u', .ctrl = true } });
- p.update(.{ .paste = "/renamed.txt" });
- var arena = std.heap.ArenaAllocator.init(p.gpa);
- defer arena.deinit();
- _ = try p.render(arena.allocator());
- const text = try pardes.tagline.tagText(p, arena.allocator(), pane);
- const save_at = std.mem.indexOf(u8, text, "Save").?;
- const x: u16 = @intCast(p.rects[0].x + pardes.TAG_TEXT_INSET + save_at - pane.tag_scroll);
- const y = p.rects[0].y;
- while (p.nextEffect()) |_| {}
- p.update(.{ .mouse = .{ .col = x, .row = y, .button = config.exec_button, .kind = .press } });
- p.update(.{ .mouse = .{ .col = x, .row = y, .button = config.exec_button, .kind = .release } });
- try std.testing.expectEqualStrings("/renamed.txt", pane.file.?.path);
- try std.testing.expect(pane.prompt == .none);
- try std.testing.expectEqualStrings("untouched\n", pane.file.?.content);
- var saves: usize = 0;
- while (p.nextEffect()) |effect| if (effect == .save_file) {
- try std.testing.expectEqual(@as(u8, 0), effect.save_file.pane);
- saves += 1;
- };
- try std.testing.expectEqual(@as(usize, 1), saves);
-}
-
-test "an oversized drafted name is refused at commit and the draft stays to correct" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
- defer p.deinit();
- const pane = try p.setTestFile("untouched\n");
- clickPathEnd(p, pane);
- const excess = try p.gpa.alloc(u8, 5000);
- defer p.gpa.free(excess);
- @memset(excess, 'x');
- excess[0] = '/';
- p.update(.{ .paste = excess });
- p.update(.{ .key = .{ .cp = Key.enter } });
- try std.testing.expect(pane.prompt == .name);
- try std.testing.expectEqualStrings("/test.txt", pane.file.?.path);
- try std.testing.expectEqualStrings("untouched\n", pane.file.?.content);
-}
-
test "paste into pane commands and prompts never inserts into the body" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
@@ -1783,60 +1078,6 @@ test "a tag that exactly fills its row stays one row, its caret at the edge as a
try std.testing.expectEqual(p.rects[0].x + p.rects[0].w - 1, surface.cursor.?.x);
}
-test "a long pane tag wraps onto rows, and a click on a wrapped row maps to the whole tag's address" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 50, .rows = 12 });
- defer p.deinit();
- const pane = try p.setTestFile("body\n");
- p.gpa.free(pane.file.?.path);
- pane.file.?.path = try p.gpa.dupe(u8, "/an/especially/deep/project/path/with/a/long/component/filename.zig");
- try pane.appendTag(" SyntaxBold");
- p.update(.{ .key = .{ .cp = ':' } });
- p.update(.{ .key = .{ .cp = 'A' } });
- var arena = std.heap.ArenaAllocator.init(p.gpa);
- defer arena.deinit();
- const surface = try p.render(arena.allocator());
- try std.testing.expect(pane.tag_rows > 1);
- try std.testing.expect(surface.cursor.?.x < p.rects[0].x + p.rects[0].w);
- const text = try pardes.tagline.tagText(p, p.gpa, pane);
- defer p.gpa.free(text);
- const shown = try pardes.tagline.shownTag(p, arena.allocator(), pane);
- const at = shown.fromReal(std.mem.indexOf(u8, text, "SyntaxBold").?);
- const pos = modal.positionAt(shown.text, at);
- const x: u16 = @intCast(p.rects[0].x + pardes.TAG_TEXT_INSET + panes.File.rawDisplayCol(modal.lineSlice(shown.text, pos.row), pos.col));
- const y = p.tagTop(pane, p.rects[0]) + @as(u16, @intCast(pos.row));
- const before = p.settings.syntax_bold;
- p.update(.{ .mouse = .{ .col = x, .row = y, .button = config.exec_button, .kind = .press } });
- p.update(.{ .mouse = .{ .col = x, .row = y, .button = config.exec_button, .kind = .release } });
- try std.testing.expectEqual(!before, p.settings.syntax_bold);
- try std.testing.expectEqualStrings(text, try pardes.tagline.tagText(p, p.scratch.allocator(), pane));
-}
-
-test "a word the tag's wrapping breaks across rows is still one word to a click" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 50, .rows = 12 });
- defer p.deinit();
- const pane = try p.setTestFile("body\n");
- try pane.appendTag(" SyntaxBold");
- var arena = std.heap.ArenaAllocator.init(p.gpa);
- defer arena.deinit();
- // Lengthen the path until the wrap splits the word after "Synt".
- var pad: usize = 1;
- const shown = while (pad < 80) : (pad += 1) {
- p.gpa.free(pane.file.?.path);
- const path = try std.fmt.allocPrint(arena.allocator(), "/{s}/f.zig", .{(&@as([80]u8, @splat('a')))[0..pad]});
- pane.file.?.path = try p.gpa.dupe(u8, path);
- p.sync();
- const s = try pardes.tagline.shownTag(p, arena.allocator(), pane);
- if (std.mem.indexOf(u8, s.text, "Synt\n") != null) break s;
- } else return error.NoSplit;
- const pos = modal.positionAt(shown.text, std.mem.indexOf(u8, shown.text, "Synt").?);
- const x: u16 = @intCast(p.rects[0].x + pardes.TAG_TEXT_INSET + pos.col + 1);
- const y = p.tagTop(pane, p.rects[0]) + @as(u16, @intCast(pos.row));
- const before = p.settings.syntax_bold;
- p.update(.{ .mouse = .{ .col = x, .row = y, .button = config.exec_button, .kind = .press } });
- p.update(.{ .mouse = .{ .col = x, .row = y, .button = config.exec_button, .kind = .release } });
- try std.testing.expectEqual(!before, p.settings.syntax_bold);
-}
-
test "terminal overlay recoloring never materializes unrelated history" {
const testing = std.testing;
const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 32, .rows = 8 });
@@ -2107,86 +1348,6 @@ test "terminal eviction and lower-region scrolling in one read preserve a surviv
try std.testing.expectEqualStrings("kept edit", pane.ovl.?.text);
}
-test "a prompt's entry and cancellation leave the tag, the body and its cursor as they were" {
- const Case = struct { key: ?Key = null, save: bool = false, marker: []const u8 };
- const cases = [_]Case{
- .{ .marker = config.search_marker },
- .{ .save = true, .marker = config.save_marker ++ "/dír space/" },
- .{ .key = .{ .cp = '|' }, .marker = config.pipe_marker },
- .{ .key = .{ .cp = '|', .alt = true }, .marker = config.pipe_marker_to },
- .{ .key = .{ .cp = '!' }, .marker = config.pipe_marker_insert },
- .{ .key = .{ .cp = '!', .alt = true }, .marker = config.pipe_marker_append },
- };
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 12 });
- defer p.deinit();
- const pane = try p.setTestFile("one\ntwo\n");
- try pane.setOwnedCwd("/dír space");
- const tail = " keep";
- for (cases) |case| {
- try setTag(pane, tail);
- pane.body.cur_row = 1;
- pane.body.cur_col = 2;
- pane.body.cur_pinned = true;
- if (case.key) |key| {
- p.update(.{ .key = key });
- } else if (case.save) {
- p.startPrompt(pane, &pane.body, .save);
- } else {
- p.startPrompt(pane, &pane.body, .{ .search = config.search_marker });
- }
- // The answer is typed into the prompt's own line, never the tag.
- try std.testing.expect(pane.focus == .body);
- try std.testing.expectEqual(.insert, pane.input.mode);
- try std.testing.expectEqualStrings(case.marker, pane.promptText().?);
- try std.testing.expectEqual(@as(i32, @intCast(case.marker.len)), pane.input.cur_col);
- try std.testing.expectEqualStrings(tail, pane.tag.own.?);
- try std.testing.expectEqualDeep(modal.Normal.State{}, pane.body.normal);
- p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expect(pane.prompt == .none);
- try std.testing.expect(pane.input.own == null);
- try std.testing.expectEqual(.normal, pane.body.mode);
- try std.testing.expectEqualStrings(tail, pane.tag.own.?);
- try std.testing.expectEqual(@as(i32, 1), pane.body.cur_row);
- try std.testing.expectEqual(@as(i32, 2), pane.body.cur_col);
- try std.testing.expectEqualStrings("one\ntwo\n", pane.file.?.content);
- }
-}
-
-test "a prompt opens whatever the tag already holds" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
- defer p.deinit();
- const pane = try p.setTestFile("one\n");
- const full = try p.gpa.alloc(u8, pardes.memory.limits.max_tag_tail);
- defer p.gpa.free(full);
- @memset(full, 'x');
- try setTag(pane, full);
- for (0..3) |case| {
- switch (case) {
- 0 => p.startPrompt(pane, &pane.body, .{ .search = config.search_marker }),
- 1 => p.startPrompt(pane, &pane.body, .save),
- else => p.update(.{ .key = .{ .cp = '|' } }),
- }
- try std.testing.expect(pane.prompt != .none);
- try std.testing.expectEqualStrings(full, pane.tag.own.?);
- p.update(.{ .key = .{ .cp = Key.escape } });
- }
-}
-
-test "generated output refuses every pipe prompt before seeding the tag" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
- defer p.deinit();
- const content = try p.gpa.dupe(u8, "generated\n");
- const pane = try panes.Output.open(p, p.freeSlot().?, "/", .{ .cmd = .Help }, "", content);
- p.active = 1;
- for ([_]Key{ .{ .cp = '|' }, .{ .cp = '|', .alt = true }, .{ .cp = '!' }, .{ .cp = '!', .alt = true } }) |key| {
- p.update(.{ .key = key });
- try std.testing.expect(pane.prompt == .none);
- try std.testing.expect(pane.tag.own == null);
- try std.testing.expect(pane.focus == .body);
- try std.testing.expectEqualStrings("generated\n", pane.file.?.content);
- }
-}
-
test "a prompt owns the pipe behavior through cancellation and submission" {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
@@ -2214,34 +1375,6 @@ test "a prompt owns the pipe behavior through cancellation and submission" {
}
}
-test "prompt cancellation restores the selection before regex previews" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
- defer p.deinit();
- const pane = try p.setTestFile("one two one");
- const cases = [_]struct { key: u21, pattern: []const u8, secondary: u8 }{
- .{ .key = 's', .pattern = "one", .secondary = 1 },
- .{ .key = 'S', .pattern = " ", .secondary = 2 },
- };
- for (cases) |case| {
- pane.body.cur_row = 0;
- pane.body.cur_col = 10;
- pane.body.cur_pinned = true;
- pane.body.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
- pane.body.nsel = 0;
- p.update(.{ .key = .{ .cp = case.key } });
- try std.testing.expect(pane.prompt == .search);
- p.update(.{ .key = .{ .cp = case.pattern[0], .text = case.pattern } });
- try std.testing.expectEqual(case.secondary, pane.body.nsel);
- p.update(.{ .key = .{ .cp = Key.escape } });
- try std.testing.expectEqual(@as(u16, 0), pane.body.nsel);
- try std.testing.expectEqual(@as(u16, 0), pane.nsel_snap);
- try std.testing.expectEqual(@as(i32, 10), pane.body.cur_col);
- try std.testing.expectEqual(@as(i32, 0), pane.body.vsel.col);
- try std.testing.expect(pane.body.vsel.active and pane.body.vsel.explicit);
- try std.testing.expectEqualStrings("one two one", pane.file.?.content);
- }
-}
-
test "a prompt that cannot be opened leaves the open one as it was" {
const Request = @typeInfo(@TypeOf(Pardes.startPrompt)).@"fn".param_types[3].?;
for ([_]Request{ .{ .search = config.search_marker }, .save, .{ .pipe = .replace }, .{ .pipe = .ignore }, .{ .pipe = .insert }, .{ .pipe = .append } }) |request| {
@@ -4600,7 +3733,6 @@ const TerminalTests = struct {
};
test {
- _ = TagNavigationTests;
_ = TagLayerTests;
_ = TagNameTintTests;
_ = TreeContextTests;
@@ -4622,83 +3754,6 @@ test {
_ = TerminalTests;
}
-test "an empty counted paste leaves no count for the next motion" {
- for ([_]bool{ false, true }) |empty_register| {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 60, .rows = 12 });
- defer p.deinit();
- const pane = try p.setTestFile("abcdefgh\n");
- if (empty_register) p.registers.put(p.gpa, '"', "", 0, 1, true);
- for ("3p") |cp| p.update(.{ .key = .{ .cp = cp } });
- try std.testing.expectEqual(modal.Normal.State{}, pane.body.normal);
- p.update(.{ .key = .{ .cp = 'l' } });
- try std.testing.expectEqual(@as(i32, 1), pane.body.cur_col);
- try std.testing.expectEqualStrings("abcdefgh\n", pane.file.?.content);
- }
-}
-
-test "cancelled normal gestures leave no count or subprefix after mouse and focus changes" {
- const Gesture = enum { body, tag, focus, last };
- for ([_][]const u8{ "3", "3g", "mr(" }) |keys| {
- for ([_]Gesture{ .body, .tag, .focus, .last }) |gesture| {
- errdefer std.debug.print("\nkeys={s} gesture={s}\n", .{ keys, @tagName(gesture) });
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 16 });
- defer p.deinit();
- const pane = try p.setTestFile("abcdefghij\n");
- p.settings.colors = false;
- p.presentation.enabled = false;
- try std.testing.expect(p.executeBuiltinLine(0, "New"));
- const other = p.active;
- try std.testing.expect(layout.splitColumn(p, other, other, false));
- p.active = 0;
- p.update(.tick);
- var frame = std.heap.ArenaAllocator.init(std.testing.allocator);
- defer frame.deinit();
- _ = try p.render(frame.allocator());
- for (keys) |cp| p.update(.{ .key = .{ .cp = cp } });
- try std.testing.expect(!std.meta.eql(modal.Normal.State{}, pane.body.normal));
- switch (gesture) {
- .body, .tag => {
- const rect = p.rects[0];
- const tag_y = tagY(p, rect);
- const body_y = p.bodyTop(pane, rect);
- const x = if (gesture == .tag)
- rect.x + pardes.TAG_TEXT_INSET + @as(u16, @intCast(panes.File.displayWidth(try pardes.tagline.tagPrefix(p, pane)))) + 3
- else
- rect.x + config.GUTTER + @as(u16, @intCast(panes.File.gutterWidth(pane))) + 3;
- const y = if (gesture == .tag) tag_y else body_y;
- p.update(.{ .mouse = .{ .button = config.select_button, .kind = .press, .col = x, .row = y } });
- p.update(.{ .mouse = .{ .button = config.select_button, .kind = .release, .col = x, .row = y } });
- if (gesture == .tag) {
- try std.testing.expect(pane.focus == .tag);
- p.update(.{ .key = .{ .cp = Key.escape } });
- p.update(.{ .key = .{ .cp = ':' } });
- try std.testing.expect(pane.focus == .body);
- }
- },
- .focus, .last => {
- p.update(.{ .key = .{ .cp = 'w', .ctrl = true } });
- p.update(.{ .key = .{ .cp = 'l' } });
- p.update(.{ .key = .{ .cp = Key.enter } });
- try std.testing.expectEqual(other, p.active);
- if (gesture == .last) {
- p.update(.{ .key = .{ .cp = Key.escape } });
- } else {
- p.update(.{ .key = .{ .cp = 'w', .ctrl = true } });
- p.update(.{ .key = .{ .cp = 'h' } });
- p.update(.{ .key = .{ .cp = Key.enter } });
- }
- try std.testing.expectEqual(@as(usize, 0), p.active);
- },
- }
- try std.testing.expectEqual(modal.Normal.State{}, pane.body.normal);
- const col = pane.body.cur_col;
- p.update(.{ .key = .{ .cp = 'l' } });
- try std.testing.expectEqual(col + 1, pane.body.cur_col);
- try std.testing.expectEqualStrings("abcdefghij\n", pane.file.?.content);
- }
- }
-}
-
test "cancelled normal gestures leave no count or subprefix through raw tty mode" {
for ([_][]const u8{ "3", "3g", "mr(" }) |keys| {
const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 12 });
@@ -4963,78 +4018,6 @@ const LookResetTests = struct {
for (pane.sel) |selection| try std.testing.expectEqual(.none, selection.state);
for (pane.pointer_selections) |selection| try std.testing.expect(selection == null);
}
-
- fn selected(pane: *const Pane) []const u8 {
- if (!pane.body.vsel.active or pane.body.cur_row != pane.body.vsel.row) return "";
- const line = modal.lineSlice(pane.file.?.content, @intCast(pane.body.cur_row));
- const lo: usize = @intCast(@min(pane.body.cur_col, pane.body.vsel.col));
- const hi: usize = @intCast(@max(pane.body.cur_col, pane.body.vsel.col));
- return line[lo..modal.nextGrapheme(line, hi)];
- }
-
- test "Look replaces old selection for same-pane addresses ranges and text fallback" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 });
- defer p.deinit();
- const pane = try p.setTestFile("alpha\nbravo\ncharlie\nneedle\n");
- try seed(pane, "/test.txt:3:2");
- // This operand is released by Look's selection cleanup.
- pardes.look.lookAt(p, 0, pane.pointer_selections[0].?.raw_text.?);
- try cleared(pane);
- try std.testing.expectEqual(@as(usize, 0), p.active);
- try std.testing.expectEqual(@as(i32, 2), pane.body.cur_row);
- try std.testing.expectEqual(@as(i32, 1), pane.body.cur_col);
- try std.testing.expect(!pane.body.vsel.active);
-
- try seed(pane, "/test.txt:2:2-4");
- pardes.look.lookAt(p, 0, pane.pointer_selections[0].?.raw_text.?);
- try cleared(pane);
- try std.testing.expectEqual(@as(i32, 1), pane.body.cur_row);
- try std.testing.expectEqualStrings("rav", selected(pane));
-
- p.gpa.free(pane.file.?.path);
- pane.file.?.path = try p.gpa.dupe(u8, "/tmp/look-selection-source.txt");
- try seed(pane, "needle");
- pardes.look.lookAt(p, 0, pane.pointer_selections[0].?.raw_text.?);
- try cleared(pane);
- try std.testing.expectEqual(@as(i32, 3), pane.body.cur_row);
- try std.testing.expectEqualStrings("needle", selected(pane));
- }
-
- test "Look clears the source's click highlight, not its dot, and the destination's selections before focus" {
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 30 });
- defer p.deinit();
- const source = try p.setTestFile("source\nlines\n");
- const id = p.freeSlot().?;
- const destination = try p.newDocPane(id);
- destination.file = .{
- .path = try p.gpa.dupe(u8, "/look-destination.txt"),
- .content = try p.gpa.dupe(u8, "alpha\nbravo\ncharlie\n"),
- .history = try panes.File.History.create(p.gpa),
- };
- layout.insert(p, 0, 1, id);
- layout.compute(p);
- for ([_]bool{ false, true }) |range| {
- p.active = 0;
- try seed(source, if (range) "/look-destination.txt:2:2-4" else "/look-destination.txt:3:2");
- try seed(destination, "previous destination");
- pardes.look.lookAt(p, 0, source.pointer_selections[0].?.raw_text.?);
- try std.testing.expectEqual(id, p.active);
- // The source keeps its dot (acme's look leaves it); the click's
- // highlight goes.
- for (source.sel) |selection| try std.testing.expectEqual(.none, selection.state);
- for (source.pointer_selections) |selection| try std.testing.expect(selection == null);
- try std.testing.expect(source.body.vsel.active);
- try cleared(destination);
- if (range) {
- try std.testing.expectEqual(@as(i32, 1), destination.body.cur_row);
- try std.testing.expectEqualStrings("rav", selected(destination));
- } else {
- try std.testing.expectEqual(@as(i32, 2), destination.body.cur_row);
- try std.testing.expectEqual(@as(i32, 1), destination.body.cur_col);
- try std.testing.expect(!destination.body.vsel.active);
- }
- }
- }
};
test {
diff --git a/test/pdf.zig b/test/pdf.zig
index fca0c240..a068fc40 100644
--- a/test/pdf.zig
+++ b/test/pdf.zig
@@ -278,56 +278,6 @@ test "PDF feature gates keep argv and builtin behavior coherent" {
}
}
-test "a +PdfSections row's first number is the page: a section not there, or on another page, is a miss said" {
- if (!pdf_enabled or platform == .web) return;
- const gpa = std.testing.allocator;
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
- const fixture = try pdf_impl.makeOutlineTestPdf(gpa);
- defer gpa.free(fixture);
- try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "outline.pdf", .data = fixture });
- var path_buf: [256]u8 = undefined;
- const path = try std.fmt.bufPrint(&path_buf, ".zig-cache/tmp/{s}/outline.pdf", .{tmp.sub_path});
- const p = try Pardes.init(gpa, .{ .file = path, .cols = 80, .rows = 28 });
- defer p.deinit();
- panes.Pdf.openSections(p, 0);
- const out_id = p.panes[0].?.search_pane orelse return error.MissingPdfSectionsOutput;
- const out = p.panes[out_id].?;
- const row = std.mem.sliceTo(out.file.?.content, '\n');
- const place = row[0 .. std.mem.indexOfScalar(u8, row, ' ') orelse row.len]; // outline.pdf:P:1
- var fields = std.mem.splitScalar(u8, place, ':');
- _ = fields.next();
- const page = try std.fmt.parseInt(usize, fields.next().?, 10);
- var line: [128]u8 = undefined;
- // As listed: found, no miss.
- p.look_missed = false;
- pardes.look.lookAt(p, out_id, place);
- try std.testing.expect(!p.look_missed);
- // The section on another page than the row says, and one not there.
- for ([_][]const u8{ try std.fmt.bufPrint(&line, "outline.pdf:{d}:1", .{page + 1}), "outline.pdf:1:999" }) |bad| {
- var copy: [128]u8 = undefined;
- @memcpy(copy[0..bad.len], bad);
- p.look_missed = false;
- const failures = p.fs.failures;
- pardes.look.lookAt(p, out_id, copy[0..bad.len]);
- try std.testing.expect(p.look_missed);
- try std.testing.expect(p.fs.failures != failures);
- }
-}
-
-test "a PDF's body puts each line of its text on a line of its own, never a heading run into the text under it" {
- if (!pdf_enabled or platform == .web) return;
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
- const p = try PdfLinkTests.init(tmp);
- defer p.deinit();
- const text = p.panes[0].?.pdf.?.ensureText(p.pdf_gpa);
- // The page's three text runs, each its own line.
- try std.testing.expect(std.mem.indexOf(u8, text, "target.txt\n") != null);
- try std.testing.expect(std.mem.indexOf(u8, text, "https://example.com/same\n") != null);
- try std.testing.expect(std.mem.indexOf(u8, text, "label\n") != null);
-}
-
test "PdfSections Look follows the exact owning PDF, not an equal path" {
if (!pdf_enabled or platform == .web) return;
const gpa = std.testing.allocator;
@@ -377,144 +327,6 @@ test "PdfSections Look follows the exact owning PDF, not an equal path" {
try std.testing.expectEqual(first_output_id, p.active);
}
-test "PdfSections on a PDF with no outline says so and opens nothing" {
- if (!pdf_enabled or platform == .web) return;
- const gpa = std.testing.allocator;
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
- const fixture = try pdf_impl.makeNoOutlineTestPdf(gpa);
- defer gpa.free(fixture);
- try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "plain.pdf", .data = fixture });
- var path_buf: [256]u8 = undefined;
- const path = try std.fmt.bufPrint(&path_buf, ".zig-cache/tmp/{s}/plain.pdf", .{tmp.sub_path});
- const p = try Pardes.init(gpa, .{ .file = path });
- defer p.deinit();
- const pane = p.panes[0].?;
- for (0..2) |_| {
- panes.Pdf.openSections(p, 0);
- try std.testing.expect(pane.search_pane == null);
- try std.testing.expectEqualStrings("PdfSections: this PDF has no outline", pane.msg[0..pane.msg_len]);
- }
-}
-
-test "Recent keeps a PDF as it keeps a file: open, then closed at its page" {
- if (!pdf_enabled or platform == .web) return;
- const gpa = std.testing.allocator;
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
- const fixture = try pdf_impl.makeNoOutlineTestPdf(gpa);
- defer gpa.free(fixture);
- try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "plain.pdf", .data = fixture });
- var dir_buf: [4096]u8 = undefined;
- const dir = dir_buf[0..try tmp.dir.realPath(std.testing.io, &dir_buf)];
- var path_buf: [4200]u8 = undefined;
- const path = try std.fmt.bufPrint(&path_buf, "{s}/plain.pdf", .{dir});
- const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 28 });
- defer p.deinit();
- pardes.look.lookAt(p, p.active, path);
- p.update(.{ .resize = .{ .cols = 80, .rows = 28 } }); // an update's end announces it
- var out: std.Io.Writer.Allocating = .init(gpa);
- defer out.deinit();
- try panes.Output.recentText(p, &out.writer, true);
- var want: [4300]u8 = undefined;
- try std.testing.expect(std.mem.indexOf(u8, out.written(), try std.fmt.bufPrint(&want, "{s}:1:1 open\n", .{path})) != null);
-}
-
-test "`:N` on a PDF turns to page N, from the pane and from the root's look, and `@pN:N` logs no err" {
- if (!pdf_enabled or platform == .web) return;
- const gpa = std.testing.allocator;
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
- const fixture = try pdf_impl.makeOutlineTestPdf(gpa);
- defer gpa.free(fixture);
- try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "outline.pdf", .data = fixture });
- var path_buf: [256]u8 = undefined;
- const path = try std.fmt.bufPrint(&path_buf, ".zig-cache/tmp/{s}/outline.pdf", .{tmp.sub_path});
- const p = try Pardes.init(gpa, .{ .file = path, .cols = 80, .rows = 28 });
- defer p.deinit();
- const doc = p.panes[0].?;
- const pages = doc.pdf.?.page_count;
- try std.testing.expect(pages >= 2);
- const failures = p.fs.failures;
- pardes.look.lookAt(p, 0, ":2");
- try std.testing.expect(!p.look_missed);
- try std.testing.expectEqual(@as(usize, 1), doc.pdf.?.page);
- var line: [64]u8 = undefined;
- pardes.look.lookAt(p, 0, try std.fmt.bufPrint(&line, "@p{d}:1", .{doc.serial}));
- try std.testing.expect(!p.look_missed);
- try std.testing.expectEqual(@as(usize, 0), doc.pdf.?.page);
- try std.testing.expectEqual(failures, p.fs.failures);
- // Over 9P too: the root's look at `@pN:2` answers ok and logs no err.
- const ctlfs = pardes.ctlfs;
- const written = p.serveFs(.{ .tag = 1, .op = .write, .node = @backingInt(ctlfs.TopFile.look), .data = try std.fmt.bufPrint(&line, "@p{d}:2\n", .{doc.serial}) });
- try std.testing.expectEqual(ctlfs.Status.ok, written.status);
- try std.testing.expectEqual(@as(usize, 1), doc.pdf.?.page);
- const log = @backingInt(ctlfs.TopFile.log);
- const h = p.serveFs(.{ .tag = 2, .op = .open, .node = log }).handle;
- const record = p.fsPayload(p.serveFs(.{ .tag = 3, .op = .read, .node = log, .handle = h, .size = 1 << 16 }));
- try std.testing.expect(std.mem.indexOf(u8, record, "\nerr ") == null);
- _ = p.serveFs(.{ .tag = 4, .op = .release, .node = log, .handle = h });
- while (p.nextEffect()) |_| {}
- // `:N:H` on the pane is hit H of its search on page N, as `file.pdf:N:H`
- // (a search row) is: with no search there is no hit 3, a miss that
- // turns no page.
- p.look_missed = false;
- pardes.look.lookAt(p, 0, ":1");
- pardes.look.lookAt(p, 0, ":2:3");
- try std.testing.expect(p.look_missed);
- try std.testing.expect(std.mem.indexOf(u8, doc.msg[0..doc.msg_len], "has no search hit 3 on page 2") != null);
- try std.testing.expectEqual(@as(usize, 0), doc.pdf.?.page);
- pardes.look.lookAt(p, 0, ":2");
- // Page 0 is no page: the has-no-page miss.
- p.look_missed = false;
- pardes.look.lookAt(p, 0, ":0");
- try std.testing.expect(p.look_missed);
- try std.testing.expect(std.mem.indexOf(u8, doc.msg[0..doc.msg_len], "has no page 0") != null);
- p.look_missed = false;
- // A byte offset or a pattern is no PDF address: refused with words.
- pardes.look.lookAt(p, 0, ":#3");
- try std.testing.expect(p.look_missed);
- try std.testing.expect(std.mem.indexOf(u8, doc.msg[0..doc.msg_len], "its address is a page, :N") != null);
- p.look_missed = false;
- pardes.look.lookAt(p, 0, try std.fmt.bufPrint(&line, ":{d}", .{pages + 1}));
- try std.testing.expect(p.look_missed);
- try std.testing.expectEqual(@as(usize, 1), doc.pdf.?.page); // where the 9P look left it
-}
-
-test "a look at a PDF's page past its last is a miss, never the last page" {
- if (!pdf_enabled or platform == .web) return;
- const gpa = std.testing.allocator;
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
- const fixture = try pdf_impl.makeNoOutlineTestPdf(gpa);
- defer gpa.free(fixture);
- try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "plain.pdf", .data = fixture });
- try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "other.pdf", .data = fixture });
- var dir_buf: [4096]u8 = undefined;
- const dir = dir_buf[0..try tmp.dir.realPath(std.testing.io, &dir_buf)];
- var path_buf: [4200]u8 = undefined;
- const path = try std.fmt.bufPrint(&path_buf, "{s}/plain.pdf", .{dir});
- const p = try Pardes.init(gpa, .{ .file = path, .cols = 80, .rows = 28 });
- defer p.deinit();
- const doc = p.panes[0].?;
- try std.testing.expect(doc.hasPdf());
- var line: [4300]u8 = undefined;
- // Open: it stays on its page.
- const page = doc.pdf.?.page;
- pardes.look.lookAt(p, 0, try std.fmt.bufPrint(&line, "{s}:999", .{path}));
- try std.testing.expect(p.look_missed);
- try std.testing.expectEqual(page, doc.pdf.?.page);
- // Not open: nothing opens.
- p.look_missed = false;
- var before: usize = 0;
- for (p.panes) |slot| before += @intFromBool(slot != null);
- pardes.look.lookAt(p, 0, try std.fmt.bufPrint(&line, "{s}/other.pdf:999", .{dir}));
- try std.testing.expect(p.look_missed);
- var after: usize = 0;
- for (p.panes) |slot| after += @intFromBool(slot != null);
- try std.testing.expectEqual(before, after);
-}
-
test "SDL PDF raster policy is materially denser than Kitty" {
try std.testing.expect(
pardes.sdl_pdf_raster_policy.dpi >= pardes.kitty_pdf_raster_policy.dpi * 2,
@@ -1334,7 +1146,7 @@ fn copySourceRect(
return out;
}
-test "PDF normal adapter consumes unsupported actions and navigates page fallback" {
+test "PDF normal mode keeps `:`, SPC and `/` on their shared paths" {
if (!pdf_enabled or platform == .web) return;
const p = try Pardes.init(std.testing.allocator, .{
@@ -1344,61 +1156,8 @@ test "PDF normal adapter consumes unsupported actions and navigates page fallbac
});
defer p.deinit();
const pane = p.panes[0].?;
- const pv = &pane.pdf.?;
- try std.testing.expect(pv.page_count > 3);
p.native_images = false;
- // Every vertical vocabulary falls back to counted page changes when the
- // shell cannot place native pixels.
- p.update(.{ .key = .{ .cp = '2' } });
- p.update(.{ .key = .{ .cp = 'j' } });
- try std.testing.expectEqual(@as(usize, 2), pv.page);
- p.update(.{ .key = .{ .cp = '2' } });
- p.update(.{ .key = .{ .cp = 'k' } });
- try std.testing.expectEqual(@as(usize, 0), pv.page);
- p.update(.{ .key = .{ .cp = '2' } });
- p.update(.{ .key = .{ .cp = 'd', .ctrl = true } });
- try std.testing.expectEqual(@as(usize, 2), pv.page);
- p.update(.{ .key = .{ .cp = '2' } });
- p.update(.{ .key = .{ .cp = 'u', .ctrl = true } });
- try std.testing.expectEqual(@as(usize, 0), pv.page);
- p.update(.{ .key = .{ .cp = '2' } });
- p.update(.{ .key = .{ .cp = 'f', .ctrl = true } });
- try std.testing.expectEqual(@as(usize, 2), pv.page);
- p.update(.{ .key = .{ .cp = '2' } });
- p.update(.{ .key = .{ .cp = 'b', .ctrl = true } });
- try std.testing.expectEqual(@as(usize, 0), pv.page);
-
- // Prefix actions and the counted text goto-line action map to pages.
- p.update(.{ .key = .{ .cp = 'g' } });
- p.update(.{ .key = .{ .cp = 'e' } });
- try std.testing.expectEqual(pv.page_count - 1, pv.page);
- p.update(.{ .key = .{ .cp = 'g' } });
- p.update(.{ .key = .{ .cp = 'g' } });
- try std.testing.expectEqual(@as(usize, 0), pv.page);
- p.update(.{ .key = .{ .cp = '3' } });
- p.update(.{ .key = .{ .cp = 'g' } });
- p.update(.{ .key = .{ .cp = 'g' } });
- try std.testing.expectEqual(@as(usize, 2), pv.page);
- p.update(.{ .key = .{ .cp = '2' } });
- p.update(.{ .key = .{ .cp = 'G' } });
- try std.testing.expectEqual(@as(usize, 1), pv.page);
-
- // Editing/selection actions are consumed no-ops: parser state clears,
- // placeholder cells never acquire a range, and PDF state stays intact.
- const page_before_noop = pv.page;
- const revision_before_noop = pv.next_raster_revision;
- p.update(.{ .key = .{ .cp = '4' } });
- p.update(.{ .key = .{ .cp = 'd' } });
- p.update(.{ .key = .{ .cp = 'v' } });
- p.update(.{ .key = .{ .cp = '|' } });
- try std.testing.expectEqual(page_before_noop, pv.page);
- try std.testing.expectEqual(revision_before_noop, pv.next_raster_revision);
- try std.testing.expectEqual(@as(u32, 0), pane.body.normal.count);
- try std.testing.expectEqual(.none, pane.body.normal.prefix);
- try std.testing.expect(!pane.body.vsel.active and !pane.body.msel.active and pane.body.nsel == 0);
- try std.testing.expect(pane.focus == .body);
-
// Cross-pane BODY-NORMAL actions keep their established shared paths.
p.update(.{ .key = .{ .cp = ':' } });
try std.testing.expect(pane.focus == .tag);
@@ -1552,7 +1311,7 @@ test "PDF continuous strip renders every intersecting short page" {
}
}
-test "PdfTint cycles pane-local state without adding tag clutter" {
+test "PDF tint resolves a theme's null page colors to its chrome" {
if (!pdf_enabled or platform == .web) return;
const p = try Pardes.init(std.testing.allocator, .{
@@ -1561,66 +1320,6 @@ test "PdfTint cycles pane-local state without adding tag clutter" {
.rows = 24,
});
defer p.deinit();
- const pane = p.panes[0].?;
- const pv = &pane.pdf.?;
- const tint_builtin = std.meta.stringToEnum(Builtin, "PdfTint") orelse
- return error.MissingPdfTintBuiltin;
-
- try std.testing.expectEqual(PdfTintMode.filtered, pv.tint);
- const initial_tag = try pardes.tagline.tagText(p, p.scratch.allocator(), pane);
- try std.testing.expect(std.mem.startsWith(u8, initial_tag, pv.path));
- try std.testing.expect(std.mem.endsWith(u8, initial_tag, " PdfSections PdfTint PdfFit Collapse Del"));
- try std.testing.expect(std.mem.indexOf(u8, initial_tag, "filtered") == null);
-
- try std.testing.expect(pardes.test_api.runBuiltin(
- p,
- @tagName(tint_builtin),
- 0,
- "",
- null,
- ));
- try std.testing.expectEqual(PdfTintMode.full, pv.tint);
- const full_tag = try pardes.tagline.tagText(p, p.scratch.allocator(), pane);
- try std.testing.expectEqualStrings(initial_tag, full_tag);
- try std.testing.expect(std.mem.indexOf(u8, full_tag, "full") == null);
-
- // Running the same pane-scoped word in a terminal cannot mutate the PDF
- // next to it. A FILE boot is one pane now, so that terminal is asked for
- // here rather than inherited from init.
- _ = try p.newShell(1, "");
- _ = layout.splitColumn(p, 0, 1, false);
- p.sync(); // rects for the new column, exactly as the two-pane boot did
- try std.testing.expect(!hasPdf(p.panes[1].?));
- try std.testing.expect(pardes.test_api.runBuiltin(
- p,
- @tagName(tint_builtin),
- 1,
- "",
- null,
- ));
- try std.testing.expectEqual(PdfTintMode.full, pv.tint);
-
- try std.testing.expect(pardes.test_api.runBuiltin(
- p,
- @tagName(tint_builtin),
- 0,
- "",
- null,
- ));
- try std.testing.expectEqual(PdfTintMode.disabled, pv.tint);
- const disabled_tag = try pardes.tagline.tagText(p, p.scratch.allocator(), pane);
- try std.testing.expectEqualStrings(initial_tag, disabled_tag);
- try std.testing.expect(std.mem.indexOf(u8, disabled_tag, "disabled") == null);
- try std.testing.expect(pardes.test_api.runBuiltin(
- p,
- @tagName(tint_builtin),
- 0,
- "",
- null,
- ));
- try std.testing.expectEqual(PdfTintMode.filtered, pv.tint);
- try std.testing.expectEqual(PdfFitMode.width, pv.fit);
-
// `dark` intentionally leaves page bg/fg null. PDF tint resolves those
// deterministically to its chrome colors rather than host defaults.
const dark_index = for (themes, 0..) |th, i| {
diff --git a/test/session.zig b/test/session.zig
index aa6288ff..16a131fd 100644
--- a/test/session.zig
+++ b/test/session.zig
@@ -237,6 +237,83 @@ pub const Session = struct {
if (r.status != .ok) return refusal(path, r);
return .{ .size = r.attr.size, .mode = r.attr.mode, .version = r.attr.version };
}
+
+ // panes:
+ /// `data` written to `path` truncated first, as a shell's `>` does.
+ pub fn replace(s: *Session, path: []const u8, data: []const u8) !void {
+ const node, const h = try s.open(path, 1);
+ defer _ = s.serve(.{ .tag = 0, .op = .release, .node = node, .handle = h, .opened = true });
+ const t = s.serve(.{ .tag = 0, .op = .setattr, .node = node, .handle = h, .truncate = true });
+ if (t.status != .ok) return refusal(path, t);
+ const w = s.serve(.{ .tag = 0, .op = .write, .node = node, .handle = h, .data = data });
+ if (w.status != .ok) return refusal(path, w);
+ }
+
+ // core:
+
+ /// /layout as its columns, left to right, `column:pane,pane` each and
+ /// a blank between (`1:2,5 3:`, column 3 empty).
+ pub fn columns(s: *Session) ![]const u8 {
+ const a = s.arena.allocator();
+ var out: std.ArrayList(u8) = .empty;
+ var lines = std.mem.tokenizeScalar(u8, try s.read("/layout"), '\n');
+ while (lines.next()) |line| {
+ if (std.mem.startsWith(u8, line, "active ")) continue;
+ var words = std.mem.tokenizeScalar(u8, line, ' ');
+ if (out.items.len > 0) try out.append(a, ' ');
+ try out.print(a, "{s}:", .{words.next().?});
+ for (0..5) |_| _ = words.next(); // index x width current empty|full
+ var sep: []const u8 = "";
+ while (words.next()) |pane| : (sep = ",") try out.print(a, "{s}{s}", .{ sep, pane });
+ }
+ return out.items;
+ }
+
+ /// The serial of the `i`th column from the left.
+ pub fn column(s: *Session, i: usize) !u32 {
+ var cols = std.mem.tokenizeScalar(u8, try s.columns(), ' ');
+ for (0..i) |_| _ = cols.next();
+ const col = cols.next() orelse return error.NoColumn;
+ return std.fmt.parseInt(u32, col[0..std.mem.indexOfScalar(u8, col, ':').?], 10);
+ }
+
+ /// Where /screen draws the cursor, column and row; null when it draws none.
+ pub fn cursor(s: *Session) !?struct { usize, usize } {
+ const json = try std.json.parseFromSliceLeaky(std.json.Value, s.arena.allocator(), try s.read("/screen"), .{});
+ const c = switch (json.object.get("cursor").?) {
+ .object => |o| o,
+ else => return null,
+ };
+ return .{ @intCast(c.get("x").?.integer), @intCast(c.get("y").?.integer) };
+ }
+
+ /// Where `text` is first drawn on /screen, column and row.
+ pub fn where(s: *Session, text: []const u8) !struct { usize, usize } {
+ return s.find(text);
+ }
+
+ // pdf:
+
+ /// A Look of `path` at the root (one relative to the working directory
+ /// made absolute first); the serial of the pane with the keyboard after.
+ /// A PDF in a build without them (-Dmupdf=false: no PdfTint in
+ /// /commands) skips the test.
+ pub fn lookFile(s: *Session, path: []const u8) !u32 {
+ if (std.mem.endsWith(u8, path, ".pdf") and std.mem.indexOf(u8, try s.read("/commands"), "PdfTint") == null) return error.SkipZigTest;
+ var buf: [4096]u8 = undefined;
+ const abs = if (std.fs.path.isAbsolute(path)) path else s.at("{s}/{s}", .{ buf[0..try std.Io.Dir.cwd().realPath(std.testing.io, &buf)], path });
+ try s.write("/look", s.at("{s}\n", .{abs}));
+ return s.focused();
+ }
+
+ /// The page a PDF pane shows and its pages, from its tag's `[page/pages]`.
+ pub fn pdfPage(s: *Session, n: u32) !struct { u32, u32 } {
+ const tag = try s.read(s.at("/pane/{d}/tag", .{n}));
+ const lo = std.mem.indexOf(u8, tag, " [") orelse return error.NoPage;
+ const close = std.mem.indexOfScalarPos(u8, tag, lo, ']') orelse return error.NoPage;
+ var it = std.mem.splitScalar(u8, tag[lo + 2 .. close], '/');
+ return .{ try std.fmt.parseInt(u32, it.next().?, 10), try std.fmt.parseInt(u32, it.next() orelse return error.NoPage, 10) };
+ }
};
fn refusal(path: []const u8, r: Reply) error{Refused} {