1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
//! docs/typ/reference.typ, Edit <edit>, through a real session's socket:
//! its commands run in the session's shell, and its w writes.
const std = @import("std");
const process = @import("../process.zig");
const eh = @import("../e2e_harness.zig");
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const expectEqualStrings = std.testing.expectEqualStrings;
pub const cases = .{
.{ "edit: < | > run off the loop and answer their write once applied, a failing one changing nothing; a held Edit write is flushed; X edits every open file it matches, w writes", editCommands },
};
fn has(hay: []const u8, needle: []const u8) bool {
return std.mem.indexOf(u8, hay, needle) != null;
}
fn refusedSaying(c: *process.Conn, path: []const u8, data: []const u8, why: []const u8) !void {
try std.testing.expectError(error.Refused, c.write(path, data));
if (!has(c.said, why)) {
std.debug.print("{s} refused saying {s}, not {s}\n", .{ path, c.said, why });
return error.WrongWords;
}
}
/// An Edit written on another connection, in a thread.
const Slow = struct {
conn: *process.Conn,
path: []const u8,
done: std.atomic.Value(bool) = .init(false),
fn go(s: *Slow) void {
s.conn.write(s.path, "Edit , | sleep 1; cat\n") catch {};
s.done.store(true, .release);
}
};
fn editCommands(gpa: std.mem.Allocator, exe: [:0]const u8) !void {
var d = try process.Detached.start(gpa, exe, "edit", .{});
defer d.deinit();
const f = &d.files;
var arena = std.heap.ArenaAllocator.init(gpa);
defer arena.deinit();
const ar = arena.allocator();
const c = try process.Conn.dial(gpa, d.socket());
defer c.deinit(gpa);
const root = d.root();
try d.put("a.txt", "pear\napple\nfig\n");
try d.put("b.txt", "apple pie\n");
const a = try c.look(ar, f.at("{s}/a.txt", .{root}), null);
const b = try c.look(ar, f.at("{s}/b.txt", .{root}), null);
const actl = f.at("/pane/{d}/ctl", .{a});
const abody = f.at("/pane/{d}/body", .{a});
// The write returns with the text sorted, through the session's shell
// in the file's directory.
try c.write(actl, "Edit , | sort\n");
try expectEqualStrings("apple\nfig\npear\n", try c.read(ar, abody));
try c.write(actl, "Edit $ < pwd\n");
try expectEqualStrings(f.at("apple\nfig\npear\n{s}\n", .{root}), try c.read(ar, abody));
try c.write(actl, "Undo\n");
try expectEqualStrings("apple\nfig\npear\n", try c.read(ar, abody));
// A per-match command, one undo step.
try c.write(actl, "Edit ,x/[a-z]+/ | tr a-z A-Z\n");
try expectEqualStrings("APPLE\nFIG\nPEAR\n", try c.read(ar, abody));
// A failing command: nothing changed, the write fails in words, its
// stderr in +Errors.
try refusedSaying(c, actl, "Edit , | echo nope >&2; exit 4\n", "exit status 4");
try expectEqualStrings("APPLE\nFIG\nPEAR\n", try c.read(ar, abody));
var said = false;
var rows = std.mem.tokenizeScalar(u8, try c.read(ar, "/index"), '\n');
while (rows.next()) |row| {
if (!has(row, "+Errors")) continue;
said = said or has(try c.read(ar, f.at("/pane/{s}/body", .{row[0..std.mem.indexOfScalar(u8, row, ' ').?]})), "nope");
}
try expect(said);
// While a slow command runs, the editor answers.
{
const other = try process.Conn.dial(gpa, d.socket());
defer other.deinit(gpa);
var slow: Slow = .{ .conn = other, .path = f.at("/pane/{d}/ctl", .{b}) };
const worker = try std.Thread.spawn(.{}, Slow.go, .{&slow});
process.sleep(200);
const began = eh.nowMs();
_ = try c.read(ar, "/index");
const quick = eh.nowMs() - began < 500 and !slow.done.load(.acquire);
worker.join();
try expect(quick); // the editor did not wait on the command
try expect(slow.done.load(.acquire));
}
// On the same connection: the Edit's write is held, and a read sent
// after it is answered first; a Tflush of it stops it, changes nothing,
// and frees the way for the next Edit.
const ctl = try c.hold(actl, 1);
const status = try c.hold("/status", 0);
const began = eh.nowMs();
const held = try c.send(.{ .write = .{ .fid = ctl, .offset = 0, .data = "Edit , | sleep 1; cat\n" } });
const read = try c.send(.{ .read = .{ .fid = status, .offset = 0, .count = 4096 } });
const first = try c.answer();
try expect(first.tag == read and first.result == .read and eh.nowMs() - began < 500);
const second = try c.answer();
try expect(second.tag == held and second.result == .write);
const flushed = try c.send(.{ .write = .{ .fid = ctl, .offset = 0, .data = "Edit , | sleep 5; tr a-z A-Z\n" } });
process.sleep(300);
const flush = try c.send(.{ .flush = .{ .oldtag = flushed } });
const one = (try c.answer()).tag;
const two = (try c.answer()).tag;
try expect((one == flushed and two == flush) or (one == flush and two == flushed));
c.clunk(ctl);
c.clunk(status);
process.sleep(1000);
try c.write(actl, "Edit , | cat\n");
process.sleep(4500);
try expectEqualStrings("APPLE\nFIG\nPEAR\n", try c.read(ar, abody));
// X: each open file whose line matches; w writes it.
try c.write(actl, "Edit X/b\\.txt$/ ,s/apple/APPLE/\n");
try expectEqualStrings("APPLE pie\n", try c.read(ar, f.at("/pane/{d}/body", .{b})));
try c.write(f.at("/pane/{d}/ctl", .{b}), "Edit w\n");
try expectEqualStrings("APPLE pie\n", try d.get(ar, "b.txt"));
try c.write(actl, "Edit 1 w first.txt\n");
try expectEqualStrings("APPLE\n", try d.get(ar, "first.txt"));
// A file changed on disk under unsaved edits: Edit's w refuses once, as
// Save does, and the next w overwrites it.
try d.put("w1.txt", "one\n");
const w = try c.look(ar, f.at("{s}/w1.txt", .{root}), null);
const wctl = f.at("/pane/{d}/ctl", .{w});
try c.write(wctl, "Edit $a/two/\n");
const changed = f.at("\nchanged {d}", .{w});
const seen = std.mem.count(u8, try c.read(ar, "/log"), changed);
try eh.appendFile(try std.fmt.allocPrintSentinel(ar, "{s}/w1.txt", .{root}, 0), "external\n");
const deadline = eh.nowMs() + 10_000;
while (std.mem.count(u8, try c.read(ar, "/log"), changed) == seen) {
if (eh.nowMs() > deadline) return error.NeverHeard;
process.sleep(50);
}
try refusedSaying(c, wctl, "Edit w\n", "modified on disk since read (w again to overwrite)");
try expectEqualStrings("one\nexternal\n", try d.get(ar, "w1.txt"));
try c.write(wctl, "Edit w\n");
try expectEqualStrings("one\ntwo", try d.get(ar, "w1.txt"));
}
|