From 23d7f949b8595ed42e938a28b0d433d90853b341 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Wed, 30 Sep 2026 13:30:40 -0300 Subject: A Newcol refused because the panes' tags would not fit logs its err alone and spends no column serial Newcol tries its column before keeping it: the new column is inserted, the panes' rows are shared out again, and where a pane would be left under its tag and two rows the column is taken back. The trial showed. insertColumn logged `newcol N` and the take-back `delcol N`, so a follower saw a column come and go around the err. Laying the column out also gave it a serial, so the next column made skipped one. The trial is now unannounced, since insert and drop have unlogged forms. A refusal puts the serial counter back where it was, after first giving every existing column its serial so the trial's is the only one spent. Only a column that stays is logged, and it gets the next serial. Co-Authored-By: Claude Opus 5.5 --- src/ninep/cols.zig | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) (limited to 'src/ninep') diff --git a/src/ninep/cols.zig b/src/ninep/cols.zig index 454cce4a..f07c7f39 100644 --- a/src/ninep/cols.zig +++ b/src/ninep/cols.zig @@ -228,6 +228,48 @@ test "New written to a column's exec makes its scratch in the session's director try testing.expectEqualStrings("/project/src/+New", p.panes[p.active].?.file.?.path); } +test "a Newcol refused because the tags would not fit logs its err alone and spends no column serial" { + const p = try pardes.Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 160, .rows = 14 }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + // Long tags wrap onto more rows as their column narrows: the boot's + // two panes share one, and each keeps its tag and two rows. + const made = try th.newPane(p); + const pane = p.panes[p.paneBySerial(made).?].?; + const col = layout.findPane(p, p.paneBySerial(made).?).?.col; + for (p.col_panes[col][0..p.col_n[col]]) |k| { + const each = p.panes[k].?; + if (each.tag.own) |old| p.gpa.free(old); + each.tag.own = try p.gpa.dupe(u8, "word " ** 60); + } + try testing.expect(p.col_n[col] >= 2); + p.sync(); + const ctl = @intFromEnum(tree.TopFile.ctl); + const focus = @intFromEnum(tree.TopFile.focus); + var digits: [16]u8 = undefined; + const own = try std.fmt.bufPrint(&digits, "{d}\n", .{pane.serial}); + var refused = false; + for (0..pardes.MAX_COLS) |_| { + // From the long tag's column, so it is the one split narrower. + _ = th.wr(p, focus, own); + const serial_before = p.next_column_serial; + const log_before = try pardes.ctlfs.events.freezeLog(p); + defer p.gpa.free(log_before.bytes); + const r = th.wr(p, ctl, "Newcol\n"); + if (r.reply.status == .ok) continue; + if (std.mem.indexOf(u8, r.reply.ename, "tags would not fit") == null) continue; + refused = true; + try testing.expectEqual(serial_before, p.next_column_serial); + const log_after = try pardes.ctlfs.events.freezeLog(p); + defer p.gpa.free(log_after.bytes); + const added = log_after.bytes[log_before.bytes.len..]; + try testing.expect(std.mem.startsWith(u8, added, "err ")); + try testing.expectEqual(@as(usize, 1), std.mem.count(u8, added, "\n")); + break; + } + try testing.expect(refused); +} + test "a tagexec word that makes, acts on and focuses no pane reads back nothing" { const p = try th.withFile(testing.allocator, "x\n"); defer p.deinit(); -- cgit v1.3