summaryrefslogtreecommitdiff
path: root/test/behaviour/look_and_exec.zig
diff options
context:
space:
mode:
Diffstat (limited to 'test/behaviour/look_and_exec.zig')
-rw-r--r--test/behaviour/look_and_exec.zig390
1 files changed, 390 insertions, 0 deletions
diff --git a/test/behaviour/look_and_exec.zig b/test/behaviour/look_and_exec.zig
index 98cab342..0d8056da 100644
--- a/test/behaviour/look_and_exec.zig
+++ b/test/behaviour/look_and_exec.zig
@@ -323,3 +323,393 @@ test "look-and-exec: a +PdfSections row's first number is the page: a section no
_ = try s.refused(look, "design.pdf:1:999\n");
try expectEqual(@as(usize, 2), try errs(&s));
}
+
+test "look-and-exec: a look's miss repeats the path whole up to 256 bytes, then gives up its middle to an ellipsis" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const long = "some/deeply/nested/directory/that/goes/on/and/on/with/a_rather_long_file_name.txt";
+ try s.write("/look", long ++ "\n");
+ try std.testing.expect(has(try s.read("/log"), "look: no match for \"" ++ long ++ "\"\n"));
+ const huge = std.mem.asBytes(&@as([150][2]u8, @splat("é".*))); // 300 bytes: its middle cut to fit 256, between characters
+ const kept = std.mem.asBytes(&@as([63][2]u8, @splat("é".*)));
+ try s.write("/look", huge ++ "\n");
+ try std.testing.expect(has(try s.read("/log"), "look: no match for \"" ++ kept ++ "…" ++ kept ++ "\"\n"));
+}
+
+test "look-and-exec: @p<serial>:<address> takes any sam address; a miss and an unknown serial are errs" {
+ var s = try Session.initFile(std.testing.allocator, "foo x foo y\nbar\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const dot = s.at("/pane/{d}/dot", .{n});
+ const Case = struct { []const u8, u32, u32 };
+ for ([_]Case{
+ .{ "0/foo/", 0, 3 },
+ .{ "/foo/", 6, 9 },
+ .{ "#12,#15", 12, 15 },
+ .{ "$", 16, 16 },
+ .{ "1,2", 0, 16 },
+ // Backward, as in addr: from the dot's start, wrapping to the last.
+ .{ "?foo?", 6, 9 },
+ .{ "$-?y?", 10, 11 },
+ }) |c| {
+ try s.write("/look", s.at("@p{d}:{s}\n", .{ n, c[0] }));
+ try expectEqual(.{ c[1], c[2] }, try s.range(dot));
+ }
+ try s.write("/look", s.at("@p{d}:/zzqq/\n", .{n}));
+ try std.testing.expect(has(try s.read("/log"), ": no match for regexp"));
+ try s.expect("/look", "");
+ try s.write("/look", "@p999:/foo/\n");
+ try std.testing.expect(has(try s.read("/log"), "look: no pane @p999"));
+ try s.expect("/look", "");
+ // A line address to no pane is a miss too, not the active pane.
+ try s.write("/look", "@p77:1\n");
+ try std.testing.expect(has(try s.read("/log"), "look: no pane @p77"));
+ try s.expect("/look", "");
+}
+
+test "look-and-exec: a look at file:3:0 is refused as addr 3:0 is, a column counting from 1" {
+ var s = try Session.initFile(std.testing.allocator, "one\ntwo\nthree\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try expectEqual(@as(u16, 22), try s.refused(s.at("/pane/{d}/addr", .{n}), "3:0"));
+ const by_addr = s.said;
+ try expectEqual(@as(u16, 22), try s.refused(s.at("/pane/{d}/look", .{n}), "/test.txt:3:0\n"));
+ try std.testing.expectEqualStrings(by_addr, s.said);
+ try s.write(s.at("/pane/{d}/look", .{n}), "/test.txt:3:1\n");
+}
+
+test "look-and-exec: a look of ./x, x or /abs/x that is not there is a miss: answered, the err logged" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const look = s.at("/pane/{d}/look", .{try s.focused()});
+ for ([_][]const u8{ "./zzq-nosuch.txt\n", "zzq-nosuch.txt\n", "/zzq-nosuch.txt\n" }) |line| try s.write(look, line);
+ try std.testing.expect(has(try s.read("/log"), "look: ./zzq-nosuch.txt: no such file"));
+}
+
+test "look-and-exec: a look at a ./ or ../ name that is not there is a miss naming the file; a plain one is looked for as text" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.createDirPath(std.testing.io, "many");
+ 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.focused();
+ try s.write(s.at("/pane/{d}/name", .{n}), s.at("{s}/many/a.txt\n", .{dir}));
+ for ([_][]const u8{ "./zz.txt", "../zz.txt" }) |name| {
+ try s.write(s.at("/pane/{d}/look", .{n}), s.at("{s}\n", .{name}));
+ try std.testing.expect(has(try s.read("/log"), s.at("look: {s}: no such file", .{name})));
+ }
+ try s.write(s.at("/pane/{d}/look", .{n}), "zz.txt\n");
+ try std.testing.expect(has(try s.read("/log"), "look: no match for \"zz.txt\""));
+}
+
+test "look-and-exec: a look at file:addr whose file is not there is one miss, quoting what was written, in a terminal too" {
+ var s = try Session.initTerm(std.testing.allocator);
+ defer s.deinit();
+ const look = s.at("/pane/{d}/look", .{try s.focused()});
+ const before = try errs(&s);
+ for ([_][]const u8{ "zzq:#3", "zzq:2", "zzq:/re/" }) |written| {
+ try s.write(look, s.at("{s}\n", .{written}));
+ try expectEqual(@as(usize, 1), std.mem.count(u8, try s.read("/log"), s.at("look: no match for \"{s}\"\n", .{written})));
+ }
+ try expectEqual(before + 3, try errs(&s));
+}
+
+test "look-and-exec: a builtin that needs its argument, written bare to an exec, is EINVAL as through ctl" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ for ([_][]const u8{ "/exec", s.at("/pane/{d}/exec", .{try s.focused()}), "/tagexec" }) |path| {
+ try expectEqual(@as(u16, 22), try s.refused(path, "Mount\n"));
+ try std.testing.expectEqualStrings("wrong #args in control message \"Mount\"", s.said);
+ }
+}
+
+test "look-and-exec: a builtin that takes no argument, written with one to an exec, is refused wrong #args, as at a ctl" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ for ([_][]const u8{ "/exec", s.at("/pane/{d}/exec", .{try s.focused()}) }) |path| for ([_][]const u8{ "Config extra\n", "DumpConfig extra\n" }) |line| {
+ try expectEqual(@as(u16, 22), try s.refused(path, line));
+ try std.testing.expect(std.mem.startsWith(u8, s.said, "wrong #args in control message"));
+ };
+}
+
+/// A fresh directory's absolute path, kept until deinit.
+fn tmpPath(s: *Session, tmp: *std.testing.TmpDir) ![]const u8 {
+ var buf: [4096]u8 = undefined;
+ return s.at("{s}", .{buf[0..try tmp.dir.realPath(std.testing.io, &buf)]});
+}
+
+test "look-and-exec: a look opens spaced paths and locations without editing the source pane" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "two words.zig", .data = "first\nsecond\nthird\n" });
+ var s = try Session.initFile(std.testing.allocator, "source stays intact\n");
+ defer s.deinit();
+ const path = s.at("{s}/two words.zig", .{try tmpPath(&s, &tmp)});
+ const source = try s.focused();
+ const ctl = try s.read(s.at("/pane/{d}/ctl", .{source}));
+ try s.write(s.at("/pane/{d}/dot", .{source}), "3 3");
+ try s.write(s.at("/pane/{d}/look", .{source}), s.at("{s}:2:3\n", .{path}));
+ const opened = try s.focused();
+ try std.testing.expect(opened != source);
+ try s.expect(s.at("/pane/{d}/name", .{opened}), s.at("{s}\n", .{path}));
+ try s.expect(s.at("/pane/{d}/body", .{opened}), "first\nsecond\nthird\n");
+ try expectEqual(@as(u32, 8), (try s.range(s.at("/pane/{d}/dot", .{opened})))[0]); // line 2, column 3
+ // The source: its text, its undo steps and its cursor as they were.
+ try s.expect(s.at("/pane/{d}/body", .{source}), "source stays intact\n");
+ const after = try s.read(s.at("/pane/{d}/ctl", .{source}));
+ try std.testing.expectEqualStrings(ctl[0..60], after[0..60]);
+ var fields = std.mem.tokenizeScalar(u8, after, ' ');
+ for (0..8) |_| _ = fields.next();
+ try std.testing.expectEqualStrings("0", fields.next().?); // still no undo step
+ try expectEqual(.{ @as(u32, 3), @as(u32, 3) }, try s.range(s.at("/pane/{d}/dot", .{source})));
+ try s.expect("/look", s.at("{d}\n", .{opened}));
+ // From the root, with the source focused: the same pane, moved.
+ try s.write("/focus", s.at("{d}\n", .{source}));
+ try s.write("/look", s.at("{s}:3:2\n", .{path}));
+ try expectEqual(opened, try s.focused());
+ try expectEqual(@as(u32, 14), (try s.range(s.at("/pane/{d}/dot", .{opened})))[0]); // line 3, column 2
+ try s.expect("/look", s.at("{d}\n", .{opened}));
+}
+
+test "look-and-exec: a look validates the whole batch before opening virtual files" {
+ var s = try Session.initFile(std.testing.allocator, "source\n");
+ defer s.deinit();
+ const source = try s.focused();
+ const look = s.at("/pane/{d}/look", .{source});
+ const index = try s.read("/index");
+ for ([_][]const u8{ "/virtual/index\x00ignored", "/virtual/index\n/virtual/\x01index\n" }) |invalid| {
+ try expectEqual(@as(u16, 22), try s.refused(look, invalid));
+ try s.expect("/index", index);
+ try expectEqual(source, try s.focused());
+ try s.expect(s.at("/pane/{d}/body", .{source}), "source\n");
+ }
+ try s.write(look, "/n/self/index\n");
+ const opened = try s.focused();
+ try s.expect(s.at("/pane/{d}/name", .{opened}), "/virtual/index\n");
+ try std.testing.expect(has(try s.read(s.at("/pane/{d}/body", .{opened})), "/test.txt"));
+ try s.expect(s.at("/pane/{d}/body", .{source}), "source\n");
+}
+
+test "look-and-exec: status reads the editor, and look and exec validate whole batches" {
+ var s = try Session.initFile(std.testing.allocator, "Msg root\n");
+ defer s.deinit();
+ const status = try s.read("/status");
+ var rows = std.mem.tokenizeScalar(u8, status, '\n');
+ try std.testing.expect(std.mem.startsWith(u8, rows.next().?, "pid "));
+ try std.testing.expect(std.mem.startsWith(u8, rows.next().?, "version "));
+ try std.testing.expectEqualStrings(s.at("panes {d}", .{lines(try s.read("/index"))}), rows.next().?);
+ try std.testing.expect(rows.next() == null);
+ const st = try s.stat("/status");
+ try expectEqual(@as(u64, status.len), st.size);
+ try expectEqual(@as(u16, 0o444), st.mode & 0o777);
+ try expectEqual(@as(u16, 1), try s.refused("/status", "anything\n"));
+ try s.expect("/exec", "");
+ const index = try s.read("/index");
+ for ([_][]const u8{ "Msg a\x00b", "Msg x\nMsg \x01y\n" }) |invalid| {
+ try expectEqual(@as(u16, 22), try s.refused("/exec", invalid));
+ try s.expect("/index", index);
+ }
+ // An empty write is a no-op, not a command.
+ try s.write("/exec", "\n \n");
+ try s.expect("/exec", "");
+ try s.expect("/status", status);
+ const n = try s.focused();
+ try s.write("/exec", "Msg hello there\n");
+ try std.testing.expect(has(try s.read("/log"), s.at("msg {d} hello there\n", .{n})));
+ try s.expect("/exec", s.at("{d}\n", .{n}));
+ try s.write("/look", "/virtual/index\n");
+ const opened = try s.focused();
+ try s.expect(s.at("/pane/{d}/name", .{opened}), "/virtual/index\n");
+ try s.expect("/look", s.at("{d}\n", .{opened}));
+ try s.write("/exec", "New\n");
+ const made = try s.focused();
+ try std.testing.expect(made != opened);
+ try s.expect("/exec", s.at("{d}\n", .{made}));
+}
+
+test "look-and-exec: a look at a file it may not read fails the write naming the file" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "locked.txt", .data = "secret\n", .flags = .{ .permissions = .fromMode(0o000) } });
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const path = s.at("{s}/locked.txt", .{try tmpPath(&s, &tmp)});
+ if (try s.refused("/look", s.at("{s}\n", .{path})) == 0) return error.SkipZigTest; // root reads anything
+ try std.testing.expectEqualStrings(s.at("look: {s}: permission denied", .{path}), s.said);
+}
+
+test "look-and-exec: a look line's trailing colon is dropped, and a look whose address fails never leaves its file open" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "a.txt", .data = "one\ntwo\nthree\n" });
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const dir = try tmpPath(&s, &tmp);
+ const before = lines(try s.read("/index"));
+ // Failing addresses: nothing opened, the write still answered.
+ for ([_][]const u8{ s.at("{s}/a.txt:/nomatch/\n", .{dir}), s.at("{s}/a.txt:9:\n", .{dir}) }) |line| {
+ _ = try s.refused("/look", line);
+ try expectEqual(before, lines(try s.read("/index")));
+ }
+ // `a.txt:2:3:` is `a.txt:2:3`: it opens there.
+ try s.write("/look", s.at("{s}/a.txt:2:3:\n", .{dir}));
+ try expectEqual(before + 1, lines(try s.read("/index")));
+ const opened = try s.focused();
+ try s.expect(s.at("/pane/{d}/name", .{opened}), s.at("{s}/a.txt\n", .{dir}));
+ try expectEqual(@as(u32, 6), (try s.range(s.at("/pane/{d}/dot", .{opened})))[0]);
+}
+
+test "look-and-exec: a look that misses file:/re/ names the file, and is logged as its pane's" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "f.txt", .data = "alpha\n" });
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const dir = try tmpPath(&s, &tmp);
+ const first = try s.focused();
+ try s.write("/look", s.at("{s}/f.txt\n", .{dir}));
+ const f = try s.focused();
+ _ = try s.refused(s.at("/pane/{d}/look", .{first}), s.at("{s}/f.txt:/zzqq/\n", .{dir}));
+ try std.testing.expect(has(try s.read("/log"), s.at("err {d} look: {s}/f.txt: no match for regexp", .{ f, dir })));
+}
+
+test "look-and-exec: a look that goes to another pane leaves the looking pane's dot alone" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "f.txt", .data = "f one\nf two\n" });
+ var s = try Session.initFile(std.testing.allocator, "alpha bravo\ncharlie\n");
+ defer s.deinit();
+ const dir = try tmpPath(&s, &tmp);
+ const source = try s.focused();
+ const other = try s.newPane();
+ try s.write(s.at("/pane/{d}/body", .{other}), "one\ntwo\nthree\n");
+ for ([_][]const u8{ s.at("@p{d}:2\n", .{other}), s.at("@p{d}:/three/\n", .{other}), s.at("{s}/f.txt:2\n", .{dir}) }) |line| {
+ try s.write(s.at("/pane/{d}/dot", .{source}), "6 11");
+ try s.write(s.at("/pane/{d}/look", .{source}), line);
+ try std.testing.expect(try s.focused() != source);
+ try expectEqual(.{ @as(u32, 6), @as(u32, 11) }, try s.range(s.at("/pane/{d}/dot", .{source})));
+ }
+}
+
+test "look-and-exec: a looked word is found in its own pane, next place after the dot, wrapping, and opens no pane; LookWord list lists it in +Search" {
+ var s = try Session.initFile(std.testing.allocator, "foo x foo y\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const look = s.at("/pane/{d}/look", .{n});
+ const index = try s.read("/index");
+ for ([_]u32{ 0, 6, 0 }) |at| {
+ try s.write(look, "foo\n");
+ try expectEqual(.{ at, at + 3 }, try s.range(s.at("/pane/{d}/dot", .{n})));
+ }
+ try s.expect("/index", index);
+ try s.write("/ctl", "LookWord list\n");
+ try s.write(look, "foo\n");
+ try std.testing.expect(lines(try s.read("/index")) > lines(index));
+ // ...and look reads back that +Search pane, where the places are.
+ const search = try paneNamed(&s, "/+Search");
+ try std.testing.expect(has(try s.read(look), s.at("{d}\n", .{search})));
+}
+
+test "look-and-exec: a second LookWord list look in a directory refills its +Search rather than stacking another" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "words.txt", .data = "alpha beta\nalpha beta\n" });
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try s.write(s.at("/pane/{d}/name", .{n}), s.at("{s}/words.txt\n", .{try tmpPath(&s, &tmp)}));
+ try s.write(s.at("/pane/{d}/exec", .{n}), "Get\n");
+ try s.write("/ctl", "LookWord list\n");
+ try s.write(s.at("/pane/{d}/look", .{n}), "alpha\n");
+ const first = try paneNamed(&s, "/+Search");
+ try s.write(s.at("/pane/{d}/look", .{n}), "beta\n");
+ try expectEqual(@as(usize, 1), std.mem.count(u8, try s.read("/index"), "/+Search "));
+ try expectEqual(first, try paneNamed(&s, "/+Search"));
+ // Refilled with beta's places (columns 7-10), not alpha's.
+ try std.testing.expect(has(try s.read(s.at("/pane/{d}/body", .{first})), "words.txt:1:7-10\n"));
+}
+
+test "look-and-exec: `@pN:` looks at pane N as `a.txt:` looks at a.txt, and a line past the end is said one way, `:N` or `file:N`" {
+ var s = try Session.initFile(std.testing.allocator, "one\ntwo\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const look = s.at("/pane/{d}/look", .{n});
+ const before = try errs(&s);
+ try s.write(look, s.at("@p{d}:\n", .{n}));
+ try expectEqual(before, try errs(&s));
+ try s.write(look, ":99999\n");
+ try s.write(look, "/test.txt:99999\n");
+ try std.testing.expect(has(try s.read("/log"), "/test.txt:99999 has no line 99999 (x2)\n"));
+}
+
+test "look-and-exec: an exec line over the command limit fails the write and says the limit; a builtin's may be longer" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const long = "echo " ++ &@as([1024]u8, @splat('y')) ++ "\n";
+ try expectEqual(@as(u16, 22), try s.refused("/exec", long));
+ try std.testing.expectEqualStrings("invalid command line: a command line is at most 1024 bytes", s.said);
+ try std.testing.expect(has(try s.read("/log"), s.at("err {d} exec: invalid command line: a command line is at most 1024 bytes", .{n})));
+ _ = try s.refused("/exec", "echo a\x01b\n");
+ try std.testing.expectEqualStrings("invalid command line: it holds a control character (or DEL) other than a tab", s.said);
+ try std.testing.expect(has(try s.read("/log"), s.at("err {d} exec: invalid command line: it holds", .{n})));
+ try s.write("/exec", "Msg " ++ &@as([1100]u8, @splat('z')) ++ "\n");
+}
+
+test "look-and-exec: a builtin that fails through exec, tagexec or a column's exec fails the write with one err and no msg" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.focused();
+ // Another failure first: the pane's `new` is logged after it.
+ _ = try s.refused("/ctl", "Unmount yyy\n");
+ for ([_][]const u8{ "/exec", s.at("/pane/{d}/exec", .{n}), "/tagexec", s.at("/col/{d}/exec", .{try s.column(0)}) }) |path| {
+ try std.testing.expect(try s.refused(path, "Unmount zzz\n") != 0);
+ try std.testing.expect(has(s.said, "Unmount: no such mount zzz"));
+ }
+ const log = try s.read("/log");
+ try std.testing.expect(!has(log, "msg "));
+ // The root's exec ran at the pane, so its err and the pane's exec's are
+ // the same record, counted.
+ try expectEqual(@as(usize, 3), std.mem.count(u8, log, "Unmount: no such mount zzz"));
+ try std.testing.expect(has(log, "mount zzz (x2)"));
+ // A control character is refused with its reason.
+ try expectEqual(@as(u16, 22), try s.refused("/exec", "Msg a\x01b\n"));
+ try std.testing.expectEqualStrings("invalid command line: it holds a control character (or DEL) other than a tab", s.said);
+ // A look miss: one err, no msg; the same miss again is that record counted.
+ try s.write("/look", "zzqqnotthere\n");
+ try std.testing.expect(has(try s.read("/log"), "look: no match for \"zzqqnotthere\""));
+ try std.testing.expect(!has(try s.read("/log"), "msg "));
+ try s.write("/look", "zzqqnotthere\n");
+ try std.testing.expect(has(try s.read("/log"), "look: no match for \"zzqqnotthere\" (x2)\n"));
+}
+
+test "look-and-exec: a served-tree pane spoils no Grep, and Look . from a gone directory is ENOENT, not /virtual/" {
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "hit.txt", .data = "needle here\n" });
+ 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}/name", .{first}), s.at("{s}/other.txt\n", .{try tmpPath(&s, &tmp)}));
+ // A pane of the served tree, and one named its root, whose directory is `/`.
+ try s.write(s.at("/pane/{d}/name", .{try s.newPane()}), "/virtual/index\n");
+ try s.write(s.at("/pane/{d}/name", .{try s.newPane()}), "/virtual\n");
+ try s.write(s.at("/pane/{d}/exec", .{first}), "Grep needle\n");
+ // `.` from a pane whose directory is gone.
+ const gone = try s.newPane();
+ try s.write(s.at("/pane/{d}/name", .{gone}), "/tmp/pardes-no-such-dir-zz/f.txt\n");
+ try expectEqual(@as(u16, 2), try s.refused(s.at("/pane/{d}/look", .{gone}), ".\n"));
+ try std.testing.expect(std.mem.startsWith(u8, s.said, "look: /tmp/pardes-no-such-dir-zz: no such directory"));
+}
+
+test "look-and-exec: a pane's tagexec runs a word as a click in its tag, and reads back what it touched" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const tagexec = s.at("/pane/{d}/tagexec", .{n});
+ try s.write(tagexec, "Msg from the tag\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), "from the tag") != null);
+ try s.expect(tagexec, s.at("{d}\n", .{n}));
+}