summaryrefslogtreecommitdiff
path: root/test/process/other_files.zig
diff options
context:
space:
mode:
Diffstat (limited to 'test/process/other_files.zig')
-rw-r--r--test/process/other_files.zig119
1 files changed, 119 insertions, 0 deletions
diff --git a/test/process/other_files.zig b/test/process/other_files.zig
index d03d6b36..ad58dd10 100644
--- a/test/process/other_files.zig
+++ b/test/process/other_files.zig
@@ -6,8 +6,33 @@ const process = @import("../process.zig");
pub const cases = .{
.{ "other-files: kbdin and mousein drive a detached session as the user would, each write done before it is answered", keysAndMouse },
.{ "other-files: a held connection lists a directory, stats a file, writes and reads, is refused in words and removes a pane", heldConnection },
+ .{ "other-files: a file opened and closed is in /recent closed, and still is in the next session; Recent's row opens it again", recentSurvivesRestart },
+ .{ "other-files: two sessions share one store: a file opened in one is in the other's /recent, a Del'd pane comes back from @p only where it was", storeShared },
};
+extern "c" fn system(cmd: [*:0]const u8) c_int;
+
+fn has(hay: []const u8, needle: []const u8) bool {
+ return std.mem.indexOf(u8, hay, needle) != null;
+}
+
+/// A session's root kept past it, removed at the test's end.
+fn keepRoot(d: *process.Detached, buf: *[4096]u8) []const u8 {
+ d.owns_root = false;
+ @memcpy(buf[0..d.root().len], d.root());
+ return buf[0..d.root().len];
+}
+
+fn removeRoot(root: []const u8) void {
+ var cmd: [4200]u8 = undefined;
+ _ = system(std.fmt.bufPrintSentinel(&cmd, "rm -rf -- '{s}'", .{root}, 0) catch return);
+}
+
+fn storeExists(root: []const u8) bool {
+ var buf: [4200]u8 = undefined;
+ return std.c.access(std.fmt.bufPrintSentinel(&buf, "{s}/.local/state/pardes/store", .{root}, 0) catch return false, 0) == 0;
+}
+
/// A script types and clicks as the user does: no sleep or poll between a
/// write and the read that checks it; where to click is read off /screen.
/// (test/fs.py's keys_and_mouse, the first case written through the files
@@ -64,3 +89,97 @@ fn heldConnection(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
try c.remove(try std.fmt.bufPrint(&path, "/pane/{d}", .{serial}));
try std.testing.expectError(error.NotFound, c.walk(body));
}
+
+/// The list is kept under $XDG_STATE_HOME (here HOME's .local/state) across
+/// restarts.
+fn recentSurvivesRestart(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var root_buf: [4096]u8 = undefined;
+ var one = try process.Detached.start(gpa, exe, "recent1", .{});
+ const root = keepRoot(&one, &root_buf);
+ defer removeRoot(root);
+ const kept = try std.fmt.allocPrint(a, "{s}/kept.txt", .{root});
+ {
+ defer one.deinit();
+ try one.put("kept.txt", "one\ntwo\n");
+ const c = try process.Conn.dial(gpa, one.socket());
+ defer c.deinit(gpa);
+ const serial = try c.look(a, try std.fmt.allocPrint(a, "{s}:2", .{kept}), null);
+ try std.testing.expect(has(try c.read(a, "/recent"), try std.fmt.allocPrint(a, "open {s}\n", .{kept})));
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{serial}), "Del\n");
+ try std.testing.expect(has(try c.read(a, "/recent"), try std.fmt.allocPrint(a, "closed {s}\n", .{kept})));
+ }
+ try std.testing.expect(storeExists(root));
+ var two = try process.Detached.start(gpa, exe, "recent2", .{ .root = root });
+ defer two.deinit();
+ const c = try process.Conn.dial(gpa, two.socket());
+ defer c.deinit(gpa);
+ try std.testing.expect(has(try c.read(a, "/recent"), try std.fmt.allocPrint(a, "closed {s}\n", .{kept})));
+ // Recent fills a query pane with it, its row relative to the pane's
+ // directory, and a look at the row opens it again.
+ try c.write("/pane/1/exec", "Recent\n");
+ var answer = std.mem.tokenizeAny(u8, try c.read(a, "/pane/1/exec"), " \n");
+ var last: []const u8 = "";
+ while (answer.next()) |w| last = w;
+ const rows = try std.fmt.parseInt(u32, last, 10);
+ const body = try c.read(a, try std.fmt.allocPrint(a, "/pane/{d}/body", .{rows}));
+ try std.testing.expect(std.mem.startsWith(u8, body, "Recent "));
+ var lines = std.mem.tokenizeScalar(u8, body, '\n');
+ const row = while (lines.next()) |l| {
+ if (std.mem.startsWith(u8, l, "kept.txt:")) break l;
+ } else return error.NoRow;
+ try c.write(try std.fmt.allocPrint(a, "/pane/{d}/look", .{rows}), try std.fmt.allocPrint(a, "{s}\n", .{row[0 .. std.mem.indexOfScalar(u8, row, ' ') orelse row.len]}));
+ try std.testing.expect(has(try c.read(a, "/recent"), try std.fmt.allocPrint(a, "open {s}\n", .{kept})));
+}
+
+/// Del, and again when the first refused over unsaved text.
+fn delTwice(c: *process.Conn, ctl: []const u8) !void {
+ c.write(ctl, "Del\n") catch try c.write(ctl, "Del\n");
+}
+
+/// The store (Store.zig) shared with no restart; a pane Del'd in one
+/// comes back where it was from a look at its @p serial there, its text
+/// with it, and only there.
+fn storeShared(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
+ var arena = std.heap.ArenaAllocator.init(gpa);
+ defer arena.deinit();
+ const a = arena.allocator();
+ var root_buf: [4096]u8 = undefined;
+ var one = try process.Detached.start(gpa, exe, "store1", .{});
+ const root = keepRoot(&one, &root_buf);
+ defer removeRoot(root);
+ {
+ defer one.deinit();
+ var two = try process.Detached.start(gpa, exe, "store2", .{ .root = root });
+ defer two.deinit();
+ const c1 = try process.Conn.dial(gpa, one.socket());
+ defer c1.deinit(gpa);
+ const c2 = try process.Conn.dial(gpa, two.socket());
+ defer c2.deinit(gpa);
+ try one.put("shared.txt", "one\ntwo\nthree\n");
+ const shared = try std.fmt.allocPrint(a, "{s}/shared.txt", .{root});
+ const serial = try c1.look(a, try std.fmt.allocPrint(a, "{s}:3", .{shared}), null);
+ try std.testing.expect(has(try c1.read(a, "/recent"), try std.fmt.allocPrint(a, "open {s}\n", .{shared})));
+ try std.testing.expect(has(try c2.read(a, "/recent"), try std.fmt.allocPrint(a, "closed {s}\n", .{shared})));
+ try c1.write(try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{serial}), "Del\n");
+ try std.testing.expect(has(try c1.read(a, "/recent"), try std.fmt.allocPrint(a, "closed {s}\n", .{shared})));
+ const scratch = try c1.newPane();
+ try c1.write(try std.fmt.allocPrint(a, "/pane/{d}/body", .{scratch}), "kept across a Del\n");
+ try delTwice(c1, try std.fmt.allocPrint(a, "/pane/{d}/ctl", .{scratch}));
+ var rows = std.mem.tokenizeScalar(u8, try c1.read(a, "/index"), '\n');
+ while (rows.next()) |r| try std.testing.expect(!std.mem.startsWith(u8, r, try std.fmt.allocPrint(a, "{d} ", .{scratch})));
+ const back = try c1.look(a, try std.fmt.allocPrint(a, "@p{d}", .{scratch}), null);
+ try std.testing.expectEqualStrings("kept across a Del\n", try c1.read(a, try std.fmt.allocPrint(a, "/pane/{d}/body", .{back})));
+ // The other window's session closed no such pane.
+ const source = try c2.newPane();
+ c2.write(try std.fmt.allocPrint(a, "/pane/{d}/look", .{source}), try std.fmt.allocPrint(a, "@p{d}\n", .{scratch})) catch {};
+ var others = std.mem.tokenizeScalar(u8, try c2.read(a, "/index"), '\n');
+ while (others.next()) |r| {
+ const body = try c2.read(a, try std.fmt.allocPrint(a, "/pane/{s}/body", .{r[0..std.mem.indexOfScalar(u8, r, ' ').?]}));
+ try std.testing.expect(!has(body, "kept across a Del"));
+ }
+ }
+ try std.testing.expect(storeExists(root));
+}