From 5322d373c78ecee48b934886c95f3b8c4471a11f Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Tue, 3 Nov 2026 17:04:29 -0300 Subject: test: five of test/pdf.zig's tests through the 9P tree alone: a PDF's body a line for each line of its page's text (panes), PdfTint stepped in its ctl and never in its tag, refused at another pane (panes), PdfSections on a PDF with no outline opening nothing (panes, a PDF written by the test), /recent keeping a PDF open then closed (other_files), the pages a PDF shown as text turns for j/k, Ctrl-d/u/f/b, ge, gg, 3gg, 2G and the editing keys consumed (keys, a new file); the parts with no surface stay as two small tests (tint colours of a theme with none, `:`/SPC/`/` on a PDF); each checked to fail against a break (the page text's newline a blank, toggleTint not stepping, the no-outline check dropped, a PDF given no Recent place, a counted text-mode j taking half its count) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge --- test/behaviour/panes.zig | 69 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+) (limited to 'test/behaviour/panes.zig') diff --git a/test/behaviour/panes.zig b/test/behaviour/panes.zig index 01820a07..8a906c2b 100644 --- a/test/behaviour/panes.zig +++ b/test/behaviour/panes.zig @@ -49,3 +49,72 @@ test "panes: Putall saves every pane with unsaved edits to a file, one each, and try s.write("/ctl", "Putall\n"); try std.testing.expectEqual(@as(usize, 1), s.saved); } + +/// `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); +} -- cgit v1.3 From 6ff5fc7447cc411dc24cb1d841130f15a410e354 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Tue, 3 Nov 2026 17:08:35 -0300 Subject: test: three of test/output.zig's tests through the 9P tree alone: DumpConfig's report in its one +DumpConfig pane, a second refreshing it in place (settings, a new file: /index, /focus and its body, Theme acme seen there), Config with no configuration directory refused, said in the log and opening nothing (settings), a Mini that cannot read its file leaving the panes, the last snapshot and the keyboard as they were (panes); the startup path line stays, a process flag with no 9P surface; each checked to fail against a break (openRead never reusing an output pane, Config taking a made-up path when there is no directory, a failed Mini giving the keyboard back to its caller) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge --- test/behaviour.zig | 1 + test/behaviour/panes.zig | 16 ++++++++++++ test/behaviour/settings.zig | 38 ++++++++++++++++++++++++++++ test/output.zig | 60 ++------------------------------------------- 4 files changed, 57 insertions(+), 58 deletions(-) create mode 100644 test/behaviour/settings.zig (limited to 'test/behaviour/panes.zig') diff --git a/test/behaviour.zig b/test/behaviour.zig index 3e377ed7..2a37693e 100644 --- a/test/behaviour.zig +++ b/test/behaviour.zig @@ -10,4 +10,5 @@ test { _ = @import("behaviour/other_files.zig"); _ = @import("behaviour/panes.zig"); _ = @import("behaviour/root_ctl.zig"); + _ = @import("behaviour/settings.zig"); } diff --git a/test/behaviour/panes.zig b/test/behaviour/panes.zig index 8a906c2b..90c283b7 100644 --- a/test/behaviour/panes.zig +++ b/test/behaviour/panes.zig @@ -118,3 +118,19 @@ test "panes: PdfSections on a PDF with no outline says so and opens nothing" { } 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/settings.zig b/test/behaviour/settings.zig new file mode 100644 index 00000000..57751ab1 --- /dev/null +++ b/test/behaviour/settings.zig @@ -0,0 +1,38 @@ +//! docs/typ/reference.typ, Settings . +const std = @import("std"); +const Session = @import("session").Session; + +fn has(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 has(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 has(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 has(try s.read("/log"), "Config: no startup file here: no configuration directory"); +} diff --git a/test/output.zig b/test/output.zig index 2b8bf1f5..4d5945cd 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 }); -- cgit v1.3 From 5cc02232d522d5cd5a453caedd1e592ca20471ea Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Tue, 3 Nov 2026 17:09:53 -0300 Subject: test: eleven more of src/pardes.zig's tests through the 9P tree alone (test/behaviour/columns_and_tags, modes, tags, panes): a click past a column tag's text typing after it, a newline there a space and a long tag scrolled to its caret, Enter and Tab in a tag running the word under the cursor, Esc alternating two panes of a kind, Esc out of a column or the workspace tag, Shift-Esc out of every mode, a name typed into the tag's path pending past Esc, an unsaved file's tag its name alone, a question ended in the log when its pane closes, focus on a closed pane to the one taking its place; Session's cursor (/screen's); each checked to fail against a break (flatten keeping newlines, the header drawn unscrolled, Enter in a header a Look, Esc in normal mode not running Last, Esc in a header not leaving it, Shift-Esc leaving insert on, the first Esc on a drafted name dropping it, a dirty tag marked ' *', del_side left out of noteRetire's answer, removeColumn's focus to any pane) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge --- src/pardes.zig | 231 ------------------------------------ test/behaviour.zig | 2 + test/behaviour/columns_and_tags.zig | 39 ++++++ test/behaviour/modes.zig | 65 ++++++++++ test/behaviour/panes.zig | 63 ++++++++++ test/behaviour/tags.zig | 19 +++ test/session.zig | 10 ++ 7 files changed, 198 insertions(+), 231 deletions(-) create mode 100644 test/behaviour/modes.zig create mode 100644 test/behaviour/tags.zig (limited to 'test/behaviour/panes.zig') diff --git a/src/pardes.zig b/src/pardes.zig index ea8b52df..3d29dfcd 100644 --- a/src/pardes.zig +++ b/src/pardes.zig @@ -1462,21 +1462,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 "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, .{}); @@ -3180,33 +3165,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 }); @@ -3389,43 +3347,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(); @@ -3456,18 +3377,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(); @@ -3487,20 +3396,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(); @@ -8272,31 +8167,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; @@ -8676,49 +8546,6 @@ test "Del from a key asks which neighbour takes the rows; nothing else asks" { try std.testing.expect(p.panes[low] == null); } -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 "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 }); @@ -8892,43 +8719,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(); @@ -9870,27 +9660,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"); diff --git a/test/behaviour.zig b/test/behaviour.zig index 32138f94..902ef520 100644 --- a/test/behaviour.zig +++ b/test/behaviour.zig @@ -6,7 +6,9 @@ test { _ = @import("behaviour/columns_and_tags.zig"); _ = @import("behaviour/edit.zig"); _ = @import("behaviour/look_and_exec.zig"); + _ = @import("behaviour/modes.zig"); _ = @import("behaviour/other_files.zig"); _ = @import("behaviour/panes.zig"); _ = @import("behaviour/root_ctl.zig"); + _ = @import("behaviour/tags.zig"); } diff --git a/test/behaviour/columns_and_tags.zig b/test/behaviour/columns_and_tags.zig index 80f9c710..5b78a6c8 100644 --- a/test/behaviour/columns_and_tags.zig +++ b/test/behaviour/columns_and_tags.zig @@ -149,3 +149,42 @@ test "columns-and-tags: New is a column tag's word, in no pane's tag nor the wor } 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); + try std.testing.expect(std.mem.indexOf(u8, try s.screen(), "\n /test.txt Save") != null); + // 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")); +} diff --git a/test/behaviour/modes.zig b/test/behaviour/modes.zig new file mode 100644 index 00000000..cdcf1be6 --- /dev/null +++ b/test/behaviour/modes.zig @@ -0,0 +1,65 @@ +//! docs/typ/guide.typ, 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()); +} diff --git a/test/behaviour/panes.zig b/test/behaviour/panes.zig index 01820a07..d0773bfb 100644 --- a/test/behaviour/panes.zig +++ b/test/behaviour/panes.zig @@ -49,3 +49,66 @@ test "panes: Putall saves every pane with unsaved edits to a file, one each, and try s.write("/ctl", "Putall\n"); try std.testing.expectEqual(@as(usize, 1), s.saved); } + +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()); +} diff --git a/test/behaviour/tags.zig b/test/behaviour/tags.zig new file mode 100644 index 00000000..ab109b78 --- /dev/null +++ b/test/behaviour/tags.zig @@ -0,0 +1,19 @@ +//! docs/typ/guide.typ, Tags . +const std = @import("std"); +const Session = @import("session").Session; + +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/session.zig b/test/session.zig index c4ed0db2..f67f3b25 100644 --- a/test/session.zig +++ b/test/session.zig @@ -210,6 +210,16 @@ pub const Session = struct { 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) }; + } }; fn refusal(path: []const u8, r: Reply) error{Refused} { -- cgit v1.3 From 3632bbeaa75f912281d0c9d636feb153d04f668e Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Tue, 3 Nov 2026 17:22:47 -0300 Subject: test: five more of src/pardes.zig's tests through the 9P tree alone (test/behaviour/placement, panes, terminals, modes): an empty active column taking a look from another column's text whole, Collapse folding a pane to its tag (no text drawn, no cursor, its tag still typed into) and restoring it, a pane its whole text fits in never scrolled for a margin, Togglettymode and Ctrl-B sharing the mode's transitions from the body or the tag and a text pane refusing it, Esc back into a file keeping its view where a look's :N centres; Session's where (the first place /screen draws a text); each checked to fail against a break (acmeColumn ignoring the active column, toggleCollapse never unfolding, the scroll margin clamped at the last line alone, toggleTty leaving the tag the keyboard, Last landing centred) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge --- src/pardes.zig | 147 ------------------------------------------- test/behaviour.zig | 2 + test/behaviour/modes.zig | 39 ++++++++++++ test/behaviour/panes.zig | 49 +++++++++++++++ test/behaviour/placement.zig | 24 +++++++ test/behaviour/terminals.zig | 46 ++++++++++++++ test/session.zig | 5 ++ 7 files changed, 165 insertions(+), 147 deletions(-) create mode 100644 test/behaviour/placement.zig create mode 100644 test/behaviour/terminals.zig (limited to 'test/behaviour/panes.zig') diff --git a/src/pardes.zig b/src/pardes.zig index 3d29dfcd..3d6b6e28 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; @@ -1259,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(); @@ -1419,24 +1337,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(); @@ -8615,53 +8515,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" }); diff --git a/test/behaviour.zig b/test/behaviour.zig index 902ef520..bec74d89 100644 --- a/test/behaviour.zig +++ b/test/behaviour.zig @@ -9,6 +9,8 @@ test { _ = @import("behaviour/modes.zig"); _ = @import("behaviour/other_files.zig"); _ = @import("behaviour/panes.zig"); + _ = @import("behaviour/placement.zig"); _ = @import("behaviour/root_ctl.zig"); _ = @import("behaviour/tags.zig"); + _ = @import("behaviour/terminals.zig"); } diff --git a/test/behaviour/modes.zig b/test/behaviour/modes.zig index cdcf1be6..dde3ffb6 100644 --- a/test/behaviour/modes.zig +++ b/test/behaviour/modes.zig @@ -63,3 +63,42 @@ test "modes: Shift-Esc backs out to the previous pane in every mode, never into 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/panes.zig b/test/behaviour/panes.zig index d0773bfb..149c8da1 100644 --- a/test/behaviour/panes.zig +++ b/test/behaviour/panes.zig @@ -112,3 +112,52 @@ test "panes: focus on a closed pane goes to the pane that takes its place, not t 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]); +} diff --git a/test/behaviour/placement.zig b/test/behaviour/placement.zig new file mode 100644 index 00000000..350e94f8 --- /dev/null +++ b/test/behaviour/placement.zig @@ -0,0 +1,24 @@ +//! docs/typ/reference.typ, 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()); +} 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 . +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/session.zig b/test/session.zig index f67f3b25..6d214874 100644 --- a/test/session.zig +++ b/test/session.zig @@ -220,6 +220,11 @@ pub const Session = struct { }; 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); + } }; fn refusal(path: []const u8, r: Reply) error{Refused} { -- cgit v1.3