diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-03 16:59:08 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-03 17:13:25 -0300 |
| commit | 023793be1112bc35b50551580d273f4cf611b3da (patch) | |
| tree | 4167a4e0435d545dbdb8e09e4f6578491b1dd1e2 /test/behaviour | |
| parent | d1273bbd99daf9b1855d82bf315db8ede20abde5 (diff) | |
| download | pardes-023793be1112bc35b50551580d273f4cf611b3da.tar.gz pardes-023793be1112bc35b50551580d273f4cf611b3da.zip | |
test: sixteen of src/ninep/ctl.zig's tests through the 9P tree alone, in new test/behaviour/{log,mounts,rules,settings}.zig and appended to edit, columns_and_tags, look_and_exec, panes and root_ctl: the log's msg and err records (a root ctl's message the session's, the same failure counted, a root exec's err its pane's), Mount's refusals (and nothing mounted, read from Unmount), Pager and Shell read back from the root ctl, a control character in any ctl and in any tag, a bad command inside an Edit block, a look's :addr and file:addr, the root look's file:/re/ from the dot, exec's readback, focus (a column tag's keyboard taken by Newcol), the pane ctl's and the root ctl's words; each checked to fail against a break: the (xN) count one short, msg - written as msg 0, a root exec's err left as -, a missing socket's words changed, Pager defaulting off, a bare Shell not clearing, tree.zig's ctl check skipped, DEL taken in a tag, an Edit block's bad command naming }, a look's address evaluated from 0 not the dot, no results recorded, focus leaving the header the keyboard, "not a pane control message", every setting value taken
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'test/behaviour')
| -rw-r--r-- | test/behaviour/columns_and_tags.zig | 11 | ||||
| -rw-r--r-- | test/behaviour/edit.zig | 10 | ||||
| -rw-r--r-- | test/behaviour/log.zig | 36 | ||||
| -rw-r--r-- | test/behaviour/look_and_exec.zig | 89 | ||||
| -rw-r--r-- | test/behaviour/mounts.zig | 25 | ||||
| -rw-r--r-- | test/behaviour/panes.zig | 66 | ||||
| -rw-r--r-- | test/behaviour/root_ctl.zig | 55 | ||||
| -rw-r--r-- | test/behaviour/rules.zig | 19 | ||||
| -rw-r--r-- | test/behaviour/settings.zig | 43 |
9 files changed, 354 insertions, 0 deletions
diff --git a/test/behaviour/columns_and_tags.zig b/test/behaviour/columns_and_tags.zig index 25ba4c64..71cff4b2 100644 --- a/test/behaviour/columns_and_tags.zig +++ b/test/behaviour/columns_and_tags.zig @@ -31,3 +31,14 @@ test "columns-and-tags: a look after Newcol fills the empty column the keyboard try std.testing.expect(std.mem.indexOf(u8, col, " full ") != null); try std.testing.expect(std.mem.endsWith(u8, col, s.at(" {d}", .{try s.focused()}))); } + +test "columns-and-tags: a tag write refuses NUL and the other control characters, the workspace's, a column's and a pane's" { + var s = try Session.initFile(std.testing.allocator, "x\n"); + defer s.deinit(); + const col = std.mem.sliceTo(try s.read("/layout"), ' '); + for ([_][]const u8{ "/tag", s.at("/col/{s}/tag", .{col}), s.at("/pane/{d}/tag", .{try s.focused()}) }) |tag| { + try std.testing.expectEqual(@as(u16, 22), try s.refused(tag, " a\x00b")); + try std.testing.expect(std.mem.startsWith(u8, s.said, "invalid tag text")); + try std.testing.expectEqual(@as(u16, 22), try s.refused(tag, " \x7f")); + } +} diff --git a/test/behaviour/edit.zig b/test/behaviour/edit.zig index e95471c6..3d1a731e 100644 --- a/test/behaviour/edit.zig +++ b/test/behaviour/edit.zig @@ -19,3 +19,13 @@ test "edit: a write of an Edit block carries it whole, to a pane's ctl, the root try s.expect(body, "<foo] x\n<foo] y\nend\n"); try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), "unmatched") != null); } + +test "edit: a bad command inside an Edit block written whole is named, not the } after it" { + var s = try Session.initFile(std.testing.allocator, "abc\n"); + defer s.deinit(); + const n = try s.focused(); + try std.testing.expect(try s.refused(s.at("/pane/{d}/ctl", .{n}), "Edit {\n,s/a/b/\nzq\n}\n") != 0); + try std.testing.expect(std.mem.indexOf(u8, s.said, "\"}\"") == null); + try std.testing.expect(std.mem.indexOf(u8, s.said, "z") != null); + try s.expect(s.at("/pane/{d}/body", .{n}), "abc\n"); +} diff --git a/test/behaviour/log.zig b/test/behaviour/log.zig new file mode 100644 index 00000000..21bccdf0 --- /dev/null +++ b/test/behaviour/log.zig @@ -0,0 +1,36 @@ +//! docs/typ/reference.typ, The log <log>. +const std = @import("std"); +const Session = @import("session").Session; + +fn has(hay: []const u8, needle: []const u8) bool { + return std.mem.indexOf(u8, hay, needle) != null; +} + +test "log: a message from a root ctl write is the session's, and its own words stand for its Verbose announcement" { + var s = try Session.initFile(std.testing.allocator, "x\n"); + defer s.deinit(); + try s.write("/ctl", "Kill\n"); + const log = try s.read("/log"); + try std.testing.expect(has(log, "\nmsg - Kill: nothing running\n")); + try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, log, "Kill")); +} + +test "log: a builtin that fails a ctl write logs only its err, so the same failure again is counted" { + var s = try Session.initFile(std.testing.allocator, "x\n"); + defer s.deinit(); + // Another failure first: the pane's `new` is logged after it. + _ = try s.refused("/ctl", "Unmount yyy\n"); + for (0..3) |_| try std.testing.expect(try s.refused("/ctl", "Unmount zzz\n") != 0); + const log = try s.read("/log"); + try std.testing.expect(std.mem.endsWith(u8, log, "err - ctl: Unmount: no such mount zzz (x3)\n")); + try std.testing.expect(!has(log, "msg - Unmount")); +} + +test "log: a root exec that fails logs its err against the pane it ran at" { + var s = try Session.initFile(std.testing.allocator, "x\n"); + defer s.deinit(); + const n = try s.focused(); + try s.write(s.at("/pane/{d}/body", .{n}), "unsaved\n"); + try std.testing.expect(try s.refused("/exec", "Exit\n") != 0); + try std.testing.expect(has(try s.read("/log"), s.at("err {d} exec: ", .{n}))); +} diff --git a/test/behaviour/look_and_exec.zig b/test/behaviour/look_and_exec.zig index 2ff4345b..f9b49ae0 100644 --- a/test/behaviour/look_and_exec.zig +++ b/test/behaviour/look_and_exec.zig @@ -36,3 +36,92 @@ test "look-and-exec: a bare :N or :N:M look addresses the pane itself, from its try s.write(s.at("/pane/{d}/event", .{n}), "ML0 0 0 2 :1\n"); try expectEqual(.{ @as(u32, 0), @as(u32, 6) }, try s.range(dot)); } + +fn has(hay: []const u8, needle: []const u8) bool { + return std.mem.indexOf(u8, hay, needle) != null; +} + +fn lines(text: []const u8) usize { + return std.mem.count(u8, text, "\n"); +} + +/// Whether /index lists the pane `serial`. +fn listed(s: *Session, serial: u32) !bool { + var it = std.mem.tokenizeScalar(u8, try s.read("/index"), '\n'); + while (it.next()) |line| { + var words = std.mem.tokenizeScalar(u8, line, ' '); + if (std.mem.eql(u8, words.next() orelse "", s.at("{d}", .{serial}))) return true; + } + return false; +} + +test "look-and-exec: a look takes acme's :addr and file:addr, and a miss changes nothing" { + var s = try Session.initFile(std.testing.allocator, "foo x foo y\nbar\n"); + defer s.deinit(); + const n = try s.focused(); + const look = s.at("/pane/{d}/look", .{n}); + const dot = s.at("/pane/{d}/dot", .{n}); + const path = std.mem.trimEnd(u8, try s.read(s.at("/pane/{d}/name", .{n})), "\n"); + // :addr is an address in this pane, evaluated from its dot. + try s.write(look, ":/y/\n"); + try expectEqual(.{ @as(u32, 10), @as(u32, 11) }, try s.range(dot)); + try s.write(look, ":#4\n"); + try expectEqual(.{ @as(u32, 4), @as(u32, 4) }, try s.range(dot)); + try s.write(look, ":/foo/\n"); // from #4: the second foo + try expectEqual(.{ @as(u32, 6), @as(u32, 9) }, try s.range(dot)); + // file:addr names the pane's own file here. + try s.write(look, s.at("{s}:/bar/\n", .{path})); + try expectEqual(.{ @as(u32, 12), @as(u32, 15) }, try s.range(dot)); + // A miss: no pane made, the selection kept, and it says so. + const panes = lines(try s.read("/index")); + try s.write(look, "zzqq\n"); + try expectEqual(panes, lines(try s.read("/index"))); + try expectEqual(.{ @as(u32, 12), @as(u32, 15) }, try s.range(dot)); + try std.testing.expect(has(try s.read("/log"), "no match for \"zzqq\"")); + // A hit answers the pane the text is selected in, not a hits pane. + try s.write(look, "foo\n"); + try s.expect(look, s.at("{d}\n", .{n})); + // A pattern with a blank in it; 0/re/ searches from the top, whatever dot is. + try s.write(look, ":/foo y/\n"); + try expectEqual(.{ @as(u32, 6), @as(u32, 11) }, try s.range(dot)); + try s.write(look, s.at("{s}:0/foo/\n", .{path})); + try expectEqual(.{ @as(u32, 0), @as(u32, 3) }, try s.range(dot)); + // file:N selects the line; a line past the end moves nothing and reads back empty. + try s.write(look, s.at("{s}:2\n", .{path})); + try expectEqual(.{ @as(u32, 12), @as(u32, 16) }, try s.range(dot)); + try s.write(look, s.at("{s}:99\n", .{path})); + try expectEqual(.{ @as(u32, 12), @as(u32, 16) }, try s.range(dot)); + try s.expect(look, ""); +} + +test "look-and-exec: the root look's file:/re/ goes on from the dot, and a miss leaves the dot as it was" { + var s = try Session.initFile(std.testing.allocator, "foo x foo y\nfoo\n"); + defer s.deinit(); + const n = try s.focused(); + const dot = s.at("/pane/{d}/dot", .{n}); + const path = std.mem.trimEnd(u8, try s.read(s.at("/pane/{d}/name", .{n})), "\n"); + for ([_]u32{ 0, 6, 12, 0 }) |at| { + try s.write("/look", s.at("{s}:/foo/\n", .{path})); + try expectEqual(.{ at, at + 3 }, try s.range(dot)); + } + try s.write("/look", s.at("{s}:/zzqq/\n", .{path})); + try expectEqual(.{ @as(u32, 0), @as(u32, 3) }, try s.range(dot)); +} + +test "look-and-exec: exec runs a builtin at the pane, and look and exec read back the pane it acted on" { + var s = try Session.initFile(std.testing.allocator, "Msg fs-ran\n"); + defer s.deinit(); + const n = try s.focused(); + const own = s.at("{d}\n", .{n}); + try s.write(s.at("/pane/{d}/exec", .{n}), "Msg from exec\n"); + try std.testing.expect(has(try s.read("/log"), s.at("msg {d} from exec\n", .{n}))); + try s.expect("/exec", own); + try s.expect(s.at("/pane/{d}/look", .{n}), own); + try s.write(s.at("/pane/{d}/exec", .{n}), "New\n"); + const made = try s.focused(); + try std.testing.expect(made != n); + try s.expect("/exec", s.at("{d}\n", .{made})); + try s.write(s.at("/pane/{d}/exec", .{made}), "Del\n"); + try std.testing.expect(try listed(&s, n) and !try listed(&s, made)); + try s.expect("/exec", s.at("{d}\n", .{made})); +} diff --git a/test/behaviour/mounts.zig b/test/behaviour/mounts.zig new file mode 100644 index 00000000..57685a38 --- /dev/null +++ b/test/behaviour/mounts.zig @@ -0,0 +1,25 @@ +//! docs/typ/reference.typ, Paths and mounts <mounts>. +const std = @import("std"); +const Session = @import("session").Session; +const expectEqual = std.testing.expectEqual; + +fn has(hay: []const u8, needle: []const u8) bool { + return std.mem.indexOf(u8, hay, needle) != null; +} + +test "mounts: Mount with no dial is wrong #args, any other x!y a bad dial address, a socket not there no such socket, and none mounts anything" { + var s = try Session.initFile(std.testing.allocator, "x\n"); + defer s.deinit(); + try expectEqual(@as(u16, 22), try s.refused("/ctl", "Mount work\n")); + try std.testing.expect(std.mem.startsWith(u8, s.said, "wrong #args")); + try expectEqual(@as(u16, 22), try s.refused("/ctl", "Mount work tcp!nohost\n")); + try std.testing.expect(std.mem.startsWith(u8, s.said, "Mount: bad dial address: tcp!nohost")); + try expectEqual(@as(u16, 2), try s.refused("/ctl", "Mount peer unix!/tmp/pardes-surely-no-socket\n")); + try std.testing.expect(has(s.said, "no such socket")); + try expectEqual(@as(u16, 22), try s.refused("/ctl", "Mount peer rel/x.sock\n")); + // Nothing was mounted under either name. + for ([_][]const u8{ "Unmount work\n", "Unmount peer\n" }) |line| { + try expectEqual(@as(u16, 2), try s.refused("/ctl", line)); + try std.testing.expect(has(s.said, "no such mount")); + } +} diff --git a/test/behaviour/panes.zig b/test/behaviour/panes.zig index 01820a07..d48ff812 100644 --- a/test/behaviour/panes.zig +++ b/test/behaviour/panes.zig @@ -49,3 +49,69 @@ test "panes: Putall saves every pane with unsaved edits to a file, one each, and try s.write("/ctl", "Putall\n"); try std.testing.expectEqual(@as(usize, 1), s.saved); } + +fn has(hay: []const u8, needle: []const u8) bool { + return std.mem.indexOf(u8, hay, needle) != null; +} + +test "panes: focus reads the pane with the keyboard, and a serial written to it moves the keyboard there, and only that" { + var s = try Session.initFile(std.testing.allocator, "x\n"); + defer s.deinit(); + const first = try s.focused(); + const second = try s.newPane(); + try s.expect("/focus", s.at("{d}\n", .{second})); + try std.testing.expect(has(try s.read(s.at("/pane/{d}/ctl", .{first})), " notcurrent ")); + // A column's tag has the keyboard: no pane does, and a write takes it back. + try s.write("/ctl", "Newcol\n"); + try s.expect("/focus", ""); + try std.testing.expect(has(try s.read(s.at("/pane/{d}/ctl", .{second})), " notcurrent ")); + try s.write("/focus", s.at("{d}\n", .{first})); + try s.expect("/focus", s.at("{d}\n", .{first})); + try std.testing.expect(has(try s.read(s.at("/pane/{d}/ctl", .{first})), " current ")); + try std.testing.expect(has(try s.read(s.at("/pane/{d}/ctl", .{second})), " notcurrent ")); + try std.testing.expectEqual(@as(u16, 2), try s.refused("/focus", "99999\n")); + try std.testing.expectEqualStrings("no such pane", s.said); + for ([_][]const u8{ "", "two", "-1", "1 2" }) |bad| try std.testing.expectEqual(@as(u16, 22), try s.refused("/focus", bad)); + try s.expect("/focus", s.at("{d}\n", .{first})); + // Focus gives the keyboard only: a folded pane stays folded. + try s.write(s.at("/pane/{d}/ctl", .{second}), "Collapse\n"); + try std.testing.expect(has(try s.read(s.at("/pane/{d}/ctl", .{second})), " collapsed ")); + try s.write("/focus", s.at("{d}", .{second})); + try s.expect("/focus", s.at("{d}\n", .{second})); + try std.testing.expect(has(try s.read(s.at("/pane/{d}/ctl", .{second})), " collapsed ")); +} + +test "panes: the pane ctl takes acme's verbs and the pane's builtins, and refuses the rest in Plan 9's words" { + var s = try Session.initFile(std.testing.allocator, "one\ntwo\n"); + defer s.deinit(); + const n = try s.focused(); + const ctl = s.at("/pane/{d}/ctl", .{n}); + // A builtin is its own capitalised word: `GET` and `DEL` are none. + for ([_][]const u8{ "lock x", "bogus", "DEL", "GET", "get x", "look /tmp", "exec Del" }) |bad| { + try std.testing.expectEqual(@as(u16, 22), try s.refused(ctl, s.at("{s}\n", .{bad}))); + try std.testing.expectEqualStrings(s.at("unknown control message \"{s}\"", .{std.mem.sliceTo(bad, ' ')}), s.said); + } + _ = try s.refused(ctl, "Newcol\n"); + try std.testing.expectEqualStrings("not a window control message \"Newcol\": write it to /ctl", s.said); + _ = try s.refused(ctl, "Verbose off\n"); + try std.testing.expectEqualStrings("not a window control message \"Verbose\": write it to /ctl", s.said); + _ = try s.refused(ctl, "Collapse now\n"); + try std.testing.expectEqualStrings("wrong #args in control message \"Collapse\"", s.said); + // Checked whole first: a bad line anywhere and nothing ran. + try std.testing.expectEqual(@as(u16, 22), try s.refused(ctl, "Msg first\nbogus\n")); + // A pane's builtin runs at that pane. + try s.write(ctl, "Msg from ctl\n"); + try std.testing.expect(has(try s.read("/log"), s.at("msg {d} from ctl\n", .{n}))); + // One that means nothing bare is refused before anything runs. + _ = try s.refused(ctl, "Find\n"); + try std.testing.expectEqualStrings("wrong #args in control message \"Find\"", s.said); + try std.testing.expectEqual(@as(u16, 22), try s.refused(ctl, "Msg first\nMsg\n")); + try std.testing.expect(!has(try s.read("/log"), "first")); + // Save with no name on a scratch would ask for one: refused, not asked. + const other = try s.newPane(); + _ = try s.refused(s.at("/pane/{d}/ctl", .{other}), "Save\n"); + try std.testing.expectEqualStrings("control message needs its argument \"Save\"", s.said); + // A line after the one that closed the pane has nowhere to run. + try std.testing.expectEqual(@as(u16, 2), try s.refused(s.at("/pane/{d}/ctl", .{other}), "Del\nMsg after\n")); + try std.testing.expectError(error.Refused, s.read(s.at("/pane/{d}/ctl", .{other}))); +} diff --git a/test/behaviour/root_ctl.zig b/test/behaviour/root_ctl.zig index bdf912da..f7ebbbb9 100644 --- a/test/behaviour/root_ctl.zig +++ b/test/behaviour/root_ctl.zig @@ -29,3 +29,58 @@ test "root-ctl: size sets the screen of a session no frontend is attached to, an try std.testing.expect(std.mem.indexOf(u8, s.said, "too small for the panes") != null); try std.testing.expectEqual(.{ @as(usize, 120), @as(usize, 40) }, try size(&s)); } + +fn has(hay: []const u8, needle: []const u8) bool { + return std.mem.indexOf(u8, hay, needle) != null; +} + +fn columns(s: *Session) !usize { + return std.mem.count(u8, try s.read("/layout"), "\n") - 1; // and `active` +} + +test "root-ctl: the root ctl reads the settings as a write takes them, and takes the session's builtins" { + var s = try Session.initFile(std.testing.allocator, "x\n"); + defer s.deinit(); + const settings = try s.read("/ctl"); + try std.testing.expect(has(settings, "Verbose on\n")); + try std.testing.expect(has(settings, "LocationsConfig ")); + try std.testing.expect(has(settings, "CallstackDepth 8\n")); + try s.write("/ctl", "CallstackDepth\n"); + // Settings only: nothing /status or the DumpConfig window says. + try std.testing.expect(!has(settings, "Platform")); + try std.testing.expect(!has(settings, "requested")); + // Every line written back is taken, and changes nothing. + try s.write("/ctl", settings); + try s.expect("/ctl", settings); + try s.write("/ctl", "Verbose off\n"); + try std.testing.expect(has(try s.read("/ctl"), "Verbose off\n")); + const before = try columns(&s); + try s.write("/ctl", "Newcol\n"); + try std.testing.expectEqual(before + 1, try columns(&s)); + const refusals = [_]struct { []const u8, []const u8 }{ + .{ "Del", "not a session control message \"Del\": write it to pane/<n>/ctl" }, + .{ "Nonsense 1", "unknown control message \"Nonsense\"" }, + .{ "Verbose maybe", "bad value in control message; takes on, off \"maybe\"" }, + .{ "Placement east", "bad value in control message; takes acme, pardes \"east\"" }, + // A number's refusal names its range. + .{ "InactiveDim 200", "bad value in control message; takes 0-100 (a percentage) \"200\"" }, + .{ "MessageLinger x", "bad value in control message; takes 0-60000 (milliseconds) \"x\"" }, + .{ "Newcol 2", "wrong #args in control message \"Newcol\"" }, + .{ "Theme", "wrong #args in control message \"Theme\"" }, + }; + for (refusals) |r| { + try std.testing.expectEqual(@as(u16, 22), try s.refused("/ctl", s.at("{s}\n", .{r[0]}))); + try std.testing.expectEqualStrings(r[1], s.said); + } + _ = try s.refused("/ctl", "Theme no-such-theme\n"); + try std.testing.expect(std.mem.startsWith(u8, s.said, "bad value in control message; like it: n")); + try std.testing.expect(std.mem.endsWith(u8, s.said, "; Themes lists all \"no-such-theme\"")); + // A bare required word fails the check, so the line before never runs. + try std.testing.expectEqual(@as(u16, 22), try s.refused("/ctl", "Verbose on\nMount\n")); + try std.testing.expect(has(try s.read("/ctl"), "Verbose off\n")); + // A builtin that fails as it runs fails the write, quoting its error and + // its line; the lines before it have taken effect, as in acme. + try std.testing.expectEqual(@as(u16, 2), try s.refused("/ctl", "Verbose on\nMount x /tmp/pardes-no-such-sock-zz\nVerbose off\n")); + try std.testing.expect(std.mem.startsWith(u8, s.said, "Mount x: /tmp/pardes-no-such-sock-zz: no such socket")); + try std.testing.expect(has(try s.read("/ctl"), "Verbose on\n")); +} diff --git a/test/behaviour/rules.zig b/test/behaviour/rules.zig new file mode 100644 index 00000000..a29db6f0 --- /dev/null +++ b/test/behaviour/rules.zig @@ -0,0 +1,19 @@ +//! docs/typ/reference.typ, Rules for every file <rules>. +const std = @import("std"); +const Session = @import("session").Session; + +test "rules: a control character in a write to any ctl refuses the whole write, and a quoted line shows a tab as a blank" { + var s = try Session.initFile(std.testing.allocator, "x\n"); + defer s.deinit(); + const n = try s.focused(); + // The first column's serial, /layout's first word. + const col = std.mem.sliceTo(try s.read("/layout"), ' '); + for ([_][]const u8{ "/ctl", s.at("/pane/{d}/ctl", .{n}), s.at("/col/{s}/ctl", .{col}) }) |ctl| { + try std.testing.expectEqual(@as(u16, 22), try s.refused(ctl, "Wrap off\nbo\x01gus\n")); + try std.testing.expectEqualStrings("invalid command line: it holds a control character (or DEL) other than a tab", s.said); + } + try std.testing.expectEqual(@as(u16, 22), try s.refused(s.at("/pane/{d}/ctl", .{n}), "bogus\tword\n")); + // The offending word alone is quoted: a tab ends it. + try std.testing.expect(std.mem.indexOf(u8, s.said, "\"bogus\"") != null); + try std.testing.expect(std.mem.indexOfScalar(u8, s.said, '\t') == null); +} diff --git a/test/behaviour/settings.zig b/test/behaviour/settings.zig new file mode 100644 index 00000000..5970e6b5 --- /dev/null +++ b/test/behaviour/settings.zig @@ -0,0 +1,43 @@ +//! docs/typ/reference.typ, Settings <settings>. +const std = @import("std"); +const Session = @import("session").Session; + +fn has(hay: []const u8, needle: []const u8) bool { + return std.mem.indexOf(u8, hay, needle) != null; +} + +/// The root ctl's line for `word`. +fn setting(s: *Session, word: []const u8) ![]const u8 { + var lines = std.mem.splitScalar(u8, try s.read("/ctl"), '\n'); + while (lines.next()) |line| if (std.mem.startsWith(u8, line, word) and line.len > word.len and line[word.len] == ' ') return line; + return error.NoSuchSetting; +} + +test "settings: Pager is pardes by default, off taken, anything else refused with its choices" { + var s = try Session.initFile(std.testing.allocator, "x\n"); + defer s.deinit(); + try std.testing.expectEqualStrings("Pager pardes", try setting(&s, "Pager")); + try s.write("/ctl", "Pager off\n"); + try std.testing.expectEqualStrings("Pager off", try setting(&s, "Pager")); + try std.testing.expectEqual(@as(u16, 22), try s.refused("/ctl", "Pager less\n")); + try std.testing.expectEqualStrings("bad value in control message; takes pardes, off \"less\"", s.said); + try std.testing.expectEqualStrings("Pager off", try setting(&s, "Pager")); +} + +test "settings: Shell refuses a path that is no executable, and bare it goes back to the default" { + var s = try Session.initFile(std.testing.allocator, "x\n"); + defer s.deinit(); + const default = try setting(&s, "Shell"); + try std.testing.expect(try s.refused("/ctl", "Shell /nonexistent/zzsh\n") != 0); + try std.testing.expect(has(s.said, "Shell: shell \"/nonexistent/zzsh\" not found")); + try std.testing.expect(has(try s.read("/log"), "shell \"/nonexistent/zzsh\" not found")); + // Its words say a directory, which a mount reads as EISDIR too. + try std.testing.expectEqual(@as(u16, 21), try s.refused("/ctl", "Shell /etc\n")); + try std.testing.expect(has(try s.read("/log"), "Shell: not a shell: /etc is a directory")); + try std.testing.expectEqualStrings(default, try setting(&s, "Shell")); + try s.write("/ctl", "Shell /bin/sh\n"); + try std.testing.expectEqualStrings("Shell /bin/sh", try setting(&s, "Shell")); + try s.write("/ctl", "Shell\n"); + try std.testing.expect(has(try s.read("/log"), "Shell: the default again, ")); + try std.testing.expectEqualStrings(default, try setting(&s, "Shell")); +} |
