summaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-04 21:29:23 -0300
committerGabriel Schneider <[email protected]>2026-11-04 21:29:23 -0300
commit528a66cc720b25252a497adeb358e729dc8f3a62 (patch)
tree872890f4f70d8a1ef07eba9a0f6fe72b491ee883 /test
parente67a1a561d9a9a7269bcc7c9af5678d3f50a95cb (diff)
downloadpardes-528a66cc720b25252a497adeb358e729dc8f3a62.tar.gz
pardes-528a66cc720b25252a497adeb358e729dc8f3a62.zip
test: the window's own tests in Zig (T4, test/process/window.zig), gui_monkey.py and gui_golden.py gone: the monkey drives the hidden window's own input (Detached.typeKeys into its pty, Detached.mouse's OSC 777 events) with clicks, drags, wheels, hovers and keys, and columns, looks, Joincol, Collapse, Delcol and themes over 9P, then the window must settle, alive, with no crash record (two combinations of 30 steps in process-test, all 40 Motion x Lift x Bloom with zig build monkey-gui -Dplatform=gui); the goldens hash the 17 scenes' frames (Detached.capture, a transition's frame 6 too) against test/gui-goldens.txt, regenerated for the offscreen window and twice reproduced, run when asked (zig build gui-golden -Dplatform=gui, PARDES_GUI_GOLDEN=update); Detached's init file, settle and capture; no Python step left in the build
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/gui-goldens.txt34
-rw-r--r--test/gui_golden.py239
-rw-r--r--test/gui_monkey.py179
-rw-r--r--test/process.zig68
-rw-r--r--test/process/window.zig364
-rw-r--r--test/process_test.zig1
-rw-r--r--test/record_demos.py2
7 files changed, 439 insertions, 448 deletions
diff --git a/test/gui-goldens.txt b/test/gui-goldens.txt
index 0d782af4..5132981f 100644
--- a/test/gui-goldens.txt
+++ b/test/gui-goldens.txt
@@ -1,17 +1,17 @@
-01-boot 6b879535ac5d120a468290175f508064a11f257a0f52924fee423df11686ffb3
-02-second-document e07139723a029c1bebcd5ca19da86f3e0cc2af20abc4cf540fc551ae8d65ad2b
-03-notice 8ad2e24e5cb5eb8ef9234a6ebd14916e5780764c5f8a2a119f3a8901dc1b042e
-04-context-rows-mid-thumb 19b1a173848a1b8895c39c58107df1512bf7b314a032d525ce815ba94180266a
-05-body-selection 533db971a21519eba77effc1c5d6222257348602131d24130d8dea62a44d698b
-06-tag-focus-selection 711220bcec560f6ba6204a694827ed58c374ecce8325c5c459154e8f2319f252
-07-prompt-notice 1d02541031d04d2a0a861102648295f6cd5b30d33b6c0dd4e55f6076d7a5c005
-08-wide-glyph-edges ddfe437d9cf36063bb09cddc36bac4bcd30b29c4bcb0d6453f9706c0c222b187
-09-collapsed-focus-tint d2f3edb45e23f84e5f3c792b388c77dd70e0e8a15a5b2bd85e0917f019de1421
-10-tagbottom 6347013122c19b7ee6505d3e7138d9fa353d8b9d8213fbb847615b75b0ddb0e5
-12-multiline-tag 48d4a0c0f45a1709d8e3dea3056e1147ab29bfe3fd6980b4568333b8183828d6
-13-image ca5c7d92e688b4c4b8a1d7f7075c55acb049bd89b49488effd2de74056f92bdf
-14-theme-ink a7cdb4de4a2a6ff3ee58040ff5052f36ac60ad1ab8d132d7832059692e96fd73
-15-theme-acme-light e3af35d1e5ae57cb74af807940a76beebf510ed04a2437f4be1f4a53133af48b
-16-debug ed971e715e45fa04f0ecddefd6b0d0b1285c912d6940ca9632a7defc377bbe61
-17-terminal a09b53740c0a6fecd354c4f9b67ef0131b19aef92af55488cdead77b030d1062
-18-mid-transition 7d09ffede92fde77722cebc91d68b6f800dd1f2bfba0afb9480ab926f001b894
+01-boot 239162cabddeed8a2edbf2d8170d158dc7d413b8fda251945c95a1573e8c1298
+02-second-document 04173d1c7aab94791cb4babc272710597cd8684b23f92e50a4892fc08df1807f
+03-notice de5203c9cacb096d2976a3c6267cb1bcdc5af087b5690ca77ebc092a14cdc5d9
+04-context-rows-mid-thumb c42a08e9fe5bb00a98c78dd54fd52eff75e207767275e879b16a974ff0f361c9
+05-body-selection 05c75c7993e6d3107ddc5d908405a8a941f94467486f36a97b659833c5e50dc0
+06-tag-focus-selection ff202b98fa512254deca1dc01d4a19c0fab176bc9f9c703a1dc53d9a3741cda5
+07-prompt-notice c4d90e8f52d020c4e713c7ec0f1e5a4e73a4b6608cedf663ddac10c394e292cf
+08-wide-glyph-edges 124b79077f1d204cb9f435f63f7cece52e199bde628491dfa083ec67054a6721
+09-collapsed-focus-tint 3d2c00a08659d37c8ad2da6c474b3dcad844905f2f5c5b68e95f2f0d72b3647e
+10-tagbottom a3926b7a9fe16b102e876ba0c536d9de4f043376c0d100e302b785c03fd81ad8
+12-multiline-tag a04558e6f11835c13bbe81b90d31cc24d6b5b4c4220a358e4b79546ae61e8a89
+13-image 4b7af674aa77394a94ed942e7144cb2244c5189fc982dd3c69f542fb0204801e
+14-theme-ink bed6e49e993e963d509d75e65f7f15ce28f72e239a063294ba72b3e5247a8f38
+15-theme-acme-light 5d2ffe65bd57afb5380891c32499e6523f5663986cef1212f2431a7559437ba1
+16-debug e7a50fbb37b8a6a7ff172ff583154626eb3f5bec5e1ac4e0d17751bce50c24dd
+17-terminal e3208d4378cce3d0762c8d1073e90487da40af44a0d6e4a7f3256e0ee73ee700
+18-mid-transition 2f22bd0dbf72ec1073d794b1b442e1213491a6e80e2c6a275cf8e0c836adb22a
diff --git a/test/gui_golden.py b/test/gui_golden.py
deleted file mode 100644
index 9afc9c19..00000000
--- a/test/gui_golden.py
+++ /dev/null
@@ -1,239 +0,0 @@
-#!/usr/bin/env python3
-"""Hash settled SDL frames of a fixed set of scenes, to prove a GUI refactor
-left every pixel where it was.
-
-python3 -B test/gui_golden.py <pardes-gui binary> compare
-python3 -B test/gui_golden.py <pardes-gui binary> --update rewrite goldens
-
-The window is hidden (PARDES_TEST renders into an offscreen capture texture),
-and the capture carries PARDES_TEST_PAD leftover pixels so edge bugs show.
-GPU rasterisation differs between machines and drivers: the goldens in
-test/gui-goldens.txt are a LOCAL gate for one machine, never a CI one. Each
-scene waits until the window says it is idle (its status file) before it is
-hashed, so a loaded machine gives the same frames.
-"""
-import argparse
-import hashlib
-import os
-from pathlib import Path
-import tempfile
-import shutil
-import time
-
-from fs import session
-from ui_review import require, wait_for
-
-GOLDENS = Path(__file__).resolve().parent / 'gui-goldens.txt'
-
-ZIG = b'''const std = @import("std");
-
-pub const Shape = union(enum) {
- circle: f32,
- square: f32,
-
- pub fn area(shape: Shape) f32 {
- return switch (shape) {
- .circle => |r| std.math.pi * r * r,
- .square => |s| s * s,
- };
- }
-};
-
-pub fn main() void {
- var total: f32 = 0;
- const shapes = [_]Shape{ .{ .circle = 1 }, .{ .square = 2 } };
- for (shapes) |shape| {
-''' + b''.join(b' total += shape.area() * %d; // line %d\n' % (n, n) for n in range(60)) + b''' }
- std.debug.print("{d}\\n", .{total});
-}
-'''
-
-
-def ppm(width, height):
- rows = []
- for y in range(height):
- rows.append(bytes(v for x in range(width) for v in ((x * 255) // width, (y * 255) // height, 128)))
- return b'P6\n%d %d\n255\n' % (width, height) + b''.join(rows)
-
-
-def panes(client):
- serials = [int(row.split()[0]) for row in client.read('/index').decode().splitlines() if row.strip()]
- return {serial: client.read(f'/pane/{serial}/tag').decode(errors='replace') for serial in serials}
-
-
-def status(root):
- """The window's (step, frames captured, idle), or None before the first."""
- try:
- step, frames, idle = (root / 'status').read_text().split()[:3]
- return int(step), int(frames), idle == '1'
- except (FileNotFoundError, ValueError):
- return None
-
-
-def settled(root):
- """The capture once the window says it is idle: a loop step past the one
- current when this was asked, with nothing owing a frame (the window's
- status file, gui.zig writeTestStatus). Every command before this call has
- been served by then (a 9P write returns once the core has it), so the
- frame is the scene's however loaded the machine is; the digest of it."""
- deadline = time.monotonic() + 60
- start = None
- while time.monotonic() < deadline:
- now = status(root)
- if now is not None:
- if start is None:
- start = now[0]
- elif now[0] >= start + 2 and now[2] and now[1] > 0:
- data = (root / 'latest.ppm').read_bytes()
- if data.startswith(b'P6'):
- return hashlib.sha256(data).hexdigest()
- time.sleep(.02)
- raise RuntimeError('the window never went idle')
-
-
-def run(args):
- results = []
- # A fixed directory: the paths it holds are drawn in the tags.
- root = Path(tempfile.gettempdir()) / 'pardes-gui-golden'
- shutil.rmtree(root, ignore_errors=True)
- root.mkdir(mode=0o700)
- # Captures go outside the session's own directory: a file written there
- # every frame is a change in the directory its panes look at, which
- # would ask for another frame, and so on for ever.
- captures = Path(tempfile.gettempdir()) / 'pardes-gui-golden-captures'
- shutil.rmtree(captures, ignore_errors=True)
- captures.mkdir(mode=0o700)
- name = 'gui-golden'
- config = root / 'config/pardes'
- config.mkdir(parents=True)
- # No linger: a dismissed message is gone, not caught part way, when a
- # scene settles.
- (config / 'init').write_text('Shell /bin/sh\nTheme forge\nMessageLinger 0\n')
- source = root / 'shapes.zig'
- source.write_bytes(ZIG)
- notes = root / 'notes.txt'
- notes.write_bytes(b'Pardes GUI golden\n\nA second document, opened by Look.\n' * 4)
- wide = root / 'wide.txt'
- # One of the two alignments puts a wide glyph across the body's right edge.
- wide.write_bytes(('x' + '\u754c' * 80 + '\n' + '\u754c' * 80 + '\n').encode())
- image = root / 'ramp.ppm'
- image.write_bytes(ppm(96, 64))
- # The session points XDG_RUNTIME_DIR at its own root, so the caller's
- # Wayland socket is passed as an absolute path.
- display = Path(os.environ.get('WAYLAND_DISPLAY', 'wayland-0'))
- if not display.is_absolute():
- display = Path(os.environ.get('XDG_RUNTIME_DIR', '/run/user/%d' % os.getuid())) / display
- # The virtual clock: a transition's frames are the same frames on any
- # machine, so one partway through can be hashed too.
- inherited = {'PARDES_TEST': '1', 'PARDES_TEST_CLOCK': '1', 'PARDES_TEST_COLS': '120', 'PARDES_TEST_ROWS': '40',
- 'PARDES_TEST_PAD': '7', 'PARDES_TEST_CAPTURE_DIR': str(captures),
- 'SDL_VIDEODRIVER': 'wayland', 'WAYLAND_DISPLAY': str(display)}
- launch = ['-c', 'stty cols 120 rows 40; exec "$@"', name, str(args.binary.resolve()),
- '--9p=' + name, str(source)]
- handles = {}
- with session('/bin/sh', root, name, socket_name=name, tty=True,
- launch=launch, inherited=inherited, terminal=handles) as (client, _):
- first = require(wait_for(lambda: next((s for s, tag in panes(client).items()
- if 'shapes.zig' in tag), None)), 'source pane missing')
-
- def scene(label, frame='latest.ppm'):
- settled(captures)
- results.append((label, hashlib.sha256((captures / frame).read_bytes()).hexdigest()))
- if args.keep:
- args.keep.mkdir(parents=True, exist_ok=True)
- shutil.copyfile(captures / frame, args.keep / (label + '.ppm'))
- print(label, results[-1][1][:16], flush=True)
-
- def mouse(kind, button, x, y):
- # The test shell's stdin takes window-pixel mouse events.
- os.write(handles['input_fd'], f'\x1b]777;mouse;{kind};{button};{x};{y}\x07'.encode())
- time.sleep(.1)
-
- def serial_of(word):
- return require(wait_for(lambda: next((s for s, tag in panes(client).items() if word in tag), None)),
- word + ' missing')
-
- scene('01-boot')
- client.write(f'/pane/{first}/look', f'{notes}\n'.encode())
- notes_pane = serial_of('notes.txt')
- scene('02-second-document')
- client.write(f'/pane/{first}/ctl', b'Msg a golden notice\n')
- scene('03-notice')
- client.write(f'/pane/{first}/ctl', b'TreeContext\n')
- client.write(f'/pane/{first}/dot', b'45\n')
- scene('04-context-rows-mid-thumb')
- client.write(f'/pane/{first}/dot', b'40,43\n')
- scene('05-body-selection')
- # A press and a drag along the source's tag: the tag takes the
- # keyboard with a selection and a caret. The pointer then rests on
- # empty body space, far right.
- mouse('down', 1, 500, 87)
- mouse('motion', 1, 620, 87)
- mouse('up', 1, 620, 87)
- mouse('motion', 0, 1880, 1300)
- scene('06-tag-focus-selection')
- os.write(handles['input_fd'], b'\x1b')
- time.sleep(.2)
- scratch = int(client.read('/pane/new'))
- client.write(f'/pane/{scratch}/exec', b'Save\n')
- scene('07-prompt-notice')
- os.write(handles['input_fd'], b'\x1b')
- time.sleep(.2)
- client.write(f'/pane/{scratch}/exec', b'Del\n')
- client.write(f'/pane/{first}/look', f'{wide}\n'.encode())
- wide_pane = serial_of('wide.txt')
- client.write(f'/pane/{wide_pane}/name', ('x' + '\u754c' * 70 + '\n').encode())
- client.write('/ctl', b'Wrap off\n')
- scene('08-wide-glyph-edges')
- client.write('/ctl', b'Wrap on\n')
- client.write(f'/pane/{wide_pane}/exec', b'Del\n')
- client.write('/ctl', b'FocusTint on\n')
- client.write(f'/pane/{notes_pane}/ctl', b'Collapse\n')
- scene('09-collapsed-focus-tint')
- client.write(f'/pane/{notes_pane}/ctl', b'Collapse\n')
- client.write('/ctl', b'Tagbottom\n')
- scene('10-tagbottom')
- client.write('/ctl', b'Tagbottom\n')
- client.write(f'/pane/{first}/tag', b' Second\nthird line of the tag')
- scene('12-multiline-tag')
- client.write(f'/pane/{first}/look', f'{image}\n'.encode())
- serial_of('ramp.ppm')
- scene('13-image')
- client.write('/ctl', b'Theme ink\n')
- scene('14-theme-ink')
- client.write('/ctl', b'Theme acme\n')
- scene('15-theme-acme-light')
- client.write('/ctl', b'Debug\n')
- scene('16-debug')
- client.write('/ctl', b'Debug\n')
- # A terminal pane: raw rows, ANSI colours, a hidden prompt.
- before = set(panes(client))
- client.write(f'/pane/{first}/exec', b'Term\n')
- terminal = require(wait_for(lambda: next((s for s in panes(client) if s not in before), None)), 'Term missing')
- client.write(f'/pane/{terminal}/pty/data', b"PS1='$ '; clear; printf '\\033[1;36mcolour\\033[0m plain \\033[32mgreen\\033[0m\\n'\r")
- require(wait_for(lambda: b'green' in client.read(f'/pane/{terminal}/body')), 'terminal output missing')
- scene('17-terminal')
- # Partway through a transition: the panes, the picture among them,
- # sliding over for a new column, frame 6 of PanelSlide's 12. Its
- # chrome slides with each pane.
- client.write('/ctl', b'PanelSlide\n')
- client.write(f'/pane/{first}/exec', b'Newcol\n')
- require(wait_for(lambda: (captures / 'transition-6.ppm').exists()), 'transition frame 6 never drawn')
- scene('18-mid-transition', 'transition-6.ppm')
- lines = ''.join(f'{label} {digest}\n' for label, digest in results)
- if args.update:
- GOLDENS.write_text(lines)
- print('updated', GOLDENS)
- return
- expected = dict(line.split() for line in GOLDENS.read_text().splitlines() if line.strip())
- bad = [label for label, digest in results if expected.get(label) != digest]
- require(not bad, 'frames changed: ' + ', '.join(bad))
- print(f'{len(results)} GUI frames byte-identical')
-
-
-if __name__ == '__main__':
- parser = argparse.ArgumentParser(description=__doc__)
- parser.add_argument('binary', type=Path)
- parser.add_argument('--update', action='store_true')
- parser.add_argument('--keep', type=Path, help='copy each hashed frame here as <scene>.ppm')
- run(parser.parse_args())
diff --git a/test/gui_monkey.py b/test/gui_monkey.py
deleted file mode 100644
index 540c377a..00000000
--- a/test/gui_monkey.py
+++ /dev/null
@@ -1,179 +0,0 @@
-#!/usr/bin/env python3
-"""A monkey over the GUI's effects: for each Motion x Lift x Bloom, a hidden
-test window gets a random burst of clicks, drags, wheels, keys, new and
-joined columns, opened files and theme changes, then must settle (its
-frames stop changing) with no crash record and its process alive.
-
-gui_monkey.py <pardes-gui> [outdir] [--seed N] [--steps N]; `zig build
-monkey-gui -Dplatform=gui -- [--seed N] [--steps N]` runs it on the built
-window. Exits 1 when any combination failed; what failed is in outdir.
-"""
-import argparse
-import hashlib
-import itertools
-import os
-import random
-import shutil
-import sys
-import tempfile
-import time
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from fs import session # noqa: E402
-
-MOTIONS = ['off', 'crisp', 'smooth', 'bouncy', 'playful']
-LIFTS = ['off', 'shadow', 'rim', 'auto']
-BLOOMS = ['0', '2']
-THEMES = ['lapis', 'lapis_plain', 'forge', 'acme', 'dusk', 'daybreak']
-W, H = 1280, 840
-
-
-def settled(cap, timeout=20):
- latest = cap / 'latest.ppm'
- previous = None
- deadline = time.monotonic() + timeout
- while time.monotonic() < deadline:
- time.sleep(.4)
- try:
- data = latest.read_bytes()
- except FileNotFoundError:
- continue
- digest = hashlib.sha256(data).hexdigest()
- if digest == previous:
- return True
- previous = digest
- return False
-
-
-def run(binary, out, motion, lift, bloom, seed, steps):
- rng = random.Random(seed)
- root = Path(tempfile.mkdtemp(prefix='pardes-gui-monkey-'))
- cap = root / 'cap'
- cap.mkdir()
- (root / 'config/pardes').mkdir(parents=True)
- (root / 'config/pardes/init').write_text(
- f'Shell /bin/sh\nMessageLinger 0\nMotion {motion}\nLift {lift}\nBloom {bloom}\nPanelSlide\nSelectionGlow on\nHoverGlow on\n')
- src = root / 'a.zig'
- src.write_text(''.join(f'pub fn f{n}(x: u32) u32 {{ return x * {n}; }} // a line\n' for n in range(200)))
- for name in ('b.txt', 'c.txt'):
- (root / name).write_text(''.join(f'{name} line {n} with some words\n' for n in range(80)))
- display = Path(os.environ.get('XDG_RUNTIME_DIR', '/run/user/%d' % os.getuid())) / os.environ.get('WAYLAND_DISPLAY', 'wayland-0')
- env = {'PARDES_TEST': '1', 'PARDES_TEST_CLOCK': '1', 'PARDES_TEST_COLS': '80', 'PARDES_TEST_ROWS': '28', 'PARDES_TEST_PAD': '0',
- 'PARDES_TEST_CAPTURE_DIR': str(cap), 'SDL_VIDEODRIVER': 'wayland', 'WAYLAND_DISPLAY': str(display)}
- name = 'monkey'
- launch = ['-c', 'stty cols 80 rows 28; exec "$@"', name, str(binary.resolve()), '--9p=' + name, str(src)]
- handles = {}
- verdict = 'ok'
- log = []
- try:
- with session('/bin/sh', root, name, socket_name=name, tty=True, launch=launch, inherited=env, terminal=handles) as (client, _):
- fd = handles['input_fd']
- time.sleep(1.0)
-
- def mouse(kind, button, x, y):
- os.write(fd, f'\x1b]777;mouse;{kind};{button};{x};{y}\x07'.encode())
-
- def first():
- rows = client.read('/index').decode().splitlines()
- return int(rows[0].split()[0]) if rows else None
-
- for _ in range(steps):
- x, y = rng.randrange(W), rng.randrange(H)
- action = rng.randrange(12)
- try:
- if action in (0, 1):
- mouse('down', 1, x, y); mouse('up', 1, x, y); log.append(f'click {x},{y}')
- elif action == 2:
- x2, y2 = rng.randrange(W), rng.randrange(H)
- mouse('down', 1, x, y)
- for i in range(1, 6):
- mouse('motion', 1, x + (x2 - x) * i // 5, y + (y2 - y) * i // 5)
- mouse('up', 1, x2, y2); log.append(f'drag {x},{y}->{x2},{y2}')
- elif action == 3:
- amount = rng.choice([-6, -2, 2, 6])
- os.write(fd, f'\x1b]777;mouse;wheel;{amount};{x};{y}\x07'.encode()); log.append(f'wheel {amount}')
- elif action == 4:
- mouse('motion', 0, x, y); log.append(f'hover {x},{y}')
- elif action == 5:
- client.write('/ctl', b'Newcol\n'); log.append('Newcol')
- elif action == 6:
- serial = first()
- if serial is not None:
- target = root / rng.choice(['b.txt', 'c.txt', 'a.zig'])
- client.write(f'/pane/{serial}/look', f'{target}\n'.encode()); log.append(f'look {target.name}')
- elif action == 7:
- serial = first()
- if serial is not None:
- # Delcol too: the last column's going leaves an
- # empty window now (acme's), not a quit.
- word = rng.choice(['Joincol', 'Collapse', 'Delcol'])
- try:
- client.write(f'/pane/{serial}/exec', (word + '\n').encode())
- except OSError:
- pass
- log.append(word)
- else:
- # An empty window: pane/new makes its column and a pane.
- try:
- client.read('/pane/new')
- except OSError:
- pass
- log.append('pane/new (empty window)')
- elif action == 8:
- os.write(fd, rng.choice([b'j', b'k', b'10j', b'gg', b'w', b'%', b'v5j', b'\x1b']))
- log.append('keys')
- elif action == 9:
- theme = rng.choice(THEMES)
- client.write('/ctl', f'Theme {theme}\n'.encode()); log.append(f'Theme {theme}')
- elif action == 10:
- mouse('down', 3, x, y); mouse('up', 3, x, y); log.append(f'look-click {x},{y}')
- else:
- time.sleep(rng.choice([0, .05, .2])); log.append('pause')
- except OSError as why:
- log.append(f'refused: {why}')
- time.sleep(.03)
- if not settled(cap):
- verdict = 'never settled'
- try:
- os.kill(handles['pid'], 0)
- except OSError:
- verdict = 'process gone'
- client.read('/index')
- except Exception as why: # noqa: BLE001
- verdict = f'failed: {type(why).__name__}: {str(why)[:300]}'
- crashes = list((root / 'config').rglob('*crash*'))
- if crashes:
- verdict = 'crash record: ' + ', '.join(str(c) for c in crashes)
- label = f'{motion}-{lift}-bloom{bloom}'
- if verdict != 'ok':
- (out / f'{label}.log').write_text('\n'.join(log) + '\n' + verdict + '\n')
- for c in crashes:
- shutil.copy(c, out / f'{label}-{c.name}')
- if (cap / 'latest.ppm').exists():
- shutil.copy(cap / 'latest.ppm', out / f'{label}-last.ppm')
- shutil.rmtree(root, ignore_errors=True)
- return label, verdict
-
-
-def main():
- ap = argparse.ArgumentParser()
- ap.add_argument('binary', type=Path)
- ap.add_argument('out', type=Path, nargs='?')
- ap.add_argument('--seed', type=int, default=1)
- ap.add_argument('--steps', type=int, default=60)
- args = ap.parse_args()
- if args.out is None:
- args.out = Path(tempfile.mkdtemp(prefix='pardes-gui-monkey-out-'))
- args.out.mkdir(parents=True, exist_ok=True)
- bad = 0
- for n, (motion, lift, bloom) in enumerate(itertools.product(MOTIONS, LIFTS, BLOOMS)):
- label, verdict = run(args.binary, args.out, motion, lift, bloom, args.seed * 1000 + n, args.steps)
- print(f'{label}: {verdict}', flush=True)
- bad += verdict != 'ok'
- print(f'{bad} of {len(MOTIONS) * len(LIFTS) * len(BLOOMS)} combinations failed; logs in {args.out}', flush=True)
- sys.exit(1 if bad else 0)
-
-
-if __name__ == '__main__':
- main()
diff --git a/test/process.zig b/test/process.zig
index bba795de..00f288a7 100644
--- a/test/process.zig
+++ b/test/process.zig
@@ -546,6 +546,8 @@ pub const Detached = struct {
root: ?[]const u8 = null,
/// The name its socket is linked as, when `--9p=<name>` names one.
socket: ?[]const u8 = null,
+ /// Its startup file (`config/pardes/init` in the root), written first.
+ init: ?[]const u8 = null,
};
/// A session of the backend's: `pardes --detach=<name>`, or the window
@@ -577,6 +579,13 @@ pub const Detached = struct {
errdefer if (d.cap_len > 0) removeDir(d.captures());
const dir = d.root();
var bufs: [6][4096]u8 = undefined;
+ if (opts.init) |text| {
+ const cfg = try std.fmt.bufPrintSentinel(&bufs[5], "{s}/config", .{dir}, 0);
+ _ = libc.mkdir(cfg, 0o755);
+ const pcfg = try std.fmt.bufPrintSentinel(&bufs[5], "{s}/config/pardes", .{dir}, 0);
+ _ = libc.mkdir(pcfg, 0o755);
+ try eh.writeFile(try std.fmt.bufPrintSentinel(&bufs[5], "{s}/config/pardes/init", .{dir}, 0), text);
+ }
const fixture = if (opts.file) |f| try std.fmt.bufPrintSentinel(&bufs[0], "{s}", .{f}, 0) else blk: {
const path = try std.fmt.bufPrintSentinel(&bufs[0], "{s}/{s}.txt", .{ dir, name }, 0);
try eh.writeFile(path, "initial\n");
@@ -672,12 +681,33 @@ pub const Detached = struct {
return d.cap_buf[0..d.cap_len];
}
- /// The window's frame once it is idle: a loop step two past the one
- /// current when this was asked, nothing owing a frame (gui.zig's
- /// writeTestStatus). Every request before this one has been served (a
- /// 9P write returns once the core has it), so the frame is the scene's
- /// however loaded the machine is. A binary PPM (P6), kept by the caller.
+ /// The window's frame once it is idle (`settle`): a binary PPM (P6),
+ /// kept by the caller.
pub fn frame(d: *Detached, gpa: std.mem.Allocator) ![]u8 {
+ return d.capture(gpa, "latest.ppm");
+ }
+
+ /// A capture the window wrote (`latest.ppm`, a transition's
+ /// `transition-<n>.ppm`), once it is there and the window is idle.
+ pub fn capture(d: *Detached, gpa: std.mem.Allocator, name: []const u8) ![]u8 {
+ try d.settle(gpa);
+ var path: [256]u8 = undefined;
+ const at = try std.fmt.bufPrint(&path, "{s}/{s}", .{ d.captures(), name });
+ const deadline = eh.nowMs() + 30_000;
+ while (eh.nowMs() < deadline) : (sleepMs(20)) {
+ const got = readWhole(gpa, at) catch continue;
+ if (std.mem.startsWith(u8, got, "P6")) return got;
+ gpa.free(got);
+ }
+ return error.NoCapture;
+ }
+
+ /// Until the window is idle: a loop step two past the one current when
+ /// this was asked, nothing owing a frame (gui.zig's writeTestStatus).
+ /// Every request before this one has been served (a 9P write returns
+ /// once the core has it), so what it then shows is the scene's however
+ /// loaded the machine is.
+ pub fn settle(d: *Detached, gpa: std.mem.Allocator) !void {
if (d.cap_len == 0) return error.NotAWindow;
var path: [128]u8 = undefined;
const status_path = try std.fmt.bufPrint(&path, "{s}/status", .{d.captures()});
@@ -694,16 +724,25 @@ pub const Detached = struct {
first_step = step;
continue;
};
- if (step >= first + 2 and idle and frames > 0) {
- var ppm: [128]u8 = undefined;
- const got = try readWhole(gpa, try std.fmt.bufPrint(&ppm, "{s}/latest.ppm", .{d.captures()}));
- if (std.mem.startsWith(u8, got, "P6")) return got;
- gpa.free(got);
- }
+ if (step >= first + 2 and idle and frames > 0) return;
}
return error.NeverIdle;
}
+ /// Keys typed at the window as its terminal gives them (its pty).
+ pub fn typeKeys(d: *Detached, bytes: []const u8) !void {
+ if (d.cap_len == 0) return error.NotAWindow;
+ if (libc.write(d.child.master, bytes.ptr, bytes.len) != @as(isize, @intCast(bytes.len))) return error.ShortWrite;
+ }
+
+ /// A mouse event at window pixels, as the window's test shell takes
+ /// one (OSC 777): `kind` down, up, motion or wheel; `button` 1 left,
+ /// 2 middle, 3 right, 0 none, a wheel's amount for wheel.
+ pub fn mouse(d: *Detached, kind: []const u8, button: i32, x: u32, y: u32) !void {
+ var buf: [96]u8 = undefined;
+ try d.typeKeys(try std.fmt.bufPrint(&buf, "\x1b]777;mouse;{s};{d};{d};{d}\x07", .{ kind, button, x, y }));
+ }
+
fn removeRoot(d: *Detached) void {
var cmd: [4200]u8 = undefined;
if (std.fmt.bufPrintSentinel(&cmd, "rm -rf -- '{s}'", .{d.root()}, 0)) |c| {
@@ -1055,7 +1094,7 @@ fn removeDir(path: []const u8) void {
} else |_| {}
}
-fn readWhole(gpa: std.mem.Allocator, path: []const u8) ![]u8 {
+pub fn readWhole(gpa: std.mem.Allocator, path: []const u8) ![]u8 {
var buf: [4096]u8 = undefined;
const z = try std.fmt.bufPrintSentinel(&buf, "{s}", .{path}, 0);
const fd = libc.open(z, .{}, @as(libc.mode_t, 0));
@@ -1072,3 +1111,8 @@ fn readWhole(gpa: std.mem.Allocator, path: []const u8) ![]u8 {
}
return out.toOwnedSlice(gpa);
}
+
+/// `data` written to `path` whole (made or truncated).
+pub fn writeFile(a: std.mem.Allocator, path: []const u8, data: []const u8) !void {
+ try eh.writeFile(try std.fmt.allocPrintSentinel(a, "{s}", .{path}, 0), data);
+}
diff --git a/test/process/window.zig b/test/process/window.zig
new file mode 100644
index 00000000..63247122
--- /dev/null
+++ b/test/process/window.zig
@@ -0,0 +1,364 @@
+//! The window's own (T4 of docs/next-tests.md): what only its pixels and
+//! its own input show, on the hidden window `zig build process-test
+//! -Dplatform=gui` drives. test/gui_monkey.py and test/gui_golden.py, here.
+const std = @import("std");
+const process = @import("../process.zig");
+extern "c" fn system(cmd: [*:0]const u8) c_int;
+
+pub const cases = .{
+ .{ "window: a monkey over the effects: random clicks, drags, wheels, keys, columns, looks and themes, then it settles, alive, with no crash record", monkey },
+ .{ "window: its scenes are the frames test/gui-goldens.txt hashes (PARDES_GUI_GOLDEN=check|update, this machine's)", goldens },
+};
+
+fn envOr(name: [*:0]const u8, default: []const u8) []const u8 {
+ return if (std.c.getenv(name)) |v| std.mem.span(v) else default;
+}
+
+/// The serial of the first pane whose tag holds `word`, waited for.
+fn paneWith(f: *process.Files, word: []const u8) !u32 {
+ const deadline = process.nowMs() + 10_000;
+ while (process.nowMs() < deadline) : (process.nap(50)) {
+ var rows = std.mem.tokenizeScalar(u8, try f.read("/index"), '\n');
+ while (rows.next()) |row| {
+ const serial = std.fmt.parseInt(u32, row[0 .. std.mem.indexOfScalar(u8, row, ' ') orelse continue], 10) catch continue;
+ if (process.has(try f.read(f.at("/pane/{d}/tag", .{serial})), word)) return serial;
+ }
+ }
+ std.debug.print("no pane's tag holds {s}\n", .{word});
+ return error.NoSuchPane;
+}
+
+const motions = [_][]const u8{ "off", "crisp", "smooth", "bouncy", "playful" };
+const lifts = [_][]const u8{ "off", "shadow", "rim", "auto" };
+const blooms = [_][]const u8{ "0", "2" };
+const themes = [_][]const u8{ "lapis", "lapis_plain", "forge", "acme", "dusk", "daybreak" };
+
+/// test/gui_monkey.py's: each Motion x Lift x Bloom gets a random burst,
+/// then must settle with its process alive and no crash record. Two
+/// combinations and 30 steps in process-test; PARDES_GUI_MONKEY=all runs
+/// all 40 (`zig build monkey-gui`), PARDES_GUI_MONKEY_SEED and _STEPS
+/// choose the rest.
+fn monkey(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ try process.only(.gui);
+ const all = std.mem.eql(u8, envOr("PARDES_GUI_MONKEY", ""), "all");
+ const seed = try std.fmt.parseInt(u64, envOr("PARDES_GUI_MONKEY_SEED", "1"), 10);
+ const steps = try std.fmt.parseInt(usize, envOr("PARDES_GUI_MONKEY_STEPS", if (all) "60" else "30"), 10);
+ var failed: usize = 0;
+ var n: usize = 0;
+ for (motions) |m| for (lifts) |l| for (blooms) |b| {
+ defer n += 1;
+ // The smoke run: the quietest combination and the busiest.
+ if (!all and n != 0 and n != motions.len * lifts.len * blooms.len - 1) continue;
+ if (!try monkeyOne(gpa, exe, m, l, b, seed * 1000 + n, steps)) failed += 1;
+ };
+ if (failed > 0) return error.MonkeyFailed;
+}
+
+fn monkeyOne(gpa: std.mem.Allocator, exe: [:0]const u8, motion: []const u8, lift: []const u8, bloom: []const u8, seed: u64, steps: usize) !bool {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const init = try std.fmt.allocPrint(a, "Shell /bin/sh\nMessageLinger 0\nMotion {s}\nLift {s}\nBloom {s}\nPanelSlide\nSelectionGlow on\nHoverGlow on\n", .{ motion, lift, bloom });
+ var d = try process.Detached.start(gpa, exe, "monkey", .{ .init = init, .env = &.{
+ .{ "PARDES_TEST_CLOCK", "1" }, .{ "PARDES_TEST_COLS", "80" }, .{ "PARDES_TEST_ROWS", "28" }, .{ "PARDES_TEST_PAD", "0" },
+ } });
+ defer d.deinit();
+ const f = &d.files;
+ var src: std.ArrayList(u8) = .empty;
+ for (0..200) |k| try src.print(a, "pub fn f{d}(x: u32) u32 {{ return x * {d}; }} // a line\n", .{ k, k });
+ try d.put("a.zig", src.items);
+ for ([_][]const u8{ "b.txt", "c.txt" }) |name| {
+ var text: std.ArrayList(u8) = .empty;
+ for (0..80) |k| try text.print(a, "{s} line {d} with some words\n", .{ name, k });
+ try d.put(name, text.items);
+ }
+ const names = [_][]const u8{ "b.txt", "c.txt", "a.zig" };
+ var prng = std.Random.DefaultPrng.init(seed);
+ const r = prng.random();
+ const w: u32 = 1280;
+ const h: u32 = 840;
+ var log: std.ArrayList(u8) = .empty;
+ for (0..steps) |_| {
+ const x = r.uintLessThan(u32, w);
+ const y = r.uintLessThan(u32, h);
+ const action = r.uintLessThan(u32, 12);
+ // A refusal is part of the burst (a Delcol of the last column, a
+ // look at a moved pane): logged, never the verdict.
+ step(&d, f, a, r, action, x, y, &names, &log) catch |err| try log.print(a, "refused {t}\n", .{err});
+ process.nap(30);
+ }
+ var verdict: []const u8 = "ok";
+ d.settle(gpa) catch {
+ verdict = "never settled";
+ };
+ if (d.exited(0) != null) verdict = "process gone";
+ _ = f.read("/index") catch {
+ verdict = "no /index";
+ };
+ const config = try std.fmt.allocPrint(a, "{s}/config/pardes", .{d.root()});
+ if (process.entries(a, config)) |listed| {
+ for (listed) |name| if (process.has(name, "crash")) {
+ verdict = try std.fmt.allocPrint(a, "crash record {s}", .{name});
+ };
+ } else |_| {}
+ const ok = std.mem.eql(u8, verdict, "ok");
+ if (!ok) std.debug.print("monkey {s}-{s}-bloom{s} (seed {d}): {s}\n{s}", .{ motion, lift, bloom, seed, verdict, log.items });
+ return ok;
+}
+
+fn step(d: *process.Detached, f: *process.Files, a: std.mem.Allocator, r: std.Random, action: u32, x: u32, y: u32, names: []const []const u8, log: *std.ArrayList(u8)) !void {
+ switch (action) {
+ 0, 1 => {
+ try d.mouse("down", 1, x, y);
+ try d.mouse("up", 1, x, y);
+ try log.print(a, "click {d},{d}\n", .{ x, y });
+ },
+ 2 => {
+ const x2 = r.uintLessThan(u32, 1280);
+ const y2 = r.uintLessThan(u32, 840);
+ try d.mouse("down", 1, x, y);
+ for (1..6) |i| {
+ const k: i64 = @intCast(i);
+ try d.mouse("motion", 1, @intCast(@as(i64, x) + @divTrunc((@as(i64, x2) - x) * k, 5)), @intCast(@as(i64, y) + @divTrunc((@as(i64, y2) - y) * k, 5)));
+ }
+ try d.mouse("up", 1, x2, y2);
+ try log.print(a, "drag {d},{d}->{d},{d}\n", .{ x, y, x2, y2 });
+ },
+ 3 => {
+ const amount = ([_]i32{ -6, -2, 2, 6 })[r.uintLessThan(usize, 4)];
+ try d.mouse("wheel", amount, x, y);
+ try log.print(a, "wheel {d}\n", .{amount});
+ },
+ 4 => {
+ try d.mouse("motion", 0, x, y);
+ try log.print(a, "hover {d},{d}\n", .{ x, y });
+ },
+ 5 => {
+ try log.print(a, "Newcol\n", .{});
+ try f.write("/ctl", "Newcol\n");
+ },
+ 6 => if (try firstPane(f)) |serial| {
+ const target = names[r.uintLessThan(usize, names.len)];
+ try log.print(a, "look {s}\n", .{target});
+ try f.write(f.at("/pane/{d}/look", .{serial}), f.at("{s}/{s}\n", .{ d.root(), target }));
+ },
+ 7 => if (try firstPane(f)) |serial| {
+ // Delcol too: the last column's going leaves an empty window
+ // (acme's), not a quit.
+ const word = ([_][]const u8{ "Joincol", "Collapse", "Delcol" })[r.uintLessThan(usize, 3)];
+ try log.print(a, "{s}\n", .{word});
+ try f.write(f.at("/pane/{d}/exec", .{serial}), f.at("{s}\n", .{word}));
+ } else {
+ // An empty window: pane/new makes its column and a pane.
+ try log.print(a, "pane/new (empty window)\n", .{});
+ _ = try f.newPane();
+ },
+ 8 => {
+ const keys = ([_][]const u8{ "j", "k", "10j", "gg", "w", "%", "v5j", "\x1b" })[r.uintLessThan(usize, 8)];
+ try log.print(a, "keys\n", .{});
+ try d.typeKeys(keys);
+ },
+ 9 => {
+ const theme = themes[r.uintLessThan(usize, themes.len)];
+ try log.print(a, "Theme {s}\n", .{theme});
+ try f.write("/ctl", f.at("Theme {s}\n", .{theme}));
+ },
+ 10 => {
+ try d.mouse("down", 3, x, y);
+ try d.mouse("up", 3, x, y);
+ try log.print(a, "look-click {d},{d}\n", .{ x, y });
+ },
+ else => {
+ process.nap(([_]u32{ 0, 50, 200 })[r.uintLessThan(usize, 3)]);
+ try log.print(a, "pause\n", .{});
+ },
+ }
+}
+
+fn firstPane(f: *process.Files) !?u32 {
+ const index = try f.read("/index");
+ const end = std.mem.indexOfScalar(u8, index, ' ') orelse return null;
+ return std.fmt.parseInt(u32, index[0..end], 10) catch null;
+}
+
+/// test/gui_golden.py's scenes, each frame's sha256 against
+/// test/gui-goldens.txt: an exact gate for one machine (a GPU, a driver,
+/// software rendering here draw their own pixels), never a CI one, so it
+/// runs only when asked: PARDES_GUI_GOLDEN=check, or =update to rewrite the
+/// goldens; PARDES_GUI_GOLDEN_KEEP=<dir> keeps each frame as <scene>.ppm.
+/// The root is fixed: its paths are drawn in the tags.
+fn goldens(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ try process.only(.gui);
+ const mode = envOr("PARDES_GUI_GOLDEN", "");
+ if (!std.mem.eql(u8, mode, "check") and !std.mem.eql(u8, mode, "update")) return error.SkipZigTest;
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const root = "/tmp/pardes-gui-golden";
+ _ = system("rm -rf -- /tmp/pardes-gui-golden");
+ if (std.c.mkdir(root, 0o700) != 0) return error.NoRoot;
+ defer _ = system("rm -rf -- /tmp/pardes-gui-golden");
+ var zig: std.ArrayList(u8) = .empty;
+ try zig.appendSlice(a,
+ \\const std = @import("std");
+ \\
+ \\pub const Shape = union(enum) {
+ \\ circle: f32,
+ \\ square: f32,
+ \\
+ \\ pub fn area(shape: Shape) f32 {
+ \\ return switch (shape) {
+ \\ .circle => |r| std.math.pi * r * r,
+ \\ .square => |s| s * s,
+ \\ };
+ \\ }
+ \\};
+ \\
+ \\pub fn main() void {
+ \\ var total: f32 = 0;
+ \\ const shapes = [_]Shape{ .{ .circle = 1 }, .{ .square = 2 } };
+ \\ for (shapes) |shape| {
+ \\
+ );
+ for (0..60) |n| try zig.print(a, " total += shape.area() * {d}; // line {d}\n", .{ n, n });
+ try zig.appendSlice(a, " }\n std.debug.print(\"{d}\\n\", .{total});\n}\n");
+ try process.writeFile(a, root ++ "/shapes.zig", zig.items);
+ var notes: std.ArrayList(u8) = .empty;
+ for (0..4) |_| try notes.appendSlice(a, "Pardes GUI golden\n\nA second document, opened by Look.\n");
+ try process.writeFile(a, root ++ "/notes.txt", notes.items);
+ // One of the two alignments puts a wide glyph across the body's right edge.
+ var wide: std.ArrayList(u8) = .empty;
+ try wide.append(a, 'x');
+ for (0..80) |_| try wide.appendSlice(a, "\u{754c}");
+ try wide.append(a, '\n');
+ for (0..80) |_| try wide.appendSlice(a, "\u{754c}");
+ try wide.append(a, '\n');
+ try process.writeFile(a, root ++ "/wide.txt", wide.items);
+ var ppm: std.ArrayList(u8) = .empty;
+ try ppm.print(a, "P6\n{d} {d}\n255\n", .{ 96, 64 });
+ for (0..64) |yy| for (0..96) |xx| try ppm.appendSlice(a, &.{ @intCast(xx * 255 / 96), @intCast(yy * 255 / 64), 128 });
+ try process.writeFile(a, root ++ "/ramp.ppm", ppm.items);
+
+ var d = try process.Detached.start(gpa, exe, "gui-golden", .{
+ .root = root,
+ .file = root ++ "/shapes.zig",
+ .init = "Shell /bin/sh\nTheme forge\nMessageLinger 0\n",
+ // The virtual clock: a transition's frames are the same frames on
+ // any machine, so one partway through can be hashed too.
+ .env = &.{ .{ "PARDES_TEST_CLOCK", "1" }, .{ "PARDES_TEST_COLS", "120" }, .{ "PARDES_TEST_ROWS", "40" }, .{ "PARDES_TEST_PAD", "7" } },
+ });
+ defer d.deinit();
+ const f = &d.files;
+ var results: std.ArrayList(u8) = .empty;
+ const keep = std.c.getenv("PARDES_GUI_GOLDEN_KEEP");
+ const Scene = struct {
+ fn shot(dd: *process.Detached, al: std.mem.Allocator, out: *std.ArrayList(u8), kept: ?[*:0]const u8, label: []const u8, file: []const u8) !void {
+ const bytes = try dd.capture(al, file);
+ var digest: [32]u8 = undefined;
+ std.crypto.hash.sha2.Sha256.hash(bytes, &digest, .{});
+ try out.print(al, "{s} {x}\n", .{ label, digest });
+ if (kept) |dir| try process.writeFile(al, try std.fmt.allocPrint(al, "{s}/{s}.ppm", .{ std.mem.span(dir), label }), bytes);
+ std.debug.print("{s} {x}\n", .{ label, digest[0..8] });
+ }
+ };
+ const shot = Scene.shot;
+ const first = try paneWith(f, "shapes.zig");
+ try shot(&d, a, &results, keep, "01-boot", "latest.ppm");
+ try f.write(f.at("/pane/{d}/look", .{first}), root ++ "/notes.txt\n");
+ const notes_pane = try paneWith(f, "notes.txt");
+ try shot(&d, a, &results, keep, "02-second-document", "latest.ppm");
+ try f.write(f.at("/pane/{d}/ctl", .{first}), "Msg a golden notice\n");
+ try shot(&d, a, &results, keep, "03-notice", "latest.ppm");
+ try f.write(f.at("/pane/{d}/ctl", .{first}), "TreeContext\n");
+ try f.write(f.at("/pane/{d}/dot", .{first}), "45\n");
+ try shot(&d, a, &results, keep, "04-context-rows-mid-thumb", "latest.ppm");
+ try f.write(f.at("/pane/{d}/dot", .{first}), "40,43\n");
+ try shot(&d, a, &results, keep, "05-body-selection", "latest.ppm");
+ // A press and a drag along the source's tag: the tag takes the keyboard
+ // with a selection and a caret. The pointer then rests on empty body
+ // space, far right.
+ for ([_]struct { []const u8, i32, u32, u32 }{ .{ "down", 1, 500, 87 }, .{ "motion", 1, 620, 87 }, .{ "up", 1, 620, 87 }, .{ "motion", 0, 1880, 1300 } }) |ev| {
+ try d.mouse(ev[0], ev[1], ev[2], ev[3]);
+ process.nap(100);
+ }
+ try shot(&d, a, &results, keep, "06-tag-focus-selection", "latest.ppm");
+ try d.typeKeys("\x1b");
+ process.nap(200);
+ const scratch = try f.newPane();
+ try f.write(f.at("/pane/{d}/exec", .{scratch}), "Save\n");
+ try shot(&d, a, &results, keep, "07-prompt-notice", "latest.ppm");
+ try d.typeKeys("\x1b");
+ process.nap(200);
+ try f.write(f.at("/pane/{d}/exec", .{scratch}), "Del\n");
+ try f.write(f.at("/pane/{d}/look", .{first}), root ++ "/wide.txt\n");
+ const wide_pane = try paneWith(f, "wide.txt");
+ var name: std.ArrayList(u8) = .empty;
+ try name.append(a, 'x');
+ for (0..70) |_| try name.appendSlice(a, "\u{754c}");
+ try name.append(a, '\n');
+ try f.write(f.at("/pane/{d}/name", .{wide_pane}), name.items);
+ try f.write("/ctl", "Wrap off\n");
+ try shot(&d, a, &results, keep, "08-wide-glyph-edges", "latest.ppm");
+ try f.write("/ctl", "Wrap on\n");
+ try f.write(f.at("/pane/{d}/exec", .{wide_pane}), "Del\n");
+ try f.write("/ctl", "FocusTint on\n");
+ try f.write(f.at("/pane/{d}/ctl", .{notes_pane}), "Collapse\n");
+ try shot(&d, a, &results, keep, "09-collapsed-focus-tint", "latest.ppm");
+ try f.write(f.at("/pane/{d}/ctl", .{notes_pane}), "Collapse\n");
+ try f.write("/ctl", "Tagbottom\n");
+ try shot(&d, a, &results, keep, "10-tagbottom", "latest.ppm");
+ try f.write("/ctl", "Tagbottom\n");
+ try f.write(f.at("/pane/{d}/tag", .{first}), " Second\nthird line of the tag");
+ try shot(&d, a, &results, keep, "12-multiline-tag", "latest.ppm");
+ try f.write(f.at("/pane/{d}/look", .{first}), root ++ "/ramp.ppm\n");
+ _ = try paneWith(f, "ramp.ppm");
+ try shot(&d, a, &results, keep, "13-image", "latest.ppm");
+ try f.write("/ctl", "Theme ink\n");
+ try shot(&d, a, &results, keep, "14-theme-ink", "latest.ppm");
+ try f.write("/ctl", "Theme acme\n");
+ try shot(&d, a, &results, keep, "15-theme-acme-light", "latest.ppm");
+ try f.write("/ctl", "Debug\n");
+ try shot(&d, a, &results, keep, "16-debug", "latest.ppm");
+ try f.write("/ctl", "Debug\n");
+ // A terminal pane: raw rows, ANSI colours, a hidden prompt.
+ const before = try f.read("/index");
+ try f.write(f.at("/pane/{d}/exec", .{first}), "Term\n");
+ const terminal = blk: {
+ const deadline = process.nowMs() + 10_000;
+ while (process.nowMs() < deadline) : (process.nap(50)) {
+ var rows = std.mem.tokenizeScalar(u8, try f.read("/index"), '\n');
+ while (rows.next()) |row| {
+ const head = row[0 .. std.mem.indexOfScalar(u8, row, ' ') orelse continue];
+ if (std.mem.indexOf(u8, before, f.at("{s} ", .{head})) == null) break :blk try std.fmt.parseInt(u32, head, 10);
+ }
+ }
+ return error.NoTerminal;
+ };
+ try f.write(f.at("/pane/{d}/pty/data", .{terminal}), "PS1='$ '; clear; printf '\\033[1;36mcolour\\033[0m plain \\033[32mgreen\\033[0m\\n'\r");
+ {
+ const deadline = process.nowMs() + 10_000;
+ while (!process.has(try f.read(f.at("/pane/{d}/body", .{terminal})), "green")) : (process.nap(50))
+ if (process.nowMs() > deadline) return error.NoTerminalOutput;
+ }
+ try shot(&d, a, &results, keep, "17-terminal", "latest.ppm");
+ // Partway through a transition: the panes, the picture among them,
+ // sliding over for a new column, frame 6 of PanelSlide's 12.
+ try f.write("/ctl", "PanelSlide\n");
+ try f.write(f.at("/pane/{d}/exec", .{first}), "Newcol\n");
+ try shot(&d, a, &results, keep, "18-mid-transition", "transition-6.ppm");
+
+ const goldens_path = "test/gui-goldens.txt";
+ if (std.mem.eql(u8, mode, "update")) {
+ try process.writeFile(a, goldens_path, results.items);
+ std.debug.print("updated {s}\n", .{goldens_path});
+ return;
+ }
+ const want = try process.readWhole(a, goldens_path);
+ var bad: usize = 0;
+ var got = std.mem.tokenizeScalar(u8, results.items, '\n');
+ while (got.next()) |line| if (std.mem.indexOf(u8, want, line) == null) {
+ bad += 1;
+ std.debug.print("frame changed: {s}\n", .{line[0..std.mem.indexOfScalar(u8, line, ' ').?]});
+ };
+ if (bad > 0) return error.FramesChanged;
+}
diff --git a/test/process_test.zig b/test/process_test.zig
index 67f28f53..e363c78a 100644
--- a/test/process_test.zig
+++ b/test/process_test.zig
@@ -17,6 +17,7 @@ const files = .{
@import("process/root_ctl.zig"),
@import("process/terminals.zig"),
@import("process/tree.zig"),
+ @import("process/window.zig"),
};
pub fn main(init: std.process.Init) !void {
diff --git a/test/record_demos.py b/test/record_demos.py
index 4468ffb6..22dc8b7e 100644
--- a/test/record_demos.py
+++ b/test/record_demos.py
@@ -285,7 +285,7 @@ class Session:
return None
def settle(self):
- """The frame once the window says it is idle (test/gui_golden.py)."""
+ """The frame once the window says it is idle (test/process.zig's Detached.settle)."""
deadline = time.monotonic() + 60
start = None
while time.monotonic() < deadline: