summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--src/ninep/pane.zig505
-rw-r--r--test/behaviour/addresses.zig91
-rw-r--r--test/behaviour/flags.zig60
-rw-r--r--test/behaviour/look_and_exec.zig10
-rw-r--r--test/behaviour/panes.zig185
-rw-r--r--test/behaviour/tags.zig53
6 files changed, 420 insertions, 484 deletions
diff --git a/src/ninep/pane.zig b/src/ninep/pane.zig
index bf9dc381..cfc93ee5 100644
--- a/src/ninep/pane.zig
+++ b/src/ninep/pane.zig
@@ -312,56 +312,6 @@ pub fn spliceBody(p: *Pardes, pane: *Pane, q0: usize, q1: usize, bytes: []const
return take;
}
-test "a shell's > into an empty pane's body is one undo step, as into any other" {
- const p = try withFile(testing.allocator, "");
- defer p.deinit();
- const pane = p.panes[0].?;
- const f = &pane.file.?;
- const body = Node.of(pane.serial, .body);
- const steps = f.history.undo_len;
- const h = call(p, .{ .tag = 1, .op = .open, .node = body, .omode = 1 }).reply.handle;
- _ = call(p, .{ .tag = 2, .op = .setattr, .node = body, .truncate = true });
- try testing.expectEqual(tree.Status.ok, call(p, .{ .tag = 3, .op = .write, .node = body, .handle = h, .data = "fresh\n" }).reply.status);
- _ = call(p, .{ .tag = 4, .op = .release, .node = body, .handle = h, .opened = true });
- try testing.expectEqualStrings("fresh\n", f.content);
- try testing.expectEqual(steps + 1, f.history.undo_len);
-}
-
-test "a write that changes nothing, an empty range deleted or a range replaced by itself, makes no undo step" {
- const p = try withFile(testing.allocator, "abc\ndef\n");
- defer p.deinit();
- const pane = p.panes[0].?;
- const serial = pane.serial;
- const f = &pane.file.?;
- const steps = f.history.undo_len;
- const revision = f.revision;
- const data = Node.of(serial, .data);
- // Each as a shell does it, on an open of its own: `: > data` after
- // an empty address, then `echo abc > data` over the line it holds.
- _ = wr(p, Node.of(serial, .addr), "#2,#2");
- const h = call(p, .{ .tag = 1, .op = .open, .node = data, .omode = 1 }).reply.handle;
- try testing.expectEqual(tree.Status.ok, call(p, .{ .tag = 2, .op = .setattr, .node = data, .truncate = true }).reply.status);
- _ = call(p, .{ .tag = 3, .op = .release, .node = data, .handle = h, .opened = true });
- for ([_][]const u8{ "abc\n", "abd\n" }) |text| {
- _ = wr(p, Node.of(serial, .addr), "1");
- const w = call(p, .{ .tag = 4, .op = .open, .node = data, .omode = 1 }).reply.handle;
- try testing.expectEqual(tree.Status.ok, call(p, .{ .tag = 5, .op = .write, .node = data, .handle = w, .data = text }).reply.status);
- _ = call(p, .{ .tag = 6, .op = .release, .node = data, .handle = w, .opened = true });
- if (text[2] == 'c') {
- try testing.expectEqualStrings("abc\ndef\n", f.content);
- try testing.expectEqual(steps, f.history.undo_len);
- try testing.expectEqual(revision, f.revision);
- }
- }
- // Edit's `s/d/d/` is the same nothing.
- const undone = f.history.undo_len;
- try testing.expectEqual(tree.Status.ok, wr(p, Node.of(serial, .ctl), "Edit ,s/d/d/\n").reply.status);
- try testing.expectEqual(undone, f.history.undo_len);
- // A real change is still one.
- try testing.expectEqualStrings("abd\ndef\n", f.content);
- try testing.expectEqual(steps + 1, f.history.undo_len);
-}
-
test "rows through the line index are the ones counting newlines gives, at every offset" {
const p = try withFile(testing.allocator, "héllo\nwo\u{301}rld\n\n last line é\ntail");
defer p.deinit();
@@ -1114,38 +1064,6 @@ test "a body write to a terminal pane types at its shell" {
try testing.expectEqual(Status.ok, r.reply.status);
}
-test "tag reads the whole tag and writes append to the editable tail" {
- const gpa = testing.allocator;
- const p = try withFile(gpa, "x\n");
- defer p.deinit();
- const pane = p.panes[0].?;
- const node = Node.of(pane.serial, .tag);
-
- const whole = rd(p, node, 0, 4096);
- try testing.expect(std.mem.startsWith(u8, whole.bytes, "/test.txt"));
- try testing.expect(std.mem.indexOf(u8, whole.bytes, "Del") != null);
- try testing.expectEqual(@as(u64, whole.bytes.len), call(p, .{ .tag = 1, .op = .getattr, .node = node }).reply.attr.size);
-
- const before = rd(p, node, 0, 4096).bytes.len;
- const w = wr(p, node, " Mine");
- try testing.expectEqual(@as(u32, 5), w.reply.written);
- try testing.expect(std.mem.endsWith(u8, tagline.curTail(pane), " Mine"));
- const after = rd(p, node, 0, 4096);
- try testing.expectEqual(before + 5, after.bytes.len);
- try testing.expect(std.mem.endsWith(u8, after.bytes, " Mine"));
-
- // A tag is a text like the body: a newline written to it stays one, and
- // the tag reads back taller by it.
- try testing.expectEqual(@as(u32, 10), wr(p, node, "\nNext Line").reply.written);
- try testing.expect(std.mem.endsWith(u8, tagline.curTail(pane), " Mine\nNext Line"));
- try testing.expect(std.mem.endsWith(u8, rd(p, node, 0, 4096).bytes, " Mine\nNext Line"));
-
- if (pane.tag.own) |own| p.gpa.free(own);
- pane.tag.own = try p.gpa.alloc(u8, limits.max_tag_tail);
- @memset(pane.tag.own.?, 'x');
- try testing.expectEqual(E.NOSPC, wr(p, node, "x").errno());
-}
-
test "data never splits a rune, in either direction" {
const gpa = testing.allocator;
const p = try withFile(gpa, "\u{00e9}x\n");
@@ -1179,32 +1097,6 @@ test "the writes of one open are one undo step, as bash's line-buffered printf m
}
}
-test "an open's writes in a row are held and go in as one edit, seen by the next request" {
- const p = try withFile(testing.allocator, "one\n");
- defer p.deinit();
- const serial = serialOf(p);
- const body = Node.of(serial, .body);
- const h = call(p, .{ .tag = 1, .op = .open, .node = body, .omode = 1 }).reply.handle;
- const revision = p.panes[0].?.file.?.revision;
- for (0..100) |_| _ = call(p, .{ .tag = 2, .op = .write, .node = body, .handle = h, .data = "0123456789\n" });
- // Held: nothing edited yet.
- try testing.expectEqual(revision, p.panes[0].?.file.?.revision);
- // Any other request puts them in, once.
- try testing.expectEqual(@as(usize, 4 + 1100), rd(p, body, 0, 4096).bytes.len);
- try testing.expectEqual(revision + 1, p.panes[0].?.file.?.revision);
- _ = call(p, .{ .tag = 3, .op = .release, .node = body, .handle = h, .opened = true });
- try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .ctl), "Undo").reply.status);
- try testing.expectEqualStrings("one\n", rd(p, body, 0, 64).bytes);
- // data inserts at its address go on the same way.
- const data = Node.of(serial, .data);
- _ = wr(p, Node.of(serial, .addr), "#0");
- const d = call(p, .{ .tag = 4, .op = .open, .node = data, .omode = 1 }).reply.handle;
- _ = call(p, .{ .tag = 5, .op = .write, .node = data, .handle = d, .data = "a" });
- _ = call(p, .{ .tag = 5, .op = .write, .node = data, .handle = d, .data = "b" });
- _ = call(p, .{ .tag = 6, .op = .release, .node = data, .handle = d, .opened = true });
- try testing.expectEqualStrings("abone\n", rd(p, body, 0, 64).bytes);
-}
-
test "writes held before the shell's clock is first seen go in at its first step" {
const p = try withFile(testing.allocator, "one\n");
defer p.deinit();
@@ -1266,97 +1158,12 @@ test "after a failed address, one that goes from it says there is none" {
try testing.expectEqual(Status.ok, wr(p, addr, ".").reply.status);
}
-test "a 9P write moves dot only as acme's textinsert does, and scrolls only the view" {
- const Case = struct { at: u32, want: State.Range };
- // dot is `cd` of `abcdef\n` (2..4); two bytes go in at `at`.
- for ([_]Case{
- .{ .at = 0, .want = .{ .q0 = 4, .q1 = 6 } }, // before: shifted
- .{ .at = 2, .want = .{ .q0 = 2, .q1 = 6 } }, // at its start: grown
- .{ .at = 3, .want = .{ .q0 = 2, .q1 = 6 } }, // inside: grown
- .{ .at = 4, .want = .{ .q0 = 2, .q1 = 4 } }, // at its end: left
- .{ .at = 6, .want = .{ .q0 = 2, .q1 = 4 } }, // after: left
- }) |c| {
- const p = try withFile(testing.allocator, "abcdef\n");
- defer p.deinit();
- const serial = serialOf(p);
- const pane = p.panes[p.paneBySerial(serial).?].?;
- setDot(pane, .{ .q0 = 2, .q1 = 4 });
- var addr: [16]u8 = undefined;
- _ = wr(p, Node.of(serial, .addr), try std.fmt.bufPrint(&addr, "#{d}", .{c.at}));
- try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .data), "XX").reply.status);
- try testing.expectEqual(c.want, dotOf(pane));
- }
- // A body append leaves dot, and a sel write after it replaces dot, not
- // the text appended.
- const p = try withFile(testing.allocator, "abcdef\n");
- defer p.deinit();
- const serial = serialOf(p);
- const pane = p.panes[p.paneBySerial(serial).?].?;
- setDot(pane, .{ .q0 = 2, .q1 = 4 });
- try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .body), "more\n").reply.status);
- try testing.expectEqual(State.Range{ .q0 = 2, .q1 = 4 }, dotOf(pane));
- try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .sel), "YY").reply.status);
- try testing.expectEqualStrings("abYYef\nmore\n", fileOf(pane).?.content);
-}
-
-test "an addr pair out of order or out of range is refused as the address form is, not clamped" {
- const p = try withFile(testing.allocator, "abcdef\n");
- defer p.deinit();
- const serial = serialOf(p);
- const addr = Node.of(serial, .addr);
- try testing.expectEqualStrings(addressing.e_order, wr(p, addr, "5 2").reply.ename);
- try testing.expectEqualStrings(addressing.e_order, wr(p, addr, "#5,#2").reply.ename);
- try testing.expectEqualStrings(addressing.e_range, wr(p, addr, "2 99").reply.ename);
- try testing.expectEqualStrings(addressing.e_range, wr(p, addr, "#2,#99").reply.ename);
- try testing.expectEqual(Status.ok, wr(p, addr, "2 4").reply.status);
- try testing.expectEqual(State.Range{ .q0 = 2, .q1 = 4 }, p.panes[p.paneBySerial(serial).?].?.fs.addr);
-}
-
-test "name refuses a directory, EISDIR, and leaves the name as it was" {
- const p = try withFile(testing.allocator, "x\n");
- defer p.deinit();
- const serial = serialOf(p);
- const node = Node.of(serial, .name);
- for ([_][]const u8{ "/\n", "/tmp/\n", "sub/\n", "/tmp\n" }) |dir| {
- if (comptime !pardes.hosted) if (std.mem.eql(u8, dir, "/tmp\n")) continue;
- const r = wr(p, node, dir);
- try testing.expectEqual(E.ISDIR, r.errno());
- try testing.expect(std.mem.indexOf(u8, r.reply.ename, "is a directory") != null);
- }
- try testing.expectEqualStrings("/test.txt", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
-}
-
-test "a write of two lines to name is refused EINVAL, on a held open or not" {
- const p = try withFile(testing.allocator, "x\n");
- defer p.deinit();
- const serial = serialOf(p);
- const node = Node.of(serial, .name);
- try testing.expectEqual(E.INVAL, wr(p, node, "/tmp/a\n/tmp/b\n").errno());
- const h = call(p, .{ .tag = 1, .op = .open, .node = node, .omode = 1 }).reply.handle;
- try testing.expectEqual(E.INVAL, call(p, .{ .tag = 2, .op = .write, .node = node, .handle = h, .data = "/tmp/a\n/tmp/b\n" }).errno());
- _ = call(p, .{ .tag = 3, .op = .release, .node = node, .handle = h, .opened = true });
- try testing.expectEqualStrings("/test.txt", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
- // Line by line, as bash writes it: the second line is refused.
- const h2 = call(p, .{ .tag = 1, .op = .open, .node = node, .omode = 1 }).reply.handle;
- try testing.expectEqual(Status.ok, call(p, .{ .tag = 2, .op = .write, .node = node, .handle = h2, .data = "/tmp/pardes-a\n" }).reply.status);
- try testing.expectEqual(E.INVAL, call(p, .{ .tag = 2, .op = .write, .node = node, .handle = h2, .data = "/tmp/pardes-b\n" }).errno());
- _ = call(p, .{ .tag = 3, .op = .release, .node = node, .handle = h2, .opened = true });
- try testing.expectEqualStrings("/tmp/pardes-a", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
-}
-
-test "a name with a component over 255 bytes is refused, and a long path's failed Save keeps its reason" {
+// The rest moved to test/behaviour/panes.zig; a Save's failure and the
+// watches a rename asks for are effects a host performs.
+test "a long path's failed Save keeps its reason" {
const p = try withFile(testing.allocator, "x\n");
defer p.deinit();
const serial = serialOf(p);
- const refused = wr(p, Node.of(serial, .name), "/tmp/" ++ &@as([256]u8, @splat('c')) ++ "/f.txt\n");
- try testing.expectEqual(E.INVAL, refused.errno());
- try testing.expectEqualStrings("invalid file name: a component over 255 bytes", refused.reply.ename);
- try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .name), "/tmp/" ++ &@as([255]u8, @splat('c')) ++ "\n").reply.status);
- // Held with no newline, it is refused by that write, not at the close.
- const held = call(p, .{ .tag = 1, .op = .open, .node = Node.of(serial, .name), .omode = 1 }).reply.handle;
- try testing.expectEqual(E.INVAL, call(p, .{ .tag = 2, .op = .write, .node = Node.of(serial, .name), .handle = held, .data = "/tmp/" ++ &@as([256]u8, @splat('e')) }).errno());
- _ = call(p, .{ .tag = 3, .op = .release, .node = Node.of(serial, .name), .handle = held, .opened = true });
- try testing.expectEqual(@as(usize, 0), p.fs.closed_lines.items.len);
// A Save of a 3000-byte path the host refuses: the waiting write's
// reason is at the end, the path giving up its middle.
// (Under /tmp: under / a user's Save is refused permission, not
@@ -1372,28 +1179,25 @@ test "a name with a component over 255 bytes is refused, and a long path's faile
try testing.expect(std.mem.endsWith(u8, late, "/f.txt: no such directory"));
}
-test "a name cut across writes is one name, applied once at its newline or its close" {
- const p = try withFile(testing.allocator, "x\n");
+test "a scratch renamed to a file watches it only after its Save, and a virtual name never" {
+ const p = try withFile(testing.allocator, "opener\n");
defer p.deinit();
- const serial = serialOf(p);
- const node = Node.of(serial, .name);
- const h = call(p, .{ .tag = 1, .op = .open, .node = node, .omode = 1 }).reply.handle;
- try testing.expect(h != 0);
- // A piece that fills its Twrite goes on in the next.
- p.fs.write_room = "/tmp/pardes-na".len;
- _ = call(p, .{ .tag = 2, .op = .write, .node = node, .handle = h, .data = "/tmp/pardes-na" });
- p.fs.write_room = 0;
- try testing.expectEqualStrings("/test.txt", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
- _ = call(p, .{ .tag = 2, .op = .write, .node = node, .handle = h, .data = "me.txt\n" });
- try testing.expectEqualStrings("/tmp/pardes-name.txt", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
- _ = call(p, .{ .tag = 3, .op = .release, .node = node, .handle = h, .opened = true });
- // No newline: held, whatever the write's size, and applied at the close.
- const h3 = call(p, .{ .tag = 1, .op = .open, .node = node, .omode = 1 }).reply.handle;
- _ = call(p, .{ .tag = 2, .op = .write, .node = node, .handle = h3, .data = "/tmp/pardes-closed.txt" });
- try testing.expectEqualStrings("/tmp/pardes-name.txt", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
- _ = call(p, .{ .tag = 3, .op = .release, .node = node, .handle = h3, .opened = true });
- tree.runClosedLines(p);
- try testing.expectEqualStrings("/tmp/pardes-closed.txt", nameOf(p, p.panes[p.paneBySerial(serial).?].?));
+ const serial = try th.newPane(p);
+ const pane = p.panes[p.paneBySerial(serial).?].?;
+ const name = Node.of(serial, .name);
+ var tmp = testing.tmpDir(.{});
+ defer tmp.cleanup();
+ var directory_buf: [4096]u8 = undefined;
+ const directory = directory_buf[0..try tmp.dir.realPath(testing.io, &directory_buf)];
+ var line: [4120]u8 = undefined;
+ const renamed = wr(p, name, try std.fmt.bufPrint(&line, "{s}/renamed.zig\n", .{directory}));
+ try testing.expectEqual(false, renamed.watch.?);
+ try testing.expect(pane.file.?.watch_after_save);
+ const virtual = try th.newPane(p);
+ _ = wr(p, Node.of(virtual, .name), try std.fmt.bufPrint(&line, "/virtual/pane/{d}/body\n", .{serial}));
+ const unchanged = wr(p, Node.of(virtual, .name), "./body\n");
+ try testing.expect(unchanged.watch == null);
+ try testing.expect(!p.panes[p.paneBySerial(virtual).?].?.file.?.watch_after_save);
}
test "a replace through data, truncate then write, is one undo step" {
@@ -1424,120 +1228,6 @@ test "writes under mark 0 are one undo step, even with no history before them" {
try testing.expectEqualStrings("one\ntwo\nthree\n", rd(p, body, 0, 64).bytes);
}
-test "truncating the tag clears its editable tail" {
- const p = try withFile(testing.allocator, "x\n");
- defer p.deinit();
- const pane = p.panes[0].?;
- const tag = Node.of(pane.serial, .tag);
- _ = wr(p, tag, " Mine");
- try testing.expect(tagline.curTail(pane).len > 0);
- const cleared = call(p, .{ .tag = 1, .op = .setattr, .node = tag, .truncate = true });
- try testing.expectEqual(Status.ok, cleared.reply.status);
- // Done at the first read or write after it (or the close).
- _ = rd(p, tag, 0, 4096);
- try testing.expectEqualStrings("", pane.tag.own.?);
- try testing.expect(std.mem.indexOf(u8, rd(p, tag, 0, 4096).bytes, " Mine") == null);
- // The tag keeps its undo: undoing in it brings back what was cleared.
- pardes.edit.doUndo(p, &pane.tag);
- try testing.expect(std.mem.endsWith(u8, tagline.curTail(pane), " Mine"));
- _ = call(p, .{ .tag = 2, .op = .setattr, .node = tag, .truncate = true });
- _ = rd(p, tag, 0, 4096);
- try testing.expectEqualStrings("", pane.tag.own.?);
-
- // Written back without a leading space, the text still stands apart
- // from the path: the computed prefix brings the separator, so Look and
- // Exec find `Get`, not `test.txtGet`.
- _ = wr(p, tag, "Get");
- try testing.expectEqualStrings("Get", pane.tag.own.?);
- const whole = rd(p, tag, 0, 4096).bytes;
- try testing.expectEqualStrings("/test.txt Get", whole);
- const word = config.wordBounds(whole, whole.len - "Get".len);
- try testing.expectEqualStrings("Get", whole[word.lo..word.hi]);
- // and a click on the G puts the tag's cursor on it
- const at = tagline.tagOffsetAt(p, pane, 0, "/test.txt ".len).?;
- try testing.expectEqualStrings("Get", whole[at.col..]);
-
- // `echo Make > tag`: the newline ending the truncating write's text is
- // dropped, one only; a newline between its writes stays.
- _ = call(p, .{ .tag = 3, .op = .release, .node = tag });
- _ = call(p, .{ .tag = 4, .op = .setattr, .node = tag, .truncate = true });
- _ = wr(p, tag, "Make\n");
- try testing.expectEqualStrings("Make", pane.tag.own.?);
- _ = wr(p, tag, "More\n\n");
- try testing.expectEqualStrings("Make\nMore\n", pane.tag.own.?);
- _ = call(p, .{ .tag = 5, .op = .release, .node = tag });
- // `>>` keeps what it is given.
- _ = wr(p, tag, " Tail\n");
- try testing.expectEqualStrings("Make\nMore\n Tail\n", pane.tag.own.?);
-}
-
-test "name reads the file name and writing it promotes a scratch without touching its body" {
- const gpa = testing.allocator;
- const p = try withFile(gpa, "opener\n");
- defer p.deinit();
- const serial = try th.newPane(p);
- const pane = p.panes[p.paneBySerial(serial).?].?;
- const name = Node.of(serial, .name);
- const body = Node.of(serial, .body);
- var scratch_name: [4200]u8 = undefined;
- const scratch_line = try std.fmt.bufPrint(&scratch_name, "{s}\n", .{nameOf(p, pane)});
- try testing.expectEqualStrings(scratch_line, rd(p, name, 0, 4096).bytes);
- try testing.expectEqual(@as(u64, scratch_line.len), call(p, .{ .tag = 1, .op = .getattr, .node = name }).reply.attr.size);
- _ = wr(p, body, "scratch ");
- _ = wr(p, body, "work\n");
- const undo_len = pane.file.?.history.undo_len;
- var tmp = testing.tmpDir(.{});
- defer tmp.cleanup();
- try tmp.dir.writeFile(testing.io, .{ .sub_path = "renamed.zig", .data = "existing target\n" });
- var directory_buf: [4096]u8 = undefined;
- const directory = directory_buf[0..try tmp.dir.realPath(testing.io, &directory_buf)];
- var path_buffer: [4096]u8 = undefined;
- const path = try std.fmt.bufPrint(&path_buffer, "{s}/renamed.zig", .{directory});
- var line: [4104]u8 = undefined;
- const renamed = wr(p, name, try std.fmt.bufPrint(&line, "{s}\n", .{path}));
- try testing.expectEqual(Status.ok, renamed.reply.status);
- try testing.expectEqual(false, renamed.watch.?);
- try testing.expectEqualStrings("scratch work\n", pane.file.?.content);
- try testing.expectEqual(undo_len, pane.file.?.history.undo_len);
- try testing.expect(pane.file.?.output == null and dirtyOf(pane));
- try testing.expect(pane.file.?.watch_after_save);
- try testing.expectEqualStrings(path, std.mem.trimEnd(u8, rd(p, name, 0, 4096).bytes, "\n"));
- const target = try fs.readFile(gpa, path);
- defer gpa.free(target);
- try testing.expectEqualStrings("existing target\n", target);
- for ([_][]const u8{ "", "\n" }) |bad|
- try testing.expectEqual(E.INVAL, wr(p, name, bad).errno());
- // One name, and what no file name holds: a second line, a NUL.
- for ([_][2][]const u8{
- .{ "two\nlines\n", "a newline" },
- .{ "nul\x00.zig\n", "a NUL" },
- }) |c| {
- const refused = wr(p, name, c[0]);
- try testing.expectEqual(E.INVAL, refused.errno());
- try testing.expectStringStartsWith(refused.reply.ename, "bad character in file name: ");
- try testing.expect(std.mem.indexOf(u8, refused.reply.ename, c[1]) != null);
- }
- // Any other byte a file name holds is taken, and reads back as written:
- // blanks at its ends, a tab, a control byte, DEL, C1, bytes not UTF-8.
- for ([_][]const u8{ " lead.zig ", "tab\t.zig", "c\x01.zig", "del\x7f.zig", "c1\xc2\x85.zig", "bad\xff.zig" }) |odd| {
- try testing.expectEqual(Status.ok, wr(p, name, try std.fmt.bufPrint(&line, "{s}\n", .{odd})).reply.status);
- const read_back = std.mem.trimEnd(u8, rd(p, name, 0, 4096).bytes, "\n");
- try testing.expect(std.mem.endsWith(u8, read_back, odd));
- var again: [4200]u8 = undefined;
- @memcpy(again[0..read_back.len], read_back);
- try testing.expectEqual(Status.ok, wr(p, name, again[0..read_back.len]).reply.status);
- try testing.expectEqualStrings(again[0..read_back.len], pane.file.?.path);
- }
- // A name that is one line and UTF-8 is taken, é and all.
- try testing.expectEqual(Status.ok, wr(p, name, "caf\xc3\xa9.zig\n").reply.status);
- try testing.expect(std.mem.endsWith(u8, pane.file.?.path, "/caf\xc3\xa9.zig"));
- try testing.expectEqual(Status.ok, wr(p, name, try std.fmt.bufPrint(&line, "{s}\n", .{path})).reply.status);
- try testing.expectEqualStrings(path, pane.file.?.path);
- try testing.expectEqual(Status.ok, wr(p, name, "two words.zig\n").reply.status);
- const spaced = try std.fmt.bufPrint(&path_buffer, "{s}/two words.zig", .{directory});
- try testing.expectEqualStrings(spaced, pane.file.?.path);
-}
-
test "name refreshes cached syntax for unchanged contents" {
if (!pardes.syntax.enabled) return error.SkipZigTest;
pardes.syntax.start(testing.allocator);
@@ -1555,58 +1245,6 @@ test "name refreshes cached syntax for unchanged contents" {
try testing.expectEqualStrings("fn check() void {}\n", pane.file.?.content);
}
-test "relative names use the file directory and can name a new target" {
- const gpa = testing.allocator;
- const p = try withFile(gpa, "retained body\n");
- defer p.deinit();
- var tmp = testing.tmpDir(.{});
- defer tmp.cleanup();
- try tmp.dir.writeFile(testing.io, .{ .sub_path = "note.txt", .data = "from pane directory\n" });
- var directory_buf: [4096]u8 = undefined;
- const directory = directory_buf[0..try tmp.dir.realPath(testing.io, &directory_buf)];
- const pane = p.panes[0].?;
- const name = Node.of(pane.serial, .name);
- const ctl_node = Node.of(pane.serial, .ctl);
- var line: [4140]u8 = undefined;
- try testing.expectEqual(Status.ok, wr(p, name, try std.fmt.bufPrint(&line, "{s}/old.txt\n", .{directory})).reply.status);
- try testing.expectEqual(Status.ok, wr(p, name, "child/../note.txt\n").reply.status);
- try testing.expectEqual(Status.ok, wr(p, ctl_node, "get\n").reply.status);
- try testing.expectEqualStrings("from pane directory\n", pane.file.?.content);
- try testing.expectEqualStrings(directory, Pardes.paneDir(pane));
- try testing.expectEqual(Status.ok, wr(p, name, "./created.txt\n").reply.status);
- var expected_buf: [4096]u8 = undefined;
- const expected = try std.fmt.bufPrint(&expected_buf, "{s}/created.txt", .{directory});
- try testing.expectEqualStrings(expected, pane.file.?.path);
- try testing.expect(!dirtyOf(pane)); // a name alone is no edit
-}
-
-test "relative names follow a pane/new scratch's session directory and virtual directories" {
- const p = try withFile(testing.allocator, "source body\n");
- defer p.deinit();
- const source = p.panes[0].?;
- try testing.expectEqual(Status.ok, wr(p, Node.of(source.serial, .name), "/elsewhere/source.zig\n").reply.status);
- // pane/new's scratch is the session's, not the active pane's.
- const session = "/project/src";
- @memcpy(p.session_dir[0..session.len], session);
- p.session_dir_len = session.len;
- const serial = try th.newPane(p);
- const scratch = p.panes[p.paneBySerial(serial).?].?;
- const name = Node.of(serial, .name);
- try testing.expectEqualStrings("/project/src", Pardes.paneDir(scratch));
- try testing.expectEqual(Status.ok, wr(p, name, "../out/./notes.txt\n").reply.status);
- try testing.expectEqualStrings("/project/out/notes.txt", scratch.file.?.path);
- try testing.expectEqualStrings("/project/out", Pardes.paneDir(scratch));
- var line: [256]u8 = undefined;
- try testing.expectEqual(Status.ok, wr(p, name, try std.fmt.bufPrint(&line, "/virtual/pane/{d}/./body\n", .{source.serial})).reply.status);
- try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .ctl), "get\n").reply.status);
- try testing.expectEqualStrings(source.file.?.content, scratch.file.?.content);
- const unchanged = wr(p, name, "./body\n");
- try testing.expectEqual(Status.ok, unchanged.reply.status);
- try testing.expect(unchanged.watch == null);
- try testing.expect(!dirtyOf(scratch));
- try testing.expect(!scratch.file.?.watch_after_save);
-}
-
test "owned cwd name promotion releases the former directory" {
const p = try th.withTerm(testing.allocator);
defer p.deinit();
@@ -1622,96 +1260,6 @@ test "owned cwd name promotion releases the former directory" {
try testing.expectEqualStrings("/old/directory", Pardes.paneDir(pane));
}
-test "errors append to one +Errors buffer per directory" {
- const gpa = testing.allocator;
- const p = try withFile(gpa, "x\n");
- defer p.deinit();
- const serial = serialOf(p);
-
- const live = for (p.panes) |slot| {
- if (slot) |q| if (q.file) |f| if (f.output) |o| if (std.meta.activeTag(o.from) == .errors) break q;
- } else null;
- try testing.expect(live == null);
-
- try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .errors), "boom\n").reply.status);
- try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .errors), "again\n").reply.status);
-
- var found: usize = 0;
- for (p.panes) |slot| {
- const q = slot orelse continue;
- const f = q.file orelse continue;
- const o = f.output orelse continue;
- if (std.meta.activeTag(o.from) != .errors) continue;
- found += 1;
- try testing.expectEqualStrings("boom\nagain\n", f.content);
- try testing.expectEqualStrings("/+Errors", f.path);
- }
- try testing.expectEqual(@as(usize, 1), found);
-}
-
-test "truncating data deletes only the addressed range, so > data replaces it" {
- const p = try withFile(testing.allocator, "hello world\nsecond line\n");
- defer p.deinit();
- const serial = serialOf(p);
- for ([_]PaneFile{ .data, .xdata }) |file| {
- _ = call(p, .{ .tag = 1, .op = .setattr, .node = Node.of(serial, .body), .truncate = true });
- _ = wr(p, Node.of(serial, .body), "hello world\nsecond line\n");
- _ = wr(p, Node.of(serial, .addr), "#0,#5");
- try testing.expectEqual(Status.ok, call(p, .{ .tag = 2, .op = .setattr, .node = Node.of(serial, file), .truncate = true }).reply.status);
- try testing.expectEqualStrings(" world\nsecond line\n", p.panes[0].?.file.?.content);
- try testing.expectEqual(Status.ok, wr(p, Node.of(serial, file), "HOWDY").reply.status);
- try testing.expectEqualStrings("HOWDY world\nsecond line\n", p.panes[0].?.file.?.content);
- }
-}
-
-test "setattr truncation empties the body and answers fresh attributes" {
- const gpa = testing.allocator;
- const p = try withFile(gpa, "one\ntwo\n");
- defer p.deinit();
- const serial = serialOf(p);
-
- const a = call(p, .{ .tag = 7, .op = .setattr, .node = Node.of(serial, .body), .truncate = true });
- try testing.expectEqual(Status.ok, a.reply.status);
- try testing.expectEqual(@as(u64, 0), a.reply.attr.size);
- try testing.expectEqualStrings("", p.panes[0].?.file.?.content);
-
- _ = wr(p, Node.of(serial, .body), "new text\n");
- try testing.expectEqualStrings("new text\n", p.panes[0].?.file.?.content);
-
- const noop = call(p, .{ .tag = 8, .op = .setattr, .node = Node.of(serial, .body) });
- try testing.expectEqual(@as(u64, 9), noop.reply.attr.size);
-}
-
-test "addresses are in runes: a combining mark and a lone \\r are places of their own" {
- const gpa = testing.allocator;
- // e, U+0301 (two bytes, 1-2), x, \r, \n
- const p = try withFile(gpa, "e\u{0301}x\r\n");
- defer p.deinit();
- const serial = serialOf(p);
- const addr_node = Node.of(serial, .addr);
- const dot = Node.of(serial, .dot);
- const Case = struct { expr: []const u8, q0: u32, q1: u32 };
- for ([_]Case{
- .{ .expr = "#1,#3", .q0 = 1, .q1 = 3 }, // the mark alone
- .{ .expr = "#2", .q0 = 1, .q1 = 1 }, // inside it: back to its start
- .{ .expr = "#4,#5", .q0 = 4, .q1 = 5 }, // the \r alone
- .{ .expr = "1:2", .q0 = 1, .q1 = 1 }, // line:col the same
- .{ .expr = "1:3", .q0 = 1, .q1 = 1 },
- .{ .expr = "0/\xCC/", .q0 = 1, .q1 = 3 }, // a match inside a rune covers it
- }) |c| {
- try testing.expectEqual(Status.ok, wr(p, addr_node, c.expr).reply.status);
- try testing.expectEqual(c.q0, p.panes[0].?.fs.addr.q0);
- try testing.expectEqual(c.q1, p.panes[0].?.fs.addr.q1);
- }
- // Copied to dot, it reads back the same.
- _ = wr(p, addr_node, "#1,#3");
- try testing.expectEqual(Status.ok, wr(p, dot, " 1 3 ").reply.status);
- p.sync();
- try testing.expectEqualStrings(" 1 3 ", rd(p, dot, 0, 100).bytes);
- _ = wr(p, addr_node, "#4,#5");
- try testing.expectEqualStrings("\r", rd(p, Node.of(serial, .xdata), 0, 100).bytes);
-}
-
test "a limit write that fails keeps the limit a truncation cleared before it" {
const gpa = testing.allocator;
const p = try withFile(gpa, "one two\n");
@@ -1727,17 +1275,6 @@ test "a limit write that fails keeps the limit a truncation cleared before it" {
try testing.expectEqualStrings("", rd(p, limit, 0, 100).bytes);
}
-test "a pane's tagexec runs a word as a click in its tag, and reads back what it touched" {
- const gpa = testing.allocator;
- const p = try withFile(gpa, "x\n");
- defer p.deinit();
- const serial = serialOf(p);
- try testing.expectEqual(Status.ok, wr(p, Node.of(serial, .tagexec), "Msg from the tag\n").reply.status);
- try testing.expect(th.logHas(p, "from the tag"));
- var want: [16]u8 = undefined;
- try testing.expectEqualStrings(try std.fmt.bufPrint(&want, "{d}\n", .{serial}), rd(p, Node.of(serial, .tagexec), 0, 64).bytes);
-}
-
test "index names a command's pane cmd, a shell's term" {
const p = try withFile(testing.allocator, "x\n");
defer p.deinit();
diff --git a/test/behaviour/addresses.zig b/test/behaviour/addresses.zig
index a1474c3d..dde36f59 100644
--- a/test/behaviour/addresses.zig
+++ b/test/behaviour/addresses.zig
@@ -63,3 +63,94 @@ test "addresses: sel reads the selection, and a write to sel replaces it and is
try s.expect(body, "ab\ntwo\n");
try s.expect(sel, "ab");
}
+
+test "addresses: a 9P write moves dot only as acme's textinsert does" {
+ // dot is `cd` of `abcdef\n` (2 4); two bytes go in at `at`.
+ for ([_][3]u32{
+ .{ 0, 4, 6 }, // before: shifted
+ .{ 2, 2, 6 }, // at its start: grown
+ .{ 3, 2, 6 }, // inside: grown
+ .{ 4, 2, 4 }, // at its end: left
+ .{ 6, 2, 4 }, // after: left
+ }) |c| {
+ var s = try Session.initFile(std.testing.allocator, "abcdef\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const dot = s.at("/pane/{d}/dot", .{n});
+ try s.write(dot, "2 4");
+ try s.write(s.at("/pane/{d}/addr", .{n}), s.at("#{d}", .{c[0]}));
+ try s.write(s.at("/pane/{d}/data", .{n}), "XX");
+ try expectEqual(.{ c[1], c[2] }, try s.range(dot));
+ }
+ // A body append leaves dot, and a sel write after it replaces dot, not
+ // the text appended.
+ var s = try Session.initFile(std.testing.allocator, "abcdef\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const dot = s.at("/pane/{d}/dot", .{n});
+ try s.write(dot, "2 4");
+ try s.write(s.at("/pane/{d}/body", .{n}), "more\n");
+ try expectEqual(.{ @as(u32, 2), @as(u32, 4) }, try s.range(dot));
+ try s.write(s.at("/pane/{d}/sel", .{n}), "YY");
+ try s.expect(s.at("/pane/{d}/body", .{n}), "abYYef\nmore\n");
+}
+
+test "addresses: a pair out of order or out of range is refused as the address form is, not clamped" {
+ var s = try Session.initFile(std.testing.allocator, "abcdef\n");
+ defer s.deinit();
+ const addr = s.at("/pane/{d}/addr", .{try s.focused()});
+ for ([_][2][]const u8{
+ .{ "5 2", "addresses out of order" },
+ .{ "#5,#2", "addresses out of order" },
+ .{ "2 99", "address out of range" },
+ .{ "#2,#99", "address out of range" },
+ }) |c| {
+ try expectEqual(@as(u16, 22), try s.refused(addr, c[0]));
+ try std.testing.expectEqualStrings(c[1], s.said);
+ }
+ try s.write(addr, "2 4");
+ try expectEqual(.{ @as(u32, 2), @as(u32, 4) }, try s.range(addr));
+}
+
+test "addresses: every address lands on a rune, and a combining mark and a lone \\r are places of their own" {
+ // e, U+0301 (two bytes, 1-2), x, \r, \n
+ var s = try Session.initFile(std.testing.allocator, "e\u{0301}x\r\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const addr = s.at("/pane/{d}/addr", .{n});
+ for ([_]struct { []const u8, u32, u32 }{
+ .{ "#1,#3", 1, 3 }, // the mark alone
+ .{ "#2", 1, 1 }, // inside it: back to its start
+ .{ "#4,#5", 4, 5 }, // the \r alone
+ .{ "1:2", 1, 1 }, // line:col the same
+ .{ "1:3", 1, 1 },
+ .{ "0/\xCC/", 1, 3 }, // a match inside a rune covers it
+ }) |c| {
+ try s.write(addr, c[0]);
+ try expectEqual(.{ c[1], c[2] }, try s.range(addr));
+ }
+ // Copied to dot, it reads back the same.
+ const dot = s.at("/pane/{d}/dot", .{n});
+ try s.write(addr, "#1,#3");
+ try s.write(dot, " 1 3 ");
+ try s.expect(dot, " 1 3 ");
+ try s.write(addr, "#4,#5");
+ try s.expect(s.at("/pane/{d}/xdata", .{n}), "\r");
+}
+
+test "addresses: truncating data or xdata deletes only the addressed range, so > data replaces it" {
+ var s = try Session.initFile(std.testing.allocator, "");
+ defer s.deinit();
+ const n = try s.focused();
+ const body = s.at("/pane/{d}/body", .{n});
+ for ([_][]const u8{ "data", "xdata" }) |file| {
+ try s.replace(body, "hello world\nsecond line\n");
+ try s.write(s.at("/pane/{d}/addr", .{n}), "#0,#5");
+ const h = try s.hold(s.at("/pane/{d}/{s}", .{ n, file }), 1);
+ try s.truncate(h);
+ try s.expect(body, " world\nsecond line\n");
+ try expectEqual(@as(u16, 0), try s.writeFid(h, "HOWDY"));
+ s.clunk(h);
+ try s.expect(body, "HOWDY world\nsecond line\n");
+ }
+}
diff --git a/test/behaviour/flags.zig b/test/behaviour/flags.zig
index 656d219f..0c8b6660 100644
--- a/test/behaviour/flags.zig
+++ b/test/behaviour/flags.zig
@@ -40,3 +40,63 @@ test "flags: dirty, mark and scroll read and write the state acme kept behind ct
try t.expect(term_dirty, "0\n");
try std.testing.expectEqual(@as(u16, 22), try t.refused(term_dirty, "1"));
}
+
+test "flags: a > into an empty body is one undo step, as into any other" {
+ var s = try Session.initFile(std.testing.allocator, "");
+ defer s.deinit();
+ const n = try s.focused();
+ const body = s.at("/pane/{d}/body", .{n});
+ try s.replace(body, "fresh\n");
+ try s.expect(body, "fresh\n");
+ try s.write(s.at("/pane/{d}/ctl", .{n}), "Undo\n");
+ try s.expect(body, "");
+}
+
+test "flags: a write that changes nothing, an empty range deleted or a range replaced by itself, is no undo step and no new version" {
+ var s = try Session.initFile(std.testing.allocator, "abc\ndef\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const body = s.at("/pane/{d}/body", .{n});
+ const addr = s.at("/pane/{d}/addr", .{n});
+ const data = s.at("/pane/{d}/data", .{n});
+ const ctl = s.at("/pane/{d}/ctl", .{n});
+ // One real change, so a step made after it would be the one undone.
+ try s.write(addr, "1");
+ try s.write(data, "abd\n");
+ const version = (try s.stat(body)).version;
+ // Each as a shell does it: `: > data` after an empty address, `echo
+ // abd > data` over the line it holds, and Edit's `s/d/d/`.
+ try s.write(addr, "#2,#2");
+ const h = try s.hold(data, 1);
+ try s.truncate(h);
+ s.clunk(h);
+ try s.write(addr, "1");
+ try s.write(data, "abd\n");
+ try s.write(ctl, "Edit ,s/d/d/\n");
+ try s.expect(body, "abd\ndef\n");
+ try std.testing.expectEqual(version, (try s.stat(body)).version);
+ try s.write(ctl, "Undo\n");
+ try s.expect(body, "abc\ndef\n");
+}
+
+test "flags: an open's writes in a row go in as one edit, seen by the next request" {
+ var s = try Session.initFile(std.testing.allocator, "one\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const body = s.at("/pane/{d}/body", .{n});
+ const version = (try s.stat(body)).version;
+ const h = try s.hold(body, 1);
+ for (0..100) |_| try std.testing.expectEqual(@as(u16, 0), try s.writeFid(h, "0123456789\n"));
+ try std.testing.expectEqual(@as(usize, 4 + 1100), (try s.read(body)).len);
+ try std.testing.expectEqual(version + 1, (try s.stat(body)).version);
+ s.clunk(h);
+ try s.write(s.at("/pane/{d}/ctl", .{n}), "Undo\n");
+ try s.expect(body, "one\n");
+ // data inserts at its address go on the same way.
+ try s.write(s.at("/pane/{d}/addr", .{n}), "#0");
+ const d = try s.hold(s.at("/pane/{d}/data", .{n}), 1);
+ _ = try s.writeFid(d, "a");
+ _ = try s.writeFid(d, "b");
+ s.clunk(d);
+ try s.expect(body, "abone\n");
+}
diff --git a/test/behaviour/look_and_exec.zig b/test/behaviour/look_and_exec.zig
index 98cab342..0777d385 100644
--- a/test/behaviour/look_and_exec.zig
+++ b/test/behaviour/look_and_exec.zig
@@ -323,3 +323,13 @@ test "look-and-exec: a +PdfSections row's first number is the page: a section no
_ = try s.refused(look, "design.pdf:1:999\n");
try expectEqual(@as(usize, 2), try errs(&s));
}
+
+test "look-and-exec: a pane's tagexec runs a word as a click in its tag, and reads back what it touched" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const tagexec = s.at("/pane/{d}/tagexec", .{n});
+ try s.write(tagexec, "Msg from the tag\n");
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), "from the tag") != null);
+ try s.expect(tagexec, s.at("{d}\n", .{n}));
+}
diff --git a/test/behaviour/panes.zig b/test/behaviour/panes.zig
index a46f8432..553b1ca9 100644
--- a/test/behaviour/panes.zig
+++ b/test/behaviour/panes.zig
@@ -363,3 +363,188 @@ test "panes: a Mini that cannot read its file leaves the panes, the last Mini's
try s.expect("/index", index);
try s.expect(s.at("/pane/{d}/body", .{mini}), body);
}
+
+test "panes: name refuses a directory, EISDIR, and leaves the name as it was" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const name = s.at("/pane/{d}/name", .{try s.focused()});
+ for ([_][]const u8{ "/\n", "/tmp/\n", "sub/\n", "/tmp\n" }) |dir| {
+ try std.testing.expectEqual(@as(u16, 21), try s.refused(name, dir));
+ try std.testing.expect(std.mem.indexOf(u8, s.said, "is a directory") != null);
+ }
+ try s.expect(name, "/test.txt\n");
+}
+
+test "panes: a write of two lines to name is refused EINVAL, on a held open or not" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const name = s.at("/pane/{d}/name", .{try s.focused()});
+ try std.testing.expectEqual(@as(u16, 22), try s.refused(name, "/tmp/a\n/tmp/b\n"));
+ const h = try s.hold(name, 1);
+ try std.testing.expectEqual(@as(u16, 22), try s.writeFid(h, "/tmp/a\n/tmp/b\n"));
+ s.clunk(h);
+ try s.expect(name, "/test.txt\n");
+ // Line by line, as bash writes it: the second line is refused.
+ const h2 = try s.hold(name, 1);
+ try std.testing.expectEqual(@as(u16, 0), try s.writeFid(h2, "/tmp/pardes-a\n"));
+ try std.testing.expectEqual(@as(u16, 22), try s.writeFid(h2, "/tmp/pardes-b\n"));
+ s.clunk(h2);
+ try s.expect(name, "/tmp/pardes-a\n");
+}
+
+test "panes: a name with a component over 255 bytes is refused by the write that holds it" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const name = s.at("/pane/{d}/name", .{try s.focused()});
+ try std.testing.expectEqual(@as(u16, 22), try s.refused(name, "/tmp/" ++ &@as([256]u8, @splat('c')) ++ "/f.txt\n"));
+ try std.testing.expectEqualStrings("invalid file name: a component over 255 bytes", s.said);
+ const longest = "/tmp/" ++ &@as([255]u8, @splat('c'));
+ try s.write(name, longest ++ "\n");
+ // Held with no newline, it is refused by that write, and the close
+ // has nothing left to apply.
+ const held = try s.hold(name, 1);
+ try std.testing.expectEqual(@as(u16, 22), try s.writeFid(held, "/tmp/" ++ &@as([256]u8, @splat('e'))));
+ s.clunk(held);
+ try s.expect(name, longest ++ "\n");
+}
+
+test "panes: a name cut across writes is one name, applied once at its newline or its close" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const name = s.at("/pane/{d}/name", .{try s.focused()});
+ const h = try s.hold(name, 1);
+ _ = try s.writeFid(h, "/tmp/pardes-na");
+ try s.expect(name, "/test.txt\n");
+ _ = try s.writeFid(h, "me.txt\n");
+ try s.expect(name, "/tmp/pardes-name.txt\n");
+ s.clunk(h);
+ // No newline: held, and applied at the close.
+ const h3 = try s.hold(name, 1);
+ _ = try s.writeFid(h3, "/tmp/pardes-closed.txt");
+ try s.expect(name, "/tmp/pardes-name.txt\n");
+ s.clunk(h3);
+ try s.expect(name, "/tmp/pardes-closed.txt\n");
+}
+
+test "panes: name reads the file name, and a write promotes a scratch without touching its body or its file" {
+ const gpa = std.testing.allocator;
+ var s = try Session.initFile(gpa, "opener\n");
+ defer s.deinit();
+ const n = try s.newPane();
+ const name = s.at("/pane/{d}/name", .{n});
+ const body = s.at("/pane/{d}/body", .{n});
+ const scratch = try s.read(name);
+ try std.testing.expect(std.mem.endsWith(u8, scratch, "/+New\n"));
+ try std.testing.expectEqual(@as(u64, scratch.len), (try s.stat(name)).size);
+ try s.write(body, "scratch ");
+ try s.write(body, "work\n");
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "renamed.zig", .data = "existing target\n" });
+ var dir_buf: [4096]u8 = undefined;
+ const dir = dir_buf[0..try tmp.dir.realPath(std.testing.io, &dir_buf)];
+ const path = s.at("{s}/renamed.zig", .{dir});
+ try s.write(name, s.at("{s}\n", .{path}));
+ try s.expect(body, "scratch work\n");
+ try s.expect(s.at("/pane/{d}/dirty", .{n}), "1\n");
+ try s.expect(name, s.at("{s}\n", .{path}));
+ var target_buf: [64]u8 = undefined;
+ try std.testing.expectEqualStrings("existing target\n", try tmp.dir.readFile(std.testing.io, "renamed.zig", &target_buf));
+ try std.testing.expectEqual(@as(u16, 22), try s.refused(name, "\n"));
+ // One name, and what no file name holds: a second line, a NUL.
+ for ([_][2][]const u8{
+ .{ "two\nlines\n", "invalid file name: one name a write, on one line" },
+ .{ "nul\x00.zig\n", "bad character in file name: a NUL" },
+ }) |c| {
+ try std.testing.expectEqual(@as(u16, 22), try s.refused(name, c[0]));
+ try std.testing.expectEqualStrings(c[1], s.said);
+ }
+ // Any other byte a file name holds is taken, and reads back as written:
+ // blanks at its ends, a tab, a control byte, DEL, C1, bytes not UTF-8.
+ for ([_][]const u8{ " lead.zig ", "tab\t.zig", "c\x01.zig", "del\x7f.zig", "c1\xc2\x85.zig", "bad\xff.zig" }) |odd| {
+ try s.write(name, s.at("{s}\n", .{odd}));
+ const read_back = std.mem.trimEnd(u8, try s.read(name), "\n");
+ try std.testing.expect(std.mem.endsWith(u8, read_back, odd));
+ try s.write(name, read_back);
+ try s.expect(name, s.at("{s}\n", .{read_back}));
+ }
+ // A name that is one line and UTF-8 is taken, é and all.
+ try s.write(name, "caf\xc3\xa9.zig\n");
+ try std.testing.expect(std.mem.endsWith(u8, try s.read(name), "/caf\xc3\xa9.zig\n"));
+ try s.write(name, "two words.zig\n");
+ try s.expect(name, s.at("{s}/two words.zig\n", .{dir}));
+ // A rename is no edit: Undo takes back the last write.
+ try s.write(s.at("/pane/{d}/ctl", .{n}), "Undo\n");
+ try s.expect(body, "scratch ");
+}
+
+test "panes: relative names go from the file's directory and can name a new target" {
+ var s = try Session.initFile(std.testing.allocator, "retained body\n");
+ defer s.deinit();
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "note.txt", .data = "from pane directory\n" });
+ var dir_buf: [4096]u8 = undefined;
+ const dir = dir_buf[0..try tmp.dir.realPath(std.testing.io, &dir_buf)];
+ const n = try s.focused();
+ const name = s.at("/pane/{d}/name", .{n});
+ try s.write(name, s.at("{s}/old.txt\n", .{dir}));
+ try s.write(name, "child/../note.txt\n");
+ try s.write(s.at("/pane/{d}/ctl", .{n}), "get\n");
+ try s.expect(s.at("/pane/{d}/body", .{n}), "from pane directory\n");
+ try s.write(name, "./created.txt\n");
+ try s.expect(name, s.at("{s}/created.txt\n", .{dir}));
+ // A name alone is no edit.
+ try s.expect(s.at("/pane/{d}/dirty", .{n}), "0\n");
+}
+
+test "panes: relative names follow a pane/new scratch's session directory, and a virtual one" {
+ var s = try Session.initFile(std.testing.allocator, "source body\n");
+ defer s.deinit();
+ const source = try s.focused();
+ try s.write(s.at("/pane/{d}/name", .{source}), "/elsewhere/source.zig\n");
+ // pane/new's scratch is the session's, not the active pane's.
+ const n = try s.newPane();
+ const name = s.at("/pane/{d}/name", .{n});
+ const session = std.fs.path.dirname(std.mem.trimEnd(u8, try s.read(name), "\n")).?;
+ try std.testing.expect(!std.mem.eql(u8, session, "/elsewhere"));
+ const up = std.fs.path.dirname(session) orelse "";
+ try s.write(name, "../out/./notes.txt\n");
+ try s.expect(name, s.at("{s}/out/notes.txt\n", .{up}));
+ try s.write(name, "again.txt\n");
+ try s.expect(name, s.at("{s}/out/again.txt\n", .{up}));
+ try s.write(name, s.at("/virtual/pane/{d}/./body\n", .{source}));
+ try s.write(s.at("/pane/{d}/ctl", .{n}), "get\n");
+ try s.expect(s.at("/pane/{d}/body", .{n}), "source body\n");
+ try s.write(name, "./body\n");
+ try s.expect(name, s.at("/virtual/pane/{d}/body\n", .{source}));
+ try s.expect(s.at("/pane/{d}/dirty", .{n}), "0\n");
+}
+
+test "panes: errors appends to one +Errors pane for the pane's directory" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.focused();
+ try std.testing.expect(std.mem.indexOf(u8, try s.read("/index"), "+Errors") == null);
+ try s.write(s.at("/pane/{d}/errors", .{n}), "boom\n");
+ try s.write(s.at("/pane/{d}/errors", .{n}), "again\n");
+ const index = try s.read("/index");
+ try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, index, " /+Errors "));
+ const at = std.mem.indexOf(u8, index, " /+Errors ").?;
+ const line = index[(if (std.mem.lastIndexOfScalar(u8, index[0..at], '\n')) |i| i + 1 else 0)..];
+ const serial = line[0..std.mem.indexOfScalar(u8, line, ' ').?];
+ try s.expect(s.at("/pane/{s}/body", .{serial}), "boom\nagain\n");
+}
+
+test "panes: truncating body empties it, and a stat says the length after" {
+ var s = try Session.initFile(std.testing.allocator, "one\ntwo\n");
+ defer s.deinit();
+ const body = s.at("/pane/{d}/body", .{try s.focused()});
+ const h = try s.hold(body, 1);
+ try s.truncate(h);
+ try std.testing.expectEqual(@as(u64, 0), (try s.stat(body)).size);
+ try s.expect(body, "");
+ s.clunk(h);
+ try s.write(body, "new text\n");
+ try std.testing.expectEqual(@as(u64, 9), (try s.stat(body)).size);
+}
diff --git a/test/behaviour/tags.zig b/test/behaviour/tags.zig
index 6c1c6fcd..f4a5a469 100644
--- a/test/behaviour/tags.zig
+++ b/test/behaviour/tags.zig
@@ -397,3 +397,56 @@ test "tags: a name typed into the tag's path survives Esc, pending, and the next
try s.expect(name, "/ztest.txt\n");
try std.testing.expect(std.mem.startsWith(u8, try s.read(s.at("/pane/{d}/tag", .{n})), "/ztest.txt "));
}
+
+test "tags: a pane's tag reads whole, its path first, and a write appends to its own text up to 4096 bytes" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const path = s.at("/pane/{d}/tag", .{n});
+ const whole = try tag(&s, n);
+ try std.testing.expect(std.mem.startsWith(u8, whole, "/test.txt"));
+ try std.testing.expect(std.mem.indexOf(u8, whole, "Del") != null);
+ try std.testing.expectEqual(@as(u64, whole.len), (try s.stat(path)).size);
+ try s.write(path, " Mine");
+ try std.testing.expectEqualStrings(s.at("{s} Mine", .{whole}), try tag(&s, n));
+ // A tag is a text like the body: a newline written to it stays one.
+ try s.write(path, "\nNext Line");
+ try std.testing.expectEqualStrings(s.at("{s} Mine\nNext Line", .{whole}), try tag(&s, n));
+ // Full, it takes not a byte more.
+ try s.replace(path, &@as([4096]u8, @splat('x')));
+ try std.testing.expectEqual(@as(u16, 28), try s.refused(path, "x"));
+}
+
+test "tags: truncating a tag clears its own text, u in the tag undoes it, and > drops the one newline ending it" {
+ var s = try Session.initFile(std.testing.allocator, "x\n");
+ defer s.deinit();
+ const n = try s.focused();
+ const path = s.at("/pane/{d}/tag", .{n});
+ try s.write(path, " Mine");
+ // Done at the first read or write after it (or the close).
+ const h = try s.hold(path, 1);
+ try s.truncate(h);
+ try std.testing.expect(std.mem.indexOf(u8, try tag(&s, n), "Mine") == null);
+ s.clunk(h);
+ try std.testing.expectEqualStrings("/test.txt", std.mem.trimEnd(u8, try tag(&s, n), " "));
+ // The tag keeps its undo: undoing in it brings back what was cleared.
+ try s.keys(":u:");
+ try std.testing.expect(std.mem.endsWith(u8, try tag(&s, n), " Mine"));
+ // Written back without a leading space, the text still stands apart
+ // from the path, and a click on its first letter lands on it.
+ try s.replace(path, "Get");
+ try std.testing.expectEqualStrings("/test.txt Get", try tag(&s, n));
+ try s.click("Get", 0, 1);
+ try std.testing.expectEqual(@as(usize, "/test.txt ".len), try tagCol(&s, "/test.txt"));
+ // `echo Make > tag`: the newline ending the truncating write's text is
+ // dropped, one only; a newline between its writes stays.
+ const m = try s.hold(path, 1);
+ try s.truncate(m);
+ _ = try s.writeFid(m, "Make\n");
+ _ = try s.writeFid(m, "More\n\n");
+ s.clunk(m);
+ try std.testing.expectEqualStrings("/test.txt Make\nMore\n", try tag(&s, n));
+ // `>>` keeps what it is given.
+ try s.write(path, " Tail\n");
+ try std.testing.expectEqualStrings("/test.txt Make\nMore\n Tail\n", try tag(&s, n));
+}