From dcd3128bc9d039831ae4f8e030baadb1225dbc3a Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Wed, 4 Nov 2026 23:11:56 -0300 Subject: tui: the terminal-input tests share one TestInput fixture (vaxis, its writer, the queue and a feed, set up in place) and one TestReader (parts a read each, a gap, asked or not) where each test had its own twelve lines of setup and its own copy of a reader Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge --- src/tui/tui.zig | 377 +++++++++++++++++++++----------------------------------- 1 file changed, 138 insertions(+), 239 deletions(-) diff --git a/src/tui/tui.zig b/src/tui/tui.zig index aaf958dc..0389b12c 100644 --- a/src/tui/tui.zig +++ b/src/tui/tui.zig @@ -341,42 +341,74 @@ fn inputFollows(tty: anytype, io: std.Io, ms: u32) !bool { return false; } -test "terminal input preserves fragmented keys queries paste and text after EOF" { - const gpa = std.testing.allocator; - const io = std.testing.io; - var env = try std.testing.environ.createMap(gpa); - defer env.deinit(); - var vx = try vaxis.init(io, gpa, &env, .{ .system_clipboard_allocator = gpa }); - var output: std.Io.Writer.Allocating = .init(gpa); - defer output.deinit(); - defer vx.deinit(gpa, &output.writer); - vx.queries_done.store(false, .unordered); - var tty: vaxis.Tty = undefined; - var loop: Loop = .init(io, &tty, &vx); - var feed: Feed = .{}; - const Reader = struct { - parts: []const []const u8, - next: usize = 0, - fn getWinsize(_: *@This()) !vaxis.Winsize { - return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 }; - } - pub fn inputFollows(self: *@This(), _: u32) bool { - return self.next < self.parts.len; - } - fn read(self: *@This(), buf: []u8) !usize { - if (self.next == self.parts.len) return 0; - const part = self.parts[self.next]; - self.next += 1; +/// What a test of a terminal's input needs: vaxis (its capabilities, its +/// parser's allocator), the loop's queue and a feed, set up in place (vaxis +/// keeps the environment's address) and torn down in the order vaxis needs. +const TestInput = struct { + env: std.process.Environ.Map, + vx: vaxis.Vaxis, + out: std.Io.Writer.Allocating, + loop: Loop, + feed: Feed, + + fn init(t: *TestInput) !void { + const gpa = std.testing.allocator; + t.env = try std.testing.environ.createMap(gpa); + errdefer t.env.deinit(); + t.vx = try vaxis.init(std.testing.io, gpa, &t.env, .{ .system_clipboard_allocator = gpa }); + t.out = .init(gpa); + t.loop = .init(std.testing.io, undefined, &t.vx); + t.feed = .{}; + } + + fn deinit(t: *TestInput) void { + t.vx.deinit(std.testing.allocator, &t.out.writer); + t.out.deinit(); + t.env.deinit(); + } +}; + +/// A terminal that hands over `parts`, a read each (an empty one passed +/// over), and says more follows (within `gap_ms`) while some are left. +const TestReader = struct { + parts: []const []const u8, + next: usize = 0, + gap_ms: u32 = 0, + asked: bool = false, + + fn getWinsize(_: *TestReader) !vaxis.Winsize { + return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 }; + } + + pub fn inputFollows(r: *TestReader, ms: u32) bool { + r.asked = true; + return r.next < r.parts.len and r.gap_ms <= ms; + } + + fn read(r: *TestReader, buf: []u8) !usize { + while (r.next < r.parts.len) { + const part = r.parts[r.next]; + r.next += 1; + if (part.len == 0) continue; @memcpy(buf[0..part.len], part); return part.len; } - }; - var reader: Reader = .{ .parts = &.{ + return 0; + } +}; + +test "terminal input preserves fragmented keys queries paste and text after EOF" { + const gpa = std.testing.allocator; + var t: TestInput = undefined; + try t.init(); + defer t.deinit(); + t.vx.queries_done.store(false, .unordered); + var reader: TestReader = .{ .parts = &.{ "plain \x1b[?62;", "4c\x1b[", "A\x1b[200", "~caf\xc3", "\xa9 \xe7", "\x95", "\x8c \xf0\x9f", "\x98\x80", "\x1b[201", "~\x1b]52;c;Y2", "xpcA==\x07tail", "\x1b", } }; - try readInput(&loop, &reader, &vx, &feed); - try std.testing.expect(vx.queries_done.load(.unordered)); + try readInput(&t.loop, &reader, &t.vx, &t.feed); + try std.testing.expect(t.vx.queries_done.load(.unordered)); var text: std.ArrayList(u8) = .empty; defer text.deinit(gpa); var resized = false; @@ -385,7 +417,7 @@ test "terminal input preserves fragmented keys queries paste and text after EOF" var pasted = false; var clipboard = false; var escape = false; - while (try loop.tryEvent()) |event| switch (event) { + while (try t.loop.tryEvent()) |event| switch (event) { .winsize => |size| { try std.testing.expect(!resized); resized = true; @@ -418,7 +450,7 @@ test "terminal input preserves fragmented keys queries paste and text after EOF" clipboard = true; }, // The device attributes' wake (a capability answer). - .nop => try std.testing.expect(vx.queries_done.load(.unordered)), + .nop => try std.testing.expect(t.vx.queries_done.load(.unordered)), else => return error.UnexpectedInputEvent, }; try std.testing.expectEqualStrings("plain café 界 😀tail", text.items); @@ -427,35 +459,11 @@ test "terminal input preserves fragmented keys queries paste and text after EOF" test "terminal replies and malformed sequences never become typed text" { const gpa = std.testing.allocator; - const io = std.testing.io; - var env = try std.testing.environ.createMap(gpa); - defer env.deinit(); - var vx = try vaxis.init(io, gpa, &env, .{ .system_clipboard_allocator = gpa }); - var output: std.Io.Writer.Allocating = .init(gpa); - defer output.deinit(); - defer vx.deinit(gpa, &output.writer); - vx.queries_done.store(false, .unordered); - var tty: vaxis.Tty = undefined; - var loop: Loop = .init(io, &tty, &vx); - var feed: Feed = .{}; - const Reader = struct { - parts: []const []const u8, - next: usize = 0, - fn getWinsize(_: *@This()) !vaxis.Winsize { - return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 }; - } - pub fn inputFollows(self: *@This(), _: u32) bool { - return self.next < self.parts.len; - } - fn read(self: *@This(), buf: []u8) !usize { - if (self.next == self.parts.len) return 0; - const part = self.parts[self.next]; - self.next += 1; - @memcpy(buf[0..part.len], part); - return part.len; - } - }; - var reader: Reader = .{ + var t: TestInput = undefined; + try t.init(); + defer t.deinit(); + t.vx.queries_done.store(false, .unordered); + var reader: TestReader = .{ .parts = &.{ // The startup width queries' answers where the terminal has no // explicit width: both used to arrive as a bare F3, typed as text. @@ -480,14 +488,14 @@ test "terminal replies and malformed sequences never become typed text" { "c", }, }; - try readInput(&loop, &reader, &vx, &feed); - try std.testing.expect(vx.queries_done.load(.unordered)); - try std.testing.expect(vx.caps.kitty_graphics); + try readInput(&t.loop, &reader, &t.vx, &t.feed); + try std.testing.expect(t.vx.queries_done.load(.unordered)); + try std.testing.expect(t.vx.caps.kitty_graphics); var text: std.ArrayList(u8) = .empty; defer text.deinit(gpa); var alt_up = false; var clicked = false; - while (try loop.tryEvent()) |event| switch (event) { + while (try t.loop.tryEvent()) |event| switch (event) { .winsize => {}, .key_press => |key| { if (key.codepoint == vaxis.Key.up and key.mods.alt) { @@ -509,40 +517,14 @@ test "terminal replies and malformed sequences never become typed text" { test "terminal input split at every byte with a gap reads as it does whole" { const gpa = std.testing.allocator; - const io = std.testing.io; - var env = try std.testing.environ.createMap(gpa); - defer env.deinit(); - var vx = try vaxis.init(io, gpa, &env, .{ .system_clipboard_allocator = gpa }); - var output: std.Io.Writer.Allocating = .init(gpa); - defer output.deinit(); - defer vx.deinit(gpa, &output.writer); - var tty: vaxis.Tty = undefined; - var loop: Loop = .init(io, &tty, &vx); - var feed: Feed = .{}; + var t: TestInput = undefined; + try t.init(); + defer t.deinit(); // Two reads with `gap_ms` between them, as an ssh link delivers a - // sequence cut across two packets. - const Reader = struct { - parts: [2][]const u8, - gap_ms: u32, - next: usize = 0, - fn getWinsize(_: *@This()) !vaxis.Winsize { - return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 }; - } - pub fn inputFollows(self: *@This(), ms: u32) bool { - return self.next < self.parts.len and self.gap_ms <= ms; - } - fn read(self: *@This(), buf: []u8) !usize { - while (self.next < self.parts.len) { - const part = self.parts[self.next]; - self.next += 1; - if (part.len == 0) continue; - @memcpy(buf[0..part.len], part); - return part.len; - } - return 0; - } + // sequence cut across two packets (TestReader). + const Events = struct { /// What the loop was handed, one line per event. - fn events(l: *Loop, out: *std.ArrayList(u8)) !void { + fn of(l: *Loop, out: *std.ArrayList(u8)) !void { out.clearRetainingCapacity(); while (try l.tryEvent()) |event| switch (event) { .winsize => {}, @@ -579,122 +561,71 @@ test "terminal input split at every byte with a gap reads as it does whole" { var split: std.ArrayList(u8) = .empty; defer split.deinit(gpa); for (cases) |case| { - vx.caps.kitty_keyboard = case.kitty; + t.vx.caps.kitty_keyboard = case.kitty; const all = try std.mem.concat(gpa, u8, &.{ "x", case.bytes, "y" }); defer gpa.free(all); - var one: Reader = .{ .parts = .{ all, "" }, .gap_ms = 0 }; - try readInput(&loop, &one, &vx, &feed); - try Reader.events(&loop, &whole); + const whole_parts = [_][]const u8{ all, "" }; + var one: TestReader = .{ .parts = &whole_parts }; + try readInput(&t.loop, &one, &t.vx, &t.feed); + try Events.of(&t.loop, &whole); for (1..all.len) |cut| { // A cut just after an ESC is the one that has to wait, and a // legacy terminal's Escape waits only 50 ms: 40 ms there. A cut // anywhere else is carried however long the gap. const after_esc = all[cut - 1] == 0x1b; - var two: Reader = .{ .parts = .{ all[0..cut], all[cut..] }, .gap_ms = if (after_esc and !case.kitty) 40 else 60 }; - try readInput(&loop, &two, &vx, &feed); - try Reader.events(&loop, &split); + const halves = [_][]const u8{ all[0..cut], all[cut..] }; + var two: TestReader = .{ .parts = &halves, .gap_ms = if (after_esc and !case.kitty) 40 else 60 }; + try readInput(&t.loop, &two, &t.vx, &t.feed); + try Events.of(&t.loop, &split); std.testing.expectEqualStrings(whole.items, split.items) catch |err| { std.debug.print("case {f} cut at {d}\n", .{ std.ascii.hexEscape(case.bytes, .lower), cut }); return err; }; } } - vx.caps.kitty_keyboard = false; + t.vx.caps.kitty_keyboard = false; } test "an ESC read by itself is the Escape key at once" { - const gpa = std.testing.allocator; - const io = std.testing.io; - var env = try std.testing.environ.createMap(gpa); - defer env.deinit(); - var vx = try vaxis.init(io, gpa, &env, .{}); - var output: std.Io.Writer.Allocating = .init(gpa); - defer output.deinit(); - defer vx.deinit(gpa, &output.writer); - var tty: vaxis.Tty = undefined; - var loop: Loop = .init(io, &tty, &vx); - var feed: Feed = .{}; + var t: TestInput = undefined; + try t.init(); + defer t.deinit(); // More always follows at once: a reader that waited on the ESC would // take `j` for the rest of its sequence (Alt-j). - const Reader = struct { - parts: []const []const u8, - next: usize = 0, - asked: bool = false, - fn getWinsize(_: *@This()) !vaxis.Winsize { - return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 }; - } - pub fn inputFollows(self: *@This(), _: u32) bool { - self.asked = true; - return self.next < self.parts.len; - } - fn read(self: *@This(), buf: []u8) !usize { - if (self.next == self.parts.len) return 0; - const part = self.parts[self.next]; - self.next += 1; - @memcpy(buf[0..part.len], part); - return part.len; - } - }; for ([_]bool{ false, true }) |kitty| { - vx.caps.kitty_keyboard = kitty; - var reader: Reader = .{ .parts = &.{ "\x1b", "j" } }; - try readInput(&loop, &reader, &vx, &feed); + t.vx.caps.kitty_keyboard = kitty; + var reader: TestReader = .{ .parts = &.{ "\x1b", "j" } }; + try readInput(&t.loop, &reader, &t.vx, &t.feed); try std.testing.expect(!reader.asked); - try std.testing.expectEqual(.winsize, std.meta.activeTag((try loop.tryEvent()).?)); - const escape = (try loop.tryEvent()).?.key_press; + try std.testing.expectEqual(.winsize, std.meta.activeTag((try t.loop.tryEvent()).?)); + const escape = (try t.loop.tryEvent()).?.key_press; try std.testing.expectEqual(vaxis.Key.escape, escape.codepoint); try std.testing.expect(!escape.mods.alt); - const j = (try loop.tryEvent()).?.key_press; + const j = (try t.loop.tryEvent()).?.key_press; try std.testing.expectEqual(@as(u21, 'j'), j.codepoint); try std.testing.expect(!j.mods.alt); - try std.testing.expect(try loop.tryEvent() == null); + try std.testing.expect(try t.loop.tryEvent() == null); } - vx.caps.kitty_keyboard = false; + t.vx.caps.kitty_keyboard = false; } test "a frame's answer is taken wherever the reads cut it, and never typed" { const gpa = std.testing.allocator; - const io = std.testing.io; - var env = try std.testing.environ.createMap(gpa); - defer env.deinit(); - var vx = try vaxis.init(io, gpa, &env, .{}); - var output: std.Io.Writer.Allocating = .init(gpa); - defer output.deinit(); - defer vx.deinit(gpa, &output.writer); - var tty: vaxis.Tty = undefined; - var loop: Loop = .init(io, &tty, &vx); - var feed: Feed = .{}; - const Reader = struct { - parts: [2][]const u8, - next: usize = 0, - fn getWinsize(_: *@This()) !vaxis.Winsize { - return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 }; - } - pub fn inputFollows(self: *@This(), _: u32) bool { - return self.next < self.parts.len; - } - fn read(self: *@This(), buf: []u8) !usize { - while (self.next < self.parts.len) { - const part = self.parts[self.next]; - self.next += 1; - if (part.len == 0) continue; - @memcpy(buf[0..part.len], part); - return part.len; - } - return 0; - } - }; + var t: TestInput = undefined; + try t.init(); + defer t.deinit(); const all = "x" ++ FrameAck.answer ++ "y"; - defer feed.ack.waiting.store(false, .release); + defer t.feed.ack.waiting.store(false, .release); for (0..all.len) |cut| { - feed.ack.waiting.store(true, .release); - var reader: Reader = .{ .parts = .{ all[0..cut], all[cut..] } }; - try readInput(&loop, &reader, &vx, &feed); - try std.testing.expect(!feed.ack.waiting.load(.acquire)); + t.feed.ack.waiting.store(true, .release); + const halves = [_][]const u8{ all[0..cut], all[cut..] }; + var reader: TestReader = .{ .parts = &halves }; + try readInput(&t.loop, &reader, &t.vx, &t.feed); + try std.testing.expect(!t.feed.ack.waiting.load(.acquire)); var typed: std.ArrayList(u8) = .empty; defer typed.deinit(gpa); var woke = false; - while (try loop.tryEvent()) |event| switch (event) { + while (try t.loop.tryEvent()) |event| switch (event) { .winsize => {}, .nop => woke = true, .key_press => |key| try typed.appendSlice(gpa, key.text orelse return error.UnexpectedInputKey), @@ -708,16 +639,16 @@ test "a frame's answer is taken wherever the reads cut it, and never typed" { } // An Escape pressed just before an answer, in the same read, is the // Escape key, not Alt on the answer. - feed.ack.waiting.store(true, .release); - var glued: Reader = .{ .parts = .{ "\x1b" ++ FrameAck.answer, "j" } }; - try readInput(&loop, &glued, &vx, &feed); - try std.testing.expectEqual(.winsize, std.meta.activeTag((try loop.tryEvent()).?)); - try std.testing.expectEqual(.nop, std.meta.activeTag((try loop.tryEvent()).?)); - const escape = (try loop.tryEvent()).?.key_press; + t.feed.ack.waiting.store(true, .release); + var glued: TestReader = .{ .parts = &.{ "\x1b" ++ FrameAck.answer, "j" } }; + try readInput(&t.loop, &glued, &t.vx, &t.feed); + try std.testing.expectEqual(.winsize, std.meta.activeTag((try t.loop.tryEvent()).?)); + try std.testing.expectEqual(.nop, std.meta.activeTag((try t.loop.tryEvent()).?)); + const escape = (try t.loop.tryEvent()).?.key_press; try std.testing.expectEqual(vaxis.Key.escape, escape.codepoint); try std.testing.expect(!escape.mods.alt); - try std.testing.expectEqual(@as(u21, 'j'), (try loop.tryEvent()).?.key_press.codepoint); - try std.testing.expect(try loop.tryEvent() == null); + try std.testing.expectEqual(@as(u21, 'j'), (try t.loop.tryEvent()).?.key_press.codepoint); + try std.testing.expect(try t.loop.tryEvent() == null); } test "a terminal that never answers a frame stops being asked after one timeout" { @@ -740,14 +671,10 @@ test "a terminal that never answers a frame stops being asked after one timeout" } test "terminal input cancellation joins blocked reads and queued EOF" { - const gpa = std.testing.allocator; const io = std.testing.io; - var env = try std.testing.environ.createMap(gpa); - defer env.deinit(); - var vx = try vaxis.init(io, gpa, &env, .{}); - var output: std.Io.Writer.Allocating = .init(gpa); - defer output.deinit(); - defer vx.deinit(gpa, &output.writer); + var t: TestInput = undefined; + try t.init(); + defer t.deinit(); const Reader = struct { file: std.Io.File, eof: bool, @@ -781,10 +708,9 @@ test "terminal input cancellation joins blocked reads and queued EOF" { defer _ = libc.close(fds[0]); defer _ = libc.close(fds[1]); var reader: Reader = .{ .file = .{ .handle = fds[0], .flags = .{ .nonblocking = false } }, .eof = eof }; - var tty: vaxis.Tty = undefined; - var loop: Loop = .init(io, &tty, &vx); + var loop: Loop = .init(io, undefined, &t.vx); var feed: Feed = .{}; - var thread: ?std.Io.Future(void) = try io.concurrent(Reader.run, .{ &loop, &reader, &vx, &feed }); + var thread: ?std.Io.Future(void) = try io.concurrent(Reader.run, .{ &loop, &reader, &t.vx, &feed }); defer stopInput(io, &thread); try std.testing.expectEqual(.winsize, std.meta.activeTag(try loop.nextEvent())); try reader.entered.wait(io); @@ -3399,35 +3325,11 @@ fn pasteBytes(key: vaxis.Key) []const u8 { test "a terminal pane gets function keys as their sequences and lone modifiers not at all" { const gpa = std.testing.allocator; - const io = std.testing.io; - var env = try std.testing.environ.createMap(gpa); - defer env.deinit(); - var vx = try vaxis.init(io, gpa, &env, .{}); - var output: std.Io.Writer.Allocating = .init(gpa); - defer output.deinit(); - defer vx.deinit(gpa, &output.writer); - vx.queries_done.store(false, .unordered); - var tty: vaxis.Tty = undefined; - var loop: Loop = .init(io, &tty, &vx); - var feed: Feed = .{}; - const Reader = struct { - parts: []const []const u8, - next: usize = 0, - fn getWinsize(_: *@This()) !vaxis.Winsize { - return .{ .rows = 24, .cols = 80, .x_pixel = 0, .y_pixel = 0 }; - } - pub fn inputFollows(self: *@This(), _: u32) bool { - return self.next < self.parts.len; - } - fn read(self: *@This(), buf: []u8) !usize { - if (self.next == self.parts.len) return 0; - const part = self.parts[self.next]; - self.next += 1; - @memcpy(buf[0..part.len], part); - return part.len; - } - }; - var reader: Reader = .{ + var t: TestInput = undefined; + try t.init(); + defer t.deinit(); + t.vx.queries_done.store(false, .unordered); + var reader: TestReader = .{ .parts = &.{ // The startup width queries' answers from a terminal without // explicit width (foot, ghostty, tmux): two F3s, typed at the prompt. @@ -3442,12 +3344,12 @@ test "a terminal pane gets function keys as their sequences and lone modifiers n "\x1b[104;;104u", }, }; - try readInput(&loop, &reader, &vx, &feed); + try readInput(&t.loop, &reader, &t.vx, &t.feed); const core = try pardes.Pardes.init(gpa, .{ .tty_only = true }); defer core.deinit(); core.panes[0].?.body.mode = .tty; while (core.nextEffect()) |_| {} - while (try loop.tryEvent()) |event| switch (event) { + while (try t.loop.tryEvent()) |event| switch (event) { .key_press => |key| core.update(vaxis_input.keyEvent(key)), else => {}, }; @@ -3618,13 +3520,10 @@ fn paintCells(win: vaxis.Window, cells: []const pardes.Cell, cols: u16, rows: u1 test "a fade sends the text it dims, not the blanks beside it" { const gpa = std.testing.allocator; - var env = try std.testing.environ.createMap(gpa); - defer env.deinit(); - var vx = try vaxis.init(std.testing.io, gpa, &env, .{}); - var out: std.Io.Writer.Allocating = .init(gpa); - defer out.deinit(); - defer vx.deinit(gpa, &out.writer); - try vx.resize(gpa, &out.writer, .{ .rows = 1, .cols = 32, .x_pixel = 0, .y_pixel = 0 }); + var t: TestInput = undefined; + try t.init(); + defer t.deinit(); + try t.vx.resize(gpa, &t.out.writer, .{ .rows = 1, .cols = 32, .x_pixel = 0, .y_pixel = 0 }); // `a`, a gap, `b`, a two-cell gap, `c`, a gap, an underlined blank // (which shows its ink) and one more blank. var cells: [32]pardes.Cell = @splat(.{ .default = false }); @@ -3636,10 +3535,10 @@ test "a fade sends the text it dims, not the blanks beside it" { defer for (sent) |bytes| gpa.free(bytes); for ([_][3]u8{ .{ 200, 200, 200 }, .{ 90, 90, 90 } }, 0..) |ink, frame| { for (&cells) |*cell| cell.style.fg = .{ .rgb = ink }; - out.clearRetainingCapacity(); - paintCells(vx.window(), &cells, 32, 1); - try vx.render(&out.writer); - sent[frame] = try out.toOwnedSlice(); + t.out.clearRetainingCapacity(); + paintCells(t.vx.window(), &cells, 32, 1); + try t.vx.render(&t.out.writer); + sent[frame] = try t.out.toOwnedSlice(); } // Against a cleared screen every cell goes. After the fade the letters // go and the underlined blank; every plain blank is jumped. -- cgit v1.3