summaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-04 16:46:18 -0300
committerGabriel Schneider <[email protected]>2026-11-04 16:55:32 -0300
commit6bcb18e021a09d51539e628106a594748637ead2 (patch)
tree954996560c694dd7f0ab410aa01def00d25c33fe /test
parentbe3985092df1c3388cfa09ca5e989d2fa66f55ec (diff)
downloadpardes-6bcb18e021a09d51539e628106a594748637ead2.tar.gz
pardes-6bcb18e021a09d51539e628106a594748637ead2.zip
test: fs.py's inline checks, quic_test, workflow_canary, python_repl_runs_one_line and signal_cleans_up moved to Zig, deleted from fs.py (its named cases stay): 21 process cases in test/process/ (flags: bad options refused in words, --9p naming the socket, forwarding a launch inside a session and the launches that start their own (mount, name, tcp, load, shells, toggle, quic), --wait and its refusals, pardes - and its +Pager (escapes, inks and Filter, progress, 11 MiB, the 256 MiB cut), $winid, the stdin boot, no terminal to draw on, a killed tty editor and its swept sockets, a signal unlinking the socket; mounts: --mount at startup, Mount and Unmount at run time, QUIC and TCP v4 and v6 detached and in a pty (skipped without -Dquic=true, passed with it); tree: the root and /os, 256-byte frames, a held ctl line, a frozen /screen, Look's precedence, 255-byte names; root-ctl: Restore detached and in a pty; builtins: Lspinfo; look-and-exec: the canary; repls: Python's pyrepl) and 3 behaviour tests (a 60 KB body write, truncated, a missing pane refused; a body write's EI record; keyword colour, not bold); process.zig gains, under fsb:, Conn.dialSized, dialTcp, replace, newPane, serials, look, pane, exec, execRefused, removePane, Files.fg, Detached.exists, abs, startTty, and Child (a program in a root's environment, its stdin fed, on a pty if asked, its stderr kept), run, code, entries, canonical, quicIncluded, nowMs, nap, has, check; each checked to fail against a break (no such option reworded, SyntaxBold on by default, a body insert's record not EI, Grep's miss reworded, already inside pardes reworded, a session already running reworded, Lspinfo's servers line reworded, no terminal to draw on reworded, unknown control message reworded); behaviour, process, fs-unit and core tests and the rest of fs.py pass
Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'test')
-rw-r--r--test/behaviour/event.zig11
-rw-r--r--test/behaviour/settings.zig34
-rw-r--r--test/behaviour/tree.zig15
-rw-r--r--test/fs.py1128
-rw-r--r--test/process.zig444
-rw-r--r--test/process/builtins.zig52
-rw-r--r--test/process/flags.zig778
-rw-r--r--test/process/look_and_exec.zig239
-rw-r--r--test/process/mounts.zig212
-rw-r--r--test/process/repls.zig79
-rw-r--r--test/process/root_ctl.zig87
-rw-r--r--test/process/tree.zig178
-rw-r--r--test/process_test.zig7
13 files changed, 2136 insertions, 1128 deletions
diff --git a/test/behaviour/event.zig b/test/behaviour/event.zig
index 77a80e30..65222175 100644
--- a/test/behaviour/event.zig
+++ b/test/behaviour/event.zig
@@ -69,3 +69,14 @@ test "event: a bad event record says what is wrong with it" {
try std.testing.expect(has(s.said, c[1]));
}
}
+
+test "event: a write to the body is an EI record to the reader holding event" {
+ var s = try Session.initFile(std.testing.allocator, "replaced\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const event = try s.hold(s.at("/pane/{d}/event", .{n}), 0);
+ defer s.clunk(event);
+ try s.write(s.at("/pane/{d}/body", .{n}), "event\n");
+ const record = try s.readFid(event);
+ try std.testing.expect(std.mem.startsWith(u8, record, "EI") and has(record, "event\n"));
+}
diff --git a/test/behaviour/settings.zig b/test/behaviour/settings.zig
index a24a3010..9a14ff50 100644
--- a/test/behaviour/settings.zig
+++ b/test/behaviour/settings.zig
@@ -269,3 +269,37 @@ test "settings: every on/off setting the root ctl reads flips when its word is w
try std.testing.expectEqualStrings("Theme acme", try setting(&s, "Theme"));
try std.testing.expectEqualStrings("Shell /bin/sh", try setting(&s, "Shell"));
}
+
+/// A cell's style (one of `Session.styles`) as its bold flag and ink.
+fn look(s: *Session, style: []const u8) !struct { bool, []const u8 } {
+ const a = s.arena.allocator();
+ const json = try std.json.parseFromSliceLeaky(std.json.Value, a, style, .{});
+ return .{ json.object.get("bold").?.bool, try std.json.Stringify.valueAlloc(a, json.object.get("fg").?, .{}) };
+}
+
+test "settings: a keyword is coloured apart from the text beside it, and not bold (SyntaxBold is off by default), at a long file's end" {
+ var s = try Session.initFile(std.testing.allocator, "initial\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try s.write(s.at("/pane/{d}/name", .{n}), "keywords.zig\n");
+ var source: std.ArrayList(u8) = .empty;
+ for (0..9999) |_| try source.appendSlice(s.arena.allocator(), "// padding\n");
+ try source.appendSlice(s.arena.allocator(), "fn check() void {\n if (true) return;\n}\n");
+ try s.replace(s.at("/pane/{d}/body", .{n}), source.items);
+ const screen = try s.screen();
+ const styles = try s.styles();
+ const cols = std.mem.indexOfScalar(u8, screen, '\n').?;
+ try std.testing.expectEqual(styles.len, cols * (std.mem.count(u8, screen, "\n") + 1));
+ for ([_][]const u8{ "fn", "if" }) |word| {
+ const col, const row = try s.where(s.at("{s} ", .{word}));
+ const at = row * cols + col;
+ _, const ink = try look(&s, styles[at]);
+ for (styles[at..][0..word.len]) |cell| {
+ const bold, const each = try look(&s, cell);
+ try std.testing.expect(!bold);
+ try std.testing.expectEqualStrings(ink, each);
+ }
+ _, const plain = try look(&s, styles[at + word.len]);
+ try std.testing.expect(!std.mem.eql(u8, ink, plain));
+ }
+}
diff --git a/test/behaviour/tree.zig b/test/behaviour/tree.zig
index 7f9b37a4..56806589 100644
--- a/test/behaviour/tree.zig
+++ b/test/behaviour/tree.zig
@@ -42,3 +42,18 @@ test "tree: a terminal is listed as term with its directory as name, which a wri
try std.testing.expectEqual(@as(u16, 22), try s.refused(s.at("/pane/{d}/name", .{n}), "/elsewhere\n"));
try std.testing.expect(std.mem.startsWith(u8, s.said, "invalid rename: a terminal is named"));
}
+
+test "tree: a body takes a 60 KB write whole, a truncating one replaces it, and a pane not there is refused" {
+ var s = try Session.initFile(std.testing.allocator, "initial\n");
+ defer s.deinit();
+ var payload: std.ArrayList(u8) = .empty;
+ for (0..3000) |_| try payload.appendSlice(s.arena.allocator(), "const value = \"λ\";\n");
+ const n = try s.newPane();
+ const body = s.at("/pane/{d}/body", .{n});
+ try s.write(body, payload.items);
+ try s.expect(body, payload.items);
+ try s.replace(body, "replaced\n");
+ try s.expect(body, "replaced\n");
+ try std.testing.expectError(error.Refused, s.read("/pane/4294967295/body"));
+ try s.expect(body, "replaced\n");
+}
diff --git a/test/fs.py b/test/fs.py
index c5dd6234..fa3388fe 100644
--- a/test/fs.py
+++ b/test/fs.py
@@ -4,9 +4,6 @@ import fcntl
import json
import os
import shutil
-import select
-import signal
-import socket
from pathlib import Path
import subprocess
import struct
@@ -777,245 +774,6 @@ def store_shared_between_windows(binary):
assert (root / '.local' / 'state' / 'pardes' / 'store').exists()
-def workflow_canary(binary):
- """One session driven as the dogfood agents drive it, asserting the log
- and the read-backs at every step: the canary for the main paths (the
- round-18 Grep that never found anything went through every narrower
- test). Look files, Grep and Find hits and misses, a plain word looked
- at, Edit in two files, Save, get, pty/run failing then passing, a
- command pane and Kill, a REPL send, the layout and a column's files,
- ask/answer, and Dump/Restore last."""
- started = time.monotonic()
- with tempfile.TemporaryDirectory(prefix='pardes-flow-') as directory:
- root = Path(directory)
- (root / 'a.txt').write_bytes(b'alpha one\nshared word\n')
- (root / 'b.txt').write_bytes(b'beta two\nshared word\n')
- (root / 's.sh').write_bytes(b'echo from-file\n')
-
- def wait(ready, what, seconds=10):
- deadline = time.monotonic() + seconds
- while not ready():
- assert time.monotonic() < deadline, what
- time.sleep(.05)
-
- with session(binary, root, 'flow') as (client, address):
- def log():
- return client.read('/log').decode('utf-8', 'replace')
-
- def made_by(serial, line):
- """The pane an exec at `serial` made, as exec reads it back."""
- client.write(f'/pane/{serial}/exec', line)
- return int(client.read(f'/pane/{serial}/exec').split()[-1])
-
- # Look opens files, and the log says new.
- a = look(client, str(root / 'a.txt'))
- b = look(client, str(root / 'b.txt'))
- assert client.read(f'/pane/{a}/body') == b'alpha one\nshared word\n'
- assert f'new {a} {root}/a.txt\n' in log() and f'new {b} {root}/b.txt\n' in log()
-
- # 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.
- grep = made_by(a, b'Grep shared\n')
- rows = client.read(f'/pane/{grep}/body').decode()
- assert rows == 'Grep shared\na.txt\na.txt:2:1 shared word\nb.txt\nb.txt:2:1 shared word\n', rows
- client.remove(f'/pane/{grep}')
- execute_refused(client, a, 'Grep zzqqnomatch', 'Grep: text not found')
- found = made_by(a, b'Find b.txt\n')
- assert 'b.txt' in client.read(f'/pane/{found}/body').decode()
- client.remove(f'/pane/{found}')
- execute_refused(client, a, 'Find zzqqnomatch', 'Find: name not found')
-
- # A plain word looked at is found in the pane, after its dot.
- client.write(f'/pane/{a}/dot', b' 0 0 ')
- client.write(f'/pane/{a}/look', b'shared\n')
- assert client.read(f'/pane/{a}/dot').split() == [b'10', b'16'], client.read(f'/pane/{a}/dot')
-
- # Edit in two files, then Save each: on disk, and logged.
- for pane in (a, b):
- client.write(f'/pane/{pane}/ctl', b'Edit ,s/shared/SHARED/g\n')
- assert client.read(f'/pane/{b}/body') == b'beta two\nSHARED word\n'
- for pane in (a, b):
- client.write(f'/pane/{pane}/exec', b'Save\n')
- assert (root / 'a.txt').read_bytes() == b'alpha one\nSHARED word\n'
- assert f'save {a} {root}/a.txt\n' in log() and f'save {b} {root}/b.txt\n' in log()
-
- # get reloads what changed on disk.
- (root / 'b.txt').write_bytes(b'from disk\n')
- client.write(f'/pane/{b}/ctl', b'get\n')
- assert client.read(f'/pane/{b}/body') == b'from disk\n'
-
- # A terminal: pty/run failing then passing.
- term = made_by(1, b'Tty\n')
-
- def run(line):
- fid = client.open(f'/pane/{term}/pty/run', 2)
- try:
- client.rpc(118, struct.pack('<IQI', fid, 0, len(line)) + line)
- return client.read_fid(fid)
- finally:
- client.close(fid)
- deadline = time.monotonic() + 10
- while (answer := run(b'true\n')) != b'exit 0\n':
- assert time.monotonic() < deadline, answer
- time.sleep(.05)
- assert run(b'false\n') == b'exit 1\n'
- assert run(b'echo passed\n') == b'exit 0\npassed\n'
- # (A run's answer is its record: the log has no err for these.)
- assert f'err {term} pty/run' not in log(), log()
-
- # A command pane, and Kill: its exit is logged.
- sleeper = made_by(a, b'sleep 30\n')
- assert f'run {sleeper} sleep 30\n' in log()
- client.write('/ctl', b'Kill sleep\n')
- wait(lambda: f'\nexit {sleeper} ' in log(), 'Kill: no exit logged')
-
- # A REPL send: a program in the terminal (cat, which says back
- # what it is sent; a nested shell reads as the shell itself)
- # bound as bash's REPL, an exec on a .sh file's body (its event
- # written back) goes there.
- s = look(client, str(root / 's.sh'))
- client.write(f'/pane/{term}/pty/data', b'cat\r')
- wait(lambda: client.read(f'/pane/{term}/pty/status').split()[-1] == b'1', ('the REPL program did not start', client.read(f'/pane/{term}/body')[-300:]))
- client.write(f'/pane/{term}/ctl', b'Repl bash\n')
- fid = client.open(f'/pane/{s}/event', 2)
- try:
- record = b'MX0 0 0 14 echo from-file\n'
- client.rpc(118, struct.pack('<IQI', fid, 0, len(record)) + record)
- finally:
- client.close(fid)
- wait(lambda: f'\nsend {s} {term} ' in log(), ('no REPL send logged', log()[-800:]))
- wait(lambda: client.read(f'/pane/{term}/body').count(b'echo from-file') >= 2, 'the REPL did not get it')
- client.write(f'/pane/{term}/ctl', b'Repl -\n')
- client.write(f'/pane/{term}/pty/data', b'\x04')
- wait(lambda: run(b'true\n') == b'exit 0\n', 'the terminal did not come back to its shell')
-
- # The layout and a column's files: Newcol, its tag, rmdir.
- assert len(client.read('/layout').splitlines()) >= 2 # a column, then `active`
- client.write('/ctl', b'Newcol\n')
- columns = [row for row in client.read('/layout').splitlines() if not row.startswith(b'active')]
- assert len(columns) == 2, columns
- empty = columns[-1].split()[0].decode()
- assert b'New' in client.read(f'/col/{empty}/tag')
- client.remove(f'/col/{empty}')
- assert len([row for row in client.read('/layout').splitlines() if not row.startswith(b'active')]) == 1
-
- # ask/answer: Save on a terminal asks for a path over 9P.
- client.write(f'/pane/{term}/exec', b'Save\n')
- wait(lambda: f'ask {term} save path\n' in log(), 'no ask logged')
- client.write(f'/pane/{term}/ctl', f'answer {root}/scroll.txt\n'.encode())
- wait(lambda: (root / 'scroll.txt').exists(), 'the answered Save wrote nothing')
- assert f'answer {term} {root}/scroll.txt\n' in log()
-
- # Dump, then Restore it: the new session names its panes.
- client.write('/ctl', b'Dump\n')
- saved = root / 'flow.dump.zon'
- wait(saved.exists, 'Dump wrote nothing')
- assert f'dump {saved}\n' in log()
- try:
- client.write('/ctl', f'Restore {saved}\n'.encode())
- except (EOFError, OSError):
- pass
- time.sleep(.5)
- with Client(address) as restored:
- wait(lambda: f'restore {saved}' in restored.read('/log').decode(), 'Restore not logged')
- names = restored.read('/index').decode()
- assert f'{root}/a.txt' in names and f'{root}/b.txt' in names, names
- # Recent goes on across the Restore, and is kept after it.
- assert f'{root}/a.txt\n' in restored.read('/recent').decode(), restored.read('/recent')
- (root / 'after.txt').write_bytes(b'after\n')
- look(restored, str(root / 'after.txt'))
- assert f'open {root}/after.txt\n' in restored.read('/recent').decode()
- state = root / '.local' / 'state' / 'pardes' / 'store'
- wait(lambda: f'{root}/after.txt'.encode() in state.read_bytes(), 'Recent not kept after Restore')
- assert time.monotonic() - started < 30, 'the canary took too long'
-
-
-def python_repl_runs_one_line(binary):
- """A one-line exec sent to Python's own REPL (3.13's pyrepl, which asks
- for bracketed paste) runs at once, with no second Enter: the Enter
- reaches it after the paste, not inside it. A real pty, a real python3."""
- python = shutil.which('python3')
- if python is None:
- return
- version = subprocess.run([python, '-c', 'import sys; print(sys.version_info >= (3, 13))'],
- capture_output=True, text=True).stdout.strip()
- if version != 'True':
- return
- with tempfile.TemporaryDirectory(prefix='pardes-repl-') as directory:
- with session(binary, Path(directory), 'repl') as (client, _):
- def panes(client):
- return {int(row.split()[0]) for row in client.read('/index').splitlines()}
- before = panes(client)
- client.write('/pane/1/ctl', b'Tty\n')
- deadline = time.monotonic() + 10
- while time.monotonic() < deadline and panes(client) == before:
- time.sleep(.05)
- tty = max(panes(client) - before)
- def body():
- return client.read(f'/pane/{tty}/body').decode('utf-8', 'replace')
- def wait_for(text, seconds=15):
- deadline = time.monotonic() + seconds
- while time.monotonic() < deadline:
- if text in body():
- return True
- time.sleep(.1)
- return False
- assert wait_for('$') or wait_for('>'), body()
- client.write(f'/pane/{tty}/pty/data', python.encode() + b' -q\r')
- assert wait_for('>>>'), body()
- client.write(f'/pane/{tty}/ctl', b'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.
- fid = client.open(f'/pane/{tty}/event', 2)
- try:
- record = b'MX0 0 0 10 print(6*7)\n'
- client.rpc(118, struct.pack('<IQI', fid, 0, len(record)) + record)
- assert wait_for('\n42'), 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 n in range(5):
- time.sleep(2)
- line = f'print({1000 + n})'.encode()
- record = b'MX0 0 0 %d %s\n' % (len(line), line)
- client.rpc(118, struct.pack('<IQI', fid, 0, len(record)) + record)
- assert wait_for(f'\n{1000 + n}'), (n, 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 code, outputs in [(b'print(11)\nprint(22)', ['11', '22']),
- (b'print(33)\nprint(44)\n', ['33', '44']),
- (b'for i in range(2):\n print(55 + i)\nprint(77)\n', ['55', '56', '77'])]:
- record = b'MX0 0 0 %d %s\n' % (len(code), code)
- client.rpc(118, struct.pack('<IQI', fid, 0, len(record)) + record)
- for out in outputs:
- assert wait_for(f'\n{out}\n'), (code, out, body())
- time.sleep(.5)
- assert body().rstrip().endswith('>>>'), (code, body()[-200:])
- finally:
- client.close(fid)
-
-
-def signal_cleans_up(binary):
- """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 sig in [signal.SIGTERM, signal.SIGINT, signal.SIGHUP]:
- with tempfile.TemporaryDirectory(prefix='pardes-sig-') as directory:
- root = Path(directory)
- seen = {}
- with session(binary, root, 'sig', terminal=seen) as (client, address):
- assert address.exists()
- if sig == signal.SIGHUP:
- os.kill(seen['pid'], sig)
- time.sleep(.3)
- assert address.exists() and client.read('/index'), 'a hangup ended a kept session'
- sig = signal.SIGTERM
- os.kill(seen['pid'], sig)
- deadline = time.monotonic() + 5
- while address.exists() and time.monotonic() < deadline:
- time.sleep(.01)
- assert not address.exists(), (sig, list(root.iterdir()))
-
-
def odd_paths(binary):
"""Long and odd paths written where a path goes -- name, look, DumpDir,
Dump, Save -- are refused or said, never a crash: a part over 255 bytes
@@ -1217,897 +975,11 @@ def test(binary, quic=False):
new_terminals_named_once(binary)
directory_panes(binary)
putall_answers_after_its_saves(binary)
- workflow_canary(binary)
recent_survives_restart(binary)
store_shared_between_windows(binary)
- python_repl_runs_one_line(binary)
- signal_cleans_up(binary)
- for options, message in [
- (['--fs'], b'no such option'),
- (['--fs9'], b'no such option'),
- (['--', 'a', 'b'], b'is the second'),
- (['--9p'], b'--9p needs a socket name'),
- (['--9p='], b'invalid 9P socket name'),
- (['--9p=a/b'], b'invalid 9P socket name'),
- (['--attach=work', '--9p=work'], b'--attach has none'),
- (['--9p-tcp'], b'--9p-tcp needs'),
- (['--9p-tcp='], b'--9p-tcp needs'),
- (['--9p-tcp=tcp!localhost!5640'], b'--9p-tcp needs'),
- (['--9p-tcp=quic!127.0.0.1!5640'], b'--9p-tcp needs'),
- (['--9p-tcp=tcp!127.0.0.1!5640', '--9p-tcp=tcp!127.0.0.1!5641'], b'specified twice'),
- (['--attach=work', '--9p-tcp=tcp!127.0.0.1!5640'], b'--attach has none'),
- (['--9p-quic'], b'--9p-quic needs'),
- (['--9p-quic='], b'--9p-quic needs'),
- (['--9p-quic=tcp!127.0.0.1!5640'], b'--9p-quic needs'),
- (['--mount=os=work'], b'invalid mount name'),
- (['--mount=peer='], b'invalid mount name or dial'),
- (['--mount=peer=one', '--mount=peer=two'], b'duplicate mount'),
- (['--mount=peer=tcp!127.0.0.1!0'], b'invalid mount dial'),
- (['--attach=work', '--mount=peer=one'], b'--attach has none'),
- ]:
- result = subprocess.run([binary, *options], capture_output=True, timeout=5)
- assert result.returncode == 1 and message in result.stderr, (options, result)
- with tempfile.TemporaryDirectory(prefix='pardes-fs-') as directory:
- root = Path(directory)
- with session(binary, root, 'renamed', '--9p=explicit', socket_name='explicit') as (named, named_address):
- assert named_address.name == 'pardes-9p-explicit.sock'
- assert not (root / 'pardes-9p-renamed.sock').exists()
- assert named.read('/pane/1/body') == b'initial\n'
- with session(binary, root, 'first') as (client, address):
- assert {'pane', 'index', 'status', 'look', 'exec', 'log', 'os'} <= set(client.list('/'))
- assert 'self' not in client.list('/')
- assert client.read('/pane/1/body') == b'initial\n'
- assert client.read('/os' + str(root / 'first.txt')) == b'initial\n'
- assert 'first.txt' in client.list('/os' + str(root))
- assert client.read('/pane/1/../1/body') == b'initial\n'
- assert client.read('/os' + str(root) + '/../' + root.name + '/first.txt') == b'initial\n'
-
- listing = root / 'listing'
- listing.mkdir()
- (listing / 'broken').symlink_to(listing / 'missing')
- for number in range(24):
- (listing / f'entry-{number:02}').touch()
- with Client(address, msize=256) as small:
- assert set(small.list('/os' + str(listing))) == {
- f'entry-{number:02}' for number in range(24)}
- # 64 KiB frames: a ctl line with no newline is held whatever the
- # size of its write -- a mount cuts lines anywhere -- and runs at
- # the close, its failure then in the log.
- with Client(address, msize=65536) as big:
- assert big.msize == 65536
- ctl = big.open('/pane/1/ctl', 1)
- line = b'bogus' + b'x' * 20000
- big.rpc(118, struct.pack('<IQI', ctl, 0, len(line)) + line)
- assert b'ctl: unknown control message' not in client.read('/log')
- big.close(ctl)
- assert b'ctl: unknown control message' in client.read('/log')
-
- frozen = client.open('/screen')
- before = bytearray(client.read_fid(frozen, count=31))
- client.write('/pane/1/body', b'screen changed\n')
- while chunk := client.read_fid(frozen, len(before)):
- before.extend(chunk)
- client.close(frozen)
- old_screen = json.loads(before)
- old_text = ''.join(cell[0] for cell in old_screen['cells'])
- assert 'initial' in old_text and 'screen changed' not in old_text
- assert 'screen changed' in ''.join(cell[0] for cell in client.screen()['cells'])
-
- payload = ('const value = "λ";\n' * 3000).encode()
- serial = new_pane(client, payload)
- body = f'/pane/{serial}/body'
- assert client.read(body) == payload
- client.write(body, b'replaced\n', truncate=True)
- assert client.read(body) == b'replaced\n'
-
- event = client.open(f'/pane/{serial}/event')
- client.write(body, b'event\n')
- record = client.read_fid(event)
- assert record.startswith(b'EI') and b'event\n' in record, record
- client.close(event)
-
- os_path = '/os' + str(root / 'first.txt')
- client.write(os_path, b'written through 9P\n', truncate=True)
- assert (root / 'first.txt').read_bytes() == b'written through 9P\n'
- assert client.read(os_path) == b'written through 9P\n'
-
- for index in range(12):
- with Client(address) as other:
- assert other.read(body) == b'replaced\nevent\n', index
-
- missing = False
- try:
- client.read('/pane/4294967295/body')
- except OSError:
- missing = True
- assert missing
- assert client.read(body) == b'replaced\nevent\n'
-
- if 'src' in client.list('/'):
- source = look(client, '/virtual/src/pardes.zig')
- assert b'pub const Pardes' in client.read(f'/pane/{source}/body')
-
- (root / 'index').write_bytes(b'OS takes precedence\n')
- opened = look(client, 'index')
- assert client.read(f'/pane/{opened}/body') == b'OS takes precedence\n'
- opened = look(client, '/n/self/index')
- index = client.read(f'/pane/{opened}/body')
- assert index.split()[0] == b'1' and b'first.txt' in index, index
- (root / 'explicit.txt').write_bytes(b'explicit OS mount\n')
- opened = look(client, '/n/os' + str(root / 'explicit.txt'))
- assert client.read(f'/pane/{opened}/body') == b'explicit OS mount\n'
-
- own = root / 'pardes-9p-second.sock'
- with session(binary, root, 'second', '--mount=peer=' + str(address),
- '--mount=own=' + str(own)) as (remote, _):
- opened = look(remote, '/n/own/pane/1/body')
- assert remote.read(f'/pane/{opened}/body') == b'initial\n'
- opened = look(remote, '/n/peer/pane/' + str(serial) + '/body')
- assert remote.read(f'/pane/{opened}/body') == b'replaced\nevent\n'
- remote.write(f'/pane/{opened}/body', b'saved to peer\n', truncate=True)
- remote.write(f'/pane/{opened}/exec', b'Save\n')
- assert client.read(body) == b'saved to peer\n'
-
- large = b'mounted file contents\n' * 60000
- large_path = root / 'large.txt'
- large_path.write_bytes(large)
- opened = look(remote, '/n/peer/os' + str(large_path))
- assert remote.read(f'/pane/{opened}/body') == large
- edited = large[:-3] + b'edited\n'
- remote.write(f'/pane/{opened}/body', edited, truncate=True)
- remote.write(f'/pane/{opened}/exec', b'Save\n')
- assert large_path.read_bytes() == edited
- assert client.read('/os' + str(large_path)) == edited
- # 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.
- remote.write('/look', b'/n/peer/os' + str(root / 'no-such-file.txt').encode() + b'\n')
- assert b'no such file' in remote.read('/log')
-
- with session(binary, root, 'runtime') as (remote, own_address):
- control = new_pane(remote, b'')
- execute(remote, control, 'Mount peer ' + str(address))
- opened = look(remote, '/n/peer/pane/1/body', source=control)
- assert remote.read(f'/pane/{opened}/body') == client.read('/pane/1/body')
- # A builtin that fails through exec fails the write (one rule).
- execute_refused(remote, control, 'Mount peer ' + str(own_address), 'already mounted')
- execute_refused(remote, control, 'Unmount peer', 'mount in use') # a pane is open on it
- remote.write(f'/pane/{opened}/body', b'runtime mounted Save\n', truncate=True)
- remote.write(f'/pane/{opened}/exec', b'Save\n')
- assert client.read('/pane/1/body') == b'runtime mounted Save\n'
- assert remote.read('/pane/1/body') == b'initial\n'
- roots = look(remote, '/n', source=control)
- assert b'/n/peer/\n' in remote.read(f'/pane/{roots}/body')
- remote.write(f'/pane/{opened}/exec', b'Del\n')
- execute(remote, control, 'Unmount peer')
- remote.write(f'/pane/{roots}/ctl', b'get\n')
- assert remote.read(f'/pane/{roots}/body') == b'/n/os/\n/n/self/\n'
- execute(remote, control, 'Mount peer ' + str(own_address))
- opened = look(remote, '/n/peer/pane/1/body', source=control)
- assert remote.read(f'/pane/{opened}/body') == b'initial\n'
-
- with session(binary, root, 'mounted-startup', '--mount=peer=' + str(address),
- file='/n/peer/pane/1/body:1') as (remote, _):
- assert remote.read('/pane/1/body') == b'runtime mounted Save\n'
-
- client.write(f'/pane/{serial}/exec', b'Del\n')
- assert str(serial) not in client.list('/pane')
-
- for tty in [False, True]:
- name = 'restore tty space' if tty else 'restore detached space'
- with session(binary, root, name, tty=tty) as (old, address):
- old.write('/pane/1/body', b'dumped state\n', truncate=True)
- control = new_pane(old, b'')
- execute_refused(old, control, 'Restore ' + str(root / 'missing dump.zon'), 'no such file')
- assert old.read('/pane/1/body') == b'dumped state\n'
- execute(old, control, 'Mount own ' + str(address))
- execute(old, control, 'Dump')
- saved = root / (name + '.dump.zon')
- deadline = time.monotonic() + 5
- while not saved.exists():
- assert time.monotonic() < deadline, 'Dump did not write its state'
- time.sleep(.005)
- held_body = old.open('/pane/1/body')
- held_screen = old.open('/screen')
- old_ids = {int(row.split()[0]) for row in old.read('/index').splitlines()}
- assert old.read_fid(held_body) == b'dumped state\n'
- assert old.read_fid(held_screen, count=1) == b'{'
- old.write('/pane/1/body', b'changed after dump\n', truncate=True)
- # Unsaved text is asked about once, as Exit asks; the second
- # Restore goes ahead, and is answered before the hang-up.
- try:
- execute(old, control, 'Restore ' + str(saved))
- except OSError as refused:
- assert 'Modified' in str(refused), refused
- assert old.read('/pane/1/body') == b'changed after dump\n'
- # Answered before the hang-up: the write's reply comes; the
- # clunk after it may meet the connection already cut.
- restore = old.open(f'/pane/{control}/exec', 1)
- line = ('Restore ' + str(saved) + '\n').encode()
- old.rpc(118, struct.pack('<IQI', restore, 0, len(line)) + line)
- try:
- old.close(restore)
- except (EOFError, OSError):
- pass
- # Refused while the connections are cut, or cut already.
- try:
- old.read_fid(held_body)
- except (EOFError, OSError):
- pass
- else:
- raise AssertionError('Restore left an old body fid usable')
- with Client(address) as restored:
- # The new log names its panes, then where they came from.
- log = restored.read('/log')
- assert b'\nrestore ' + str(saved).encode() + b'\n' in log, log
- # Its panes are the dump's, their serials too.
- restored_ids = [int(row.split()[0]) for row in restored.read('/index').splitlines()]
- assert len(restored_ids) == 2 and set(restored_ids) == old_ids, restored_ids
- file_id, control_id = restored_ids
- contents = restored.read(f'/pane/{file_id}/body')
- assert contents == b'dumped state\n', (contents, saved.read_text(), restored.read('/index'))
- assert restored.read(f'/pane/{control_id}/body') == b'', 'commands ran through exec, not the body'
- assert restored.screen()['cols'] == (80 if tty else 160) # a detached one is 160x50
- opened = look(restored, '/n/own/os' + str(root / (name + '.txt')), source=control_id)
- assert restored.read(f'/pane/{opened}/body') == b'initial\n'
-
- with session(binary, root, 'forwarding') as (client, address):
- child_dir = root / 'child-working-directory'
- child_dir.mkdir()
- spaced = child_dir / 'space name.txt'
- spaced.write_bytes(b'first line\nsecond line\n')
- env = os.environ.copy()
- # PARDES_PID is what says "you are inside a pardes"; the socket
- # and the pane only say how to reach it. Without the pid the child
- # starts its own session, so this test used to pass only when the
- # runner itself happened to be running inside one.
- status = dict(line.split(maxsplit=1) for line in client.read('/status').decode().splitlines())
- env.update(PARDES_9P=str(address), PARDES_PANE='1', PARDES_PID=status['pid'])
- env.pop('PARDES_FORWARD_LOOK', None)
- for word, expected, selected, reuse in [('space name.txt:2:4', spaced.read_bytes(), [14, 14], False),
- ('/n/self/pane/1/body', b'initial\n', None, False),
- ('/virtual/pane/1/body:1:2-4', b'initial\n', [1, 4], True)]:
- before = {int(row.split()[0]) for row in client.read('/index').splitlines()}
- result = subprocess.run([binary, '--tty', word], cwd=child_dir, env=env,
- capture_output=True, timeout=3)
- assert result.returncode == 0, (word, result.stderr)
- after = {int(row.split()[0]) for row in client.read('/index').splitlines()}
- if reuse:
- assert after == before
- else:
- opened, = after - before
- assert client.read(f'/pane/{opened}/body') == expected
- assert client.read('/pane/1/body') == b'initial\n'
- if selected is not None:
- # The selection is dot; reading it takes no command at all.
- actual = list(map(int, client.read(f'/pane/{opened}/dot').split()))
- assert actual == selected, (word, actual, selected)
- addr = client.open('/pane/1/addr', 2)
- limit = client.open('/pane/1/limit', 2)
- for fid, text in [(addr, b'#0,#3'), (limit, b'#0,#3'), (addr, b'#0')]:
- client.rpc(118, struct.pack('<IQI', fid, 0, len(text)) + text)
- try:
- for _ in range(8):
- result = subprocess.run([binary], cwd=child_dir, env=env,
- capture_output=True, timeout=3)
- assert result.returncode == 1 and b'already inside pardes' in result.stderr
- text = b'/tial/'
- try:
- client.rpc(118, struct.pack('<IQI', addr, 0, len(text)) + text)
- except OSError:
- pass
- else:
- raise AssertionError('no-argument child cleared the parent address limit')
- finally:
- client.close(addr)
- client.close(limit)
- client.read('/pane/1/ctl')
-
- control = new_pane(client, b'')
- execute(client, control, 'Dump')
- saved = root / 'forwarding.dump.zon'
- deadline = time.monotonic() + 3
- while not saved.exists():
- assert time.monotonic() < deadline, 'forwarding fixture Dump did not finish'
- time.sleep(.005)
- before = client.read('/index')
- inherited = {key: env[key] for key in ['PARDES_9P', 'PARDES_PANE', 'PARDES_PID']}
- cases = [
- ('mount', ['--mount=peer=' + str(address), '/n/peer/pane/1/body'], None),
- ('name', ['--9p=forwarded-name'], 'forwarded-name'),
- ('tcp', ['--9p-tcp=tcp!127.0.0.1!0'], None),
- ('load', ['-l', str(saved)], None),
- ('shells', ['-n', '3'], None),
- ('toggle', ['--tty-toggle=q'], None),
- ('toggle-arg', ['--tty-toggle', 'q'], None),
- ]
- if quic:
- cases.append(('quic', ['--9p-quic=quic!127.0.0.1!0'], None))
- for name, options, socket_name in cases:
- with session(binary, root, 'forward-' + name, tty=True, socket_name=socket_name,
- launch=[*([] if name == 'shells' else ['--tty']), *options],
- inherited=inherited) as (local, local_address):
- assert local_address != address
- index = local.read('/index').splitlines()
- if name == 'mount':
- assert len(index) == 1 and b'/n/peer/' in index[0], index
- assert local.read('/pane/1/body') == b'initial\n'
- elif name == 'load':
- assert local.read('/index') == before
- assert local.read('/pane/1/body') == b'initial\n'
- else:
- # A bare tty launch is a shell plus the empty text pane
- # the boot puts under it; --shells=3 is the classic
- # three-shell layout and has no scratch.
- assert len(index) == (3 if name == 'shells' else 2), index
- if name in ['tcp', 'quic']:
- assert (name + '!127.0.0.1!').encode() in local.read('/listeners')
- assert client.read('/index') == before
- assert client.read('/pane/1/body') == b'initial\n'
-
- # 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 drawn inside the pane that asked.
- gone = subprocess.run([binary, '--tty', str(spaced)], cwd=root,
- env=dict(env, PARDES_PANE='4294967295'), stdin=subprocess.DEVNULL,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert gone.returncode == 1 and gone.stderr.startswith(b'pardes: '), gone
- assert client.read('/index') == before
- for name, identity, word in [
- ('stale-file', dict(inherited, PARDES_9P=str(root / 'absent.sock')), str(spaced)),
- ('stale-missing', dict(inherited, PARDES_9P=str(root / 'absent.sock')), 'missing-child-file.txt'),
- ('stale-noarg', dict(inherited, PARDES_9P=str(root / 'absent.sock')), None),
- # No pid means "not inside a pardes at all", which is what
- # --nested withholds and what a plain shell has.
- ('not-nested', {k: v for k, v in inherited.items() if k != 'PARDES_PID'}, str(spaced)),
- ]:
- with session(binary, root, name, tty=True, inherited=identity,
- launch=['--tty', *([word] if word else [])]) as (local, local_address):
- assert local_address != address
- if word == str(spaced):
- assert local.read('/pane/1/body') == spaced.read_bytes()
- elif word:
- assert word.encode() in local.read('/index') or word in ''.join(
- cell[0] for cell in local.screen()['cells'])
- assert client.read('/index') == before
-
- # --wait (acme's E): a launch inside a pane lasts until the pane it
- # opened is deleted, as an $EDITOR must; one on a file already open
- # waits on that pane; a session that goes away ends it with 1.
- with session(binary, root, 'wait') as (client, address):
- # A command run from a pane's tag gets acme's $winid, that pane;
- # one from the workspace's tag, none.
- def command_body(node, line):
- client.write(node, line)
- serial = int(client.read(node).split()[-1])
- deadline = time.monotonic() + 10
- while True:
- log = client.read('/log').decode()
- ran = log.rfind(f'\nrun {serial} ')
- if ran >= 0 and f'\nexit {serial} ' in log[ran:]:
- body = client.read(f'/pane/{serial}/body').decode().split('% echo winid')[-1]
- client.remove(f'/pane/{serial}')
- return body
- assert time.monotonic() < deadline, log[-400:]
- time.sleep(.05)
- first_pane = min(int(row.split()[0]) for row in client.read('/index').splitlines())
- assert f'winid={first_pane}\n' in command_body(f'/pane/{first_pane}/tagexec', b'echo winid=$winid\n')
- assert 'winid=\n' in command_body('/tagexec', b'echo winid=$winid\n')
- # A second --detach of a name a live session holds: said, exit 1,
- # no Zig error trace.
- second_env = {k: v for k, v in os.environ.items() if not k.startswith('PARDES_')}
- second_env.update(HOME=str(root), XDG_RUNTIME_DIR=str(root))
- second = subprocess.run([binary, '--detach=wait'], cwd=root, env=second_env,
- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, timeout=20)
- assert second.returncode == 1, second
- assert second.stderr == b'pardes: a session named wait is already running\n', second.stderr
- status = dict(line.split(maxsplit=1) for line in client.read('/status').decode().splitlines())
- env = {k: v for k, v in os.environ.items() if k != 'PARDES_FORWARD_LOOK'}
- env.update(PARDES_9P=str(address), PARDES_PANE='1', PARDES_PID=status['pid'])
- edited = root / 'wait edit.txt'
- edited.write_bytes(b'edit me\n')
-
- def serials():
- return {int(row.split()[0]) for row in client.read('/index').splitlines()}
-
- def launch(flag):
- before = serials()
- child = subprocess.Popen([binary, flag, str(edited)], cwd=root, env=env,
- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
- deadline = time.monotonic() + 3
- while child.poll() is None and not serials() - before and time.monotonic() < deadline:
- time.sleep(.01)
- return child
-
- first = launch('--wait')
- opened, = serials() - {1}
- second = launch('-w')
- time.sleep(.5)
- assert first.poll() is None and second.poll() is None, (first.stderr.read(), second.stderr.read())
- assert serials() == {1, opened}
- client.write(f'/pane/{opened}/body', b'edited\n', truncate=True)
- execute(client, opened, 'Save')
- client.remove(f'/pane/{opened}')
- deleted = time.monotonic()
- assert first.wait(timeout=5) == 0
- # Woken by the `del` record, not a poll.
- assert time.monotonic() - deleted < .05, time.monotonic() - deleted
- assert second.wait(timeout=5) == 0
- assert edited.read_bytes() == b'edited\n'
- # --wait from outside the session's panes, $PARDES_9P alone (an
- # agent's EDITOR): asked of the session, not a screen of its own.
- outside_env = {k: v for k, v in env.items() if k not in ('PARDES_PANE', 'PARDES_PID')}
- far = root / 'wait far.txt'
- far.write_bytes(b'far\n')
- before = serials()
- waiting = subprocess.Popen([binary, '--wait', str(far)], cwd=root, env=outside_env,
- stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
- deadline = time.monotonic() + 5
- while not serials() - before and time.monotonic() < deadline:
- time.sleep(.01)
- far_pane, = serials() - before
- time.sleep(.3)
- assert waiting.poll() is None, waiting.stderr.read()
- client.remove(f'/pane/{far_pane}')
- assert waiting.wait(timeout=5) == 0
- # --wait with a $PARDES_9P that answers no more: said, exit 1,
- # never a screen of its own drawn in the asker's terminal.
- dead_env = dict(outside_env, PARDES_9P=str(root / 'pardes-9p-gone.sock'))
- gone = subprocess.run([binary, '--wait', str(far)], cwd=root, env=dead_env, capture_output=True, timeout=10)
- assert gone.returncode == 1 and b'does not answer' in gone.stderr, gone
- # --wait with no FILE says it needs one, and waits on nothing.
- bare = subprocess.run([binary, '--wait'], cwd=root, env=env, capture_output=True, timeout=10)
- assert bare.returncode == 1 and b'--wait needs a FILE' in bare.stderr, bare
- # `--` ends the options: a name starting with a dash is a name.
- dash = root / '-dash.txt'
- dash.write_bytes(b'dash\n')
- before = serials()
- assert subprocess.run([binary, '--', dash.name], cwd=root, env=env, capture_output=True, timeout=10).returncode == 0
- dashed, = serials() - before
- assert client.read(f'/pane/{dashed}/name').rstrip(b'\n') == str(dash).encode()
- client.remove(f'/pane/{dashed}')
- # A name under a directory that may not be searched is refused,
- # permission denied, exit 1, no pane: its Save could never be.
- # (Root searches any directory.)
- if os.geteuid() != 0:
- (root / 'noperm').mkdir()
- (root / 'noperm').chmod(0)
- before = serials()
- try:
- denied = subprocess.run([binary, 'noperm/a/b/c'], cwd=root, env=env, capture_output=True, timeout=10)
- finally:
- (root / 'noperm').chmod(0o755)
- assert denied.returncode == 1 and b'permission denied' in denied.stderr, denied
- assert serials() == before
- # --wait waits on the pane its look answered, on the look's own
- # open: a name /index shows escaped (a backslash is `\\` there)
- # is still the pane waited on, not one already gone.
- odd = root / 'wait\\odd.txt'
- odd.write_bytes(b'odd\n')
- before = serials()
- waiting = subprocess.Popen([binary, '--wait', str(odd)], cwd=root, env=env,
- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
- deadline = time.monotonic() + 3
- while not serials() - before and time.monotonic() < deadline:
- time.sleep(.01)
- odd_pane, = serials() - before
- time.sleep(.5)
- assert waiting.poll() is None, waiting.stderr.read()
- client.remove(f'/pane/{odd_pane}')
- assert waiting.wait(timeout=5) == 0
- # 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.
- fresh = root / 'wait new.txt'
- before = serials()
- made = subprocess.Popen([binary, '--wait', fresh.name], cwd=root, env=env,
- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
- # The launch makes the pane (pane/new), then names it: wait for
- # the name, not the pane.
- deadline = time.monotonic() + 3
- while str(fresh).encode() not in client.read('/index'):
- assert made.poll() is None, made.stderr.read()
- assert time.monotonic() < deadline, 'a new name opened no pane named it'
- time.sleep(.01)
- named, = serials() - before
- client.write(f'/pane/{named}/body', b'new\n')
- execute(client, named, 'Save')
- client.remove(f'/pane/{named}')
- code = made.wait(timeout=5)
- assert code == 0, (code, made.stderr.read())
- assert fresh.read_bytes() == b'new\n'
- # ...in a directory not there either: forwarded all the same, and
- # Save makes the directories.
- deep = root / 'wait-missing' / 'sub' / 'new.txt'
- before = serials()
- made = subprocess.Popen([binary, 'wait-missing/sub/new.txt'], cwd=root, env=env,
- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
- assert made.wait(timeout=5) == 0, made.stderr.read()
- deadline = time.monotonic() + 3
- while str(deep).encode() not in client.read('/index'):
- assert time.monotonic() < deadline, 'a name in a missing directory opened no pane named it'
- time.sleep(.01)
- named, = serials() - before
- client.write(f'/pane/{named}/body', b'deep\n')
- execute(client, named, 'Save')
- client.remove(f'/pane/{named}')
- assert deep.read_bytes() == b'deep\n'
- # `pardes '~/x'`, quoted so the shell left the `~`: home all the
- # same: the launching shell's HOME.
- before = serials()
- quoted = subprocess.run([binary, '~/fwd-tilde.txt'], cwd=root, env=dict(env, HOME=str(root)),
- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, timeout=10)
- assert quoted.returncode == 0, quoted.stderr
- assert f'{root}/fwd-tilde.txt'.encode() in client.read('/index'), client.read('/index')
- for serial in serials() - before:
- client.remove(f'/pane/{serial}')
- # A name the session refuses: its reason and exit 1, as B's,
- # never a nested editor, and no pane left for it.
- before = serials()
- refused = subprocess.run([binary, 'x' * 300 + '.txt'], cwd=root, env=env,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert refused.returncode == 1, refused
- assert b'a component over 255 bytes' in refused.stderr, refused.stderr
- assert serials() == before, (serials(), before)
- # 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.
- # `pardes -` (a terminal's PAGER): stdin, its escapes stripped, in a
- # +Pager pane of the session, clean, and back at once.
- fed = subprocess.run([binary, '-'], cwd=root, env=env, input=b'\x1b[1mbold\x1b[0m text\n',
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert fed.returncode == 0, fed.stderr
- made_now, = serials() - before
- assert client.read(f'/pane/{made_now}/name') == f'{root}/+Pager\n'.encode()
- assert client.read(f'/pane/{made_now}/body') == b'bold text\n'
- row = [r for r in client.read('/index').splitlines() if r.split()[0] == str(made_now).encode()][0]
- assert row.split()[2] == b'0', row # clean: nothing to ask at Exit
- # Its `new` record names it as it is: no +New and a rename.
- log_now = client.read('/log').decode()
- assert f'\nnew {made_now} {root}/+Pager\n' in '\n' + log_now, log_now[-400:]
- assert f'\nrename {made_now} ' not in '\n' + log_now
- # Its colours are the pane's, drawn and never read: the body is
- # the plain text, and the screen shows `red` in the theme's red,
- # the rest in the pane's ink. Mapped through the theme, as a
- # terminal's are; Filter shows them as sent, `rgb` in the colour
- # given.
- # Each run is its own +Pager; one there already keeps its page.
- fed = subprocess.run([binary, '-'], cwd=root, env=env,
- input=b'\x1b]0;title\x07\x1b[31mred\x1b[m \x1b[38;2;1;2;3mrgb\x1b[m plain\n',
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert fed.returncode == 0, fed.stderr
- coloured, = serials() - before - {made_now}
- assert client.read(f'/pane/{coloured}/name') == f'{root}/+Pager\n'.encode()
- assert client.read(f'/pane/{coloured}/body') == b'red rgb plain\n'
- assert client.read(f'/pane/{made_now}/body') == b'bold text\n'
- def inks():
- screen = client.screen()
- for row in range(screen['rows']):
- cells = screen['cells'][row * screen['cols']:(row + 1) * screen['cols']]
- at = ''.join(cell[0] for cell in cells).find('red rgb plain')
- if at >= 0:
- return [screen['styles'][cells[at + i][1]]['fg'] for i in (0, 4, 8)]
- raise AssertionError(('the paged text is not on the screen', screen))
- ink = inks()
- assert ink[0] != ink[2] and ink[1] != {'rgb': [1, 2, 3]}, ink
- client.write(f'/pane/{coloured}/exec', b'Filter\n')
- ink = inks()
- assert ink[1] == {'rgb': [1, 2, 3]}, ink
- assert ink[0] != ink[2] and ink[0] != ink[1], ink
- # A progress line keeps its last state.
- fed = subprocess.run([binary, '-'], cwd=root, env=env, input=b'again\r\nprogress 10%\rprogress 100%\n',
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert fed.returncode == 0, fed.stderr
- again, = serials() - before - {made_now, coloured}
- assert client.read(f'/pane/{again}/body') == b'again\nprogress 100%\n'
- for serial in (made_now, coloured, again):
- client.remove(f'/pane/{serial}')
- # More than one 8 MiB write's worth arrives whole, byte for byte,
- # in its +Pager (each write once replaced the last).
- big = b''.join(b'line %08d of the paged text\n' % i for i in range(400000)) # ~11 MiB
- assert len(big) > 8 * 1024 * 1024
- fed = subprocess.run([binary, '-'], cwd=root, env=env, input=big,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=120)
- assert fed.returncode == 0, fed.stderr
- big_pane, = serials() - before
- assert client.read(f'/pane/{big_pane}/body') == big, 'the paged body is not the text'
- # Past the 256 MiB cap: the first 256 MiB, then the cut note.
- cap = 256 * 1024 * 1024
- huge = subprocess.Popen(['sh', '-c', f'yes 0123456789abcdef | head -c {cap + 4096}'], stdout=subprocess.PIPE)
- fed = subprocess.run([binary, '-'], cwd=root, env=env, stdin=huge.stdout,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=600)
- huge.wait()
- assert fed.returncode == 0, fed.stderr
- client.remove(f'/pane/{big_pane}')
- big_pane, = serials() - before
- got = client.read(f'/pane/{big_pane}/body')
- note = b'\n[pardes: the rest of stdin is cut: a pane holds at most a file\'s limit]\n'
- assert got.endswith(note) and len(got) == cap + len(note), (len(got), got[-120:])
- assert got[:cap] == (b'0123456789abcdef\n' * (cap // 17 + 1))[:cap]
- del got, big
- client.remove(f'/pane/{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.
- odd = root / 'two\nlines'
- odd.mkdir()
- fed = subprocess.run([binary, '-'], cwd=odd, env=env, input=b'odd dir text\n',
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert fed.returncode == 0, fed.stderr
- odd_pane, = serials() - before
- assert client.read(f'/pane/{odd_pane}/name') == f'{root}/+Pager\n'.encode()
- assert client.read(f'/pane/{odd_pane}/body') == b'odd dir text\n'
- client.remove(f'/pane/{odd_pane}')
- # Nothing on stdin: no pane, and done.
- fed = subprocess.run([binary, '-'], cwd=root, env=env, input=b'',
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert fed.returncode == 0 and serials() == before, (fed, serials())
- # A new name in a directory there but not writable: refused now,
- # not a pane that only fails at Save. (Root writes anywhere.)
- shut = root / 'shut-dir'
- shut.mkdir()
- shut.chmod(0o500)
- try:
- if os.geteuid() != 0:
- refused = subprocess.run([binary, 'shut-dir/new.txt'], cwd=root, env=env,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert refused.returncode == 1, refused
- assert b'may not be read or written' in refused.stderr, refused.stderr
- assert serials() == before, (serials(), before)
- finally:
- shut.chmod(0o755)
- for word, said in (('@p999:1', b'pardes: @p999:1: this session has no such pane'),
- ('two\nlines.txt', b'pardes: two\\nlines.txt: a file name is one line')):
- refused = subprocess.run([binary, word], cwd=root, env=env,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert refused.returncode == 1, refused
- assert said in refused.stderr, refused.stderr
- assert b'NotOneLine' not in refused.stderr and b'NoSuchPane' not in refused.stderr
- assert serials() == before, (serials(), before)
- looked = subprocess.run([binary, '@p1:1'], cwd=root, env=env,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
- assert looked.returncode == 0, looked.stderr
- assert serials() == before, (serials(), before)
- orphan = launch('--wait')
- assert orphan.poll() is None
- assert orphan.wait(timeout=5) == 1
-
- # `pardes -` outside a session: an editor whose first pane is a
- # +Pager of stdin, as `vim -`; here a detached one, to read it.
- outside_env = {k: v for k, v in os.environ.items() if not k.startswith('PARDES_')}
- outside_env.update(HOME=str(root), XDG_RUNTIME_DIR=str(root), PARDES_NOTIME='1')
- boot = subprocess.Popen([binary, '--detach=stdinboot', '-'], cwd=root, env=outside_env,
- stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
- start_new_session=True)
- try:
- boot.stdin.write(b'\x1b[32mfrom stdin\x1b[m\nsecond\n')
- boot.stdin.close()
- sock = root / 'pardes-9p-stdinboot.sock'
- deadline = time.monotonic() + 10
- while not sock.exists():
- assert boot.poll() is None, boot.stderr.read()
- assert time.monotonic() < deadline, 'the stdin boot never listened'
- time.sleep(.05)
- with Client(str(sock)) as booted:
- first = booted.read('/index').split(b'\n')[0].split()
- assert first[3] == f'{root}/+Pager'.encode(), first
- assert booted.read(f'/pane/{first[0].decode()}/body') == b'from stdin\nsecond\n'
- finally:
- boot.terminate()
- boot.wait(timeout=10)
-
- # Killed with SIGTERM or SIGHUP, a tty editor puts its terminal
- # back (main screen, cooked mode) before it dies: a nested one
- # killed in a pane leaves that pane usable.
- # ...and its 9P socket goes with it. One a dead editor left behind
- # (no process has its pid) is swept at the next start; a live
- # pid's, here this test's own, never is.
- def unix_socket_file(path):
- made = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
- made.bind(str(path))
- made.close()
- for sig in (signal.SIGTERM, signal.SIGHUP):
- dead_socket = root / 'pardes-9p-2147483647.sock'
- live_socket = root / f'pardes-9p-{os.getpid()}.sock'
- for path in (dead_socket, live_socket):
- if not path.exists():
- unix_socket_file(path)
- master, slave = os.openpty()
- fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack('HHHH', 24, 80, 0, 0))
- cooked = termios.tcgetattr(slave)
- env = {k: v for k, v in os.environ.items() if not k.startswith('PARDES_')}
- env.update(HOME=str(root), XDG_RUNTIME_DIR=str(root), TERM='xterm-256color', PARDES_NOTIME='1')
- existing = set(root.glob('pardes-9p-*.sock'))
- killed = subprocess.Popen([binary, '--tty', 'x.txt'], cwd=root, env=env,
- stdin=slave, stdout=slave, stderr=subprocess.DEVNULL,
- start_new_session=True,
- preexec_fn=lambda: fcntl.ioctl(0, termios.TIOCSCTTY, 0))
- seen = b''
- try:
- deadline = time.monotonic() + 10
- while b'\x1b[?1049h' not in seen:
- assert time.monotonic() < deadline, seen[-200:]
- if select.select([master], [], [], .1)[0]:
- seen += os.read(master, 65536)
- time.sleep(.3)
- # The session's own, named by its pid: forked off the
- # launched process, which stays as its stub.
- own_socket, = set(root.glob('pardes-9p-*.sock')) - existing
- assert not dead_socket.exists()
- assert live_socket.exists()
- killed.send_signal(sig)
- assert killed.wait(timeout=5) == -sig
- if sig == signal.SIGHUP:
- # A hangup is the terminal's end: the session carries on
- # detached (the daemon keeps it) until told to end.
- assert own_socket.exists(), own_socket
- os.kill(int(own_socket.name[len('pardes-9p-'):-len('.sock')]), signal.SIGTERM)
- deadline = time.monotonic() + 5
- while own_socket.exists() and time.monotonic() < deadline:
- time.sleep(.01)
- assert not own_socket.exists(), own_socket
- while select.select([master], [], [], .2)[0]:
- try:
- chunk = os.read(master, 65536)
- except OSError:
- break
- if not chunk:
- break
- seen += chunk
- tail = seen[seen.rindex(b'\x1b[?1049h'):]
- assert b'\x1b[?1049l' in tail, tail[-200:]
- assert termios.tcgetattr(slave)[3] & termios.ICANON == cooked[3] & termios.ICANON
- finally:
- if killed.poll() is None:
- killed.kill()
- killed.wait()
- os.close(master)
- os.close(slave)
-
- # 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.
- master, slave = os.openpty()
- try:
- env = {k: v for k, v in os.environ.items() if not k.startswith('PARDES_')}
- env.update(HOME=str(root), XDG_RUNTIME_DIR=str(root), TERM='xterm-256color')
- result = subprocess.run([binary, '--tty', 'x.txt'], cwd=root, env=env, stdin=slave, stdout=slave,
- stderr=subprocess.PIPE, start_new_session=True, timeout=10)
- finally:
- os.close(master)
- os.close(slave)
- assert result.returncode == 1, result
- assert b'pardes: no terminal to draw on' in result.stderr and b'.zig:' not in result.stderr, result.stderr
-
- for tty in [False, True]:
- name = 'lsp-tty' if tty else 'lsp-detached'
- with session(binary, root, name, tty=tty) as (client, _):
- control = new_pane(client, b'')
- execute(client, control, 'Lspinfo')
- deadline = time.monotonic() + 3
- while True:
- matches = [int(row.split()[0]) for row in client.read('/index').splitlines()
- if b'+Lsp' in row]
- if matches:
- break
- assert time.monotonic() < deadline, (name, 'Lspinfo did not complete')
- time.sleep(.005)
- assert len(matches) == 1, matches
- result = client.read(f'/pane/{matches[0]}/body')
- assert result.startswith(b'backend: lsp-client\n'), result
- assert b'protocol servers (lsp-client):' in result, result
- assert client.read('/pane/1/body') == b'initial\n'
- assert '+Lsp' in ''.join(cell[0] for cell in client.screen()['cells'])
-
- with session(binary, root, 'highlight') as (client, _):
- client.write('/pane/1/name', b'keywords.zig\n')
- source = b'// padding\n' * 9999 + b'fn check() void {\n if (true) return;\n}\n'
- client.write('/pane/1/body', source, truncate=True)
- screen = client.screen()
- assert len(screen['cells']) == screen['cols'] * screen['rows']
- found = set()
- for row in range(screen['rows']):
- cells = screen['cells'][row * screen['cols']:(row + 1) * screen['cols']]
- text = ''.join(cell[0] for cell in cells)
- for word in ['fn', 'if']:
- start = text.find(word + ' ')
- if start < 0:
- continue
- styles = [screen['styles'][cell[1]] for cell in cells[start:start + len(word)]]
- # Weight is opt-in (SyntaxBold, off by default); colour is
- # not, so the keyword must differ from the text beside it.
- plain = screen['styles'][cells[start + len(word)][1]]
- assert all(not style['bold'] and style['fg'] == styles[0]['fg'] for style in styles), (word, styles)
- assert styles[0]['fg'] != plain['fg'], (word, styles[0], plain)
- found.add(word)
- assert found == {'fn', 'if'}, screen
-
- with session(binary, root, 'long-names') as (client, _):
- directory = root / ('directory-' + 'd' * 54)
- directory.mkdir()
- for length in [29, 63, 127, 255]:
- name = 'f' * (length - 4) + '.txt'
- path = directory / name
- path.write_bytes(b'long filename\n')
- wire_path = '/os' + str(path)
- assert name in client.list('/os' + str(directory))
- assert client.read(wire_path) == b'long filename\n'
- client.write(wire_path, b'written through long filename\n', truncate=True)
- assert path.read_bytes() == b'written through long filename\n'
- opened = look(client, '/n/os' + str(path))
- assert client.read(f'/pane/{opened}/body') == path.read_bytes()
- client.remove(f'/pane/{opened}') # a long name's tag takes rows
- opened = look(client, '/n/os' + str(directory))
- listing = client.read(f'/pane/{opened}/body')
- for path in directory.iterdir():
- assert ('/n/os' + str(path)).encode() in listing
- if quic:
- quic_test(binary)
print(f'9P integration: passed ({time.monotonic() - started:.3f}s)')
-def quic_test(binary):
- for tty in [False, True]:
- for host in ['127.0.0.1', '::1']:
- with tempfile.TemporaryDirectory(prefix='pardes-quic-fs-') as directory:
- root = Path(directory)
- ports = {}
- with session(binary, root, 'server', '--9p-tcp=tcp!' + host + '!0',
- '--9p-quic=quic!' + host + '!0', tty=tty, network=ports) as (unix, address):
- assert set(unix.read('/listeners').decode().splitlines()) == {
- 'unix!' + str(address), 'tcp!' + host + '!' + str(ports['TCP']),
- 'quic!' + host + '!' + str(ports['QUIC'])}
- with Client((host, ports['TCP'])) as tcp:
- unix_body = unix.open('/pane/1/body')
- tcp_body = tcp.open('/pane/1/body')
- with session(binary, root, 'client') as (remote, _):
- control = new_pane(remote, b'')
- dial = 'quic!' + host + '!' + str(ports['QUIC'])
- execute(remote, control, 'Mount peer ' + dial)
- opened = look(remote, '/n/peer/pane/1/body', source=control)
- body = f'/pane/{opened}/body'
- assert remote.read(body) == b'initial\n'
- payload = 'saved café λ\n'.encode() + b'x' * (3 * 8192 + 27) + b'\n'
- remote.write(body, payload, truncate=True)
- remote.write(f'/pane/{opened}/exec', b'Save\n')
- assert unix.read_fid(unix_body) == payload[:unix.msize - 11]
- assert tcp.read('/pane/1/body') == payload
- tcp.write('/pane/1/body', b'TCP to QUIC Get\n', truncate=True)
- remote.write(f'/pane/{opened}/ctl', b'get\n')
- assert remote.read(body) == b'TCP to QUIC Get\n'
- assert unix.read_fid(unix_body) == b'TCP to QUIC Get\n'
- assert tcp.read_fid(tcp_body) == b'TCP to QUIC Get\n'
- screen_pane = look(remote, '/n/peer/screen', source=control)
- screen = json.loads(remote.read(f'/pane/{screen_pane}/body'))
- assert len(screen['cells']) == screen['cols'] * screen['rows']
- # The peer's own screen, whole, over QUIC. Its pane's
- # tag, not its text: where the view sits after the
- # body shrank from a long wrapped line depends on
- # whether a frame was drawn meanwhile (sometimes
- # on the empty last line, ` 2`, text off-screen).
- assert 'server.txt Save' in ''.join(cell[0] for cell in screen['cells'])
- large = ('normal λ line\n' * 20000).encode()
- fixture = root / 'large.txt'
- fixture.write_bytes(large)
- large_pane = look(remote, '/n/peer/os' + str(fixture), source=control)
- assert remote.read(f'/pane/{large_pane}/body') == large
- edited = b'QUIC file saved\n'
- remote.write(f'/pane/{large_pane}/body', edited, truncate=True)
- remote.write(f'/pane/{large_pane}/exec', b'Save\n')
- assert fixture.read_bytes() == edited
- for pane in [opened, screen_pane, large_pane]:
- remote.write(f'/pane/{pane}/exec', b'Del\n')
- execute(remote, control, 'Unmount peer')
- roots = look(remote, '/n', source=control)
- assert remote.read(f'/pane/{roots}/body') == b'/n/os/\n/n/self/\n'
- assert unix.read_fid(unix_body) == b'TCP to QUIC Get\n'
- assert tcp.read_fid(tcp_body) == b'TCP to QUIC Get\n'
- # Not checked: a session Looking at its OWN tree through
- # a QUIC mount ('Mount own quic!...'). QUIC is still
- # answered on the editor's thread (cloud9's QUIC adapter
- # is not std.Io based), so that Look waits on the loop
- # it is running in and opens nothing; features.txt lists
- # it under "Left as they are". Unix and TCP self-mounts
- # are covered by test/selfmount.py.
- unix.close(unix_body)
- tcp.close(tcp_body)
-
if __name__ == '__main__':
if len(sys.argv) in [3, 4] and sys.argv[2] == '--discovery':
diff --git a/test/process.zig b/test/process.zig
index f797c063..3d74c72b 100644
--- a/test/process.zig
+++ b/test/process.zig
@@ -182,6 +182,128 @@ pub const Conn = struct {
}
return names.toOwnedSlice(gpa);
}
+
+ // fsb:
+
+ /// `dial`, versioned at `size` (a client of small frames, at least
+ /// 217, cloud9's least).
+ pub fn dialSized(gpa: std.mem.Allocator, path: []const u8, size: u32) !*Conn {
+ var addr: libc.sockaddr.un = .{ .path = undefined };
+ if (path.len >= addr.path.len) return error.NameTooLong;
+ @memset(&addr.path, 0);
+ @memcpy(addr.path[0..path.len], path);
+ return connectTo(gpa, libc.AF.UNIX, @ptrCast(&addr), @sizeOf(libc.sockaddr.un), size);
+ }
+
+ /// A connection over TCP to `host` (numeric, v4 or v6) at `port`.
+ pub fn dialTcp(gpa: std.mem.Allocator, host: [:0]const u8, port: u16) !*Conn {
+ if (std.mem.indexOfScalar(u8, host, ':') != null) {
+ var addr: libc.sockaddr.in6 = .{ .port = std.mem.nativeToBig(u16, port), .flowinfo = 0, .addr = undefined, .scope_id = 0 };
+ if (inet_pton(libc.AF.INET6, host, &addr.addr) != 1) return error.BadHost;
+ return connectTo(gpa, libc.AF.INET6, @ptrCast(&addr), @sizeOf(libc.sockaddr.in6), msize);
+ }
+ var addr: libc.sockaddr.in = .{ .port = std.mem.nativeToBig(u16, port), .addr = undefined };
+ if (inet_pton(libc.AF.INET, host, &addr.addr) != 1) return error.BadHost;
+ return connectTo(gpa, libc.AF.INET, @ptrCast(&addr), @sizeOf(libc.sockaddr.in), msize);
+ }
+
+ fn connectTo(gpa: std.mem.Allocator, family: c_uint, addr: *const libc.sockaddr, len: libc.socklen_t, size: u32) !*Conn {
+ const c = try gpa.create(Conn);
+ errdefer gpa.destroy(c);
+ c.* = .{ .fd = -1, .cl = undefined };
+ c.cl = c9.Client.init(.{ .in = &c.in, .out = &c.out });
+ c.fd = libc.socket(family, libc.SOCK.STREAM | libc.SOCK.CLOEXEC, 0);
+ if (c.fd < 0) return error.NoSocket;
+ errdefer _ = libc.close(c.fd);
+ if (libc.connect(c.fd, addr, len) != 0) return error.ConnectFailed;
+ _ = try c.call(.{ .version = .{ .msize = size } });
+ _ = try c.call(.{ .attach = .{ .fid = 0, .uname = "test" } });
+ return c;
+ }
+
+ /// The frame size the server agreed to.
+ pub fn msizeAgreed(c: *const Conn) u32 {
+ return c.cl.msize;
+ }
+
+ /// `data` written to `path` truncated first (`>`), in as many writes
+ /// as it takes.
+ pub fn replace(c: *Conn, path: []const u8, data: []const u8) !void {
+ const fid = try c.hold(path, 1 | 16);
+ var off: usize = 0;
+ while (off < data.len) {
+ const n = c.writeFid(fid, off, data[off..@min(data.len, off + c.cl.maxWrite())]) catch |err| {
+ c.clunk(fid);
+ return err;
+ };
+ off += n;
+ }
+ _ = try c.call(.{ .clunk = .{ .fid = fid } });
+ }
+
+ /// A new pane, made by opening /pane/new; its serial.
+ pub fn newPane(c: *Conn, gpa: std.mem.Allocator) !u32 {
+ const got = try c.read(gpa, "/pane/new");
+ defer gpa.free(got);
+ return std.fmt.parseInt(u32, std.mem.trim(u8, got, "\n"), 10);
+ }
+
+ /// The serials /index lists, in its order.
+ pub fn serials(c: *Conn, gpa: std.mem.Allocator) ![]u32 {
+ const index = try c.read(gpa, "/index");
+ defer gpa.free(index);
+ var out: std.ArrayList(u32) = .empty;
+ var rows = std.mem.tokenizeScalar(u8, index, '\n');
+ while (rows.next()) |row| try out.append(gpa, try std.fmt.parseInt(u32, row[0 .. std.mem.indexOfScalar(u8, row, ' ') orelse row.len], 10));
+ return out.toOwnedSlice(gpa);
+ }
+
+ /// A Look at `path` from pane `source`, or from a scratch pane removed
+ /// after; the one pane it answers (test/fs.py's look).
+ pub fn look(c: *Conn, gpa: std.mem.Allocator, path: []const u8, source: ?u32) !u32 {
+ const from = source orelse try c.newPane(gpa);
+ var buf: [64]u8 = undefined;
+ const line = try std.fmt.allocPrint(gpa, "{s}\n", .{path});
+ defer gpa.free(line);
+ try c.write(try std.fmt.bufPrint(&buf, "/pane/{d}/look", .{from}), line);
+ const got = try c.read(gpa, "/look");
+ defer gpa.free(got);
+ const answer = std.mem.trim(u8, got, "\n");
+ const opened = std.fmt.parseInt(u32, answer, 10) catch {
+ std.debug.print("look {s}: answered {s}\n", .{ path, got });
+ return error.NotOneLook;
+ };
+ if (opened == from) return error.NotOneLook;
+ // A column holds only so many panes, each its tag and two rows.
+ if (source == null) try c.remove(try std.fmt.bufPrint(&buf, "/pane/{d}", .{from}));
+ return opened;
+ }
+
+ /// Pane `n`'s `file` read whole.
+ pub fn pane(c: *Conn, gpa: std.mem.Allocator, n: u32, file: []const u8) ![]u8 {
+ var buf: [64]u8 = undefined;
+ return c.read(gpa, try std.fmt.bufPrint(&buf, "/pane/{d}/{s}", .{ n, file }));
+ }
+
+ /// A line written to pane `n`'s exec, a middle click on it.
+ pub fn exec(c: *Conn, n: u32, line: []const u8) !void {
+ var buf: [64]u8 = undefined;
+ try c.write(try std.fmt.bufPrint(&buf, "/pane/{d}/exec", .{n}), line);
+ }
+
+ /// An exec that fails: refused, its words holding `words`.
+ pub fn execRefused(c: *Conn, n: u32, line: []const u8, words: []const u8) !void {
+ if (c.exec(n, line)) |_| {
+ std.debug.print("{s}: taken\n", .{line});
+ return error.Taken;
+ } else |err| if (err != error.Refused) return err;
+ try check(has(c.said, words), "{s}: refused {s}", .{ line, c.said });
+ }
+
+ pub fn removePane(c: *Conn, n: u32) !void {
+ var buf: [64]u8 = undefined;
+ try c.remove(try std.fmt.bufPrint(&buf, "/pane/{d}", .{n}));
+ }
};
/// A running pardes's file tree, dialled by its pid or socket path.
@@ -276,6 +398,18 @@ pub const Files = struct {
pub fn at(f: *Files, comptime fmt: []const u8, args: anytype) []const u8 {
return std.fmt.allocPrint(f.arena.allocator(), fmt, args) catch @panic("out of memory");
}
+
+ // fsb:
+
+ /// The ink /screen draws at a cell, as its JSON (`{"rgb":[1,2,3]}`).
+ pub fn fg(f: *Files, col: usize, row: usize) ![]const u8 {
+ const a = f.arena.allocator();
+ const json = try std.json.parseFromSliceLeaky(std.json.Value, a, try f.read("/screen"), .{});
+ const cols: usize = @intCast(json.object.get("cols").?.integer);
+ const cell = json.object.get("cells").?.array.items[row * cols + col];
+ const style = json.object.get("styles").?.array.items[@intCast(cell.array.items[1].integer)];
+ return std.json.Stringify.valueAlloc(a, style.object.get("fg").?, .{});
+ }
};
/// The files of the app a pty harness started.
@@ -476,9 +610,319 @@ pub const Detached = struct {
}
d.pid = 0;
}
+
+ // fsb:
+
+ /// Whether `rel` under the root is there (a dangling link is not).
+ pub fn exists(d: *const Detached, rel: []const u8) bool {
+ var buf: [4096]u8 = undefined;
+ const path = std.fmt.bufPrintSentinel(&buf, "{s}/{s}", .{ d.root(), rel }, 0) catch return false;
+ return libc.access(path, 0) == 0;
+ }
+
+ /// `rel` under the root, absolute, kept until deinit.
+ pub fn abs(d: *Detached, rel: []const u8) [:0]const u8 {
+ return std.fmt.allocPrintSentinel(d.files.arena.allocator(), "{s}/{s}", .{ d.root(), rel }, 0) catch @panic("out of memory");
+ }
+
+ /// Another session in this root, in a pty, as fs.py's tty sessions:
+ /// `pardes --tty --9p=<name> <args> <root>/<name>.txt` (holding
+ /// "initial\n"), back once its socket (`abs("pardes-9p-<name>.sock")`)
+ /// is there.
+ pub fn startTty(d: *Detached, exe: [:0]const u8, name: []const u8, args: []const [:0]const u8) !Child {
+ const a = d.files.arena.allocator();
+ try d.put(try std.fmt.allocPrint(a, "{s}.txt", .{name}), "initial\n");
+ var argv: std.ArrayList([:0]const u8) = .empty;
+ try argv.appendSlice(a, &.{ exe, "--tty", try std.fmt.allocPrintSentinel(a, "--9p={s}", .{name}, 0) });
+ try argv.appendSlice(a, args);
+ try argv.append(a, d.abs(try std.fmt.allocPrint(a, "{s}.txt", .{name})));
+ const env = try a.dupe([2][:0]const u8, &.{.{ "PARDES_DUMP", d.abs(try std.fmt.allocPrint(a, "{s}.dump.zon", .{name})) }});
+ var c = try Child.spawn(argv.items, .{ .root = d.root(), .env = env, .pty = .{ .log = d.abs(try std.fmt.allocPrint(a, "{s}.pty", .{name})) } });
+ errdefer c.deinit();
+ try c.waitPath(d.abs(try std.fmt.allocPrint(a, "pardes-9p-{s}.sock", .{name})), 10_000);
+ return c;
+ }
};
fn sleepMs(ms: u32) void {
var ts: libc.timespec = .{ .sec = 0, .nsec = @as(isize, ms) * std.time.ns_per_ms };
_ = libc.nanosleep(&ts, null);
}
+
+// fsb:
+
+extern "c" fn readdir(dir: *libc.DIR) ?*libc.dirent;
+extern "c" fn ioctl(fd: c_int, request: c_ulong, ...) c_int;
+extern "c" fn openpty(master: *c_int, slave: *c_int, name: ?[*]u8, termp: ?*const anyopaque, winp: ?*const std.posix.winsize) c_int;
+extern "c" fn signal(sig: c_int, handler: usize) usize;
+extern "c" var environ: [*:null]?[*:0]u8;
+extern "c" fn inet_pton(family: c_uint, src: [*:0]const u8, dst: *anyopaque) c_int;
+extern "c" fn pipe2(fds: *[2]c_int, flags: c_int) c_int;
+// shortcut: Linux's O_CLOEXEC, TIOCSCTTY and TCGETS, the only host these
+// run on; take them from std for another.
+const o_cloexec: c_int = 0o2000000;
+
+/// A program run as a shell in `root` would run it: the caller's
+/// environment without a session's (PARDES_*, a PAGER), HOME and the
+/// runtime and config directories the root, no daemon (PARDES_DAEMON=off:
+/// the process is the session) and no language servers, unless `env` says
+/// otherwise. Its stderr is kept (`said`).
+pub const Child = struct {
+ pid: libc.pid_t,
+ err_fd: c_int,
+ status: ?c_int = null,
+ /// A pty's ends, when on one, and the process copying its output to
+ /// `Pty.log`.
+ master: c_int = -1,
+ slave: c_int = -1,
+ drain: libc.pid_t = 0,
+
+ pub const Pty = struct {
+ /// Where everything the program draws goes.
+ log: [:0]const u8,
+ /// Made its controlling terminal; else a pty that is no one's.
+ ctty: bool = true,
+ };
+
+ pub const Options = struct {
+ /// HOME and the runtime and config directories; null: the caller's.
+ root: ?[]const u8 = null,
+ /// Where it runs; null: `root`, or here.
+ cwd: ?[]const u8 = null,
+ /// Set after the root's.
+ env: []const [2][:0]const u8 = &.{},
+ /// Unset after that.
+ unset: []const [:0]const u8 = &.{},
+ /// Its stdin, written whole and closed; null: /dev/null.
+ stdin: ?[]const u8 = null,
+ /// Started in a 24x80 pty, its stdin and stdout.
+ pty: ?Pty = null,
+ };
+
+ pub fn spawn(argv: []const [:0]const u8, opts: Options) !Child {
+ // A child gone before its stdin is written is EPIPE, not our end.
+ _ = signal(@intCast(@intFromEnum(libc.SIG.PIPE)), 1);
+ var args: [32:null]?[*:0]const u8 = @splat(null);
+ if (argv.len > args.len) return error.TooManyArgs;
+ for (argv, 0..) |a, i| args[i] = a;
+ var bufs: [4][4096]u8 = undefined;
+ // The build hands the binary over by a relative path, and the child
+ // runs elsewhere.
+ if (std.mem.indexOfScalar(u8, argv[0], '/') != null) args[0] = realpath(argv[0], &bufs[3]) orelse return error.NoBinary;
+ const root_z: ?[:0]const u8 = if (opts.root) |r| try std.fmt.bufPrintSentinel(&bufs[0], "{s}", .{r}, 0) else null;
+ const config = if (opts.root) |r| try std.fmt.bufPrintSentinel(&bufs[1], "{s}/config", .{r}, 0) else "";
+ const cwd: ?[:0]const u8 = if (opts.cwd) |c| try std.fmt.bufPrintSentinel(&bufs[2], "{s}", .{c}, 0) else root_z;
+ // Close-on-exec, so a later child holds none of these.
+ var err_pipe: [2]c_int = undefined;
+ if (pipe2(&err_pipe, o_cloexec) != 0) return error.NoPipe;
+ var in_pipe: [2]c_int = .{ -1, -1 };
+ if (opts.stdin != null and pipe2(&in_pipe, o_cloexec) != 0) return error.NoPipe;
+ var c: Child = .{ .pid = 0, .err_fd = err_pipe[0] };
+ if (opts.pty != null) {
+ var ws: std.posix.winsize = .{ .row = 24, .col = 80, .xpixel = 0, .ypixel = 0 };
+ if (openpty(&c.master, &c.slave, null, null, &ws) != 0) return error.NoPty;
+ for ([_]c_int{ c.master, c.slave }) |fd| _ = libc.fcntl(fd, libc.F.SETFD, @as(c_int, 1)); // FD_CLOEXEC
+ }
+ const pid = libc.fork();
+ if (pid < 0) return error.ForkFailed;
+ if (pid == 0) {
+ var i: usize = 0;
+ while (environ[i]) |kv| {
+ const entry = std.mem.span(kv);
+ const eq = std.mem.indexOfScalar(u8, entry, '=') orelse entry.len;
+ if (std.mem.startsWith(u8, entry, "PARDES_") or std.mem.indexOf(u8, entry[0..eq], "PAGER") != null) {
+ var name: [256]u8 = undefined;
+ const n = std.fmt.bufPrintSentinel(&name, "{s}", .{entry[0..@min(eq, 255)]}, 0) catch _exit(126);
+ _ = unsetenv(n);
+ i = 0;
+ } else i += 1;
+ }
+ if (root_z) |r| for ([_][2][*:0]const u8{
+ .{ "HOME", r }, .{ "XDG_RUNTIME_DIR", r }, .{ "XDG_CONFIG_HOME", config }, .{ "PARDES_NOTIME", "1" },
+ }) |kv| if (setenv(kv[0], kv[1], 1) != 0) _exit(126);
+ for ([_][2][*:0]const u8{
+ .{ "PARDES_DAEMON", "off" }, .{ "PARDES_LSP_RS", "" }, .{ "PARDES_LSP_C", "" }, .{ "PARDES_LSP_GO", "" },
+ .{ "PARDES_LSP_TS", "" }, .{ "PARDES_LSP_PY", "" },
+ }) |kv| if (setenv(kv[0], kv[1], 1) != 0) _exit(126);
+ if (opts.pty != null and setenv("TERM", "xterm-256color", 1) != 0) _exit(126);
+ for (opts.env) |kv| if (setenv(kv[0], kv[1], 1) != 0) _exit(126);
+ for (opts.unset) |name| _ = unsetenv(name);
+ if (cwd) |d| if (libc.chdir(d) != 0) _exit(126);
+ _ = libc.setsid();
+ if (opts.pty) |p| {
+ if (p.ctty) _ = ioctl(c.slave, 0x540E, @as(c_int, 0));
+ _ = libc.dup2(c.slave, 0);
+ _ = libc.dup2(c.slave, 1);
+ } else {
+ const null_fd = libc.open("/dev/null", .{ .ACCMODE = .RDWR }, @as(libc.mode_t, 0));
+ _ = libc.dup2(if (opts.stdin != null) in_pipe[0] else null_fd, 0);
+ _ = libc.dup2(null_fd, 1);
+ }
+ _ = libc.dup2(err_pipe[1], 2);
+ _ = execvp(args[0].?, &args);
+ _exit(127);
+ }
+ c.pid = pid;
+ _ = libc.close(err_pipe[1]);
+ if (opts.stdin) |bytes| {
+ _ = libc.close(in_pipe[0]);
+ var off: usize = 0;
+ while (off < bytes.len) {
+ const n = libc.write(in_pipe[1], bytes[off..].ptr, @min(bytes.len - off, 1 << 20));
+ if (n <= 0) break;
+ off += @intCast(n);
+ }
+ _ = libc.close(in_pipe[1]);
+ }
+ if (opts.pty) |p| {
+ const drain = libc.fork();
+ if (drain == 0) {
+ const fd = libc.open(p.log, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true }, @as(libc.mode_t, 0o644));
+ var buf: [16 * 1024]u8 = undefined;
+ while (true) {
+ const n = libc.read(c.master, &buf, buf.len);
+ if (n <= 0) _exit(0);
+ _ = libc.write(fd, &buf, @intCast(n));
+ }
+ }
+ c.drain = drain;
+ }
+ return c;
+ }
+
+ /// Its wait(2) word once it has exited, waiting up to `ms`; null while it runs.
+ pub fn wait(c: *Child, ms: i64) ?c_int {
+ if (c.status) |s| return s;
+ const deadline = eh.nowMs() + ms;
+ while (true) {
+ var status: c_int = 0;
+ if (libc.waitpid(c.pid, &status, std.c.W.NOHANG) == c.pid) {
+ c.status = status;
+ return status;
+ }
+ if (eh.nowMs() >= deadline) return null;
+ sleepMs(1);
+ }
+ }
+
+ /// Everything it wrote to stderr, read to its end (its exit, or every
+ /// process holding it gone).
+ pub fn said(c: *Child, gpa: std.mem.Allocator) ![]u8 {
+ var out: std.ArrayList(u8) = .empty;
+ var buf: [4096]u8 = undefined;
+ while (true) {
+ const n = libc.read(c.err_fd, &buf, buf.len);
+ if (n <= 0) break;
+ try out.appendSlice(gpa, buf[0..@intCast(n)]);
+ }
+ return out.toOwnedSlice(gpa);
+ }
+
+ /// Waits up to `ms` for `path` (its socket) to be there; its stderr
+ /// said if it exits first.
+ pub fn waitPath(c: *Child, path: []const u8, ms: i64) !void {
+ var buf: [4096]u8 = undefined;
+ const z = try std.fmt.bufPrintSentinel(&buf, "{s}", .{path}, 0);
+ const deadline = eh.nowMs() + ms;
+ while (libc.access(z, 0) != 0) {
+ if (c.wait(0)) |status| {
+ const words = c.said(std.heap.page_allocator) catch "";
+ std.debug.print("exited, status {d}, before {s}: {s}\n", .{ status, path, words });
+ return error.Exited;
+ }
+ if (eh.nowMs() > deadline) return error.Timeout;
+ sleepMs(5);
+ }
+ }
+
+ pub fn kill(c: *const Child, sig: libc.SIG) void {
+ if (c.status == null) _ = libc.kill(c.pid, sig);
+ }
+
+ /// Ended (SIGTERM, SIGKILL after 5 s) and its fds closed.
+ pub fn deinit(c: *Child) void {
+ if (c.wait(0) == null) {
+ _ = libc.kill(c.pid, libc.SIG.TERM);
+ if (c.wait(5_000) == null) {
+ _ = libc.kill(c.pid, libc.SIG.KILL);
+ _ = c.wait(5_000);
+ }
+ }
+ if (c.drain > 0) {
+ _ = libc.kill(c.drain, libc.SIG.KILL);
+ var st: c_int = 0;
+ _ = libc.waitpid(c.drain, &st, 0);
+ }
+ for ([_]c_int{ c.err_fd, c.master, c.slave }) |fd| if (fd >= 0) {
+ _ = libc.close(fd);
+ };
+ }
+};
+
+/// What a run ended with: its exit code (a signal's is minus it, as
+/// Python's returncode) and its stderr.
+pub const Ran = struct { code: c_int, said: []u8 };
+
+/// `argv` run to its end.
+pub fn run(gpa: std.mem.Allocator, argv: []const [:0]const u8, opts: Child.Options) !Ran {
+ var c = try Child.spawn(argv, opts);
+ defer c.deinit();
+ const words = try c.said(gpa);
+ var status: c_int = 0;
+ _ = libc.waitpid(c.pid, &status, 0);
+ c.status = status;
+ return .{ .code = code(status), .said = words };
+}
+
+/// A wait(2) word as an exit code, a signal's as minus it.
+pub fn code(status: c_int) c_int {
+ const sig = status & 0x7f;
+ return if (sig != 0) -sig else (status >> 8) & 0xff;
+}
+
+/// The names in directory `dir`, kept in `gpa`.
+pub fn entries(gpa: std.mem.Allocator, dir: []const u8) ![]const []const u8 {
+ var buf: [4096]u8 = undefined;
+ const d = libc.opendir(try std.fmt.bufPrintSentinel(&buf, "{s}", .{dir}, 0)) orelse return error.NoDir;
+ defer _ = libc.closedir(d);
+ var names: std.ArrayList([]const u8) = .empty;
+ while (readdir(d)) |e| {
+ const name = std.mem.sliceTo(&e.name, 0);
+ if (std.mem.eql(u8, name, ".") or std.mem.eql(u8, name, "..")) continue;
+ try names.append(gpa, try gpa.dupe(u8, name));
+ }
+ return names.toOwnedSlice(gpa);
+}
+
+/// Whether the line discipline of the terminal at `fd` is canonical.
+pub fn canonical(fd: c_int) !bool {
+ var t: std.os.linux.termios = undefined;
+ if (ioctl(fd, 0x5401, &t) != 0) return error.NoTermios; // TCGETS
+ return t.lflag.ICANON;
+}
+
+/// Monotonic milliseconds.
+pub const nowMs = eh.nowMs;
+
+pub fn nap(ms: u32) void {
+ sleepMs(ms);
+}
+
+pub fn has(hay: []const u8, needle: []const u8) bool {
+ return std.mem.indexOf(u8, hay, needle) != null;
+}
+
+/// `ok`, or what is wrong said and the test failed.
+pub fn check(ok: bool, comptime what: []const u8, args: anytype) !void {
+ if (ok) return;
+ std.debug.print(what ++ "\n", args);
+ return error.TestUnexpectedResult;
+}
+
+/// Whether `exe` was built with QUIC (-Dquic=true): refused for that, or
+/// for --attach's own reason, which comes after.
+pub fn quicIncluded(gpa: std.mem.Allocator, exe: [:0]const u8) !bool {
+ const r = try run(gpa, &.{ exe, "--attach=work", "--9p-quic=quic!127.0.0.1!0" }, .{});
+ defer gpa.free(r.said);
+ return !has(r.said, "QUIC is not included");
+}
diff --git a/test/process/builtins.zig b/test/process/builtins.zig
new file mode 100644
index 00000000..39a043c0
--- /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(a);
+ 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/flags.zig b/test/process/flags.zig
new file mode 100644
index 00000000..2ae8d0c7
--- /dev/null
+++ b/test/process/flags.zig
@@ -0,0 +1,778 @@
+//! 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(a);
+ 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();
+ // 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();
+ 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});
+ daemonGone(&d);
+ }
+}
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..7d44f4fb
--- /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(a);
+ 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(a);
+ 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(a);
+ 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/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..87c9e777
--- /dev/null
+++ b/test/process/root_ctl.zig
@@ -0,0 +1,87 @@
+//! docs/typ/reference.typ, The root ctl <root-ctl>: Dump and Restore in a
+//! real session, 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 = .{
+ .{ "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 },
+};
+
+/// 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(a);
+ 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/tree.zig b/test/process/tree.zig
new file mode 100644
index 00000000..c7b9e657
--- /dev/null
+++ b/test/process/tree.zig
@@ -0,0 +1,178 @@
+//! docs/typ/reference.typ, The tree <tree>, through a real session's
+//! socket: what a client on the wire sees, and /os on the disk.
+const std = @import("std");
+const process = @import("../process.zig");
+const Conn = process.Conn;
+const has = process.has;
+const check = process.check;
+
+pub const cases = .{
+ .{ "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: a ctl line with no newline is held whatever its write's size, and runs at the close, its failure in the log", heldLine },
+ .{ "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 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 (names) |n| try check(std.mem.startsWith(u8, n, "entry-"), "listed {s}", .{n});
+ 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 heldLine(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, "held", .{});
+ defer d.deinit();
+ // 64 KiB frames: a line with no newline is held whatever the size of its
+ // write (a mount cuts lines anywhere), and runs at the close.
+ const c = try Conn.dial(gpa, d.socket());
+ defer c.deinit(gpa);
+ const ctl = try c.hold("/pane/1/ctl", 1);
+ const line = try a.alloc(u8, 5 + 20000);
+ @memcpy(line[0..5], "bogus");
+ @memset(line[5..], 'x');
+ _ = try c.writeFid(ctl, 0, line);
+ try check(!has(try c.read(a, "/log"), "ctl: unknown control message"), "ran before the close", .{});
+ c.clunk(ctl);
+ try check(has(try c.read(a, "/log"), "ctl: unknown control message"), "never ran", .{});
+}
+
+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});
+}
diff --git a/test/process_test.zig b/test/process_test.zig
index 9924b9dd..828edff9 100644
--- a/test/process_test.zig
+++ b/test/process_test.zig
@@ -6,7 +6,14 @@
const std = @import("std");
const files = .{
+ @import("process/builtins.zig"),
+ @import("process/flags.zig"),
+ @import("process/look_and_exec.zig"),
+ @import("process/mounts.zig"),
@import("process/other_files.zig"),
+ @import("process/repls.zig"),
+ @import("process/root_ctl.zig"),
+ @import("process/tree.zig"),
};
pub fn main(init: std.process.Init) !void {