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 => { // A clicked tag is in normal mode: `:` goes back. try s.click("/test.txt Save", "/test.txt ".len + 3, 1); try s.keys(":"); }, .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: a PDF's moving keys scroll its strip, counted, gg G and ge go to pages, and the editing keys do nothing" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); s.graphics(); const n = try s.lookFile("docs/design.pdf"); const pages = (try s.pdfPage(n))[1]; try std.testing.expect(pages > 3); for ([_]struct { []const u8, u32 }{ .{ "ge", pages }, .{ "gg", 1 }, .{ "3gg", 3 }, .{ "2G", 2 }, .{ "G", pages }, .{ "gg", 1 } }) |step| { try s.keys(step[0]); try std.testing.expectEqual(step[1], (try s.pdfPage(n))[0]); } // j a cell's pixels, Ctrl-f a window's: a count moves that many, so // thirty windows down is past the first page (a window is a few rows // of a page here), thirty back at the first, and k at the top stays. try s.keys("k"); try std.testing.expectEqual(@as(u32, 1), (try s.pdfPage(n))[0]); try s.keys("30\x06"); try std.testing.expect((try s.pdfPage(n))[0] > 1); try s.keys("30\x02"); try std.testing.expectEqual(@as(u32, 1), (try s.pdfPage(n))[0]); try s.keys("200j"); try std.testing.expect((try s.pdfPage(n))[0] > 1); try s.keys("2G"); // Consumed, with their count: the page stays, no selection begins, and // no mode changes. try s.keys("4dv|i"); 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 ")); } 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")); } test "keys: Save's prompt on a scratch starts from the scratch's directory, one slash after it" { for ([_][2][]const u8{ .{ "/dír space/f.txt", " Save /dír space/zq" }, .{ "/f.txt", " Save /zq" } }) |c| { var s = try Session.initFile(std.testing.allocator, "one\n"); defer s.deinit(); const n = try s.focused(); try s.write(s.at("/pane/{d}/name", .{n}), s.at("{s}\n", .{c[0]})); // New from the file's pane: a scratch in its directory. try s.write(s.at("/pane/{d}/exec", .{n}), "New\n"); try std.testing.expect(try s.focused() != n); try s.keys(":\tzq"); _ = try s.where(c[1]); try s.keys("\x1b"); } } /// A B1 sweep from cell (x0, y0) to (x1, y1). fn sweep(s: *Session, x0: usize, y0: usize, x1: usize, y1: usize) !void { try s.write("/mousein", s.at("m {d} {d} 1\nm {d} {d} 1\nm {d} {d} 0\n", .{ x0, y0, x1, y1, x1, y1 })); } /// Whether any cell /screen draws is in `style`. fn drawsIn(s: *Session, style: []const u8) !bool { for (try s.styles()) |cell| if (std.mem.eql(u8, cell, style)) return true; return false; } test "keys: Ctrl-o and Ctrl-i jump back and forth, leaving no sweep drawn, a wrapped Unicode and tab one included" { const ctl = "\u{F017}"; for ([_]struct { []const u8, []const u8, bool }{ .{ "alpha\nbravo\n", "alpha", false }, .{ "界\tabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\n", "界", true }, }) |c| for ([_]bool{ false, true }) |reverse| { const prefix, const first, const wrap = c; var buf: [4096]u8 = undefined; @memcpy(buf[0..prefix.len], prefix); for (0..80) |i| @memcpy(buf[prefix.len + i * 27 ..][0..27], "unrelated destination text\n"); var s = try Session.initFile(std.testing.allocator, buf[0 .. prefix.len + 80 * 27]); defer s.deinit(); const n = try s.focused(); s.detach(); try s.write("/ctl", "size 34 10\n"); try s.write("/ctl", if (wrap) "Wrap on\n" else "Wrap off\n"); const dot = s.at("/pane/{d}/dot", .{n}); const addr = s.at("/pane/{d}/addr", .{n}); // Two places in the jump list: line 60, then line 1. try s.keys("60G1G"); const x, const y = try s.where(first); const plain = (try s.styles())[0]; if (reverse) try sweep(&s, x + 3, y + 1, x + 1, y) else try sweep(&s, x + 1, y, x + 3, y + 1); const screen = try s.screen(); const cols = try std.unicode.utf8CountCodepoints(screen[0..std.mem.indexOfScalar(u8, screen, '\n').?]); const swept = (try s.styles())[(y + 1) * cols + x]; try std.testing.expect(!std.mem.eql(u8, swept, plain)); try s.keys(ctl ++ "o"); try s.write(addr, "60"); const line60 = (try s.range(addr))[0]; try std.testing.expectEqual(.{ line60, line60 }, try s.range(dot)); try std.testing.expectError(error.NotOnScreen, s.where(first)); try std.testing.expect(!try drawsIn(&s, swept)); // A sweep made after Back is gone after Forward. const x2, const y2 = try s.where("unrelated"); try sweep(&s, x2 + 1, y2, x2 + 3, y2 + 1); try std.testing.expect(try drawsIn(&s, swept)); try s.keys(ctl ++ "i"); // Back where the sweep left the caret, nothing selected. const q0, const q1 = try s.range(dot); try std.testing.expect(q0 == q1 and q1 < line60); _ = try s.where(first); try std.testing.expect(!try drawsIn(&s, swept)); }; } // Its rows whole and Tab running one are the Themes walk's test above. test "keys: SPC j n from the pane a Look gave the keyboard walks back into the command output" { var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); for ([_][]const u8{ "a.txt", "b.txt" }) |name| try tmp.dir.writeFile(std.testing.io, .{ .sub_path = name, .data = "x\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(); try s.write("/look", s.at("{s}/a.txt\n", .{at})); const a = try s.focused(); try s.write(s.at("/pane/{d}/exec", .{a}), "Themes\n"); try s.keys(" jn"); const themes = try s.focused(); try std.testing.expect(themes != a); const sel = s.at("/pane/{d}/sel", .{themes}); try s.expect(sel, "Theme orchard"); try s.write(s.at("/pane/{d}/exec", .{a}), "Look b.txt\n"); try std.testing.expect(try s.focused() != themes); try s.keys(" jn"); try std.testing.expectEqual(themes, try s.focused()); try std.testing.expect(std.mem.startsWith(u8, try s.read(sel), "Theme ")); } /// Screen row `row` as drawn. fn screenRow(s: *Session, row: usize) ![]const u8 { var rows = std.mem.splitScalar(u8, try s.screen(), '\n'); for (0..row) |_| _ = rows.next(); return rows.next().?; } test "keys: a PDF in normal mode keeps : (its tag and back), SPC (a leader, cancelled by a key it has not) and / (a search prompt, Esc closing it)" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); const n = try s.lookFile("docs/design.pdf"); // A page has no text cursor: the body shows none. try std.testing.expect(try s.cursor() == null); _ = try s.pdfPage(n); const tag = (try s.where("[1/"))[1]; try s.keys(":"); // On its tag, which runs to three rows (its path, the core's art words). const on_tag = (try s.cursor()).?[1]; try std.testing.expect(on_tag >= tag and on_tag <= tag + 2); try std.testing.expect(std.mem.endsWith(u8, try s.read(s.at("/pane/{d}/ctl", .{n})), " mode:normal ")); try s.keys(":"); try std.testing.expect(try s.cursor() == null); // The leader shows its keys until one it has not. try s.keys(" "); try std.testing.expect(std.mem.indexOf(u8, try s.screen(), " SPC") != null); try s.keys("!"); try std.testing.expect(std.mem.indexOf(u8, try s.screen(), " SPC") == null); try s.keys("/"); try std.testing.expect(try s.cursor() != null); try std.testing.expectEqual(n, try s.focused()); try s.keys("\x1b"); try std.testing.expect(try s.cursor() == null); try std.testing.expectEqual(n, try s.focused()); } test "keys: zz and zc put the cursor's line in the middle row of an odd view, as many lines above it as below (helix align_view)" { var lines: [30][4]u8 = undefined; for (&lines, 0..) |*l, i| _ = try std.fmt.bufPrint(l, "l{d:0>2}\n", .{i}); var s = try Session.initFile(std.testing.allocator, std.mem.asBytes(&lines)); defer s.deinit(); for ([_][]const u8{ "15jzz", "ztzc" }) |keys| { try s.keys(keys); // 80x24 gives the pane 21 rows: l05 to l25, l15 the eleventh const top = (try s.where("l05"))[1]; try std.testing.expectEqual(top + 10, (try s.where("l15"))[1]); try std.testing.expectEqual(top + 20, (try s.where("l25"))[1]); try std.testing.expectError(error.NotOnScreen, s.where("l04")); try std.testing.expectError(error.NotOnScreen, s.where("l26")); } }