summaryrefslogtreecommitdiff
path: root/test/process
diff options
context:
space:
mode:
Diffstat (limited to 'test/process')
-rw-r--r--test/process/builtins.zig52
-rw-r--r--test/process/edit.zig139
-rw-r--r--test/process/flags.zig780
-rw-r--r--test/process/look_and_exec.zig239
-rw-r--r--test/process/mounts.zig212
-rw-r--r--test/process/other_files.zig119
-rw-r--r--test/process/repls.zig79
-rw-r--r--test/process/root_ctl.zig183
-rw-r--r--test/process/terminals.zig352
-rw-r--r--test/process/tree.zig636
10 files changed, 2791 insertions, 0 deletions
diff --git a/test/process/builtins.zig b/test/process/builtins.zig
new file mode 100644
index 00000000..410a3f54
--- /dev/null
+++ b/test/process/builtins.zig
@@ -0,0 +1,52 @@
+//! docs/typ/reference.typ, Builtins <builtins> a real session runs, detached
+//! and in a pty.
+const std = @import("std");
+const process = @import("../process.zig");
+const Conn = process.Conn;
+const has = process.has;
+const check = process.check;
+
+pub const cases = .{
+ .{ "builtins: Lspinfo opens one +Lsp pane saying the backend and its servers, detached and in a pty", lspinfo },
+};
+
+fn lspinfo(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ for ([_]bool{ false, true }) |tty| {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const name = if (tty) "lsp-tty" else "lsp-detached";
+ var d = try process.Detached.start(gpa, exe, if (tty) "lsp-root" else name, .{});
+ defer d.deinit();
+ var term: ?process.Child = null;
+ defer if (term) |*t| t.deinit();
+ if (tty) term = try d.startTty(exe, name, &.{});
+ const address = d.abs(try std.fmt.allocPrint(a, "pardes-9p-{s}.sock", .{name}));
+ const c = try Conn.dial(gpa, address);
+ defer c.deinit(gpa);
+ const control = try c.newPane();
+ try c.exec(control, "Lspinfo\n");
+ const deadline = process.nowMs() + 3_000;
+ const lsp = while (true) {
+ var found: ?u32 = null;
+ var count: usize = 0;
+ var rows = std.mem.tokenizeScalar(u8, try c.read(a, "/index"), '\n');
+ while (rows.next()) |row| if (has(row, "+Lsp")) {
+ count += 1;
+ found = try std.fmt.parseInt(u32, row[0..std.mem.indexOfScalar(u8, row, ' ').?], 10);
+ };
+ if (found) |n| {
+ try check(count == 1, "{s}: {d} +Lsp panes", .{ name, count });
+ break n;
+ }
+ if (process.nowMs() > deadline) return error.LspinfoNeverDone;
+ process.nap(5);
+ };
+ const body = try c.pane(a, lsp, "body");
+ try check(std.mem.startsWith(u8, body, "backend: lsp-client\n") and has(body, "protocol servers (lsp-client):"), "{s}", .{body});
+ try std.testing.expectEqualStrings("initial\n", try c.read(a, "/pane/1/body"));
+ var f: process.Files = .init(gpa, address);
+ defer f.deinit();
+ try check(has(try f.screen(), "+Lsp"), "+Lsp not drawn", .{});
+ }
+}
diff --git a/test/process/edit.zig b/test/process/edit.zig
new file mode 100644
index 00000000..30477552
--- /dev/null
+++ b/test/process/edit.zig
@@ -0,0 +1,139 @@
+//! docs/typ/reference.typ, Edit <edit>, through a real session's socket:
+//! its commands run in the session's shell, and its w writes.
+const std = @import("std");
+const process = @import("../process.zig");
+const eh = @import("../e2e_harness.zig");
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+const expectEqualStrings = std.testing.expectEqualStrings;
+
+pub const cases = .{
+ .{ "edit: < | > run off the loop and answer their write once applied, a failing one changing nothing; a held Edit write is flushed; X edits every open file it matches, w writes", editCommands },
+};
+
+fn has(hay: []const u8, needle: []const u8) bool {
+ return std.mem.indexOf(u8, hay, needle) != null;
+}
+
+fn refusedSaying(c: *process.Conn, path: []const u8, data: []const u8, why: []const u8) !void {
+ try std.testing.expectError(error.Refused, c.write(path, data));
+ if (!has(c.said, why)) {
+ std.debug.print("{s} refused saying {s}, not {s}\n", .{ path, c.said, why });
+ return error.WrongWords;
+ }
+}
+
+/// An Edit written on another connection, in a thread.
+const Slow = struct {
+ conn: *process.Conn,
+ path: []const u8,
+ done: std.atomic.Value(bool) = .init(false),
+
+ fn go(s: *Slow) void {
+ s.conn.write(s.path, "Edit , | sleep 1; cat\n") catch {};
+ s.done.store(true, .release);
+ }
+};
+
+fn editCommands(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var d = try process.Detached.start(gpa, exe, "edit", .{});
+ defer d.deinit();
+ const f = &d.files;
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const ar = arena.allocator();
+ const c = try process.Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const root = d.root();
+ try d.put("a.txt", "pear\napple\nfig\n");
+ try d.put("b.txt", "apple pie\n");
+ const a = try c.look(ar, f.at("{s}/a.txt", .{root}), null);
+ const b = try c.look(ar, f.at("{s}/b.txt", .{root}), null);
+ const actl = f.at("/pane/{d}/ctl", .{a});
+ const abody = f.at("/pane/{d}/body", .{a});
+ // The write returns with the text sorted, through the session's shell
+ // in the file's directory.
+ try c.write(actl, "Edit , | sort\n");
+ try expectEqualStrings("apple\nfig\npear\n", try c.read(ar, abody));
+ try c.write(actl, "Edit $ < pwd\n");
+ try expectEqualStrings(f.at("apple\nfig\npear\n{s}\n", .{root}), try c.read(ar, abody));
+ try c.write(actl, "Undo\n");
+ try expectEqualStrings("apple\nfig\npear\n", try c.read(ar, abody));
+ // A per-match command, one undo step.
+ try c.write(actl, "Edit ,x/[a-z]+/ | tr a-z A-Z\n");
+ try expectEqualStrings("APPLE\nFIG\nPEAR\n", try c.read(ar, abody));
+ // A failing command: nothing changed, the write fails in words, its
+ // stderr in +Errors.
+ try refusedSaying(c, actl, "Edit , | echo nope >&2; exit 4\n", "exit status 4");
+ try expectEqualStrings("APPLE\nFIG\nPEAR\n", try c.read(ar, abody));
+ var said = false;
+ var rows = std.mem.tokenizeScalar(u8, try c.read(ar, "/index"), '\n');
+ while (rows.next()) |row| {
+ if (!has(row, "+Errors")) continue;
+ said = said or has(try c.read(ar, f.at("/pane/{s}/body", .{row[0..std.mem.indexOfScalar(u8, row, ' ').?]})), "nope");
+ }
+ try expect(said);
+ // While a slow command runs, the editor answers.
+ {
+ const other = try process.Conn.dial(gpa, d.socket());
+ defer other.deinit(gpa);
+ var slow: Slow = .{ .conn = other, .path = f.at("/pane/{d}/ctl", .{b}) };
+ const worker = try std.Thread.spawn(.{}, Slow.go, .{&slow});
+ process.sleep(200);
+ const began = eh.nowMs();
+ _ = try c.read(ar, "/index");
+ const quick = eh.nowMs() - began < 500 and !slow.done.load(.acquire);
+ worker.join();
+ try expect(quick); // the editor did not wait on the command
+ try expect(slow.done.load(.acquire));
+ }
+ // On the same connection: the Edit's write is held, and a read sent
+ // after it is answered first; a Tflush of it stops it, changes nothing,
+ // and frees the way for the next Edit.
+ const ctl = try c.hold(actl, 1);
+ const status = try c.hold("/status", 0);
+ const began = eh.nowMs();
+ const held = try c.send(.{ .write = .{ .fid = ctl, .offset = 0, .data = "Edit , | sleep 1; cat\n" } });
+ const read = try c.send(.{ .read = .{ .fid = status, .offset = 0, .count = 4096 } });
+ const first = try c.answer();
+ try expect(first.tag == read and first.result == .read and eh.nowMs() - began < 500);
+ const second = try c.answer();
+ try expect(second.tag == held and second.result == .write);
+ const flushed = try c.send(.{ .write = .{ .fid = ctl, .offset = 0, .data = "Edit , | sleep 5; tr a-z A-Z\n" } });
+ process.sleep(300);
+ const flush = try c.send(.{ .flush = .{ .oldtag = flushed } });
+ const one = (try c.answer()).tag;
+ const two = (try c.answer()).tag;
+ try expect((one == flushed and two == flush) or (one == flush and two == flushed));
+ c.clunk(ctl);
+ c.clunk(status);
+ process.sleep(1000);
+ try c.write(actl, "Edit , | cat\n");
+ process.sleep(4500);
+ try expectEqualStrings("APPLE\nFIG\nPEAR\n", try c.read(ar, abody));
+ // X: each open file whose line matches; w writes it.
+ try c.write(actl, "Edit X/b\\.txt$/ ,s/apple/APPLE/\n");
+ try expectEqualStrings("APPLE pie\n", try c.read(ar, f.at("/pane/{d}/body", .{b})));
+ try c.write(f.at("/pane/{d}/ctl", .{b}), "Edit w\n");
+ try expectEqualStrings("APPLE pie\n", try d.get(ar, "b.txt"));
+ try c.write(actl, "Edit 1 w first.txt\n");
+ try expectEqualStrings("APPLE\n", try d.get(ar, "first.txt"));
+ // A file changed on disk under unsaved edits: Edit's w refuses once, as
+ // Save does, and the next w overwrites it.
+ try d.put("w1.txt", "one\n");
+ const w = try c.look(ar, f.at("{s}/w1.txt", .{root}), null);
+ const wctl = f.at("/pane/{d}/ctl", .{w});
+ try c.write(wctl, "Edit $a/two/\n");
+ const changed = f.at("\nchanged {d}", .{w});
+ const seen = std.mem.count(u8, try c.read(ar, "/log"), changed);
+ try eh.appendFile(try std.fmt.allocPrintSentinel(ar, "{s}/w1.txt", .{root}, 0), "external\n");
+ const deadline = eh.nowMs() + 10_000;
+ while (std.mem.count(u8, try c.read(ar, "/log"), changed) == seen) {
+ if (eh.nowMs() > deadline) return error.NeverHeard;
+ process.sleep(50);
+ }
+ try refusedSaying(c, wctl, "Edit w\n", "modified on disk since read (w again to overwrite)");
+ try expectEqualStrings("one\nexternal\n", try d.get(ar, "w1.txt"));
+ try c.write(wctl, "Edit w\n");
+ try expectEqualStrings("one\ntwo", try d.get(ar, "w1.txt"));
+}
diff --git a/test/process/flags.zig b/test/process/flags.zig
new file mode 100644
index 00000000..fffc2867
--- /dev/null
+++ b/test/process/flags.zig
@@ -0,0 +1,780 @@
+//! docs/typ/reference.typ, Flags <flags>: a real pardes launched with
+//! them, inside a session and out (test/fs.py's inline checks).
+const std = @import("std");
+const libc = std.c;
+const process = @import("../process.zig");
+const Conn = process.Conn;
+const Child = process.Child;
+
+pub const cases = .{
+ .{ "flags: a bad option, socket name, dial or mount is refused in words, exit 1", refusals },
+ .{ "flags: --9p=<name> names the socket, not --detach's name", explicitName },
+ .{ "flags: a launch inside a session forwards its file there, refuses what it cannot, and one with flags of a session's own starts its own", forwarding },
+ .{ "flags: --wait lasts until its pane goes; a forwarded name is opened, made or refused in words; pardes - pages stdin into a +Pager", waitAndPager },
+ .{ "flags: a command from a pane's tag gets $winid, one from the workspace's tag none", winid },
+ .{ "flags: pardes - outside a session boots on stdin's +Pager; a launch with no terminal to draw on says so", outside },
+ .{ "flags: a tty editor killed by SIGTERM or SIGHUP puts its terminal back and its socket goes; a dead editor's socket is swept", killedTty },
+ .{ "flags: a detached session told to stop by a signal unlinks its socket; a hangup does not stop it", signalCleansUp },
+};
+
+extern "c" fn realpath(path: [*:0]const u8, resolved: [*]u8) ?[*:0]const u8;
+
+const long_name: [:0]const u8 = blk: {
+ var name: [304:0]u8 = @splat('x');
+ @memcpy(name[300..], ".txt");
+ const done = name;
+ break :blk &done;
+};
+
+const has = process.has;
+const check = process.check;
+
+fn z(a: std.mem.Allocator, comptime fmt: []const u8, args: anytype) [:0]const u8 {
+ return std.fmt.allocPrintSentinel(a, fmt, args, 0) catch @panic("out of memory");
+}
+
+fn contains(set: []const u32, n: u32) bool {
+ return std.mem.indexOfScalar(u32, set, n) != null;
+}
+
+/// The serials in `after` not in `before`.
+fn added(a: std.mem.Allocator, before: []const u32, after: []const u32) []const u32 {
+ var out: std.ArrayList(u32) = .empty;
+ for (after) |n| if (!contains(before, n)) out.append(a, n) catch @panic("out of memory");
+ return out.items;
+}
+
+/// The one pane made since `before`.
+fn madeOne(a: std.mem.Allocator, c: *Conn, before: []const u32) !u32 {
+ const new = added(a, before, try c.serials(a));
+ try check(new.len == 1, "made {any}, not one pane", .{new});
+ return new[0];
+}
+
+fn same(a: []const u32, b: []const u32) bool {
+ return std.mem.eql(u32, a, b);
+}
+
+/// The session's pid, from /status.
+fn statusPid(a: std.mem.Allocator, c: *Conn) ![:0]const u8 {
+ var lines = std.mem.tokenizeScalar(u8, try c.read(a, "/status"), '\n');
+ while (lines.next()) |line| if (std.mem.startsWith(u8, line, "pid ")) return z(a, "{s}", .{line[4..]});
+ return error.NoPid;
+}
+
+/// Waits up to `ms` for the session's log to hold `text`.
+fn waitLog(a: std.mem.Allocator, c: *Conn, text: []const u8, ms: i64) !void {
+ const deadline = process.nowMs() + ms;
+ while (!has(try c.read(a, "/log"), text)) {
+ if (process.nowMs() > deadline) {
+ std.debug.print("not in the log: {s}\n", .{text});
+ return error.Timeout;
+ }
+ process.nap(20);
+ }
+}
+
+fn isSocketName(name: []const u8) bool {
+ return std.mem.startsWith(u8, name, "pardes-9p-") and std.mem.endsWith(u8, name, ".sock");
+}
+
+/// The socket a launched session made in `root`, none of `existing`: one
+/// named by its pid, as fs.py's glob found it.
+fn newSocket(a: std.mem.Allocator, root: []const u8, existing: []const []const u8, child: *Child) ![]const u8 {
+ const deadline = process.nowMs() + 10_000;
+ while (true) {
+ for (try process.entries(a, root)) |name| {
+ if (!isSocketName(name)) continue;
+ for (existing) |old| {
+ if (std.mem.eql(u8, old, name)) break;
+ } else return std.fmt.allocPrint(a, "{s}/{s}", .{ root, name });
+ }
+ if (child.wait(0)) |status| {
+ std.debug.print("exited {d} before its socket: {s}\n", .{ status, child.said(a) catch "" });
+ return error.Exited;
+ }
+ if (process.nowMs() > deadline) return error.NoSocket;
+ process.nap(5);
+ }
+}
+
+fn refusals(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const Row = struct { []const [:0]const u8, []const u8 };
+ for ([_]Row{
+ .{ &.{"--fs"}, "no such option" },
+ .{ &.{"--fs9"}, "no such option" },
+ .{ &.{ "--", "a", "b" }, "is the second" },
+ .{ &.{"--9p"}, "--9p needs a socket name" },
+ .{ &.{"--9p="}, "invalid 9P socket name" },
+ .{ &.{"--9p=a/b"}, "invalid 9P socket name" },
+ .{ &.{ "--attach=work", "--9p=work" }, "--attach has none" },
+ .{ &.{"--9p-tcp"}, "--9p-tcp needs" },
+ .{ &.{"--9p-tcp="}, "--9p-tcp needs" },
+ .{ &.{"--9p-tcp=tcp!localhost!5640"}, "--9p-tcp needs" },
+ .{ &.{"--9p-tcp=quic!127.0.0.1!5640"}, "--9p-tcp needs" },
+ .{ &.{ "--9p-tcp=tcp!127.0.0.1!5640", "--9p-tcp=tcp!127.0.0.1!5641" }, "specified twice" },
+ .{ &.{ "--attach=work", "--9p-tcp=tcp!127.0.0.1!5640" }, "--attach has none" },
+ .{ &.{"--9p-quic"}, "--9p-quic needs" },
+ .{ &.{"--9p-quic="}, "--9p-quic needs" },
+ .{ &.{"--9p-quic=tcp!127.0.0.1!5640"}, "--9p-quic needs" },
+ .{ &.{"--mount=os=work"}, "invalid mount name" },
+ .{ &.{"--mount=peer="}, "invalid mount name or dial" },
+ .{ &.{ "--mount=peer=one", "--mount=peer=two" }, "duplicate mount" },
+ .{ &.{"--mount=peer=tcp!127.0.0.1!0"}, "invalid mount dial" },
+ .{ &.{ "--attach=work", "--mount=peer=one" }, "--attach has none" },
+ }) |row| {
+ var argv: [4][:0]const u8 = undefined;
+ argv[0] = exe;
+ for (row[0], 1..) |arg, i| argv[i] = arg;
+ const r = try process.run(a, argv[0 .. 1 + row[0].len], .{});
+ try check(r.code == 1 and has(r.said, row[1]), "{any}: exit {d}: {s}", .{ row[0], r.code, r.said });
+ }
+}
+
+fn explicitName(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var d = try process.Detached.start(gpa, exe, "renamed", .{ .args = &.{"--9p=explicit"}, .socket = "explicit" });
+ defer d.deinit();
+ try std.testing.expect(d.exists("pardes-9p-explicit.sock"));
+ try std.testing.expect(!d.exists("pardes-9p-renamed.sock"));
+ try d.files.expect("/pane/1/body", "initial\n");
+}
+
+fn forwarding(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var d = try process.Detached.start(gpa, exe, "forwarding", .{});
+ defer d.deinit();
+ const c = try Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const address = d.abs("pardes-9p-forwarding.sock");
+ _ = libc.mkdir(d.abs("child-working-directory"), 0o755);
+ const child_dir = d.abs("child-working-directory");
+ const spaced_text = "first line\nsecond line\n";
+ try d.put("child-working-directory/space name.txt", spaced_text);
+ const spaced = d.abs("child-working-directory/space name.txt");
+ // PARDES_PID says "you are inside a pardes"; the socket and the pane
+ // only say how to reach it.
+ const pid = try statusPid(a, c);
+ const inherited = [_][2][:0]const u8{ .{ "PARDES_9P", address }, .{ "PARDES_PANE", "1" }, .{ "PARDES_PID", pid } };
+ const opts: Child.Options = .{ .root = d.root(), .cwd = child_dir, .env = &inherited };
+ var opened: u32 = 0;
+ const Word = struct { [:0]const u8, []const u8, ?[2]u32, bool };
+ for ([_]Word{
+ .{ "space name.txt:2:4", spaced_text, .{ 14, 14 }, false },
+ .{ "/n/self/pane/1/body", "initial\n", null, false },
+ .{ "/virtual/pane/1/body:1:2-4", "initial\n", .{ 1, 4 }, true },
+ }) |row| {
+ const before = try c.serials(a);
+ const r = try process.run(a, &.{ exe, "--tty", row[0] }, opts);
+ try check(r.code == 0, "{s}: exit {d}: {s}", .{ row[0], r.code, r.said });
+ if (row[3]) {
+ try check(same(before, try c.serials(a)), "{s} made a pane", .{row[0]});
+ } else opened = try madeOne(a, c, before);
+ try std.testing.expectEqualStrings(row[1], try c.pane(a, opened, "body"));
+ try std.testing.expectEqualStrings("initial\n", try c.read(a, "/pane/1/body"));
+ // The selection is dot; reading it takes no command at all.
+ if (row[2]) |sel| {
+ var it = std.mem.tokenizeScalar(u8, try c.pane(a, opened, "dot"), ' ');
+ const got = [2]u32{ try std.fmt.parseInt(u32, it.next().?, 10), try std.fmt.parseInt(u32, std.mem.trim(u8, it.next().?, " \n"), 10) };
+ try check(std.mem.eql(u32, &got, &sel), "{s}: dot {any}, not {any}", .{ row[0], got, sel });
+ }
+ }
+ // A launch with no file inside a session is refused, and never clears
+ // the address limit its parent's pane holds.
+ const addr = try c.hold("/pane/1/addr", 2);
+ const limit = try c.hold("/pane/1/limit", 2);
+ _ = try c.writeFid(addr, 0, "#0,#3");
+ _ = try c.writeFid(limit, 0, "#0,#3");
+ _ = try c.writeFid(addr, 0, "#0");
+ for (0..8) |_| {
+ const r = try process.run(a, &.{exe}, opts);
+ try check(r.code == 1 and has(r.said, "already inside pardes"), "no-argument child: exit {d}: {s}", .{ r.code, r.said });
+ if (c.writeFid(addr, 0, "/tial/")) |_| {
+ return error.LimitCleared;
+ } else |_| {}
+ }
+ c.clunk(addr);
+ c.clunk(limit);
+ _ = try c.read(a, "/pane/1/ctl");
+
+ const control = try c.newPane();
+ try c.exec(control, "Dump\n");
+ const deadline = process.nowMs() + 3_000;
+ while (!d.exists("forwarding.dump.zon")) {
+ if (process.nowMs() > deadline) return error.NoDump;
+ process.nap(5);
+ }
+ const saved = d.abs("forwarding.dump.zon");
+ const before = try c.read(a, "/index");
+ // Flags of a session's own start one, never forwarded.
+ const Launch = struct { []const u8, []const [:0]const u8, ?[]const u8 };
+ for ([_]Launch{
+ .{ "mount", &.{ "--tty", z(a, "--mount=peer={s}", .{address}), "/n/peer/pane/1/body" }, null },
+ .{ "name", &.{ "--tty", "--9p=forwarded-name" }, "forwarded-name" },
+ .{ "tcp", &.{ "--tty", "--9p-tcp=tcp!127.0.0.1!0" }, null },
+ .{ "load", &.{ "--tty", "-l", saved }, null },
+ .{ "shells", &.{ "-n", "3" }, null },
+ .{ "toggle", &.{ "--tty", "--tty-toggle=q" }, null },
+ .{ "toggle-arg", &.{ "--tty", "--tty-toggle", "q" }, null },
+ .{ "quic", &.{ "--tty", "--9p-quic=quic!127.0.0.1!0" }, null },
+ }) |row| {
+ if (std.mem.eql(u8, row[0], "quic") and !try process.quicIncluded(a, exe)) continue;
+ var argv: [8][:0]const u8 = undefined;
+ argv[0] = exe;
+ for (row[1], 1..) |arg, i| argv[i] = arg;
+ const existing = try process.entries(a, d.root());
+ var child = try Child.spawn(argv[0 .. 1 + row[1].len], .{ .root = d.root(), .env = &inherited, .pty = .{ .log = d.abs(try std.fmt.allocPrint(a, "forward-{s}.pty", .{row[0]})) } });
+ defer child.deinit();
+ const sock = if (row[2]) |name| blk: {
+ const p = try std.fmt.allocPrint(a, "{s}/pardes-9p-{s}.sock", .{ d.root(), name });
+ try child.waitPath(p, 10_000);
+ break :blk p;
+ } else try newSocket(a, d.root(), existing, &child);
+ try check(!std.mem.eql(u8, sock, address), "{s} forwarded", .{row[0]});
+ var local: process.Files = .init(gpa, sock);
+ defer local.deinit();
+ const index = try local.read("/index");
+ const rows = std.mem.count(u8, index, "\n");
+ if (std.mem.eql(u8, row[0], "mount")) {
+ try check(rows == 1 and has(index, "/n/peer/"), "mount: {s}", .{index});
+ try local.expect("/pane/1/body", "initial\n");
+ } else if (std.mem.eql(u8, row[0], "load")) {
+ try std.testing.expectEqualStrings(before, index);
+ try local.expect("/pane/1/body", "initial\n");
+ } else {
+ // A bare tty launch is a shell plus the empty text pane the
+ // boot puts under it; --shells=3 is three shells, no scratch.
+ try check(rows == @as(usize, if (std.mem.eql(u8, row[0], "shells")) 3 else 2), "{s}: {s}", .{ row[0], index });
+ }
+ if (std.mem.eql(u8, row[0], "tcp") or std.mem.eql(u8, row[0], "quic"))
+ try check(has(try local.read("/listeners"), try std.fmt.allocPrint(a, "{s}!127.0.0.1!", .{row[0]})), "{s}: no listener", .{row[0]});
+ try std.testing.expectEqualStrings(before, try c.read(a, "/index"));
+ try std.testing.expectEqualStrings("initial\n", try c.read(a, "/pane/1/body"));
+ }
+
+ // A session that answers takes the file or says why, as acme's B does:
+ // a pane it has not is its refusal and exit 1, never a nested editor.
+ const gone = try process.run(a, &.{ exe, "--tty", spaced }, .{ .root = d.root(), .env = &.{ inherited[0], .{ "PARDES_PANE", "4294967295" }, inherited[2] } });
+ try check(gone.code == 1 and std.mem.startsWith(u8, gone.said, "pardes: "), "gone pane: exit {d}: {s}", .{ gone.code, gone.said });
+ try std.testing.expectEqualStrings(before, try c.read(a, "/index"));
+ const absent = d.abs("absent.sock");
+ const stale = [_][2][:0]const u8{ .{ "PARDES_9P", absent }, inherited[1], inherited[2] };
+ const Stale = struct { []const u8, []const [2][:0]const u8, ?[:0]const u8 };
+ for ([_]Stale{
+ .{ "stale-file", &stale, spaced },
+ .{ "stale-missing", &stale, "missing-child-file.txt" },
+ .{ "stale-noarg", &stale, null },
+ // No pid is "not inside a pardes at all", as a plain shell has.
+ .{ "not-nested", inherited[0..2], spaced },
+ }) |row| {
+ const existing = try process.entries(a, d.root());
+ var argv: [3][:0]const u8 = .{ exe, "--tty", undefined };
+ if (row[2]) |w| argv[2] = w;
+ var child = try Child.spawn(argv[0..if (row[2] != null) 3 else 2], .{ .root = d.root(), .env = row[1], .pty = .{ .log = d.abs(try std.fmt.allocPrint(a, "{s}.pty", .{row[0]})) } });
+ defer child.deinit();
+ const sock = try newSocket(a, d.root(), existing, &child);
+ try check(!std.mem.eql(u8, sock, address), "{s} forwarded", .{row[0]});
+ var local: process.Files = .init(gpa, sock);
+ defer local.deinit();
+ if (row[2]) |w| {
+ if (std.mem.eql(u8, w, spaced)) {
+ try local.expect("/pane/1/body", spaced_text);
+ } else try check(has(try local.read("/index"), w) or has(try local.screen(), w), "{s}: {s} not shown", .{ row[0], w });
+ }
+ try std.testing.expectEqualStrings(before, try c.read(a, "/index"));
+ }
+}
+
+/// `pardes <flag> <file>` started, back once it has made a pane or exited.
+fn launch(a: std.mem.Allocator, c: *Conn, argv: []const [:0]const u8, opts: Child.Options) !Child {
+ const before = try c.serials(a);
+ var child = try Child.spawn(argv, opts);
+ const deadline = process.nowMs() + 3_000;
+ while (child.wait(0) == null and same(before, try c.serials(a)) and process.nowMs() < deadline) process.nap(10);
+ return child;
+}
+
+fn running(a: std.mem.Allocator, child: *Child) !void {
+ if (child.wait(0)) |status| {
+ std.debug.print("exited {d}: {s}\n", .{ status, child.said(a) catch "" });
+ return error.Exited;
+ }
+}
+
+fn exitsWith(child: *Child, want: c_int, ms: i64) !void {
+ const status = child.wait(ms) orelse return error.StillRunning;
+ try std.testing.expectEqual(want, process.code(status));
+}
+
+fn waitAndPager(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var d = try process.Detached.start(gpa, exe, "wait", .{});
+ var ended = false;
+ defer if (!ended) d.deinit();
+ const c = try Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const root = d.root();
+ // A second --detach of a name a live session holds: said, exit 1, no
+ // Zig error trace.
+ const second_detach = try process.run(a, &.{ exe, "--detach=wait" }, .{ .root = root });
+ try std.testing.expectEqual(@as(c_int, 1), second_detach.code);
+ try std.testing.expectEqualStrings("pardes: a session named wait is already running\n", second_detach.said);
+ const address = d.abs("pardes-9p-wait.sock");
+ const env = [_][2][:0]const u8{ .{ "PARDES_9P", address }, .{ "PARDES_PANE", "1" }, .{ "PARDES_PID", try statusPid(a, c) } };
+ const opts: Child.Options = .{ .root = root, .env = &env };
+ try d.put("wait edit.txt", "edit me\n");
+ const edited = d.abs("wait edit.txt");
+
+ // --wait (acme's E): a launch inside a pane lasts until the pane it
+ // opened is deleted; one on a file already open waits on that pane.
+ var first = try launch(a, c, &.{ exe, "--wait", edited }, opts);
+ defer first.deinit();
+ const opened = blk: {
+ const now = try c.serials(a);
+ try check(now.len == 2 and now[0] == 1, "--wait: {any}", .{now});
+ break :blk now[1];
+ };
+ var second = try launch(a, c, &.{ exe, "-w", edited }, opts);
+ defer second.deinit();
+ process.nap(500);
+ try running(a, &first);
+ try running(a, &second);
+ try check(same(try c.serials(a), &.{ 1, opened }), "-w made a pane", .{});
+ try c.replace(try std.fmt.allocPrint(a, "/pane/{d}/body", .{opened}), "edited\n");
+ try c.exec(opened, "Save\n");
+ try c.removePane(opened);
+ const deleted = process.nowMs();
+ try exitsWith(&first, 0, 5_000);
+ // Woken by the `del` record, not a poll.
+ try check(process.nowMs() - deleted < 50, "--wait woke {d} ms after the del", .{process.nowMs() - deleted});
+ try exitsWith(&second, 0, 5_000);
+ try std.testing.expectEqualStrings("edited\n", try d.get(a, "wait edit.txt"));
+
+ // --wait from outside the session's panes, $PARDES_9P alone (an
+ // agent's EDITOR): asked of the session, not a screen of its own.
+ const outside_env = env[0..1];
+ try d.put("wait far.txt", "far\n");
+ const far = d.abs("wait far.txt");
+ {
+ const before = try c.serials(a);
+ var waiting = try Child.spawn(&.{ exe, "--wait", far }, .{ .root = root, .env = outside_env });
+ defer waiting.deinit();
+ const deadline = process.nowMs() + 5_000;
+ while (same(before, try c.serials(a)) and process.nowMs() < deadline) process.nap(10);
+ const far_pane = try madeOne(a, c, before);
+ process.nap(300);
+ try running(a, &waiting);
+ try c.removePane(far_pane);
+ try exitsWith(&waiting, 0, 5_000);
+ }
+ // --wait with a $PARDES_9P that answers no more: said, exit 1.
+ const dead = try process.run(a, &.{ exe, "--wait", far }, .{ .root = root, .env = &.{.{ "PARDES_9P", d.abs("pardes-9p-gone.sock") }} });
+ try check(dead.code == 1 and has(dead.said, "does not answer"), "dead: exit {d}: {s}", .{ dead.code, dead.said });
+ // --wait with no FILE says it needs one, and waits on nothing.
+ const bare = try process.run(a, &.{ exe, "--wait" }, opts);
+ try check(bare.code == 1 and has(bare.said, "--wait needs a FILE"), "bare: exit {d}: {s}", .{ bare.code, bare.said });
+ // `--` ends the options: a name starting with a dash is a name.
+ try d.put("-dash.txt", "dash\n");
+ {
+ const before = try c.serials(a);
+ const r = try process.run(a, &.{ exe, "--", "-dash.txt" }, opts);
+ try check(r.code == 0, "--: exit {d}: {s}", .{ r.code, r.said });
+ const dashed = try madeOne(a, c, before);
+ try std.testing.expectEqualStrings(d.abs("-dash.txt"), std.mem.trimEnd(u8, try c.pane(a, dashed, "name"), "\n"));
+ try c.removePane(dashed);
+ }
+ // A name under a directory that may not be searched is refused,
+ // permission denied, exit 1, no pane. (Root searches any directory.)
+ if (libc.geteuid() != 0) {
+ _ = libc.mkdir(d.abs("noperm"), 0);
+ const before = try c.serials(a);
+ const denied = process.run(a, &.{ exe, "noperm/a/b/c" }, opts);
+ _ = libc.chmod(d.abs("noperm"), 0o755);
+ const r = try denied;
+ try check(r.code == 1 and has(r.said, "permission denied"), "noperm: exit {d}: {s}", .{ r.code, r.said });
+ try check(same(before, try c.serials(a)), "noperm made a pane", .{});
+ }
+ // --wait waits on the pane its look answered: a name /index shows
+ // escaped (a backslash is `\\` there) is still the pane waited on.
+ try d.put("wait\\odd.txt", "odd\n");
+ {
+ const before = try c.serials(a);
+ var waiting = try launch(a, c, &.{ exe, "--wait", d.abs("wait\\odd.txt") }, opts);
+ defer waiting.deinit();
+ const odd_pane = try madeOne(a, c, before);
+ process.nap(500);
+ try running(a, &waiting);
+ try c.removePane(odd_pane);
+ try exitsWith(&waiting, 0, 5_000);
+ }
+ // A name not there yet opens a pane named it, as acme's B does, and
+ // Save creates it: git's and fish's temporary files are.
+ {
+ const before = try c.serials(a);
+ var made = try Child.spawn(&.{ exe, "--wait", "wait new.txt" }, opts);
+ defer made.deinit();
+ // The launch makes the pane, then names it: wait for the name.
+ const deadline = process.nowMs() + 3_000;
+ while (!has(try c.read(a, "/index"), d.abs("wait new.txt"))) {
+ try running(a, &made);
+ if (process.nowMs() > deadline) return error.NoPaneNamed;
+ process.nap(10);
+ }
+ const named = try madeOne(a, c, before);
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/body", .{named}), "new\n");
+ try c.exec(named, "Save\n");
+ try c.removePane(named);
+ try exitsWith(&made, 0, 5_000);
+ try std.testing.expectEqualStrings("new\n", try d.get(a, "wait new.txt"));
+ }
+ // ...in a directory not there either: forwarded all the same, and Save
+ // makes the directories.
+ {
+ const before = try c.serials(a);
+ const r = try process.run(a, &.{ exe, "wait-missing/sub/new.txt" }, opts);
+ try check(r.code == 0, "deep: exit {d}: {s}", .{ r.code, r.said });
+ const deadline = process.nowMs() + 3_000;
+ while (!has(try c.read(a, "/index"), d.abs("wait-missing/sub/new.txt"))) {
+ if (process.nowMs() > deadline) return error.NoPaneNamed;
+ process.nap(10);
+ }
+ const named = try madeOne(a, c, before);
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/body", .{named}), "deep\n");
+ try c.exec(named, "Save\n");
+ try c.removePane(named);
+ try std.testing.expectEqualStrings("deep\n", try d.get(a, "wait-missing/sub/new.txt"));
+ }
+ // `pardes '~/x'`, quoted so the shell left the `~`: the launching
+ // shell's HOME all the same.
+ {
+ const before = try c.serials(a);
+ const r = try process.run(a, &.{ exe, "~/fwd-tilde.txt" }, opts);
+ try check(r.code == 0, "tilde: exit {d}: {s}", .{ r.code, r.said });
+ try check(has(try c.read(a, "/index"), d.abs("fwd-tilde.txt")), "no ~ pane", .{});
+ for (added(a, before, try c.serials(a))) |n| try c.removePane(n);
+ }
+ // A name the session refuses: its reason and exit 1, no pane left.
+ const before = try c.serials(a);
+ {
+ const r = try process.run(a, &.{ exe, long_name }, opts);
+ try check(r.code == 1 and has(r.said, "a component over 255 bytes"), "long: exit {d}: {s}", .{ r.code, r.said });
+ try check(same(before, try c.serials(a)), "a long name made a pane", .{});
+ }
+ // `pardes -` (a terminal's PAGER): stdin, its escapes stripped, in a
+ // +Pager pane of the session, clean, and back at once.
+ const pager_name = try std.fmt.allocPrint(a, "{s}/+Pager\n", .{root});
+ const made_now = blk: {
+ const r = try process.run(a, &.{ exe, "-" }, .{ .root = root, .env = &env, .stdin = "\x1b[1mbold\x1b[0m text\n" });
+ try check(r.code == 0, "pager: exit {d}: {s}", .{ r.code, r.said });
+ break :blk try madeOne(a, c, before);
+ };
+ try std.testing.expectEqualStrings(pager_name, try c.pane(a, made_now, "name"));
+ try std.testing.expectEqualStrings("bold text\n", try c.pane(a, made_now, "body"));
+ {
+ var rows = std.mem.tokenizeScalar(u8, try c.read(a, "/index"), '\n');
+ const row = while (rows.next()) |r| {
+ if (std.mem.startsWith(u8, r, try std.fmt.allocPrint(a, "{d} ", .{made_now}))) break r;
+ } else return error.NotListed;
+ var words = std.mem.tokenizeScalar(u8, row, ' ');
+ _ = words.next();
+ _ = words.next();
+ try check(std.mem.eql(u8, words.next().?, "0"), "a +Pager is dirty: {s}", .{row}); // clean: nothing to ask at Exit
+ // Its `new` record names it as it is: no +New and a rename.
+ const log = try std.fmt.allocPrint(a, "\n{s}", .{try c.read(a, "/log")});
+ try check(has(log, try std.fmt.allocPrint(a, "\nnew {d} {s}/+Pager\n", .{ made_now, root })), "no new record: {s}", .{log});
+ try check(!has(log, try std.fmt.allocPrint(a, "\nrename {d} ", .{made_now})), "a +Pager renamed", .{});
+ }
+ // Its colours are the pane's, drawn and never read: mapped through the
+ // theme, as a terminal's are; Filter shows them as sent. Each run is its
+ // own +Pager; one there already keeps its page.
+ const coloured = blk: {
+ const r = try process.run(a, &.{ exe, "-" }, .{ .root = root, .env = &env, .stdin = "\x1b]0;title\x07\x1b[31mred\x1b[m \x1b[38;2;1;2;3mrgb\x1b[m plain\n" });
+ try check(r.code == 0, "colours: exit {d}: {s}", .{ r.code, r.said });
+ const new = added(a, before, try c.serials(a));
+ try check(new.len == 2 and new[0] == made_now, "colours: {any}", .{new});
+ break :blk new[1];
+ };
+ try std.testing.expectEqualStrings(pager_name, try c.pane(a, coloured, "name"));
+ try std.testing.expectEqualStrings("red rgb plain\n", try c.pane(a, coloured, "body"));
+ try std.testing.expectEqualStrings("bold text\n", try c.pane(a, made_now, "body"));
+ const rgb = "{\"rgb\":[1,2,3]}";
+ {
+ const ink = try inks(&d.files);
+ try check(!std.mem.eql(u8, ink[0], ink[2]) and !std.mem.eql(u8, ink[1], rgb), "drawn inks {s} {s} {s}", .{ ink[0], ink[1], ink[2] });
+ }
+ try c.exec(coloured, "Filter\n");
+ {
+ const ink = try inks(&d.files);
+ try std.testing.expectEqualStrings(rgb, ink[1]);
+ try check(!std.mem.eql(u8, ink[0], ink[2]) and !std.mem.eql(u8, ink[0], ink[1]), "filtered inks {s} {s} {s}", .{ ink[0], ink[1], ink[2] });
+ }
+ // A progress line keeps its last state.
+ const again = blk: {
+ const r = try process.run(a, &.{ exe, "-" }, .{ .root = root, .env = &env, .stdin = "again\r\nprogress 10%\rprogress 100%\n" });
+ try check(r.code == 0, "progress: exit {d}: {s}", .{ r.code, r.said });
+ const new = added(a, before, try c.serials(a));
+ try check(new.len == 3, "progress: {any}", .{new});
+ break :blk new[2];
+ };
+ try std.testing.expectEqualStrings("again\nprogress 100%\n", try c.pane(a, again, "body"));
+ for ([_]u32{ made_now, coloured, again }) |n| try c.removePane(n);
+ // More than one 8 MiB write's worth arrives whole, byte for byte.
+ {
+ var big: std.ArrayList(u8) = .empty;
+ defer big.deinit(gpa);
+ for (0..400_000) |i| try big.print(gpa, "line {d:0>8} of the paged text\n", .{i}); // ~11 MiB
+ try std.testing.expect(big.items.len > 8 * 1024 * 1024);
+ const r = try process.run(a, &.{ exe, "-" }, .{ .root = root, .env = &env, .stdin = big.items });
+ try check(r.code == 0, "big: exit {d}: {s}", .{ r.code, r.said });
+ const big_pane = try madeOne(a, c, before);
+ const got = try c.read(gpa, try std.fmt.allocPrint(a, "/pane/{d}/body", .{big_pane}));
+ defer gpa.free(got);
+ try check(std.mem.eql(u8, got, big.items), "the paged body is not the text", .{});
+ // Past the 256 MiB cap: the first 256 MiB, then the cut note.
+ const cap = 256 * 1024 * 1024;
+ var exe_buf: [4096]u8 = undefined;
+ const huge = try process.run(a, &.{ "sh", "-c", z(a, "yes 0123456789abcdef | head -c {d} | \"$0\" -", .{cap + 4096}), std.mem.span(realpath(exe, &exe_buf) orelse return error.NoBinary) }, .{ .root = root, .env = &env });
+ try check(huge.code == 0, "huge: exit {d}: {s}", .{ huge.code, huge.said });
+ try c.removePane(big_pane);
+ }
+ {
+ const cap = 256 * 1024 * 1024;
+ const big_pane = try madeOne(a, c, before);
+ const got = try c.read(gpa, try std.fmt.allocPrint(a, "/pane/{d}/body", .{big_pane}));
+ defer gpa.free(got);
+ const note = "\n[pardes: the rest of stdin is cut: a pane holds at most a file's limit]\n";
+ try check(std.mem.endsWith(u8, got, note) and got.len == cap + note.len, "huge: {d} bytes", .{got.len});
+ const line = "0123456789abcdef\n";
+ var i: usize = 0;
+ while (i < cap) : (i += line.len) {
+ const n = @min(line.len, cap - i);
+ if (!std.mem.eql(u8, got[i..][0..n], line[0..n])) return error.NotTheText;
+ }
+ try c.removePane(big_pane);
+ }
+ // From a directory whose name could not be a ctl line: the session's
+ // directory's +Pager, the text whole, no stray +New.
+ _ = libc.mkdir(d.abs("two\nlines"), 0o755);
+ {
+ const r = try process.run(a, &.{ exe, "-" }, .{ .root = root, .cwd = d.abs("two\nlines"), .env = &env, .stdin = "odd dir text\n" });
+ try check(r.code == 0, "odd dir: exit {d}: {s}", .{ r.code, r.said });
+ const odd_pane = try madeOne(a, c, before);
+ try std.testing.expectEqualStrings(pager_name, try c.pane(a, odd_pane, "name"));
+ try std.testing.expectEqualStrings("odd dir text\n", try c.pane(a, odd_pane, "body"));
+ try c.removePane(odd_pane);
+ }
+ // Nothing on stdin: no pane, and done.
+ {
+ const r = try process.run(a, &.{ exe, "-" }, .{ .root = root, .env = &env, .stdin = "" });
+ try check(r.code == 0 and same(before, try c.serials(a)), "empty stdin: exit {d}: {s}", .{ r.code, r.said });
+ }
+ // A new name in a directory there but not writable: refused now, not a
+ // pane that only fails at Save. (Root writes anywhere.)
+ _ = libc.mkdir(d.abs("shut-dir"), 0o500);
+ if (libc.geteuid() != 0) {
+ const r = try process.run(a, &.{ exe, "shut-dir/new.txt" }, opts);
+ try check(r.code == 1 and has(r.said, "may not be read or written"), "shut-dir: exit {d}: {s}", .{ r.code, r.said });
+ try check(same(before, try c.serials(a)), "shut-dir made a pane", .{});
+ }
+ _ = libc.chmod(d.abs("shut-dir"), 0o755);
+ // A pane address the session has not is refused in words, exit 1, no
+ // pane made for a file of that name; one it has is looked at. A name
+ // with a newline is said in words, not an error name.
+ for ([_][2][:0]const u8{
+ .{ "@p999:1", "pardes: @p999:1: this session has no such pane" },
+ .{ "two\nlines.txt", "pardes: two\\nlines.txt: a file name is one line" },
+ }) |row| {
+ const r = try process.run(a, &.{ exe, row[0] }, opts);
+ try check(r.code == 1 and has(r.said, row[1]), "{s}: exit {d}: {s}", .{ row[0], r.code, r.said });
+ try check(!has(r.said, "NotOneLine") and !has(r.said, "NoSuchPane"), "an error name: {s}", .{r.said});
+ try check(same(before, try c.serials(a)), "{s} made a pane", .{row[0]});
+ }
+ const looked = try process.run(a, &.{ exe, "@p1:1" }, opts);
+ try check(looked.code == 0, "@p1:1: exit {d}: {s}", .{ looked.code, looked.said });
+ try check(same(before, try c.serials(a)), "@p1:1 made a pane", .{});
+ // A session that goes away ends a --wait on it with 1.
+ var orphan = try launch(a, c, &.{ exe, "--wait", edited }, opts);
+ defer orphan.deinit();
+ try running(a, &orphan);
+ d.deinit();
+ ended = true;
+ try exitsWith(&orphan, 1, 5_000);
+}
+
+/// The inks of `red rgb plain`'s three words, as /screen draws them.
+fn inks(f: *process.Files) ![3][]const u8 {
+ const col, const row = try f.where("red rgb plain");
+ return .{ try f.fg(col, row), try f.fg(col + 4, row), try f.fg(col + 8, row) };
+}
+
+fn winid(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var d = try process.Detached.start(gpa, exe, "winid", .{});
+ defer d.deinit();
+ const c = try Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const first = std.mem.min(u32, try c.serials(a));
+ try check(has(try commandBody(a, c, try std.fmt.allocPrint(a, "/pane/{d}/tagexec", .{first})), try std.fmt.allocPrint(a, "winid={d}\n", .{first})), "a pane's tag: no $winid", .{});
+ try check(has(try commandBody(a, c, "/tagexec"), "winid=\n"), "the workspace's tag: a $winid", .{});
+}
+
+/// What `echo winid=$winid` written to `node` printed, its pane removed.
+fn commandBody(a: std.mem.Allocator, c: *Conn, node: []const u8) ![]const u8 {
+ try c.write(node, "echo winid=$winid\n");
+ var words = std.mem.tokenizeAny(u8, try c.read(a, node), " \n");
+ var last: []const u8 = "";
+ while (words.next()) |w| last = w;
+ const serial = try std.fmt.parseInt(u32, last, 10);
+ const deadline = process.nowMs() + 10_000;
+ while (true) {
+ const log = try c.read(a, "/log");
+ if (std.mem.lastIndexOf(u8, log, try std.fmt.allocPrint(a, "\nrun {d} ", .{serial}))) |ran| {
+ if (has(log[ran..], try std.fmt.allocPrint(a, "\nexit {d} ", .{serial}))) {
+ const body = try c.pane(a, serial, "body");
+ var parts = std.mem.splitSequence(u8, body, "% echo winid");
+ var tail: []const u8 = "";
+ while (parts.next()) |p| tail = p;
+ try c.removePane(serial);
+ return tail;
+ }
+ }
+ if (process.nowMs() > deadline) return error.NeverExited;
+ process.nap(50);
+ }
+}
+
+fn outside(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ // A session for its root alone.
+ var d = try process.Detached.start(gpa, exe, "outside", .{});
+ defer d.deinit();
+ // `pardes -` outside a session: an editor whose first pane is a +Pager
+ // of stdin, as `vim -`; here a detached one, to read it.
+ {
+ var boot = try Child.spawn(&.{ exe, "--detach=stdinboot", "-" }, .{ .root = d.root(), .stdin = "\x1b[32mfrom stdin\x1b[m\nsecond\n" });
+ defer boot.deinit();
+ const sock = d.abs("pardes-9p-stdinboot.sock");
+ try boot.waitPath(sock, 10_000);
+ var booted: process.Files = .init(gpa, sock);
+ defer booted.deinit();
+ var first = std.mem.tokenizeScalar(u8, std.mem.sliceTo(try booted.read("/index"), '\n'), ' ');
+ const serial = first.next().?;
+ _ = first.next();
+ _ = first.next();
+ try std.testing.expectEqualStrings(d.abs("+Pager"), first.next().?);
+ try booted.expect(booted.at("/pane/{s}/body", .{serial}), "from stdin\nsecond\n");
+ }
+ // A launch with no terminal to draw on (a pty that is no one's
+ // controlling terminal) says so and exits 1, no error trace.
+ var tty = try Child.spawn(&.{ exe, "--tty", "x.txt" }, .{ .root = d.root(), .pty = .{ .log = d.abs("noctty.pty"), .ctty = false } });
+ defer tty.deinit();
+ const words = try tty.said(a);
+ try exitsWith(&tty, 1, 10_000);
+ try check(has(words, "pardes: no terminal to draw on") and !has(words, ".zig:"), "no terminal: {s}", .{words});
+}
+
+/// A unix socket's file at `path`, bound and closed, as a dead editor
+/// leaves one.
+fn socketFile(path: []const u8) !void {
+ const fd = libc.socket(libc.AF.UNIX, libc.SOCK.STREAM, 0);
+ if (fd < 0) return error.NoSocket;
+ defer _ = libc.close(fd);
+ var addr: libc.sockaddr.un = .{ .path = undefined };
+ @memset(&addr.path, 0);
+ @memcpy(addr.path[0..path.len], path);
+ if (libc.bind(fd, @ptrCast(&addr), @sizeOf(libc.sockaddr.un)) != 0) return error.NoBind;
+}
+
+fn killedTty(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var d = try process.Detached.start(gpa, exe, "killed", .{});
+ defer d.deinit();
+ // Before the deinit, a failure's way out too: else the root comes back.
+ defer daemonGone(&d);
+ // Killed with SIGTERM or SIGHUP, a tty editor puts its terminal back
+ // (main screen, cooked mode) before it dies, and its 9P socket goes
+ // with it. One a dead editor left (no process has its pid) is swept at
+ // the next start; a live pid's, here this test's own, never is.
+ for ([_]libc.SIG{ .TERM, .HUP }) |sig| {
+ const dead = "pardes-9p-2147483647.sock";
+ const live = try std.fmt.allocPrint(a, "pardes-9p-{d}.sock", .{libc.getpid()});
+ for ([_][]const u8{ dead, live }) |name| if (!d.exists(name)) try socketFile(d.abs(name));
+ const existing = try process.entries(a, d.root());
+ const log = d.abs(try std.fmt.allocPrint(a, "killed-{t}.pty", .{sig}));
+ // The daemon's, as a user's editor has: a hangup leaves the session.
+ var killed = try Child.spawn(&.{ exe, "--tty", "x.txt" }, .{ .root = d.root(), .env = &.{.{ "PARDES_DAEMON", "on" }}, .pty = .{ .log = log } });
+ defer killed.deinit();
+ const deadline = process.nowMs() + 10_000;
+ while (!has(d.get(a, std.fs.path.basename(log)) catch "", "\x1b[?1049h")) {
+ if (process.nowMs() > deadline) return error.NeverDrew;
+ process.nap(20);
+ }
+ process.nap(300);
+ // The session's own, named by its pid: forked off the launched
+ // process, which stays as its stub.
+ const own = try newSocket(a, d.root(), existing, &killed);
+ try check(!d.exists(dead), "a dead editor's socket kept", .{});
+ try check(d.exists(live), "a live pid's socket swept", .{});
+ killed.kill(sig);
+ try exitsWith(&killed, -@as(c_int, @intCast(@intFromEnum(sig))), 5_000);
+ const own_z = z(a, "{s}", .{own});
+ if (sig == .HUP) {
+ // A hangup is the terminal's end: the session carries on
+ // detached (the daemon keeps it) until told to end.
+ try check(libc.access(own_z, 0) == 0, "a hangup ended the session", .{});
+ const name = std.fs.path.basename(own);
+ _ = libc.kill(try std.fmt.parseInt(libc.pid_t, name["pardes-9p-".len .. name.len - ".sock".len], 10), .TERM);
+ }
+ const gone_by = process.nowMs() + 5_000;
+ while (libc.access(own_z, 0) == 0 and process.nowMs() < gone_by) process.nap(10);
+ try check(libc.access(own_z, 0) != 0, "{s} left behind", .{own});
+ process.nap(200);
+ const seen = try d.get(a, std.fs.path.basename(log));
+ const tail = seen[std.mem.lastIndexOf(u8, seen, "\x1b[?1049h").?..];
+ try check(has(tail, "\x1b[?1049l"), "the main screen not put back", .{});
+ try check(try process.canonical(killed.slave), "the terminal left raw", .{});
+ daemonGone(&d);
+ }
+}
+
+/// The daemon a session had (PARDES_DAEMON=on) outlives it a little and,
+/// going, makes its runtime directory (the root) again: waited for.
+fn daemonGone(d: *const process.Detached) void {
+ const deadline = process.nowMs() + 5_000;
+ while (d.exists("pardes-daemon.sock") and process.nowMs() < deadline) process.nap(20);
+ process.nap(100);
+}
+
+fn signalCleansUp(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ // A detached session told to stop by a signal unlinks its sockets. A
+ // hangup is a terminal's end, not a session's: the daemon keeps it.
+ for ([_]libc.SIG{ .TERM, .INT, .HUP }) |first| {
+ var d = try process.Detached.start(gpa, exe, "sig", .{ .env = &.{.{ "PARDES_DAEMON", "on" }} });
+ defer d.deinit();
+ defer daemonGone(&d);
+ try std.testing.expect(d.exists("pardes-9p-sig.sock"));
+ var sig = first;
+ if (sig == .HUP) {
+ _ = libc.kill(d.pid, sig);
+ process.nap(300);
+ try check(d.exists("pardes-9p-sig.sock") and (try d.files.read("/index")).len > 0, "a hangup ended a kept session", .{});
+ sig = .TERM;
+ }
+ _ = libc.kill(d.pid, sig);
+ const deadline = process.nowMs() + 5_000;
+ while (d.exists("pardes-9p-sig.sock") and process.nowMs() < deadline) process.nap(10);
+ try check(!d.exists("pardes-9p-sig.sock"), "{t}: the socket left", .{first});
+ }
+}
diff --git a/test/process/look_and_exec.zig b/test/process/look_and_exec.zig
new file mode 100644
index 00000000..2a0266f8
--- /dev/null
+++ b/test/process/look_and_exec.zig
@@ -0,0 +1,239 @@
+//! docs/typ/reference.typ, look and exec <look-and-exec>: one session
+//! driven as the dogfood agents drive it (test/fs.py's workflow_canary).
+const std = @import("std");
+const process = @import("../process.zig");
+const Conn = process.Conn;
+const has = process.has;
+const check = process.check;
+
+pub const cases = .{
+ .{ "look-and-exec: the canary: Look, Grep and Find hit and miss, a word looked at, Edit and Save, get, pty/run, Kill, a REPL send, columns, ask and answer, Dump and Restore, in under 30 s", canary },
+};
+
+const Flow = struct {
+ a: std.mem.Allocator,
+ c: *Conn,
+
+ fn log(f: Flow) ![]const u8 {
+ return f.c.read(f.a, "/log");
+ }
+
+ /// Waits up to 10 s for the log to hold `text`.
+ fn waitLog(f: Flow, text: []const u8) !void {
+ const deadline = process.nowMs() + 10_000;
+ while (!has(try f.log(), text)) {
+ if (process.nowMs() > deadline) {
+ std.debug.print("not in the log: {s}\n", .{text});
+ return error.Timeout;
+ }
+ process.nap(50);
+ }
+ }
+
+ /// The pane an exec at `serial` made, as exec reads it back.
+ fn madeBy(f: Flow, serial: u32, line: []const u8) !u32 {
+ try f.c.exec(serial, line);
+ var words = std.mem.tokenizeAny(u8, try f.c.pane(f.a, serial, "exec"), " \n");
+ var last: []const u8 = "";
+ while (words.next()) |w| last = w;
+ return std.fmt.parseInt(u32, last, 10);
+ }
+
+ /// A line run in terminal `term` through pty/run: its answer.
+ fn run(f: Flow, term: u32, line: []const u8) ![]const u8 {
+ const fid = try f.c.hold(try std.fmt.allocPrint(f.a, "/pane/{d}/pty/run", .{term}), 2);
+ defer f.c.clunk(fid);
+ _ = try f.c.writeFid(fid, 0, line);
+ return f.a.dupe(u8, try f.c.readFid(fid, 0, 65536));
+ }
+
+ /// An event record written back on pane `n`'s event, as a reader acts.
+ fn event(f: Flow, n: u32, record: []const u8) !void {
+ const fid = try f.c.hold(try std.fmt.allocPrint(f.a, "/pane/{d}/event", .{n}), 2);
+ defer f.c.clunk(fid);
+ _ = try f.c.writeFid(fid, 0, record);
+ }
+
+ fn columns(f: Flow) !usize {
+ var n: usize = 0;
+ var rows = std.mem.tokenizeScalar(u8, try f.c.read(f.a, "/layout"), '\n');
+ while (rows.next()) |row| n += @intFromBool(!std.mem.startsWith(u8, row, "active"));
+ return n;
+ }
+};
+
+fn canary(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ const started = process.nowMs();
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var d = try process.Detached.start(gpa, exe, "flow", .{});
+ defer d.deinit();
+ try d.put("a.txt", "alpha one\nshared word\n");
+ try d.put("b.txt", "beta two\nshared word\n");
+ try d.put("s.sh", "echo from-file\n");
+ const root = d.root();
+ const c = try Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const f: Flow = .{ .a = a, .c = c };
+
+ // Look opens files, and the log says new.
+ const pa = try c.look(a, d.abs("a.txt"), null);
+ const pb = try c.look(a, d.abs("b.txt"), null);
+ try std.testing.expectEqualStrings("alpha one\nshared word\n", try c.pane(a, pa, "body"));
+ try check(has(try f.log(), try std.fmt.allocPrint(a, "new {d} {s}/a.txt\n", .{ pa, root })) and
+ has(try f.log(), try std.fmt.allocPrint(a, "new {d} {s}/b.txt\n", .{ pb, root })), "no new records", .{});
+
+ // Grep and Find: a hit fills its query pane, line 1 the query and the
+ // lines under each file's name; a miss fails ENOENT.
+ const grep = try f.madeBy(pa, "Grep shared\n");
+ try std.testing.expectEqualStrings("Grep shared\na.txt\na.txt:2:1 shared word\nb.txt\nb.txt:2:1 shared word\n", try c.pane(a, grep, "body"));
+ try c.removePane(grep);
+ try c.execRefused(pa, "Grep zzqqnomatch\n", "Grep: text not found");
+ const found = try f.madeBy(pa, "Find b.txt\n");
+ try check(has(try c.pane(a, found, "body"), "b.txt"), "Find found nothing", .{});
+ try c.removePane(found);
+ try c.execRefused(pa, "Find zzqqnomatch\n", "Find: name not found");
+
+ // A plain word looked at is found in the pane, after its dot.
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/dot", .{pa}), " 0 0 ");
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/look", .{pa}), "shared\n");
+ {
+ var it = std.mem.tokenizeAny(u8, try c.pane(a, pa, "dot"), " \n");
+ try check(std.mem.eql(u8, it.next().?, "10") and std.mem.eql(u8, it.next().?, "16"), "the word not found after dot", .{});
+ }
+
+ // Edit in two files, then Save each: on disk, and logged.
+ for ([_]u32{ pa, pb }) |n| try c.write(try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{n}), "Edit ,s/shared/SHARED/g\n");
+ try std.testing.expectEqualStrings("beta two\nSHARED word\n", try c.pane(a, pb, "body"));
+ for ([_]u32{ pa, pb }) |n| try c.exec(n, "Save\n");
+ try std.testing.expectEqualStrings("alpha one\nSHARED word\n", try d.get(a, "a.txt"));
+ try check(has(try f.log(), try std.fmt.allocPrint(a, "save {d} {s}/a.txt\n", .{ pa, root })) and
+ has(try f.log(), try std.fmt.allocPrint(a, "save {d} {s}/b.txt\n", .{ pb, root })), "no save records", .{});
+
+ // get reloads what changed on disk.
+ try d.put("b.txt", "from disk\n");
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{pb}), "get\n");
+ try std.testing.expectEqualStrings("from disk\n", try c.pane(a, pb, "body"));
+
+ // A terminal: pty/run failing then passing.
+ const term = try f.madeBy(1, "Tty\n");
+ {
+ const deadline = process.nowMs() + 10_000;
+ while (true) {
+ const answer = try f.run(term, "true\n");
+ if (std.mem.eql(u8, answer, "exit 0\n")) break;
+ if (process.nowMs() > deadline) {
+ std.debug.print("pty/run answered {s}\n", .{answer});
+ return error.Timeout;
+ }
+ process.nap(50);
+ }
+ }
+ try std.testing.expectEqualStrings("exit 1\n", try f.run(term, "false\n"));
+ try std.testing.expectEqualStrings("exit 0\npassed\n", try f.run(term, "echo passed\n"));
+ // (A run's answer is its record: the log has no err for these.)
+ try check(!has(try f.log(), try std.fmt.allocPrint(a, "err {d} pty/run", .{term})), "pty/run logged an err", .{});
+
+ // A command pane, and Kill: its exit is logged.
+ const sleeper = try f.madeBy(pa, "sleep 30\n");
+ try check(has(try f.log(), try std.fmt.allocPrint(a, "run {d} sleep 30\n", .{sleeper})), "no run record", .{});
+ try c.write("/ctl", "Kill sleep\n");
+ try f.waitLog(try std.fmt.allocPrint(a, "\nexit {d} ", .{sleeper}));
+
+ // A REPL send: a program in the terminal (cat, which says back what it
+ // is sent) bound as bash's REPL; an exec on a .sh file's body (its event
+ // written back) goes there.
+ const s = try c.look(a, d.abs("s.sh"), null);
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/pty/data", .{term}), "cat\r");
+ {
+ const deadline = process.nowMs() + 10_000;
+ while (true) {
+ const status = std.mem.trimEnd(u8, try c.pane(a, term, "pty/status"), " \n");
+ if (std.mem.endsWith(u8, status, " 1") or std.mem.eql(u8, status, "1")) break;
+ if (process.nowMs() > deadline) return error.ReplNeverStarted;
+ process.nap(50);
+ }
+ }
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{term}), "Repl bash\n");
+ try f.event(s, "MX0 0 0 14 echo from-file\n");
+ try f.waitLog(try std.fmt.allocPrint(a, "\nsend {d} {d} ", .{ s, term }));
+ {
+ const deadline = process.nowMs() + 10_000;
+ while (std.mem.count(u8, try c.pane(a, term, "body"), "echo from-file") < 2) {
+ if (process.nowMs() > deadline) return error.ReplNeverGotIt;
+ process.nap(50);
+ }
+ }
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{term}), "Repl -\n");
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/pty/data", .{term}), "\x04");
+ {
+ const deadline = process.nowMs() + 10_000;
+ while (!std.mem.eql(u8, try f.run(term, "true\n"), "exit 0\n")) {
+ if (process.nowMs() > deadline) return error.ShellNeverBack;
+ process.nap(50);
+ }
+ }
+
+ // The layout and a column's files: Newcol, its tag, rmdir.
+ try check(std.mem.count(u8, try c.read(a, "/layout"), "\n") >= 2, "no column in /layout", .{}); // a column, then `active`
+ try c.write("/ctl", "Newcol\n");
+ try std.testing.expectEqual(@as(usize, 2), try f.columns());
+ const empty = blk: {
+ var rows = std.mem.tokenizeScalar(u8, try c.read(a, "/layout"), '\n');
+ var last: []const u8 = "";
+ while (rows.next()) |row| if (!std.mem.startsWith(u8, row, "active")) {
+ last = row;
+ };
+ break :blk std.mem.sliceTo(last, ' ');
+ };
+ try check(has(try c.read(a, try std.fmt.allocPrint(a, "/col/{s}/tag", .{empty})), "New"), "a column's tag has no New", .{});
+ try c.remove(try std.fmt.allocPrint(a, "/col/{s}", .{empty}));
+ try std.testing.expectEqual(@as(usize, 1), try f.columns());
+
+ // ask/answer: Save on a terminal asks for a path over 9P.
+ try c.exec(term, "Save\n");
+ try f.waitLog(try std.fmt.allocPrint(a, "ask {d} save path\n", .{term}));
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{term}), try std.fmt.allocPrint(a, "answer {s}/scroll.txt\n", .{root}));
+ {
+ const deadline = process.nowMs() + 10_000;
+ while (!d.exists("scroll.txt")) {
+ if (process.nowMs() > deadline) return error.AnsweredSaveWroteNothing;
+ process.nap(50);
+ }
+ }
+ try check(has(try f.log(), try std.fmt.allocPrint(a, "answer {d} {s}/scroll.txt\n", .{ term, root })), "no answer record", .{});
+
+ // Dump, then Restore it: the new session names its panes.
+ try c.write("/ctl", "Dump\n");
+ const saved = d.abs("flow.dump.zon");
+ {
+ const deadline = process.nowMs() + 10_000;
+ while (!d.exists("flow.dump.zon")) {
+ if (process.nowMs() > deadline) return error.DumpWroteNothing;
+ process.nap(50);
+ }
+ }
+ try check(has(try f.log(), try std.fmt.allocPrint(a, "dump {s}\n", .{saved})), "no dump record", .{});
+ c.write("/ctl", try std.fmt.allocPrint(a, "Restore {s}\n", .{saved})) catch {};
+ process.nap(500);
+ const restored = try Conn.dial(gpa, d.socket());
+ defer restored.deinit(gpa);
+ const r: Flow = .{ .a = a, .c = restored };
+ try r.waitLog(try std.fmt.allocPrint(a, "restore {s}", .{saved}));
+ const names = try restored.read(a, "/index");
+ try check(has(names, d.abs("a.txt")) and has(names, d.abs("b.txt")), "restored {s}", .{names});
+ // Recent goes on across the Restore, and is kept after it.
+ try check(has(try restored.read(a, "/recent"), try std.fmt.allocPrint(a, "{s}/a.txt\n", .{root})), "Recent lost", .{});
+ try d.put("after.txt", "after\n");
+ _ = try restored.look(a, d.abs("after.txt"), null);
+ try check(has(try restored.read(a, "/recent"), try std.fmt.allocPrint(a, "open {s}/after.txt\n", .{root})), "no open in Recent", .{});
+ {
+ const deadline = process.nowMs() + 10_000;
+ while (!has(d.get(a, ".local/state/pardes/store") catch "", d.abs("after.txt"))) {
+ if (process.nowMs() > deadline) return error.RecentNotKept;
+ process.nap(50);
+ }
+ }
+ try check(process.nowMs() - started < 30_000, "the canary took {d} ms", .{process.nowMs() - started});
+}
diff --git a/test/process/mounts.zig b/test/process/mounts.zig
new file mode 100644
index 00000000..10dc7b5a
--- /dev/null
+++ b/test/process/mounts.zig
@@ -0,0 +1,212 @@
+//! docs/typ/reference.typ, Mounts <mounts>: sessions mounting each other's
+//! trees over their sockets, at startup and at run time.
+const std = @import("std");
+const process = @import("../process.zig");
+const Conn = process.Conn;
+const Detached = process.Detached;
+const has = process.has;
+const check = process.check;
+
+pub const cases = .{
+ .{ "mounts: --mount at startup reads a peer's panes and its disk, a Save through it lands there, and a path not there is a miss in the log", startup },
+ .{ "mounts: a session listening on TCP and QUIC too (-Dquic=true) is mounted over QUIC, saved and got through, its screen read, and unmounted, v4 and v6, detached and in a pty", quic },
+ .{ "mounts: Mount and Unmount at run time, refused in words when mounted already or in use; a session's /n lists its mounts; a file through a mount opens at startup", runtime },
+};
+
+/// A session whose pane `serial` holds "replaced\nevent\n", as fs.py's
+/// `first` had one when its peers mounted it.
+fn peer(gpa: std.mem.Allocator, exe: [:0]const u8, a: std.mem.Allocator) !struct { Detached, *Conn, u32 } {
+ var d = try Detached.start(gpa, exe, "first", .{});
+ errdefer d.deinit();
+ const c = try Conn.dial(gpa, d.socket());
+ const serial = try c.newPane();
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/body", .{serial}), "replaced\nevent\n");
+ return .{ d, c, serial };
+}
+
+fn startup(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var first, const client, const serial = try peer(gpa, exe, a);
+ defer first.deinit();
+ defer client.deinit(gpa);
+ const address = first.abs("pardes-9p-first.sock");
+ const own = first.abs("pardes-9p-second.sock");
+ var second = try Detached.start(gpa, exe, "second", .{
+ .root = first.root(),
+ .args = &.{ try std.fmt.allocPrintSentinel(a, "--mount=peer={s}", .{address}, 0), try std.fmt.allocPrintSentinel(a, "--mount=own={s}", .{own}, 0) },
+ });
+ defer second.deinit();
+ const remote = try Conn.dial(gpa, second.socket());
+ defer remote.deinit(gpa);
+ var opened = try remote.look(a, "/n/own/pane/1/body", null);
+ try std.testing.expectEqualStrings("initial\n", try remote.pane(a, opened, "body"));
+ opened = try remote.look(a, try std.fmt.allocPrint(a, "/n/peer/pane/{d}/body", .{serial}), null);
+ try std.testing.expectEqualStrings("replaced\nevent\n", try remote.pane(a, opened, "body"));
+ try remote.replace(try std.fmt.allocPrint(a, "/pane/{d}/body", .{opened}), "saved to peer\n");
+ try remote.exec(opened, "Save\n");
+ try std.testing.expectEqualStrings("saved to peer\n", try client.pane(a, serial, "body"));
+
+ var large: std.ArrayList(u8) = .empty;
+ for (0..60000) |_| try large.appendSlice(a, "mounted file contents\n");
+ try first.put("large.txt", large.items);
+ opened = try remote.look(a, try std.fmt.allocPrint(a, "/n/peer/os{s}", .{first.abs("large.txt")}), null);
+ try check(std.mem.eql(u8, try remote.pane(a, opened, "body"), large.items), "the mounted file is not whole", .{});
+ const edited = try std.fmt.allocPrint(a, "{s}edited\n", .{large.items[0 .. large.items.len - 3]});
+ try remote.replace(try std.fmt.allocPrint(a, "/pane/{d}/body", .{opened}), edited);
+ try remote.exec(opened, "Save\n");
+ try check(std.mem.eql(u8, try first.get(a, "large.txt"), edited), "the Save through the mount is not on disk", .{});
+ try check(std.mem.eql(u8, try client.read(a, try std.fmt.allocPrint(a, "/os{s}", .{first.abs("large.txt")})), edited), "the peer's /os disagrees", .{});
+ // A path not there under a peer's mount is a miss, as any path to no
+ // file is: the write answered, the err logged.
+ try remote.write("/look", try std.fmt.allocPrint(a, "/n/peer/os{s}\n", .{first.abs("no-such-file.txt")}));
+ try check(has(try remote.read(a, "/log"), "no such file"), "no miss logged", .{});
+ try client.exec(serial, "Del\n");
+ for (try client.list(a, "/pane")) |n| try check(!std.mem.eql(u8, n, try std.fmt.allocPrint(a, "{d}", .{serial})), "Del left the pane", .{});
+}
+
+fn runtime(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var first, const client, _ = try peer(gpa, exe, a);
+ defer first.deinit();
+ defer client.deinit(gpa);
+ const address = first.abs("pardes-9p-first.sock");
+ {
+ var d = try Detached.start(gpa, exe, "runtime", .{ .root = first.root() });
+ defer d.deinit();
+ const remote = try Conn.dial(gpa, d.socket());
+ defer remote.deinit(gpa);
+ const own_address = first.abs("pardes-9p-runtime.sock");
+ const control = try remote.newPane();
+ try remote.exec(control, try std.fmt.allocPrint(a, "Mount peer {s}\n", .{address}));
+ var opened = try remote.look(a, "/n/peer/pane/1/body", control);
+ try std.testing.expectEqualStrings(try client.read(a, "/pane/1/body"), try remote.pane(a, opened, "body"));
+ // A builtin that fails through exec fails the write (one rule).
+ try remote.execRefused(control, try std.fmt.allocPrint(a, "Mount peer {s}\n", .{own_address}), "already mounted");
+ try remote.execRefused(control, "Unmount peer\n", "mount in use"); // a pane is open on it
+ try remote.replace(try std.fmt.allocPrint(a, "/pane/{d}/body", .{opened}), "runtime mounted Save\n");
+ try remote.exec(opened, "Save\n");
+ try std.testing.expectEqualStrings("runtime mounted Save\n", try client.read(a, "/pane/1/body"));
+ try std.testing.expectEqualStrings("initial\n", try remote.read(a, "/pane/1/body"));
+ const roots = try remote.look(a, "/n", control);
+ try check(has(try remote.pane(a, roots, "body"), "/n/peer/\n"), "/n lists no peer", .{});
+ try remote.exec(opened, "Del\n");
+ try remote.exec(control, "Unmount peer\n");
+ try remote.write(try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{roots}), "get\n");
+ try std.testing.expectEqualStrings("/n/os/\n/n/self/\n", try remote.pane(a, roots, "body"));
+ try remote.exec(control, try std.fmt.allocPrint(a, "Mount peer {s}\n", .{own_address}));
+ opened = try remote.look(a, "/n/peer/pane/1/body", control);
+ try std.testing.expectEqualStrings("initial\n", try remote.pane(a, opened, "body"));
+ }
+ var d = try Detached.start(gpa, exe, "mounted-startup", .{
+ .root = first.root(),
+ .args = &.{try std.fmt.allocPrintSentinel(a, "--mount=peer={s}", .{address}, 0)},
+ .file = "/n/peer/pane/1/body:1",
+ });
+ defer d.deinit();
+ try d.files.expect("/pane/1/body", "runtime mounted Save\n");
+}
+
+/// The port of /listeners' `<net>!<host>!<port>` line.
+fn port(listeners: []const u8, net: []const u8) !u16 {
+ var rows = std.mem.tokenizeScalar(u8, listeners, '\n');
+ while (rows.next()) |row| {
+ var parts = std.mem.splitScalar(u8, row, '!');
+ if (!std.mem.eql(u8, parts.first(), net)) continue;
+ _ = parts.next() orelse return error.BadListener;
+ const p = try std.fmt.parseInt(u16, parts.next() orelse return error.BadListener, 10);
+ try check(parts.next() == null and p > 0, "listener {s}", .{row});
+ return p;
+ }
+ return error.NoListener;
+}
+
+fn quic(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ if (!try process.quicIncluded(gpa, exe)) {
+ std.debug.print("SKIP a build without QUIC (-Dquic=true)\n", .{});
+ return;
+ }
+ for ([_]bool{ false, true }) |tty| for ([_][:0]const u8{ "127.0.0.1", "::1" }) |host| {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const args = [_][:0]const u8{
+ try std.fmt.allocPrintSentinel(a, "--9p-tcp=tcp!{s}!0", .{host}, 0),
+ try std.fmt.allocPrintSentinel(a, "--9p-quic=quic!{s}!0", .{host}, 0),
+ };
+ var d = try Detached.start(gpa, exe, if (tty) "quic-root" else "server", .{ .args = if (tty) &.{} else &args });
+ defer d.deinit();
+ var term: ?process.Child = null;
+ defer if (term) |*t| t.deinit();
+ if (tty) term = try d.startTty(exe, "server", &args);
+ const address = d.abs("pardes-9p-server.sock");
+ const unix = try Conn.dial(gpa, address);
+ defer unix.deinit(gpa);
+ const listeners = try unix.read(a, "/listeners");
+ const tcp_port = try port(listeners, "tcp");
+ const quic_port = try port(listeners, "quic");
+ try std.testing.expectEqual(@as(usize, 3), std.mem.count(u8, listeners, "\n"));
+ for ([_][]const u8{
+ try std.fmt.allocPrint(a, "unix!{s}\n", .{address}),
+ try std.fmt.allocPrint(a, "tcp!{s}!{d}\n", .{ host, tcp_port }),
+ try std.fmt.allocPrint(a, "quic!{s}!{d}\n", .{ host, quic_port }),
+ }) |row| try check(has(listeners, row), "no {s} in {s}", .{ row, listeners });
+ const tcp = try Conn.dialTcp(gpa, host, tcp_port);
+ defer tcp.deinit(gpa);
+ const unix_body = try unix.hold("/pane/1/body", 0);
+ defer unix.clunk(unix_body);
+ const tcp_body = try tcp.hold("/pane/1/body", 0);
+ defer tcp.clunk(tcp_body);
+ var client = try Detached.start(gpa, exe, "client", .{ .root = d.root() });
+ defer client.deinit();
+ const remote = try Conn.dial(gpa, client.socket());
+ defer remote.deinit(gpa);
+ const control = try remote.newPane();
+ try remote.exec(control, try std.fmt.allocPrint(a, "Mount peer quic!{s}!{d}\n", .{ host, quic_port }));
+ const opened = try remote.look(a, "/n/peer/pane/1/body", control);
+ const body = try std.fmt.allocPrint(a, "/pane/{d}/body", .{opened});
+ try std.testing.expectEqualStrings("initial\n", try remote.read(a, body));
+ var payload: std.ArrayList(u8) = .empty;
+ try payload.appendSlice(a, "saved café λ\n");
+ try payload.appendNTimes(a, 'x', 3 * 8192 + 27);
+ try payload.append(a, '\n');
+ try remote.replace(body, payload.items);
+ try remote.exec(opened, "Save\n");
+ try std.testing.expectEqualStrings(payload.items[0..@min(payload.items.len, unix.cl.maxRead())], try unix.readFid(unix_body, 0, 65536));
+ try check(std.mem.eql(u8, try tcp.read(a, "/pane/1/body"), payload.items), "TCP reads another body", .{});
+ try tcp.replace("/pane/1/body", "TCP to QUIC Get\n");
+ try remote.write(try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{opened}), "get\n");
+ try std.testing.expectEqualStrings("TCP to QUIC Get\n", try remote.read(a, body));
+ try std.testing.expectEqualStrings("TCP to QUIC Get\n", try unix.readFid(unix_body, 0, 65536));
+ try std.testing.expectEqualStrings("TCP to QUIC Get\n", try tcp.readFid(tcp_body, 0, 65536));
+ // The peer's own screen, whole, over QUIC: its pane's tag, not its
+ // text, whose place after the body shrank depends on a frame drawn.
+ const screen_pane = try remote.look(a, "/n/peer/screen", control);
+ const json = try std.json.parseFromSliceLeaky(std.json.Value, a, try remote.pane(a, screen_pane, "body"), .{});
+ const cells = json.object.get("cells").?.array.items;
+ try std.testing.expectEqual(@as(usize, @intCast(json.object.get("cols").?.integer * json.object.get("rows").?.integer)), cells.len);
+ var text: std.ArrayList(u8) = .empty;
+ for (cells) |cell| try text.appendSlice(a, cell.array.items[0].string);
+ try check(has(text.items, "server.txt Save"), "the peer's screen has no tag", .{});
+ var large: std.ArrayList(u8) = .empty;
+ for (0..20000) |_| try large.appendSlice(a, "normal λ line\n");
+ try d.put("large.txt", large.items);
+ const large_pane = try remote.look(a, try std.fmt.allocPrint(a, "/n/peer/os{s}", .{d.abs("large.txt")}), control);
+ try check(std.mem.eql(u8, try remote.pane(a, large_pane, "body"), large.items), "the large file is not whole", .{});
+ try remote.replace(try std.fmt.allocPrint(a, "/pane/{d}/body", .{large_pane}), "QUIC file saved\n");
+ try remote.exec(large_pane, "Save\n");
+ try std.testing.expectEqualStrings("QUIC file saved\n", try d.get(a, "large.txt"));
+ for ([_]u32{ opened, screen_pane, large_pane }) |n| try remote.exec(n, "Del\n");
+ try remote.exec(control, "Unmount peer\n");
+ const roots = try remote.look(a, "/n", control);
+ try std.testing.expectEqualStrings("/n/os/\n/n/self/\n", try remote.pane(a, roots, "body"));
+ try std.testing.expectEqualStrings("TCP to QUIC Get\n", try unix.readFid(unix_body, 0, 65536));
+ try std.testing.expectEqualStrings("TCP to QUIC Get\n", try tcp.readFid(tcp_body, 0, 65536));
+ // Not checked: a session Looking at its OWN tree through a QUIC
+ // mount: QUIC is answered on the editor's thread, so that Look waits
+ // on the loop it runs in (features.txt, "Left as they are").
+ };
+}
diff --git a/test/process/other_files.zig b/test/process/other_files.zig
index d03d6b36..ad58dd10 100644
--- a/test/process/other_files.zig
+++ b/test/process/other_files.zig
@@ -6,8 +6,33 @@ const process = @import("../process.zig");
pub const cases = .{
.{ "other-files: kbdin and mousein drive a detached session as the user would, each write done before it is answered", keysAndMouse },
.{ "other-files: a held connection lists a directory, stats a file, writes and reads, is refused in words and removes a pane", heldConnection },
+ .{ "other-files: a file opened and closed is in /recent closed, and still is in the next session; Recent's row opens it again", recentSurvivesRestart },
+ .{ "other-files: two sessions share one store: a file opened in one is in the other's /recent, a Del'd pane comes back from @p only where it was", storeShared },
};
+extern "c" fn system(cmd: [*:0]const u8) c_int;
+
+fn has(hay: []const u8, needle: []const u8) bool {
+ return std.mem.indexOf(u8, hay, needle) != null;
+}
+
+/// A session's root kept past it, removed at the test's end.
+fn keepRoot(d: *process.Detached, buf: *[4096]u8) []const u8 {
+ d.owns_root = false;
+ @memcpy(buf[0..d.root().len], d.root());
+ return buf[0..d.root().len];
+}
+
+fn removeRoot(root: []const u8) void {
+ var cmd: [4200]u8 = undefined;
+ _ = system(std.fmt.bufPrintSentinel(&cmd, "rm -rf -- '{s}'", .{root}, 0) catch return);
+}
+
+fn storeExists(root: []const u8) bool {
+ var buf: [4200]u8 = undefined;
+ return std.c.access(std.fmt.bufPrintSentinel(&buf, "{s}/.local/state/pardes/store", .{root}, 0) catch return false, 0) == 0;
+}
+
/// A script types and clicks as the user does: no sleep or poll between a
/// write and the read that checks it; where to click is read off /screen.
/// (test/fs.py's keys_and_mouse, the first case written through the files
@@ -64,3 +89,97 @@ fn heldConnection(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
try c.remove(try std.fmt.bufPrint(&path, "/pane/{d}", .{serial}));
try std.testing.expectError(error.NotFound, c.walk(body));
}
+
+/// The list is kept under $XDG_STATE_HOME (here HOME's .local/state) across
+/// restarts.
+fn recentSurvivesRestart(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var root_buf: [4096]u8 = undefined;
+ var one = try process.Detached.start(gpa, exe, "recent1", .{});
+ const root = keepRoot(&one, &root_buf);
+ defer removeRoot(root);
+ const kept = try std.fmt.allocPrint(a, "{s}/kept.txt", .{root});
+ {
+ defer one.deinit();
+ try one.put("kept.txt", "one\ntwo\n");
+ const c = try process.Conn.dial(gpa, one.socket());
+ defer c.deinit(gpa);
+ const serial = try c.look(a, try std.fmt.allocPrint(a, "{s}:2", .{kept}), null);
+ try std.testing.expect(has(try c.read(a, "/recent"), try std.fmt.allocPrint(a, "open {s}\n", .{kept})));
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{serial}), "Del\n");
+ try std.testing.expect(has(try c.read(a, "/recent"), try std.fmt.allocPrint(a, "closed {s}\n", .{kept})));
+ }
+ try std.testing.expect(storeExists(root));
+ var two = try process.Detached.start(gpa, exe, "recent2", .{ .root = root });
+ defer two.deinit();
+ const c = try process.Conn.dial(gpa, two.socket());
+ defer c.deinit(gpa);
+ try std.testing.expect(has(try c.read(a, "/recent"), try std.fmt.allocPrint(a, "closed {s}\n", .{kept})));
+ // Recent fills a query pane with it, its row relative to the pane's
+ // directory, and a look at the row opens it again.
+ try c.write("/pane/1/exec", "Recent\n");
+ var answer = std.mem.tokenizeAny(u8, try c.read(a, "/pane/1/exec"), " \n");
+ var last: []const u8 = "";
+ while (answer.next()) |w| last = w;
+ const rows = try std.fmt.parseInt(u32, last, 10);
+ const body = try c.read(a, try std.fmt.allocPrint(a, "/pane/{d}/body", .{rows}));
+ try std.testing.expect(std.mem.startsWith(u8, body, "Recent "));
+ var lines = std.mem.tokenizeScalar(u8, body, '\n');
+ const row = while (lines.next()) |l| {
+ if (std.mem.startsWith(u8, l, "kept.txt:")) break l;
+ } else return error.NoRow;
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/look", .{rows}), try std.fmt.allocPrint(a, "{s}\n", .{row[0 .. std.mem.indexOfScalar(u8, row, ' ') orelse row.len]}));
+ try std.testing.expect(has(try c.read(a, "/recent"), try std.fmt.allocPrint(a, "open {s}\n", .{kept})));
+}
+
+/// Del, and again when the first refused over unsaved text.
+fn delTwice(c: *process.Conn, ctl: []const u8) !void {
+ c.write(ctl, "Del\n") catch try c.write(ctl, "Del\n");
+}
+
+/// The store (Store.zig) shared with no restart; a pane Del'd in one
+/// comes back where it was from a look at its @p serial there, its text
+/// with it, and only there.
+fn storeShared(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var root_buf: [4096]u8 = undefined;
+ var one = try process.Detached.start(gpa, exe, "store1", .{});
+ const root = keepRoot(&one, &root_buf);
+ defer removeRoot(root);
+ {
+ defer one.deinit();
+ var two = try process.Detached.start(gpa, exe, "store2", .{ .root = root });
+ defer two.deinit();
+ const c1 = try process.Conn.dial(gpa, one.socket());
+ defer c1.deinit(gpa);
+ const c2 = try process.Conn.dial(gpa, two.socket());
+ defer c2.deinit(gpa);
+ try one.put("shared.txt", "one\ntwo\nthree\n");
+ const shared = try std.fmt.allocPrint(a, "{s}/shared.txt", .{root});
+ const serial = try c1.look(a, try std.fmt.allocPrint(a, "{s}:3", .{shared}), null);
+ try std.testing.expect(has(try c1.read(a, "/recent"), try std.fmt.allocPrint(a, "open {s}\n", .{shared})));
+ try std.testing.expect(has(try c2.read(a, "/recent"), try std.fmt.allocPrint(a, "closed {s}\n", .{shared})));
+ try c1.write(try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{serial}), "Del\n");
+ try std.testing.expect(has(try c1.read(a, "/recent"), try std.fmt.allocPrint(a, "closed {s}\n", .{shared})));
+ const scratch = try c1.newPane();
+ try c1.write(try std.fmt.allocPrint(a, "/pane/{d}/body", .{scratch}), "kept across a Del\n");
+ try delTwice(c1, try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{scratch}));
+ var rows = std.mem.tokenizeScalar(u8, try c1.read(a, "/index"), '\n');
+ while (rows.next()) |r| try std.testing.expect(!std.mem.startsWith(u8, r, try std.fmt.allocPrint(a, "{d} ", .{scratch})));
+ const back = try c1.look(a, try std.fmt.allocPrint(a, "@p{d}", .{scratch}), null);
+ try std.testing.expectEqualStrings("kept across a Del\n", try c1.read(a, try std.fmt.allocPrint(a, "/pane/{d}/body", .{back})));
+ // The other window's session closed no such pane.
+ const source = try c2.newPane();
+ c2.write(try std.fmt.allocPrint(a, "/pane/{d}/look", .{source}), try std.fmt.allocPrint(a, "@p{d}\n", .{scratch})) catch {};
+ var others = std.mem.tokenizeScalar(u8, try c2.read(a, "/index"), '\n');
+ while (others.next()) |r| {
+ const body = try c2.read(a, try std.fmt.allocPrint(a, "/pane/{s}/body", .{r[0..std.mem.indexOfScalar(u8, r, ' ').?]}));
+ try std.testing.expect(!has(body, "kept across a Del"));
+ }
+ }
+ try std.testing.expect(storeExists(root));
+}
diff --git a/test/process/repls.zig b/test/process/repls.zig
new file mode 100644
index 00000000..09e25e96
--- /dev/null
+++ b/test/process/repls.zig
@@ -0,0 +1,79 @@
+//! docs/typ/reference.typ, REPLs <repls>: an exec sent to a real REPL in
+//! a real pty.
+const std = @import("std");
+const process = @import("../process.zig");
+const Conn = process.Conn;
+const has = process.has;
+const check = process.check;
+
+pub const cases = .{
+ .{ "repls: a one-line exec sent to Python's own REPL (pyrepl, bracketed paste) runs at once, after idling too, and a block runs whole", pythonRepl },
+};
+
+/// Waits up to `ms` for the terminal's body to hold `text`.
+fn waitFor(a: std.mem.Allocator, c: *Conn, tty: u32, text: []const u8, ms: i64) !bool {
+ const deadline = process.nowMs() + ms;
+ while (process.nowMs() < deadline) {
+ if (has(try c.pane(a, tty, "body"), text)) return true;
+ process.nap(100);
+ }
+ return false;
+}
+
+fn pythonRepl(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ // 3.13's pyrepl asks for bracketed paste; an older one or none is no test.
+ const version = try process.run(a, &.{ "python3", "-c", "import sys; sys.exit(sys.version_info < (3, 13))" }, .{});
+ if (version.code != 0) {
+ std.debug.print("SKIP no python3 3.13 or later\n", .{});
+ return;
+ }
+ var d = try process.Detached.start(gpa, exe, "repl", .{});
+ defer d.deinit();
+ const c = try Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const before = try c.serials(a);
+ try c.write("/pane/1/ctl", "Tty\n");
+ const deadline = process.nowMs() + 10_000;
+ var tty: u32 = 0;
+ while (tty == 0 and process.nowMs() < deadline) : (process.nap(50)) {
+ for (try c.serials(a)) |n| if (std.mem.indexOfScalar(u32, before, n) == null) {
+ tty = @max(tty, n);
+ };
+ }
+ try check(tty != 0, "Tty made no pane", .{});
+ try check(try waitFor(a, c, tty, "$", 15_000) or try waitFor(a, c, tty, ">", 15_000), "no prompt: {s}", .{try c.pane(a, tty, "body")});
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/pty/data", .{tty}), "python3 -q\r");
+ try check(try waitFor(a, c, tty, ">>>", 15_000), "no >>>: {s}", .{try c.pane(a, tty, "body")});
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{tty}), "Repl python\n");
+ // An exec on the REPL's own body goes to the REPL, as its event record
+ // written back does: an empty range acts on its text.
+ const fid = try c.hold(try std.fmt.allocPrint(a, "/pane/{d}/event", .{tty}), 2);
+ defer c.clunk(fid);
+ _ = try c.writeFid(fid, 0, "MX0 0 0 10 print(6*7)\n");
+ try check(try waitFor(a, c, tty, "\n42", 15_000), "no 42: {s}", .{try c.pane(a, tty, "body")});
+ // After the session has sat idle, the Enter still waits for the paste:
+ // core time is as old as the last frame then.
+ for (0..5) |n| {
+ process.nap(2_000);
+ const line = try std.fmt.allocPrint(a, "print({d})", .{1000 + n});
+ _ = try c.writeFid(fid, 0, try std.fmt.allocPrint(a, "MX0 0 0 {d} {s}\n", .{ line.len, line }));
+ try check(try waitFor(a, c, tty, try std.fmt.allocPrint(a, "\n{d}", .{1000 + n}), 15_000), "{d}: {s}", .{ n, try c.pane(a, tty, "body") });
+ }
+ // More than one line, with and without a newline at the end, and a block
+ // with a statement after it: each runs whole, and the REPL is back at
+ // its prompt, not at `...`.
+ for ([_]struct { []const u8, []const []const u8 }{
+ .{ "print(11)\nprint(22)", &.{ "11", "22" } },
+ .{ "print(33)\nprint(44)\n", &.{ "33", "44" } },
+ .{ "for i in range(2):\n print(55 + i)\nprint(77)\n", &.{ "55", "56", "77" } },
+ }) |row| {
+ _ = try c.writeFid(fid, 0, try std.fmt.allocPrint(a, "MX0 0 0 {d} {s}\n", .{ row[0].len, row[0] }));
+ for (row[1]) |out| try check(try waitFor(a, c, tty, try std.fmt.allocPrint(a, "\n{s}\n", .{out}), 15_000), "{s}: no {s}: {s}", .{ row[0], out, try c.pane(a, tty, "body") });
+ process.nap(500);
+ const body = try c.pane(a, tty, "body");
+ try check(std.mem.endsWith(u8, std.mem.trimEnd(u8, body, " \t\r\n"), ">>>"), "{s}: not at its prompt: {s}", .{ row[0], body[body.len -| 200..] });
+ }
+}
diff --git a/test/process/root_ctl.zig b/test/process/root_ctl.zig
new file mode 100644
index 00000000..008cc882
--- /dev/null
+++ b/test/process/root_ctl.zig
@@ -0,0 +1,183 @@
+//! docs/typ/reference.typ, The root ctl <root-ctl>, through a real
+//! session's socket: it exits, keeps its own clock and saves.
+const std = @import("std");
+const libc = std.c;
+const process = @import("../process.zig");
+const eh = @import("../e2e_harness.zig");
+const expect = std.testing.expect;
+const expectEqualStrings = std.testing.expectEqualStrings;
+const Conn = process.Conn;
+const has = process.has;
+const check = process.check;
+
+pub const cases = .{
+ .{ "root-ctl: Exit is answered before the editor quits", exitAnswers },
+ .{ "root-ctl: with nothing attached a message leaves after MessageLinger on its own clock", messagesExpire },
+ .{ "root-ctl: Putall with one pane's file changed on disk fails, answered once the other panes' saves have landed", putallAfterSaves },
+ .{ "root-ctl: long and odd paths where a path goes (name, look, DumpDir, Dump, Save) are refused or said, never a crash; a bad ThemeFile fails the write", oddPaths },
+ .{ "root-ctl: Restore asks once about unsaved text, is answered before it cuts every connection, and the dump's panes come back under their serials", restore },
+};
+
+fn exitAnswers(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var d = try process.Detached.start(gpa, exe, "exit", .{});
+ defer d.deinit();
+ try d.files.write("/ctl", "Exit\n");
+ if (d.exited(5_000) == null) return error.StillRunning;
+}
+
+/// Nothing attached, no key, no click, no other request comes to move it along.
+fn messagesExpire(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var d = try process.Detached.start(gpa, exe, "msg", .{});
+ defer d.deinit();
+ try d.files.write("/pane/1/ctl", "Msg lingering-words\n");
+ try expect(has(try d.files.screen(), "lingering-words"));
+ // Reading /screen is itself a request, so wait without asking.
+ process.sleep(2500);
+ try expect(!has(try d.files.screen(), "lingering-words"));
+}
+
+fn putallAfterSaves(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var d = try process.Detached.start(gpa, exe, "putall", .{});
+ defer d.deinit();
+ const f = &d.files;
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const ar = arena.allocator();
+ const c = try process.Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ try d.put("a.txt", "a\n");
+ try d.put("b.txt", "b\n");
+ const a = try c.look(ar, f.at("{s}/a.txt", .{d.root()}), null);
+ const b = try c.look(ar, f.at("{s}/b.txt", .{d.root()}), null);
+ for ([_]u32{ a, b }) |serial| try c.write(f.at("/pane/{d}/body", .{serial}), "edited\n");
+ try d.put("b.txt", "changed on disk\n");
+ const deadline = eh.nowMs() + 10_000;
+ while (!has(try c.read(ar, "/log"), f.at("changed {d}", .{b}))) {
+ if (eh.nowMs() > deadline) return error.NeverHeard;
+ process.sleep(50);
+ }
+ try std.testing.expectError(error.Refused, c.write("/ctl", "Putall\n"));
+ try expect(has(c.said, "modified on disk"));
+ try expectEqualStrings("a\nedited\n", try d.get(ar, "a.txt"));
+ try expectEqualStrings("changed on disk\n", try d.get(ar, "b.txt"));
+}
+
+/// A part over 255 bytes (ENAMETOOLONG), a loop of links (ELOOP), a file
+/// taken for a directory (ENOTDIR), one not ours (EACCES).
+fn oddPaths(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var d = try process.Detached.start(gpa, exe, "odd", .{});
+ defer d.deinit();
+ const f = &d.files;
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const c = try process.Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const root = d.root();
+ const loop = try std.fmt.allocPrintSentinel(a, "{s}/loop", .{root}, 0);
+ try expect(libc.symlink(loop, loop) == 0);
+ try d.put("plain", "x\n");
+ const long: [300]u8 = @splat('x');
+ const odd = [_][]const u8{
+ f.at("/tmp/{s}/f.txt", .{&long}), f.at("{s}/{s}", .{ root, &long }), f.at("{s}/loop/f", .{root}),
+ f.at("{s}/plain/f", .{root}), "/root/nope/f", f.at("{s}/a/../b.txt", .{root}),
+ };
+ const serial = try c.newPane();
+ try c.write(f.at("/pane/{d}/body", .{serial}), "text\n");
+ for (odd) |path| {
+ for ([_][2][]const u8{
+ .{ f.at("/pane/{d}/name", .{serial}), path }, .{ "/look", path }, .{ "/ctl", f.at("DumpDir {s}", .{path}) },
+ .{ "/ctl", "Dump" }, .{ f.at("/pane/{d}/ctl", .{serial}), "Save" },
+ }) |w| {
+ c.write(w[0], f.at("{s}\n", .{w[1]})) catch {};
+ try expect((try c.read(a, "/index")).len > 0);
+ }
+ }
+ try c.write("/ctl", "DumpDir\n");
+ // A theme file that is not there, or no theme, fails the write.
+ try d.put("bad.zon", ".{ .nonsense = 1 }");
+ for ([_][2][]const u8{
+ .{ f.at("ThemeFile {s}/missing.zon\n", .{root}), "theme file" },
+ .{ f.at("ThemeFile {s}/bad.zon\n", .{root}), "theme file" },
+ .{ "ThemeFile notes.txt\n", "a theme file is a .zon" },
+ }) |t| {
+ try std.testing.expectError(error.Refused, c.write("/ctl", t[0]));
+ try expect(has(c.said, t[1]));
+ }
+}
+
+/// A connection to `path`, waiting up to 5 s for it to answer.
+fn redial(gpa: std.mem.Allocator, path: []const u8) !*Conn {
+ const deadline = process.nowMs() + 5_000;
+ while (true) {
+ if (Conn.dial(gpa, path)) |c| return c else |err| if (process.nowMs() > deadline) return err;
+ process.nap(20);
+ }
+}
+
+fn restore(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ for ([_]bool{ false, true }) |tty| {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const name = if (tty) "restore tty space" else "restore detached space";
+ var d = try process.Detached.start(gpa, exe, if (tty) "restore-root" else name, .{});
+ defer d.deinit();
+ var term: ?process.Child = null;
+ defer if (term) |*t| t.deinit();
+ if (tty) term = try d.startTty(exe, name, &.{});
+ const address = d.abs(try std.fmt.allocPrint(a, "pardes-9p-{s}.sock", .{name}));
+ const old = try Conn.dial(gpa, address);
+ defer old.deinit(gpa);
+ try old.replace("/pane/1/body", "dumped state\n");
+ const control = try old.newPane();
+ try old.execRefused(control, try std.fmt.allocPrint(a, "Restore {s}\n", .{d.abs("missing dump.zon")}), "no such file");
+ try std.testing.expectEqualStrings("dumped state\n", try old.read(a, "/pane/1/body"));
+ try old.exec(control, try std.fmt.allocPrint(a, "Mount own {s}\n", .{address}));
+ try old.exec(control, "Dump\n");
+ const saved_rel = try std.fmt.allocPrint(a, "{s}.dump.zon", .{name});
+ const saved = d.abs(saved_rel);
+ const deadline = process.nowMs() + 5_000;
+ while (!d.exists(saved_rel)) {
+ if (process.nowMs() > deadline) return error.NoDump;
+ process.nap(5);
+ }
+ const held_body = try old.hold("/pane/1/body", 0);
+ const held_screen = try old.hold("/screen", 0);
+ const old_ids = try old.serials(a);
+ try std.testing.expectEqualStrings("dumped state\n", try old.readFid(held_body, 0, 65536));
+ try std.testing.expectEqualStrings("{", try old.readFid(held_screen, 0, 1));
+ try old.replace("/pane/1/body", "changed after dump\n");
+ // Unsaved text is asked about once, as Exit asks; the second Restore
+ // goes ahead, and is answered before the hang-up.
+ const line = try std.fmt.allocPrint(a, "Restore {s}\n", .{saved});
+ if (old.exec(control, line)) |_| {} else |err| {
+ if (err != error.Refused) return err;
+ try check(has(old.said, "Modified"), "Restore refused: {s}", .{old.said});
+ }
+ try std.testing.expectEqualStrings("changed after dump\n", try old.read(a, "/pane/1/body"));
+ // Answered before the hang-up: the write's reply comes; the clunk
+ // after it may meet the connection already cut.
+ const restore_fid = try old.hold(try std.fmt.allocPrint(a, "/pane/{d}/exec", .{control}), 1);
+ _ = try old.writeFid(restore_fid, 0, line);
+ old.clunk(restore_fid);
+ // Refused while the connections are cut, or cut already.
+ if (old.readFid(held_body, 0, 65536)) |_| return error.OldFidUsable else |_| {}
+ const restored = try redial(gpa, address);
+ defer restored.deinit(gpa);
+ // The new log names its panes, then where they came from.
+ const log = try restored.read(a, "/log");
+ try check(has(log, try std.fmt.allocPrint(a, "\nrestore {s}\n", .{saved})), "no restore logged: {s}", .{log});
+ // Its panes are the dump's, their serials too.
+ const ids = try restored.serials(a);
+ try check(ids.len == 2 and std.mem.eql(u32, ids, old_ids), "restored {any}, dumped {any}", .{ ids, old_ids });
+ try std.testing.expectEqualStrings("dumped state\n", try restored.pane(a, ids[0], "body"));
+ try check((try restored.pane(a, ids[1], "body")).len == 0, "commands ran through exec, not the body", .{});
+ var screen: process.Files = .init(gpa, address);
+ defer screen.deinit();
+ const width = try std.unicode.utf8CountCodepoints(std.mem.sliceTo(try screen.screen(), '\n'));
+ try std.testing.expectEqual(@as(usize, if (tty) 80 else 160), width); // a detached one is 160x50
+ const opened = try restored.look(a, try std.fmt.allocPrint(a, "/n/own/os{s}", .{d.abs(try std.fmt.allocPrint(a, "{s}.txt", .{name}))}), ids[1]);
+ try std.testing.expectEqualStrings("initial\n", try restored.pane(a, opened, "body"));
+ }
+}
diff --git a/test/process/terminals.zig b/test/process/terminals.zig
new file mode 100644
index 00000000..e810ceb1
--- /dev/null
+++ b/test/process/terminals.zig
@@ -0,0 +1,352 @@
+//! docs/typ/guide.typ, Terminals <terminals>, through a real session's
+//! socket: its shells run.
+const std = @import("std");
+const libc = std.c;
+const process = @import("../process.zig");
+const eh = @import("../e2e_harness.zig");
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+const expectEqualStrings = std.testing.expectEqualStrings;
+
+extern "c" fn system(cmd: [*:0]const u8) c_int;
+
+pub const cases = .{
+ .{ "terminals: pty/run takes a line and answers how it ended, then what it printed, on the same open; busy while a job holds the tty, gone with its shell", runFile },
+ .{ "terminals: a terminal started outside the session's directory is named by it from its new on, and a shell that cannot start leaves no pane", namedOnce },
+ .{ "terminals: a program's prompt shows and holds still, input sent unsubmitted shows, and ^U takes the screen back to what it was", prompt },
+ .{ "terminals: what a program prints past a screenful stays in the terminal's body, and its prompt after it shows", history },
+ .{ "terminals: a control byte through pty/data reaches a program in raw mode, which then carries on", rawKey },
+};
+
+fn has(hay: []const u8, needle: []const u8) bool {
+ return std.mem.indexOf(u8, hay, needle) != null;
+}
+
+fn refusedSaying(c: *process.Conn, path: []const u8, data: []const u8, why: []const u8) !void {
+ try std.testing.expectError(error.Refused, c.write(path, data));
+ if (!has(c.said, why)) {
+ std.debug.print("{s} refused saying {s}, not {s}\n", .{ path, c.said, why });
+ return error.WrongWords;
+ }
+}
+
+/// A line written to a terminal's pty/run and the answer read on the same open.
+fn run(a: std.mem.Allocator, c: *process.Conn, serial: u32, line: []const u8) ![]const u8 {
+ var buf: [64]u8 = undefined;
+ const fid = try c.hold(try std.fmt.bufPrint(&buf, "/pane/{d}/pty/run", .{serial}), 2);
+ defer c.clunk(fid);
+ _ = try c.writeFid(fid, 0, line);
+ return a.dupe(u8, try c.readFid(fid, 0, 1 << 16));
+}
+
+/// The serials of /index's rows whose fourth word, the path, is `path`.
+fn panesAt(a: std.mem.Allocator, c: *process.Conn, path: []const u8) ![]const []const u8 {
+ var out: std.ArrayList([]const u8) = .empty;
+ var rows = std.mem.tokenizeScalar(u8, try c.read(a, "/index"), '\n');
+ while (rows.next()) |row| {
+ var w = std.mem.tokenizeScalar(u8, row, ' ');
+ const serial = w.next().?;
+ _ = w.next();
+ _ = w.next();
+ if (std.mem.eql(u8, w.next() orelse "", path)) try out.append(a, serial);
+ }
+ return out.items;
+}
+
+/// The serials /index lists.
+fn serials(a: std.mem.Allocator, c: *process.Conn) ![]const u32 {
+ var out: std.ArrayList(u32) = .empty;
+ var rows = std.mem.tokenizeScalar(u8, try c.read(a, "/index"), '\n');
+ while (rows.next()) |row| try out.append(a, try std.fmt.parseInt(u32, row[0..std.mem.indexOfScalar(u8, row, ' ').?], 10));
+ return out.items;
+}
+
+fn shell(a: std.mem.Allocator, comptime fmt: []const u8, args: anytype) c_int {
+ return system(std.fmt.allocPrintSentinel(a, fmt, args, 0) catch @panic("out of memory"));
+}
+
+/// A run on another connection, as another client's, in a thread.
+const Other = struct {
+ a: std.mem.Allocator,
+ conn: *process.Conn,
+ serial: u32,
+ line: []const u8,
+ got: []const u8 = "",
+
+ fn go(o: *Other) void {
+ o.got = run(o.a, o.conn, o.serial, o.line) catch "";
+ }
+};
+
+fn runFile(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var d = try process.Detached.start(gpa, exe, "run", .{});
+ defer d.deinit();
+ const f = &d.files;
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const c = try process.Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const root = d.root();
+ // From a pane on a peer's path no command or terminal starts: refused
+ // before any pane is made, no `exit 127` pane left.
+ const peer = try c.newPane();
+ try c.write(f.at("/pane/{d}/name", .{peer}), "/n/nosuchpeer/d/f.txt\n");
+ const count = std.mem.count(u8, try c.read(a, "/index"), "\n");
+ try refusedSaying(c, f.at("/pane/{d}/exec", .{peer}), "ls\n", "no such directory");
+ try refusedSaying(c, f.at("/pane/{d}/exec", .{peer}), "Tty\n", "no such directory");
+ try expectEqual(count, std.mem.count(u8, try c.read(a, "/index"), "\n"));
+ try expect(!has(try c.read(a, "/log"), "exit 127"));
+ try c.remove(f.at("/pane/{d}", .{peer}));
+ try c.write("/exec", "Shell bash\n");
+ try c.write("/exec", "Tty\n");
+ var term: u32 = 0;
+ var rows = std.mem.tokenizeScalar(u8, try c.read(a, "/index"), '\n');
+ while (rows.next()) |r| {
+ var w = std.mem.tokenizeScalar(u8, r, ' ');
+ const serial = try std.fmt.parseInt(u32, w.next().?, 10);
+ if (std.mem.eql(u8, w.next().?, "term")) term = @max(term, serial);
+ }
+ const deadline = eh.nowMs() + 10_000;
+ while (std.mem.eql(u8, try run(a, c, term, "true\n"), "busy\n")) { // deadline its first prompt
+ if (eh.nowMs() > deadline) return error.NoPrompt;
+ process.sleep(50);
+ }
+ try expectEqualStrings("exit 1\n", try run(a, c, term, "false\n"));
+ try expectEqualStrings("exit 0\none\ntwo\n", try run(a, c, term, "printf \"one\\ntwo\\n\"\n")); // then what it printed
+ try expectEqualStrings("exit 7\n", try run(a, c, term, "sh -c \"exit 7\"\n"));
+ try expectEqualStrings("error not run\n", try run(a, c, term, "fi\n")); // a syntax error runs nothing
+ try expectEqualStrings("error not run\n", try run(a, c, term, "echo 'open\n")); // nor does an open quote
+ try expectEqualStrings("exit 0\n", try run(a, c, term, "true\n")); // ...and the shell is clear after
+ // With no frontend attached the pty's size is in pixels too, at a
+ // nominal 8x16 cell: a program sizes its kitty graphics by it.
+ const said = try run(a, c, term, "python3 -c 'import fcntl,termios,struct;print(*struct.unpack(\"4H\",fcntl.ioctl(0,termios.TIOCGWINSZ,bytes(8))))'\n");
+ var lines = std.mem.splitScalar(u8, said, '\n');
+ _ = lines.next();
+ var size = std.mem.tokenizeScalar(u8, lines.next() orelse "", ' ');
+ var n: [4]u32 = undefined;
+ for (&n) |*v| v.* = try std.fmt.parseInt(u32, size.next() orelse return error.NoSize, 10);
+ try expect(n[2] == n[1] * 8 and n[3] == n[0] * 16 and n[2] > 0);
+ // A paging command run through pty/run does not wait in less: the
+ // terminal's PAGER is `pardes -`, and its text is a +Pager pane.
+ if (shell(a, "command -v git >/dev/null", .{}) == 0) {
+ const git = f.at("HOME='{s}' git -C '{s}/pagedrepo' -c user.name=p -c user.email=p@x", .{ root, root });
+ try expectEqual(@as(c_int, 0), shell(a, "mkdir '{s}/pagedrepo' && {s} init -q && echo x > '{s}/pagedrepo/f' && {s} add f && {s} commit -qm paged-commit-subject", .{ root, git, root, git, git }));
+ try expect(std.mem.startsWith(u8, try run(a, c, term, "git -C pagedrepo log\n"), "exit 0\n"));
+ const pager = try panesAt(a, c, f.at("{s}/pagedrepo/+Pager", .{root})); // git -C runs it in the repo
+ try expectEqual(@as(usize, 1), pager.len);
+ const body = try c.read(a, f.at("/pane/{s}/body", .{pager[0]}));
+ try expect(has(body, "paged-commit-subject") and !has(body, "\x1b"));
+ try c.remove(f.at("/pane/{s}", .{pager[0]}));
+ }
+ // systemd's tools page through their own variable: set too, its secure
+ // mode off, the path unquoted where it needs none. Read by the shell:
+ // coreutils 9.12's printenv quotes a value with a blank on a terminal.
+ const systemd = try run(a, c, term, "printf \"%s\\n\" \"$SYSTEMD_PAGER\" \"$SYSTEMD_PAGERSECURE\"\n");
+ try expect(std.mem.startsWith(u8, systemd, "exit 0\n") and std.mem.endsWith(u8, std.mem.trimEnd(u8, systemd, " \n"), " -\n0"));
+ if (shell(a, "command -v journalctl >/dev/null", .{}) == 0) {
+ try expect(std.mem.startsWith(u8, try run(a, c, term, "journalctl -n 3 --no-hostname\n"), "exit "));
+ for (try panesAt(a, c, f.at("{s}/+Pager", .{root}))) |p| try c.remove(f.at("/pane/{s}", .{p}));
+ }
+ // A pty is not given one row (it loses the prompt's input mark, and the
+ // shell would read busy for ever): refused, and said.
+ const ptyctl = f.at("/pane/{d}/pty/ctl", .{term});
+ try refusedSaying(c, ptyctl, "winsize 20 1\n", "at least 2 rows");
+ try c.write(ptyctl, "winsize 20 2\n");
+ process.sleep(500);
+ try expectEqualStrings("exit 0\n", try run(a, c, term, "true\n"));
+ var words = std.mem.tokenizeAny(u8, try c.read(a, ptyctl), " \n");
+ _ = words.next();
+ _ = words.next();
+ try expectEqualStrings("2", words.next() orelse ""); // not `.?`: a panic leaves the session running
+ try c.write(ptyctl, "winsize 80 24\n");
+ // A shell started again that cannot start (its directory is there but
+ // cannot be entered) fails the write and leaves the running shell be:
+ // runs still work.
+ const locked = try std.fmt.allocPrintSentinel(a, "{s}/locked", .{root}, 0);
+ try expectEqual(@as(c_int, 0), libc.mkdir(locked, 0o755));
+ try expectEqualStrings("exit 0\n", try run(a, c, term, f.at("cd {s}\n", .{locked})));
+ const moved_by = eh.nowMs() + 5_000;
+ while (!has(try c.read(a, "/index"), locked)) {
+ if (eh.nowMs() > moved_by) return error.NeverMoved;
+ process.sleep(50);
+ }
+ _ = libc.chmod(locked, 0o600);
+ const refused = if (libc.geteuid() != 0) refusedSaying(c, ptyctl, "exec\n", "shell") else {}; // root enters any directory
+ _ = libc.chmod(locked, 0o755);
+ try refused;
+ try expectEqualStrings("exit 0\n", try run(a, c, term, "true\n"));
+ try expectEqualStrings("exit 0\n", try run(a, c, term, f.at("cd {s}\n", .{root})));
+ const other = try process.Conn.dial(gpa, d.socket());
+ defer other.deinit(gpa);
+ const tv: libc.timeval = .{ .sec = 10, .usec = 0 };
+ _ = libc.setsockopt(other.fd, libc.SOL.SOCKET, libc.SO.RCVTIMEO, &tv, @sizeOf(libc.timeval));
+ var slow: Other = .{ .a = a, .conn = other, .serial = term, .line = "sleep 1\n" };
+ var waiter = try std.Thread.spawn(.{}, Other.go, .{&slow});
+ process.sleep(300);
+ // The job the other client ran holds the tty, and says so.
+ const busy = run(a, c, term, "true\n");
+ waiter.join();
+ try expectEqualStrings("busy: sleep is running\n", try busy);
+ try expectEqualStrings("exit 0\n", slow.got);
+ var closing: Other = .{ .a = a, .conn = other, .serial = term, .line = "sleep 30\n" };
+ waiter = try std.Thread.spawn(.{}, Other.go, .{&closing});
+ process.sleep(300);
+ const del = c.write(f.at("/pane/{d}/exec", .{term}), "Del\n");
+ waiter.join();
+ try del;
+ try expectEqualStrings("error shell gone\n", closing.got);
+}
+
+fn namedOnce(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var d = try process.Detached.start(gpa, exe, "names", .{});
+ defer d.deinit();
+ const f = &d.files;
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const c = try process.Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const root = d.root();
+ try expectEqual(@as(c_int, 0), libc.mkdir(try std.fmt.allocPrintSentinel(a, "{s}/sub", .{root}, 0), 0o755));
+ // A look at a directory starts a terminal there (DirLook terminal);
+ // DirLook pane, the default, lists it in a pane.
+ try c.write("/ctl", "DirLook terminal\n");
+ var made: std.ArrayList(u32) = .empty;
+ try made.append(a, try c.look(a, f.at("{s}/sub", .{root}), null));
+ const before = try serials(a, c);
+ try c.write("/pane/1/ctl", "Tty\n");
+ if (shell(a, "command -v fish >/dev/null", .{}) == 0) try c.write("/pane/1/ctl", "Tty fish\n");
+ for (try serials(a, c)) |s| if (std.mem.indexOfScalar(u32, before, s) == null) try made.append(a, s);
+ try expect(made.items.len >= 2);
+ process.sleep(1500); // their shells start and say where they are
+ // A shell started again by pty/ctl exec: named as it was.
+ try c.write(f.at("/pane/{d}/pty/ctl", .{made.items[0]}), "exec\n");
+ process.sleep(1500);
+ const log = f.at("\n{s}", .{try c.read(a, "/log")});
+ for (made.items) |s| {
+ try expect(!has(log, f.at("\nrename {d} ", .{s})));
+ try expect(has(log, f.at("\nnew {d} {s}", .{ s, root })));
+ }
+ // A shell that cannot start (its interpreter is not there): Tty fails
+ // the write with why and leaves no pane; pty/ctl exec fails with why
+ // and keeps its terminal.
+ try d.put("badsh", "#!/nonexistent/interp\n");
+ const bad = f.at("{s}/badsh", .{root});
+ _ = libc.chmod(try std.fmt.allocPrintSentinel(a, "{s}", .{bad}, 0), 0o755);
+ const panes = std.mem.count(u8, try c.read(a, "/index"), "\n");
+ try refusedSaying(c, "/pane/1/ctl", f.at("Tty {s}\n", .{bad}), "interpreter /nonexistent/interp not found");
+ try refusedSaying(c, "/ctl", f.at("Shell {s}\n", .{bad}), "interpreter /nonexistent/interp not found");
+ process.sleep(300);
+ try expectEqual(panes, std.mem.count(u8, try c.read(a, "/index"), "\n"));
+ try expect(!has(try c.read(a, "/log"), "shell: shell not found"));
+ try expect(std.mem.indexOfScalar(u32, try serials(a, c), made.items[0]) != null);
+}
+
+const ready = "AGENT_READY> ";
+
+fn prompt(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ try drive(gpa, exe, "printf \"AGENT_READY> \"; read answer", null, 0);
+}
+
+fn history(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ try drive(gpa, exe, "printf \"AGENT_READY> \"; sleep .3; seq 1 3000; printf \"AGENT_READY> \"; read answer", null, 1000);
+}
+
+fn rawKey(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ try drive(gpa, exe, "stty raw -echo; printf \"AGENT_READY> \"; dd bs=1 count=1 of=/dev/null 2>/dev/null; stty sane; seq 1 3000; printf \"AGENT_READY> \"; read answer", 0x0f, 1000);
+}
+
+/// The script run in a new terminal's shell, as `/bin/sh command.sh`: its
+/// prompt waited for, `key` sent and the prompt waited for again, the body
+/// holding at least `rows` lines (and, with none asked, fewer than a
+/// thousand: nothing printed is nothing kept), then a probe typed and
+/// taken back with ^U.
+fn drive(gpa: std.mem.Allocator, exe: [:0]const u8, script: []const u8, key: ?u8, rows: usize) !void {
+ var d = try process.Detached.start(gpa, exe, "agent", .{});
+ defer d.deinit();
+ const f = &d.files;
+ try d.put("command.sh", f.at("exec /bin/sh -c '{s}'\n", .{script}));
+ try f.write("/ctl", "Shell /bin/sh\n");
+ try f.write("/exec", "Tty\n");
+ const term = try f.focused();
+ const body = f.at("/pane/{d}/body", .{term});
+ const data = f.at("/pane/{d}/pty/data", .{term});
+ try until(f, body, struct {
+ fn ok(text: []const u8) bool {
+ return std.mem.trim(u8, text, " \n").len > 0;
+ }
+ }.ok);
+ try f.write(data, f.at("/bin/sh {s}/command.sh\r", .{d.root()}));
+ _ = try settled(f);
+ if (key) |k| {
+ try f.write(data, &.{k});
+ _ = try settled(f);
+ }
+ const deadline = eh.nowMs() + 10_000;
+ while (lineCount(try f.read(body)) < rows) {
+ if (eh.nowMs() > deadline) return error.ShortHistory;
+ sleepMs(50);
+ }
+ if (rows == 0) try std.testing.expect(lineCount(try f.read(body)) < 1000);
+ const before = try settled(f);
+ const probe = "pq7c0ffee2b9d";
+ try std.testing.expect(std.mem.indexOf(u8, before, probe) == null);
+ try f.write(data, probe);
+ const shown_by = eh.nowMs() + 10_000;
+ while (std.mem.indexOf(u8, try unwrapped(f), probe) == null) {
+ if (eh.nowMs() > shown_by) return error.ProbeNotShown;
+ sleepMs(10);
+ }
+ try f.write(data, "\x15");
+ const back_by = eh.nowMs() + 10_000;
+ while (!std.mem.eql(u8, try f.screen(), before)) {
+ if (eh.nowMs() > back_by) return error.ScreenNotRestored;
+ sleepMs(10);
+ }
+}
+
+/// The screen once it shows the prompt and holds still between two reads.
+fn settled(f: *process.Files) ![]const u8 {
+ const deadline = eh.nowMs() + 10_000;
+ var previous: []const u8 = "";
+ while (true) {
+ const text = try f.screen();
+ if (std.mem.indexOf(u8, text, ready) != null and std.mem.eql(u8, text, previous)) return text;
+ if (eh.nowMs() > deadline) {
+ std.debug.print("no settled prompt on the screen:\n{s}\n", .{text});
+ return error.NotReady;
+ }
+ previous = text;
+ sleepMs(50);
+ }
+}
+
+fn until(f: *process.Files, path: []const u8, ok: fn ([]const u8) bool) !void {
+ const deadline = eh.nowMs() + 10_000;
+ while (!ok(try f.read(path))) {
+ if (eh.nowMs() > deadline) return error.Timeout;
+ sleepMs(10);
+ }
+}
+
+/// The screen's text with its rows run together, as a long line wraps.
+fn unwrapped(f: *process.Files) ![]const u8 {
+ const text = try f.screen();
+ const out = try f.arena.allocator().alloc(u8, text.len);
+ var n: usize = 0;
+ for (text) |c| if (c != '\n') {
+ out[n] = c;
+ n += 1;
+ };
+ return out[0..n];
+}
+
+fn lineCount(text: []const u8) usize {
+ return std.mem.count(u8, text, "\n") + @intFromBool(text.len > 0 and text[text.len - 1] != '\n');
+}
+
+fn sleepMs(ms: u32) void {
+ var ts: std.c.timespec = .{ .sec = 0, .nsec = @as(isize, ms) * std.time.ns_per_ms };
+ _ = std.c.nanosleep(&ts, null);
+}
diff --git a/test/process/tree.zig b/test/process/tree.zig
new file mode 100644
index 00000000..358e7040
--- /dev/null
+++ b/test/process/tree.zig
@@ -0,0 +1,636 @@
+//! docs/typ/reference.typ, The tree <tree>, through a real session's socket.
+const std = @import("std");
+const libc = std.c;
+const process = @import("../process.zig");
+const c9 = @import("cloud9");
+const eh = @import("../e2e_harness.zig");
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+const expectEqualStrings = std.testing.expectEqualStrings;
+const Conn = process.Conn;
+const has = process.has;
+const check = process.check;
+
+pub const cases = .{
+ .{ "tree: listing, stat and find are inert; new, remove, look, exec, name, sel, log, ctl lock, focus, the ctl split, commands, Save and the slots behave", discovery },
+ .{ "tree: a write bigger than a 9P message runs each line once, whole, an Edit block once it ends; a detached session is 160x50 until told", cutWrites },
+ .{ "tree: the root lists its files and not self; /os reads the disk, `..` taken as a walk takes it, and writes it truncated", rootAndOs },
+ .{ "tree: a client of 256-byte frames lists /os whole, a dangling link left out; one of 64 KiB is agreed", frames },
+ .{ "tree: /screen freezes at its open; a dozen connections in turn each read a body", frozenScreen },
+ .{ "tree: a Look at a relative name finds the disk's file first; /n/self is the session's tree, /n/os the disk", looks },
+ .{ "tree: names up to 255 bytes list, read, write and open through /os and /n/os, and a directory lists them", longNames },
+};
+
+fn contains(names: []const []const u8, name: []const u8) bool {
+ for (names) |n| if (std.mem.eql(u8, n, name)) return true;
+ return false;
+}
+
+/// A write refused, its words holding `why`.
+fn refusedSaying(c: *process.Conn, path: []const u8, data: []const u8, why: []const u8) !void {
+ try std.testing.expectError(error.Refused, c.write(path, data));
+ if (!has(c.said, why)) {
+ std.debug.print("{s} refused saying {s}, not {s}\n", .{ path, c.said, why });
+ return error.WrongWords;
+ }
+}
+
+/// A read on `c` given up after `sec` seconds, so a wait that never ends fails.
+fn timeout(c: *process.Conn, sec: i64) void {
+ const tv: libc.timeval = .{ .sec = sec, .usec = 0 };
+ _ = libc.setsockopt(c.fd, libc.SOL.SOCKET, libc.SO.RCVTIMEO, &tv, @sizeOf(libc.timeval));
+}
+
+/// /index's row for `serial`.
+fn indexRow(index: []const u8, serial: u32) ![]const u8 {
+ var rows = std.mem.tokenizeScalar(u8, index, '\n');
+ while (rows.next()) |row| {
+ const sp = std.mem.indexOfScalar(u8, row, ' ') orelse continue;
+ if ((std.fmt.parseInt(u32, row[0..sp], 10) catch continue) == serial) return row;
+ }
+ return error.NoRow;
+}
+
+/// The serials of /index's rows whose fourth word, the path, is `path`.
+fn panesAt(a: std.mem.Allocator, c: *process.Conn, path: []const u8) ![]const []const u8 {
+ var out: std.ArrayList([]const u8) = .empty;
+ var rows = std.mem.tokenizeScalar(u8, try c.read(a, "/index"), '\n');
+ while (rows.next()) |row| {
+ var w = std.mem.tokenizeScalar(u8, row, ' ');
+ const serial = w.next().?;
+ _ = w.next();
+ _ = w.next();
+ if (std.mem.eql(u8, w.next() orelse "", path)) try out.append(a, serial);
+ }
+ return out.items;
+}
+
+const Seen = struct { path: []const u8, mode: u32, mtime: u32 };
+
+/// Every entry below `path` stated, as `find` does, without opening one.
+fn walkTree(a: std.mem.Allocator, c: *process.Conn, path: []const u8, seen: *std.ArrayList(Seen)) !void {
+ for (try c.list(a, path)) |name| {
+ const child = try std.fmt.allocPrint(a, "{s}/{s}", .{ std.mem.trimEnd(u8, path, "/"), name });
+ const st = try c.stat(child);
+ try seen.append(a, .{ .path = child, .mode = st.mode, .mtime = st.mtime });
+ if (st.mode & c9.dmdir != 0 and !contains(&.{ "/log", "/os", "/screen" }, child)) try walkTree(a, c, child, seen);
+ }
+}
+
+/// A follower's read on a held /log, which waits for a new record.
+const Follower = struct {
+ conn: *process.Conn,
+ fid: u32,
+ off: u64,
+ buf: [256]u8 = undefined,
+ len: usize = 0,
+
+ fn run(w: *Follower) void {
+ const got = w.conn.readFid(w.fid, w.off, 4096) catch return;
+ w.len = @min(got.len, w.buf.len);
+ @memcpy(w.buf[0..w.len], got[0..w.len]);
+ }
+};
+
+fn discovery(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var d = try process.Detached.start(gpa, exe, "discovery", .{});
+ defer d.deinit();
+ const f = &d.files;
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const c = try process.Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const root = d.root();
+
+ const top = try c.list(a, "/");
+ // A set: which files the root holds, not the order a listing gives.
+ const want = [_][]const u8{ "README", "index", "status", "focus", "ctl", "commands", "recent", "look", "exec", "pager", "log", "screen", "listeners", "sessions", "layout", "tag", "tagexec", "kbdin", "mousein", "pane", "col", "os" };
+ var others: usize = 0;
+ for (top) |n| {
+ if (contains(&.{ "src", "shaders" }, n)) continue;
+ others += 1;
+ try expect(contains(&want, n));
+ }
+ try expectEqual(want.len, others);
+ for (want) |n| try expect(contains(top, n));
+ const embedded = contains(top, "src");
+ const before = try c.read(a, "/index");
+ const guide = try c.read(a, "/README");
+ try expect(std.mem.count(u8, guide, "\n") <= 45 and has(guide, "Msg hello") and has(guide, "pane/new"));
+ try expectEqual(guide.len, (try c.stat("/README")).length);
+ // ls/stat/find over the whole tree, without opening, creates nothing.
+ var seen: std.ArrayList(Seen) = .empty;
+ try walkTree(a, c, "/", &seen);
+ var names: std.ArrayList([]const u8) = .empty;
+ for (seen.items) |s| try names.append(a, s.path);
+ for ([_][]const u8{ "/index", "/status", "/look", "/exec", "/log", "/pane/1", "/pane/1/body", "/pane/1/name", "/pane/1/sel", "/pane/1/ctl", "/pane/1/tag", "/pane/1/event", "/pane/1/dot", "/pane/1/limit", "/pane/1/dirty", "/pane/1/mark", "/pane/1/scroll", "/pane/1/look", "/pane/1/exec" }) |n| try expect(contains(names.items, n));
+ try expect(!contains(names.items, "/pane/1/pty")); // the fixture file pane grew no pty/
+ for (seen.items) |s| {
+ try expect(!std.mem.startsWith(u8, s.path, "/self") and !std.mem.endsWith(u8, s.path, "/rdsel") and !std.mem.endsWith(u8, s.path, "/wrsel"));
+ const mode = s.mode & 0o777;
+ try expect(mode == 0o755 or mode == 0o644 or mode == 0o666 or mode == 0o444 or mode == 0o222 or mode == 0o555);
+ try expect(s.mtime > 0);
+ }
+ try expectEqualStrings(before, try c.read(a, "/index")); // browsing created no pane
+ try expect(before.len > 0);
+ try expectEqual(@as(u64, 0), (try c.stat("/index")).length); // a view made by each read stats 0 (reference.typ, Stats)
+ try expectEqual(@as(u32, 0o444), (try c.stat("/index")).mode & 0o777);
+ try expectEqual(@as(u32, 0o444), (try c.stat("/status")).mode & 0o777);
+ try expectEqual(@as(u32, 0o666), (try c.stat("/exec")).mode & 0o777);
+ try expectEqual(@as(u32, 0o666), (try c.stat("/pane/1/body")).mode & 0o777);
+ try expectEqual(@as(u32, 0o755), (try c.stat("/pane")).mode & 0o777);
+ // A range file reads the pair it takes; a flag file reads 0 or 1.
+ try expectEqual(@as(u64, 24), (try c.stat("/pane/1/addr")).length);
+ try expectEqual(@as(u64, 0), (try c.stat("/pane/1/limit")).length);
+ try expectEqualStrings("0\n", try c.read(a, "/pane/1/dirty"));
+ try expectEqualStrings("1\n", try c.read(a, "/pane/1/scroll"));
+ const fixture = try std.fmt.parseInt(u32, before[0..std.mem.indexOfScalar(u8, before, ' ').?], 10);
+ try expect(std.mem.startsWith(u8, before, f.at("{d} text 0 ", .{fixture})));
+ try expect(std.mem.endsWith(u8, before[0..std.mem.lastIndexOfScalar(u8, std.mem.trimEnd(u8, before, "\n"), ' ').?], "/discovery.txt"));
+ // /status reports the editor; /exec has nothing to report yet.
+ var pid: i64 = 0;
+ var version = false;
+ var panes: i64 = 0;
+ var lines = std.mem.tokenizeScalar(u8, try c.read(a, "/status"), '\n');
+ while (lines.next()) |line| {
+ const sp = std.mem.indexOfScalar(u8, line, ' ') orelse continue;
+ const key, const value = .{ line[0..sp], std.mem.trim(u8, line[sp..], " ") };
+ if (std.mem.eql(u8, key, "pid")) pid = try std.fmt.parseInt(i64, value, 10);
+ if (std.mem.eql(u8, key, "version")) version = value.len > 0;
+ if (std.mem.eql(u8, key, "panes")) panes = try std.fmt.parseInt(i64, value, 10);
+ }
+ try expect(pid > 0 and version and panes >= 1);
+ try expectEqualStrings("", try c.read(a, "/exec"));
+ // An open of /pane/new makes a pane and the read names it; each open
+ // makes another. A stat makes none, which is why new can be listed at
+ // all: ls -l stats every name a listing gave it. /log answers the
+ // recent past and ends; `follow` written to the same open makes its
+ // reads past that wait for new records.
+ const log = try c.hold("/log", 2);
+ const frozen = (try c.readFid(log, 0, 1 << 16)).len;
+ _ = try c.writeFid(log, 0, "follow\n");
+ const first = try c.newPane();
+ try expectEqual(first, try c.newest(a));
+ const second = try c.newPane();
+ try expect(first != second and first != fixture);
+ try expect(contains(try c.list(a, "/pane"), "new"));
+ _ = try c.stat("/pane/new");
+ try expectEqual(second, try c.newest(a)); // a stat of new made no pane
+ // What the editor said is in the stream too.
+ const paneEvent = struct {
+ fn next(conn: *process.Conn, al: std.mem.Allocator, fid: u32, off: u64) ![]const u8 {
+ while (true) {
+ const record = try conn.readFid(fid, off, 1 << 16);
+ if (!std.mem.startsWith(u8, record, "msg ") and !std.mem.startsWith(u8, record, "err ")) return al.dupe(u8, record);
+ }
+ }
+ }.next;
+ try expectEqualStrings(f.at("new {d} {s}/+New\n", .{ first, root }), try paneEvent(c, a, log, frozen));
+ try expectEqualStrings(f.at("new {d} {s}/+New\n", .{ second, root }), try paneEvent(c, a, log, frozen));
+ // A follower that is waiting wakes when the editor logs, not when some
+ // unrelated request next happens to wait.
+ {
+ const follower = try process.Conn.dial(gpa, d.socket());
+ defer follower.deinit(gpa);
+ timeout(follower, 5);
+ const waiting = try follower.hold("/log", 2);
+ const start = (try follower.readFid(waiting, 0, 1 << 16)).len;
+ _ = try follower.writeFid(waiting, 0, "follow\n");
+ var w: Follower = .{ .conn = follower, .fid = waiting, .off = start };
+ const reader = try std.Thread.spawn(.{}, Follower.run, .{&w});
+ process.sleep(200);
+ try c.write("/exec", "Msg woken\n");
+ reader.join();
+ try expect(std.mem.endsWith(u8, w.buf[0..w.len], " woken\n"));
+ }
+ // A pane's ctl takes acme's lock: a second open's lock fails at once
+ // with "file in use" until the holder unlocks, and nothing else waits
+ // on it meanwhile.
+ {
+ const other = try process.Conn.dial(gpa, d.socket());
+ defer other.deinit(gpa);
+ const ctl = f.at("/pane/{d}/ctl", .{first});
+ const mine = try c.hold(ctl, 2);
+ _ = try c.writeFid(mine, 0, "lock\n");
+ const theirs = try other.hold(ctl, 1);
+ try std.testing.expectError(error.Refused, other.writeFid(theirs, 0, "lock\n"));
+ try expect(has(other.said, "file in use"));
+ try c.write(f.at("/pane/{d}/addr", .{first}), "#0");
+ _ = try c.writeFid(mine, 0, "unlock\n");
+ _ = try other.writeFid(theirs, 0, "lock\n");
+ c.clunk(mine);
+ other.clunk(theirs);
+ }
+ // /focus names the pane with the keyboard and moves it, as rio's wctl
+ // `current` does; a pane's ctl line ends saying which it is.
+ try c.write("/focus", f.at("{d}\n", .{first}));
+ try expectEqualStrings(f.at("{d}\n", .{first}), try c.read(a, "/focus"));
+ try expect(has(try c.read(a, f.at("/pane/{d}/ctl", .{first})), " current "));
+ try expect(has(try c.read(a, f.at("/pane/{d}/ctl", .{second})), " notcurrent "));
+ try refusedSaying(c, "/focus", "99999\n", "no such pane");
+ // /ctl reads the settings as a write takes them and takes the session's
+ // builtins; a pane's ctl takes the pane's.
+ const settings = try c.read(a, "/ctl");
+ try expect(has(settings, "Verbose ") and !has(settings, "Platform"));
+ try c.write("/ctl", settings);
+ try expectEqualStrings(settings, try c.read(a, "/ctl"));
+ try c.write("/ctl", "Verbose off\n");
+ try expect(has(try c.read(a, "/ctl"), "Verbose off\n"));
+ try refusedSaying(c, "/ctl", "Del\n", "not a session control message \"Del\"");
+ try refusedSaying(c, "/ctl", "Nope 3\n", "unknown control message \"Nope\"");
+ try refusedSaying(c, f.at("/pane/{d}/ctl", .{first}), "Newcol\n", "not a window control message \"Newcol\"");
+ const commands = try c.read(a, "/commands");
+ const row = struct {
+ fn row(text: []const u8, start: []const u8) bool {
+ var rows = std.mem.tokenizeScalar(u8, text, '\n');
+ while (rows.next()) |r| if (std.mem.eql(u8, r, start) or (std.mem.startsWith(u8, r, start) and r.len > start.len and r[start.len] == ' ')) return true;
+ return false;
+ }
+ }.row;
+ try expect(row(commands, "Newcol root") and row(commands, "Save arg pane") and row(commands, "Edit arg both"));
+ // word, `arg` if it takes one, its ctl, a setting's values, then `-- ` what it does
+ var crows = std.mem.tokenizeScalar(u8, commands, '\n');
+ while (crows.next()) |r| {
+ var w = std.mem.tokenizeScalar(u8, r, ' ');
+ _ = w.next();
+ var which = w.next().?;
+ if (std.mem.eql(u8, which, "arg")) which = w.next().?;
+ try expect(contains(&.{ "root", "pane", "both" }, which));
+ }
+ try expect(row(commands, "Placement arg root acme,pardes"));
+ try expect(std.mem.endsWith(u8, commands, "\n"));
+ try expectEqual(commands.len, (try c.stat("/commands")).length);
+ try c.write(f.at("/pane/{d}/ctl", .{first}), "Msg said through ctl\n");
+ try expect(has(try f.screen(), "said through ctl"));
+ const listed = try c.list(a, "/pane");
+ try expectEqual(@as(usize, 4), listed.len);
+ for ([_]u32{ fixture, first, second }) |n| try expect(contains(listed, f.at("{d}", .{n})));
+ try expect(contains(listed, "new"));
+ try c.replace(f.at("/pane/{d}/body", .{first}), "first pane");
+ try expectEqualStrings("first pane", try c.read(a, f.at("/pane/{d}/body", .{first})));
+ try expectEqualStrings("", try c.read(a, f.at("/pane/{d}/body", .{second})));
+ try expectEqual(@as(u64, "first pane".len), (try c.stat(f.at("/pane/{d}/body", .{first}))).length);
+ const index = try c.read(a, "/index");
+ try expect(std.mem.startsWith(u8, try indexRow(index, first), f.at("{d} text 1 ", .{first})));
+ try expect(std.mem.startsWith(u8, try indexRow(index, second), f.at("{d} text 0 ", .{second})));
+ // name: read the file name, write to rename; sel: the selection.
+ const name = f.at("/pane/{d}/name", .{first});
+ try expectEqualStrings(f.at("{s}/+New\n", .{root}), try c.read(a, name));
+ try c.write(name, "notes.txt\n");
+ try expectEqualStrings(f.at("{s}/notes.txt\n", .{root}), try c.read(a, name));
+ try expectEqualStrings(f.at("rename {d} {s}/notes.txt\n", .{ first, root }), try paneEvent(c, a, log, frozen));
+ try expectEqual(@as(u64, f.at("{s}/notes.txt\n", .{root}).len), (try c.stat(name)).length);
+ // Copying addr onto dot selects that range; sel reads and replaces it.
+ const addr = f.at("/pane/{d}/addr", .{first});
+ const dot = f.at("/pane/{d}/dot", .{first});
+ const sel = f.at("/pane/{d}/sel", .{first});
+ try c.write(addr, "#0,#5");
+ try c.write(dot, try c.read(a, addr));
+ try expectEqualStrings(try c.read(a, addr), try c.read(a, dot));
+ try expectEqualStrings("first", try c.read(a, sel));
+ try expectEqual(@as(u64, 5), (try c.stat(sel)).length);
+ try c.write(sel, "FIRST");
+ try expectEqualStrings("FIRST pane", try c.read(a, f.at("/pane/{d}/body", .{first})));
+ try expectEqualStrings("FIRST", try c.read(a, sel)); // what a write to sel put there is selected
+ // exec Msg shows text; exec Save writes the named file; rmdir closes.
+ try c.write(f.at("/pane/{d}/exec", .{first}), "Msg hello from 9P\n");
+ try expect(has(try f.screen(), "hello from 9P"));
+ try expectEqualStrings("1\n", try c.read(a, f.at("/pane/{d}/dirty", .{first})));
+ try c.write(f.at("/pane/{d}/exec", .{first}), "Save\n");
+ try expectEqualStrings("FIRST pane", try d.get(a, "notes.txt"));
+ try expectEqualStrings(f.at("save {d} {s}/notes.txt\n", .{ first, root }), try paneEvent(c, a, log, frozen));
+ try expectEqualStrings(f.at("{d}\n", .{first}), try c.read(a, "/exec"));
+ try expectEqualStrings("0\n", try c.read(a, f.at("/pane/{d}/dirty", .{first})));
+ try c.remove(f.at("/pane/{d}", .{second}));
+ try expectEqualStrings(f.at("del {d} {s}/+New\n", .{ second, root }), try paneEvent(c, a, log, frozen));
+ try expect(!contains(try c.list(a, "/pane"), f.at("{d}", .{second})));
+ // look opens a file; the serial reads back.
+ try d.put("opened.txt", "one\ntwo\nthree\n");
+ try c.write("/look", f.at("{s}/opened.txt:2\n", .{root}));
+ const opened = try std.fmt.parseInt(u32, std.mem.trim(u8, try c.read(a, "/look"), "\n"), 10);
+ try expect(opened != fixture and opened != first and opened != second);
+ try expectEqualStrings("one\ntwo\nthree\n", try c.read(a, f.at("/pane/{d}/body", .{opened})));
+ try expectEqualStrings(f.at("{s}/opened.txt\n", .{root}), try c.read(a, f.at("/pane/{d}/name", .{opened})));
+ try expectEqualStrings(f.at("new {d} {s}/opened.txt\n", .{ opened, root }), try paneEvent(c, a, log, frozen));
+ try c.write(f.at("/pane/{d}/look", .{first}), f.at("{s}/opened.txt:3\n", .{root}));
+ try expectEqualStrings(f.at("{d}\n", .{opened}), try c.read(a, "/look")); // a repeated look targets the open pane
+ for ([_]u32{ fixture, first, opened }) |n| try expect(contains(try c.list(a, "/pane"), f.at("{d}", .{n})));
+ // Writing an event record back still performs the action it names.
+ try c.replace(f.at("/pane/{d}/body", .{first}), "Msg via event");
+ try c.write(f.at("/pane/{d}/event", .{first}), "FX0 13\n");
+ try expect(has(try f.screen(), "via event"));
+ // A command line may not carry control characters, and nothing else in
+ // the tree may be created or removed.
+ if (c.write("/exec", "Msg a\x00b")) |_| return error.Taken else |_| {}
+ if (c.write("/status", "anything\n")) |_| return error.Taken else |_| {}
+ if (c.create("/", "x", c9.dmdir | 0o755)) |_| return error.Taken else |_| {}
+ if (c.create("/pane", "one", c9.dmdir | 0o755)) |_| return error.Taken else |_| {}
+ if (c.create("/pane", "plain-file", 0o644)) |_| return error.Taken else |_| {}
+ if (c.remove("/pane/1/body")) |_| return error.Taken else |_| {}
+ if (c.remove("/index")) |_| return error.Taken else |_| {}
+ c.clunk(log);
+ if (embedded) {
+ try expect(std.mem.startsWith(u8, try c.read(a, "/src/pardes.zig"), "const std"));
+ try expectEqual(@as(u32, 0o444), (try c.stat("/src/pardes.zig")).mode & 0o777);
+ try expect(has(try c.read(a, f.at("/pane/{d}/body", .{try c.look(a, "/virtual/src/pardes.zig", null)})), "pub const Pardes"));
+ }
+ // An open of data with OTRUNC (a shell's >) deletes the addressed range
+ // only, so the write after it replaces that range.
+ const scratch = try c.newPane();
+ try c.write(f.at("/pane/{d}/body", .{scratch}), "hello world\nsecond line\n");
+ try c.write(f.at("/pane/{d}/addr", .{scratch}), "#0,#5");
+ try c.replace(f.at("/pane/{d}/data", .{scratch}), "HOWDY");
+ try expectEqualStrings("HOWDY world\nsecond line\n", try c.read(a, f.at("/pane/{d}/body", .{scratch})));
+ // sam's regexps: ^ at any line; a miss says so and leaves no address,
+ // so the data write after it refuses.
+ try c.write(f.at("/pane/{d}/addr", .{scratch}), "/^second/");
+ try expectEqualStrings(" 12 18 ", try c.read(a, f.at("/pane/{d}/addr", .{scratch})));
+ try refusedSaying(c, f.at("/pane/{d}/addr", .{scratch}), "/nowhere/", "no match for regexp");
+ try refusedSaying(c, f.at("/pane/{d}/data", .{scratch}), "LOST", "no address");
+ try expectEqualStrings("HOWDY world\nsecond line\n", try c.read(a, f.at("/pane/{d}/body", .{scratch})));
+ // Through a mount both read as EINVAL; the log says which and why.
+ try expect(has(try c.read(a, "/log"), f.at("err {d} addr: no match for regexp\n", .{scratch})));
+ try c.remove(f.at("/pane/{d}", .{scratch}));
+ // Real `diff -u` in a command pane: the terminal turns the tab before
+ // each timestamp into blanks, and a look at a changed line still opens
+ // the new file at it.
+ try d.put("diff-old.txt", "one\ntwo\nthree\n");
+ try d.put("diff-new.txt", "one\nTWO\nthree\n");
+ const exits = std.mem.count(u8, try c.read(a, "/log"), "\nexit ");
+ try c.write("/exec", "diff -u diff-old.txt diff-new.txt\n");
+ const deadline = eh.nowMs() + 10_000;
+ while (std.mem.count(u8, try c.read(a, "/log"), "\nexit ") <= exits) {
+ if (eh.nowMs() > deadline) return error.DiffNeverEnded;
+ process.sleep(50);
+ }
+ // A command's pane is kind cmd, not term: no shell to type into.
+ var ran: u32 = 0;
+ var irows = std.mem.tokenizeScalar(u8, try c.read(a, "/index"), '\n');
+ while (irows.next()) |r| {
+ var w = std.mem.tokenizeScalar(u8, r, ' ');
+ const serial = w.next().?;
+ if (std.mem.eql(u8, w.next() orelse "", "cmd")) ran = try std.fmt.parseInt(u32, serial, 10);
+ }
+ const shown = try c.read(a, f.at("/pane/{d}/body", .{ran}));
+ try expect(has(shown, "+++ diff-new.txt") and !has(shown, "\t"));
+ try c.write(f.at("/pane/{d}/look", .{ran}), "+TWO\n");
+ const diffed = try panesAt(a, c, f.at("{s}/diff-new.txt", .{root}));
+ try expectEqual(@as(usize, 1), diffed.len);
+ try c.remove(f.at("/pane/{s}", .{diffed[0]}));
+ try c.remove(f.at("/pane/{d}", .{ran}));
+ // A Save makes the directories its file goes in, whatever names it: the
+ // pane's own name or Save's path. `~` is home (this session's HOME, the
+ // test's root) wherever a path is typed: Save, name, a look, with an
+ // address or not.
+ const tilde = try c.newPane();
+ try c.write(f.at("/pane/{d}/body", .{tilde}), "one\ntwo\nthree\n");
+ try c.write(f.at("/pane/{d}/ctl", .{tilde}), "Save ~/tilde-made/sub/x.txt\n");
+ try expectEqualStrings("one\ntwo\nthree\n", try d.get(a, "tilde-made/sub/x.txt"));
+ try c.write(f.at("/pane/{d}/name", .{tilde}), "~/tilde-named.txt\n");
+ try expectEqualStrings(f.at("{s}/tilde-named.txt\n", .{root}), try c.read(a, f.at("/pane/{d}/name", .{tilde})));
+ try c.remove(f.at("/pane/{d}", .{tilde}));
+ try c.write("/look", "~/tilde-made/sub/x.txt:3\n");
+ const looked = try panesAt(a, c, f.at("{s}/tilde-made/sub/x.txt", .{root}));
+ try expectEqual(@as(usize, 1), looked.len);
+ // At line 3: dot, offset 8, where the look put it (addr is a 9P client's own register).
+ try expect(std.mem.startsWith(u8, std.mem.trimStart(u8, try c.read(a, f.at("/pane/{s}/dot", .{looked[0]})), " "), "8 "));
+ try c.remove(f.at("/pane/{s}", .{looked[0]}));
+ const made_dirs = try c.newPane();
+ try c.write(f.at("/pane/{d}/body", .{made_dirs}), "deep\n");
+ try c.write(f.at("/pane/{d}/ctl", .{made_dirs}), f.at("Save {s}/save-made/a/b/x.txt\n", .{root}));
+ try expectEqualStrings("deep\n", try d.get(a, "save-made/a/b/x.txt"));
+ try c.write(f.at("/pane/{d}/name", .{made_dirs}), f.at("{s}/save-named/c/y.txt\n", .{root}));
+ try c.write(f.at("/pane/{d}/ctl", .{made_dirs}), "Save\n");
+ try expectEqualStrings("deep\n", try d.get(a, "save-named/c/y.txt"));
+ try c.remove(f.at("/pane/{d}", .{made_dirs}));
+ // A save the host cannot do (a directory it may not make) fails the
+ // write that asked for it, and the log's err record names the path and
+ // why.
+ const unsaved = try c.newPane();
+ try c.write(f.at("/pane/{d}/body", .{unsaved}), "unsaved\n");
+ try refusedSaying(c, f.at("/pane/{d}/ctl", .{unsaved}), "Save /nonexistent-pardes-dir/x.txt\n", "Save /nonexistent-pardes-dir/x.txt: permission denied"); // a directory it may not make
+ try expect(has(try c.read(a, "/log"), f.at("err {d} ctl: Save /nonexistent-pardes-dir/x.txt: ", .{unsaved})));
+ try c.remove(f.at("/pane/{d}", .{unsaved}));
+ // Sixteen connections fill the slots; the next is told why.
+ {
+ var extra: [15]*process.Conn = undefined;
+ var n: usize = 0;
+ defer for (extra[0..n]) |e| e.deinit(gpa);
+ while (n < extra.len) : (n += 1) extra[n] = try process.Conn.dial(gpa, d.socket());
+ var words: [256]u8 = undefined;
+ try expect(has(try process.Conn.dialRefusal(gpa, d.socket(), &words), "too many connections"));
+ }
+ const until = eh.nowMs() + 5_000;
+ while (!has(try c.read(a, "/log"), "err - 9p: too many connections")) {
+ if (eh.nowMs() > until) return error.NotLogged;
+ process.sleep(10);
+ }
+}
+
+fn screenSize(f: *process.Files) !struct { i64, i64 } {
+ const json = try std.json.parseFromSliceLeaky(std.json.Value, f.arena.allocator(), try f.read("/screen"), .{});
+ return .{ json.object.get("cols").?.integer, json.object.get("rows").?.integer };
+}
+
+/// A write bigger than a 9P message comes as several, cut anywhere: each
+/// command line runs once, whole, an Edit block once it ends, and a last
+/// line with no newline when the open closes. Never a fragment.
+fn cutWrites(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var d = try process.Detached.start(gpa, exe, "cut", .{});
+ defer d.deinit();
+ const f = &d.files;
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const c = try process.Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ // As test/fs.py's client cut them: an 8192-byte msize's writes.
+ const cut = 8192 - 23;
+ var burst: std.ArrayList(u8) = .empty;
+ for (0..1000) |i| try burst.print(a, "Msg burst-{d:0>4}\n", .{i});
+ try expect(burst.items.len > 8192);
+ try c.writeCut("/exec", 1, burst.items, cut);
+ const log = try c.read(a, "/log");
+ var i: usize = 0;
+ var lines = std.mem.tokenizeScalar(u8, log, '\n');
+ while (lines.next()) |line| {
+ if (!std.mem.startsWith(u8, line, "msg ") or !has(line, "burst-")) continue;
+ var w = std.mem.splitScalar(u8, line, ' ');
+ _ = w.next();
+ _ = w.next();
+ try expectEqualStrings(f.at("burst-{d:0>4}", .{i}), w.rest());
+ i += 1;
+ }
+ try expectEqual(@as(usize, 1000), i);
+ try expect(!has(log, "\nrun ") and !has(log, "exit 127"));
+ try c.write("/exec", "Msg no-newline-at-end");
+ const said = try c.read(a, "/log");
+ // An error, not `.?`: a panic would leave the session running.
+ const upto = said[0 .. std.mem.indexOf(u8, said, "no-newline-at-end") orelse return error.NeverRun];
+ try expect(has(upto[upto.len -| 40..], "msg "));
+ const serial = try c.newPane();
+ var block: std.ArrayList(u8) = .empty;
+ try block.appendSlice(a, "Edit ,a\n");
+ for (0..2500) |k| try block.print(a, "line {d:0>5} of the block\n", .{k});
+ try block.appendSlice(a, ".\n");
+ try expect(block.items.len > 50000);
+ try c.writeCut(f.at("/pane/{d}/ctl", .{serial}), 1, block.items, cut);
+ var body = std.mem.splitScalar(u8, std.mem.trimEnd(u8, try c.read(a, f.at("/pane/{d}/body", .{serial})), "\n"), '\n');
+ var k: usize = 0;
+ while (body.next()) |line| : (k += 1) try expectEqualStrings(f.at("line {d:0>5} of the block", .{k}), line);
+ try expectEqual(@as(usize, 2500), k);
+ // A detached session with no frontend is 160x50 until told.
+ const cols, const rows = try screenSize(f);
+ try expect(cols == 160 and rows == 50);
+ try c.write("/ctl", "size 132 40\n");
+ const cols2, const rows2 = try screenSize(f);
+ try expect(cols2 == 132 and rows2 == 40);
+}
+
+fn rootAndOs(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var d = try process.Detached.start(gpa, exe, "first", .{});
+ defer d.deinit();
+ const c = try Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const root = d.root();
+ const names = try c.list(a, "/");
+ for ([_][]const u8{ "pane", "index", "status", "look", "exec", "log", "os" }) |want| {
+ for (names) |n| {
+ if (std.mem.eql(u8, n, want)) break;
+ } else return error.NotListed;
+ }
+ for (names) |n| try check(!std.mem.eql(u8, n, "self"), "self listed", .{});
+ try std.testing.expectEqualStrings("initial\n", try c.read(a, "/pane/1/body"));
+ const os_path = try std.fmt.allocPrint(a, "/os{s}/first.txt", .{root});
+ try std.testing.expectEqualStrings("initial\n", try c.read(a, os_path));
+ const listed = try c.list(a, try std.fmt.allocPrint(a, "/os{s}", .{root}));
+ for (listed) |n| {
+ if (std.mem.eql(u8, n, "first.txt")) break;
+ } else return error.NotListed;
+ try std.testing.expectEqualStrings("initial\n", try c.read(a, "/pane/1/../1/body"));
+ try std.testing.expectEqualStrings("initial\n", try c.read(a, try std.fmt.allocPrint(a, "/os{s}/../{s}/first.txt", .{ root, std.fs.path.basename(root) })));
+ try c.replace(os_path, "written through 9P\n");
+ try std.testing.expectEqualStrings("written through 9P\n", try d.get(a, "first.txt"));
+ try std.testing.expectEqualStrings("written through 9P\n", try c.read(a, os_path));
+}
+
+fn frames(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var d = try process.Detached.start(gpa, exe, "frames", .{});
+ defer d.deinit();
+ _ = std.c.mkdir(d.abs("listing"), 0o755);
+ _ = symlink(d.abs("listing/missing"), d.abs("listing/broken"));
+ for (0..24) |i| try d.put(try std.fmt.allocPrint(a, "listing/entry-{d:0>2}", .{i}), "");
+ const small = try Conn.dialSized(gpa, d.socket(), 256);
+ defer small.deinit(gpa);
+ const names = try small.list(a, try std.fmt.allocPrint(a, "/os{s}/listing", .{d.root()}));
+ try check(names.len == 24, "listed {d}: {any}", .{ names.len, names });
+ for (0..24) |i| {
+ const want = try std.fmt.allocPrint(a, "entry-{d:0>2}", .{i});
+ for (names) |n| {
+ if (std.mem.eql(u8, n, want)) break;
+ } else return error.NotListed;
+ }
+ const big = try Conn.dial(gpa, d.socket());
+ defer big.deinit(gpa);
+ try std.testing.expectEqual(@as(u32, 65536), big.msizeAgreed());
+}
+
+extern "c" fn symlink(target: [*:0]const u8, path: [*:0]const u8) c_int;
+
+fn frozenScreen(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var d = try process.Detached.start(gpa, exe, "frozen", .{});
+ defer d.deinit();
+ const c = try Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const frozen = try c.hold("/screen", 0);
+ var before: std.ArrayList(u8) = .empty;
+ try before.appendSlice(a, try c.readFid(frozen, 0, 31));
+ try c.write("/pane/1/body", "screen changed\n");
+ while (true) {
+ const chunk = try c.readFid(frozen, before.items.len, 65536);
+ if (chunk.len == 0) break;
+ try before.appendSlice(a, chunk);
+ }
+ c.clunk(frozen);
+ const json = try std.json.parseFromSliceLeaky(std.json.Value, a, before.items, .{});
+ var old: std.ArrayList(u8) = .empty;
+ for (json.object.get("cells").?.array.items) |cell| try old.appendSlice(a, cell.array.items[0].string);
+ try check(has(old.items, "initial") and !has(old.items, "screen changed"), "the open's screen moved", .{});
+ try check(has(try d.files.screen(), "screen changed"), "a new open shows the old screen", .{});
+ const body = "initial\nscreen changed\n";
+ for (0..12) |i| {
+ const other = try Conn.dial(gpa, d.socket());
+ defer other.deinit(gpa);
+ try check(std.mem.eql(u8, try other.read(a, "/pane/1/body"), body), "connection {d}", .{i});
+ }
+}
+
+fn looks(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var d = try process.Detached.start(gpa, exe, "first", .{});
+ defer d.deinit();
+ const c = try Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ // A build with its sources (-Dembed-sources) serves them under /src.
+ for (try c.list(a, "/")) |n| if (std.mem.eql(u8, n, "src")) {
+ const source = try c.look(a, "/virtual/src/pardes.zig", null);
+ try check(has(try c.pane(a, source, "body"), "pub const Pardes"), "/virtual/src", .{});
+ };
+ try d.put("index", "OS takes precedence\n");
+ var opened = try c.look(a, "index", null);
+ try std.testing.expectEqualStrings("OS takes precedence\n", try c.pane(a, opened, "body"));
+ opened = try c.look(a, "/n/self/index", null);
+ const index = try c.pane(a, opened, "body");
+ try check(std.mem.startsWith(u8, index, "1 ") and has(index, "first.txt"), "/n/self/index: {s}", .{index});
+ try d.put("explicit.txt", "explicit OS mount\n");
+ opened = try c.look(a, try std.fmt.allocPrint(a, "/n/os{s}", .{d.abs("explicit.txt")}), null);
+ try std.testing.expectEqualStrings("explicit OS mount\n", try c.pane(a, opened, "body"));
+}
+
+fn longNames(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var d = try process.Detached.start(gpa, exe, "long-names", .{});
+ defer d.deinit();
+ const c = try Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const dir_rel = try a.alloc(u8, 64);
+ @memcpy(dir_rel[0..10], "directory-");
+ @memset(dir_rel[10..], 'd');
+ _ = std.c.mkdir(d.abs(dir_rel), 0o755);
+ const dir = d.abs(dir_rel);
+ for ([_]usize{ 29, 63, 127, 255 }) |length| {
+ const name = try a.alloc(u8, length);
+ @memset(name[0 .. length - 4], 'f');
+ @memcpy(name[length - 4 ..], ".txt");
+ const rel = try std.fmt.allocPrint(a, "{s}/{s}", .{ dir_rel, name });
+ try d.put(rel, "long filename\n");
+ const wire = try std.fmt.allocPrint(a, "/os{s}", .{d.abs(rel)});
+ const listed = try c.list(a, try std.fmt.allocPrint(a, "/os{s}", .{dir}));
+ for (listed) |n| {
+ if (std.mem.eql(u8, n, name)) break;
+ } else return error.NotListed;
+ try std.testing.expectEqualStrings("long filename\n", try c.read(a, wire));
+ try c.replace(wire, "written through long filename\n");
+ try std.testing.expectEqualStrings("written through long filename\n", try d.get(a, rel));
+ const opened = try c.look(a, try std.fmt.allocPrint(a, "/n/os{s}", .{d.abs(rel)}), null);
+ try std.testing.expectEqualStrings("written through long filename\n", try c.pane(a, opened, "body"));
+ try c.removePane(opened); // a long name's tag takes rows
+ }
+ const opened = try c.look(a, try std.fmt.allocPrint(a, "/n/os{s}", .{dir}), null);
+ const listing = try c.pane(a, opened, "body");
+ for (try process.entries(a, dir)) |n| try check(has(listing, try std.fmt.allocPrint(a, "/n/os{s}/{s}", .{ dir, n })), "{s} not listed", .{n});
+}