summaryrefslogtreecommitdiff
path: root/test/behaviour/modes.zig
blob: e615920d3309bfd25ec1448fa33e3c5cbbf4ccb4 (plain) (blame)
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
//! docs/typ/guide.typ, Modes <modes>.
const std = @import("std");
const Session = @import("session").Session;
const expectEqual = std.testing.expectEqual;

fn mode(s: *Session, pane: u32) ![]const u8 {
    const ctl = try s.read(s.at("/pane/{d}/ctl", .{pane}));
    const at = std.mem.lastIndexOf(u8, ctl, " mode:").? + " mode:".len;
    return std.mem.trimEnd(u8, ctl[at..], " ");
}

test "modes: Esc in normal mode alternates between two panes of the same kind" {
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "b.txt", .data = "b\n" });
    var dir: [4096]u8 = undefined;
    const at = dir[0..try tmp.dir.realPath(std.testing.io, &dir)];
    var s = try Session.initFile(std.testing.allocator, "a\n");
    defer s.deinit();
    const a = try s.focused();
    try s.write("/look", s.at("{s}/b.txt\n", .{at}));
    const b = try s.focused();
    try std.testing.expect(a != b);
    for (0..6) |_| {
        const was = try s.focused();
        try s.keys("\x1b");
        try expectEqual(if (was == a) b else a, try s.focused());
    }
}

test "modes: Esc in a column or the workspace tag gives the keyboard back to a pane, as Shift-Esc does" {
    var s = try Session.initFile(std.testing.allocator, "x\n");
    defer s.deinit();
    _ = try s.newPane();
    for ([_][]const u8{ "New Term", "Newcol" }) |tag| {
        const was = try s.focused();
        // A click puts the tag in normal mode, the keyboard there; Esc is
        // out of it.
        try s.click(tag, 0, 1);
        try s.expect("/focus", "");
        try s.keys("\x1b");
        try std.testing.expect(was != try s.focused());
    }
}

test "modes: Shift-Esc backs out to the previous pane in every mode, never into raw" {
    var s = try Session.initFile(std.testing.allocator, "x\n");
    defer s.deinit();
    const doc = try s.focused();
    try s.keys("\u{F015}n"); // a shell under the doc
    const shell = try s.focused();
    if (std.mem.eql(u8, try mode(&s, shell), "tty")) try s.keys("\x02");
    try std.testing.expectEqualStrings("normal", try mode(&s, shell));
    // A terminal in normal mode: out, still normal, never raw.
    try s.keys("\u{F016}\x1b");
    try expectEqual(doc, try s.focused());
    try std.testing.expectEqualStrings("normal", try mode(&s, shell));
    // A text pane in insert mode: out of insert, and out of the pane.
    try s.keys("i");
    try std.testing.expectEqualStrings("insert", try mode(&s, doc));
    try s.keys("\u{F016}\x1b");
    try std.testing.expectEqualStrings("normal", try mode(&s, doc));
    try std.testing.expect(doc != try s.focused());
}

/// The first line number drawn under the tag that starts with `tag`.
fn topLine(s: *Session, tag: []const u8) !usize {
    const row = (try s.where(tag))[1];
    var rows = std.mem.splitScalar(u8, try s.screen(), '\n');
    for (0..row + 1) |_| _ = rows.next();
    var words = std.mem.tokenizeScalar(u8, rows.next().?, ' ');
    return std.fmt.parseInt(usize, words.next().?, 10);
}

test "modes: Esc back into a file leaves its view where it was, and a look centres its line" {
    var s = try Session.initFile(std.testing.allocator, std.mem.asBytes(&@as([100][4]u8, @splat("row\n".*))));
    defer s.deinit();
    const doc = try s.focused();
    const dot = s.at("/pane/{d}/dot", .{doc});
    try s.keys("\u{F015}n"); // a shell under the doc
    const shell = try s.focused();
    try s.keys("\x1b");
    try expectEqual(doc, try s.focused());
    // Ride the cursor down until the view has scrolled.
    try s.keys(&@as([20]u8, @splat('j')));
    const top = try topLine(&s, "/test.txt");
    const at = try s.range(dot);
    try std.testing.expect(top > 1);
    try s.keys("\x1b");
    try expectEqual(shell, try s.focused());
    try s.keys("\x1b");
    try expectEqual(doc, try s.focused());
    // Nothing moved: the old landing recentred the line under the cursor.
    try expectEqual(top, try topLine(&s, "/test.txt"));
    try expectEqual(at, try s.range(dot));
    // The other arm still centres: a look's `:NN`.
    const line = 60;
    try s.write(s.at("/pane/{d}/look", .{doc}), s.at(":{d}\n", .{line}));
    const rows = (try s.where("Term Save Mode"))[1] - (try s.where("/test.txt"))[1] - 1;
    // Drawn mid-pane, a row either way.
    const drawn_at = line - try topLine(&s, "/test.txt");
    try std.testing.expect(drawn_at + 1 >= rows / 2 and drawn_at <= rows / 2 + 1);
}

/// Three panes named /a.txt (left column), /b.txt over /c.txt (right),
/// the keyboard on /a.txt; their serials.
fn threePanes(s: *Session) ![3]u32 {
    const a = try s.focused();
    try s.write(s.at("/pane/{d}/name", .{a}), "/a.txt\n");
    try s.write("/ctl", "Newcol\n");
    try s.write(s.at("/col/{d}/exec", .{try s.column(1)}), "New\n");
    const b = try s.focused();
    try s.write(s.at("/pane/{d}/exec", .{b}), "New\n");
    const c = try s.focused();
    try s.write(s.at("/pane/{d}/name", .{b}), "/b.txt\n");
    try s.write(s.at("/pane/{d}/name", .{c}), "/c.txt\n");
    try s.write("/focus", s.at("{d}\n", .{a}));
    return .{ a, b, c };
}

/// The panes whose tag (`name Save`) is drawn in `lit`, the outline's colour.
fn outlined(s: *Session, lit: []const u8, names: []const []const u8) ![]const u8 {
    var found: []const u8 = "";
    for (names) |name| {
        const x, const y = try s.where(s.at("{s} Save", .{name}));
        if (std.mem.eql(u8, lit, try s.bg(x, y))) found = s.at("{s}{s}", .{ found, name });
    }
    return found;
}

test "modes: Ctrl-w outlines a pane, h j k l move the outline, and Enter, Esc, : or a pane's letter gives it the keyboard" {
    var s = try Session.initFile(std.testing.allocator, "left\n");
    defer s.deinit();
    const a, const b, const c = try threePanes(&s);
    const names = &[_][]const u8{ "/a.txt", "/b.txt", "/c.txt" };
    try s.keys("\x17");
    const x, const y = try s.where("/a.txt Save");
    const lit = try s.bg(x, y);
    try std.testing.expectEqualStrings("/a.txt", try outlined(&s, lit, names));
    // Each pane's box shows its letter: the left column's is a.
    try std.testing.expectEqualStrings("a /a.txt", (try s.screen())[y * 81 ..][0.."a /a.txt".len]);
    try s.keys("l");
    try std.testing.expectEqualStrings("/b.txt", try outlined(&s, lit, names));
    try s.keys("j");
    try std.testing.expectEqualStrings("/c.txt", try outlined(&s, lit, names));
    try expectEqual(a, try s.focused());
    try s.keys("\n");
    try expectEqual(c, try s.focused());
    try std.testing.expectEqualStrings("", try outlined(&s, lit, names));
    // SPC w enters it too, and Esc leaves it on the outlined pane.
    try s.keys(" wh\x1b");
    try expectEqual(a, try s.focused());
    // Other keys change nothing.
    try s.keys("\x17!");
    try std.testing.expectEqualStrings("/a.txt", try outlined(&s, lit, names));
    try s.keys("\x1b");
    // `:` gives the outlined pane's tag the keyboard.
    try s.keys("\x17l:");
    try expectEqual(b, try s.focused());
    try expectEqual((try s.where("/b.txt Save"))[1], (try s.cursor()).?[1]);
    try s.keys("\x1b");
    // A letter goes straight there.
    try s.keys("\x17a");
    try expectEqual(a, try s.focused());
    try std.testing.expectEqualStrings("", try outlined(&s, lit, names));
}

fn listed(s: *Session, n: u32) !bool {
    var rows = std.mem.tokenizeScalar(u8, try s.read("/index"), '\n');
    while (rows.next()) |row| if (std.mem.startsWith(u8, row, s.at("{d} ", .{n}))) return true;
    return false;
}

test "modes: in window mode d deletes the outlined pane, asking k or j between two, c collapses it, and the mode stays on" {
    var s = try Session.initFile(std.testing.allocator, "top\n");
    defer s.deinit();
    const top = try s.focused();
    try s.write(s.at("/pane/{d}/exec", .{top}), "New\n");
    const mid = try s.focused();
    try s.write(s.at("/pane/{d}/exec", .{mid}), "New\n");
    const low = try s.focused();
    try s.write(s.at("/pane/{d}/name", .{mid}), "/mid\n");
    try s.write(s.at("/pane/{d}/name", .{low}), "/low\n");
    const names = &[_][]const u8{ "/test.txt", "/mid", "/low" };
    const row_top = (try s.where("/test.txt Save"))[1];
    const row_mid = (try s.where("/mid Save"))[1];
    const row_low = (try s.where("/low Save"))[1];
    // From the bottom pane, the outline up to the middle one.
    const mx, const my = try s.where("/mid Save");
    const plain = try s.bg(mx, my);
    try s.keys("\x17k");
    const lit = try s.bg(mx, my);
    try std.testing.expect(!std.mem.eql(u8, plain, lit));
    try std.testing.expectEqualStrings("/mid", try outlined(&s, lit, names));
    // c folds it to its tag and back, the mode staying.
    try s.keys("c");
    try std.testing.expect(std.mem.indexOf(u8, try s.read(s.at("/pane/{d}/ctl", .{mid})), " collapsed ") != null);
    try std.testing.expectEqualStrings("/mid", try outlined(&s, lit, names));
    try s.keys("c");
    try std.testing.expect(std.mem.indexOf(u8, try s.read(s.at("/pane/{d}/ctl", .{mid})), " collapsed ") == null);
    try expectEqual(row_low, (try s.where("/low Save"))[1]);
    // d between two panes asks, as SPC d does; Esc takes it back, the
    // outline where it was.
    try s.keys("d");
    try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), s.at("ask {d} del k j\n", .{mid})) != null);
    try s.keys("\x1b");
    try std.testing.expect(try listed(&s, mid));
    try std.testing.expectEqualStrings("/mid", try outlined(&s, lit, names));
    // j: the pane below takes the rows, and the outline goes with them.
    try s.keys("dj");
    try std.testing.expect(!try listed(&s, mid));
    try expectEqual(row_top, (try s.where("/test.txt Save"))[1]);
    try expectEqual(row_mid, (try s.where("/low Save"))[1]);
    try std.testing.expectEqualStrings("/low", try outlined(&s, lit, &.{ "/test.txt", "/low" }));
    // With one neighbour nothing is asked: d closes it, the outline on the
    // pane that grew.
    try s.keys("d");
    try std.testing.expect(!try listed(&s, low));
    try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), s.at("ask {d} ", .{low})) == null);
    try std.testing.expectEqualStrings("/test.txt", try outlined(&s, lit, &.{"/test.txt"}));
    // Enter leaves the mode on it.
    try s.keys("\n");
    try expectEqual(top, try s.focused());
    try std.testing.expectEqualStrings("", try outlined(&s, lit, &.{"/test.txt"}));
}

test "modes: window keys walk from a pane up through its column's tag and the workspace's, across, and back down" {
    var s = try Session.initFile(std.testing.allocator, "body\n");
    defer s.deinit();
    const a = try s.focused();
    try s.write("/ctl", "Newcol\n");
    try s.write(s.at("/col/{d}/exec", .{try s.column(1)}), "New\n");
    try s.write("/focus", s.at("{d}\n", .{a}));
    const right = 40; // two columns on 80 cells: the right one's first
    // Up from the top pane: its column's tag, in normal mode (w moves).
    try s.keys("\x17k");
    try s.expect("/focus", "");
    const x0, const y0 = (try s.cursor()).?;
    try expectEqual(@as(usize, 1), y0);
    try std.testing.expect(x0 < right);
    const tag = s.at("/col/{d}/tag", .{try s.column(0)});
    const words = try s.read(tag);
    try s.keys("w");
    try s.expect(tag, words);
    const remembered = (try s.cursor()).?;
    try std.testing.expect(remembered[0] > x0);
    // Across to the right column's tag, and back to where the caret was.
    try s.keys("\x17l");
    try std.testing.expect((try s.cursor()).?[0] >= right);
    try s.keys("\x17h");
    try expectEqual(remembered, (try s.cursor()).?);
    // Up again: the workspace tag; down, the column's, then the pane.
    try s.keys("\x17k");
    try expectEqual(@as(usize, 0), (try s.cursor()).?[1]);
    try s.keys("\x17j");
    try expectEqual(@as(usize, 1), (try s.cursor()).?[1]);
    try s.keys("\x17j");
    try expectEqual(a, try s.focused());
    // `:` in a column's tag is the way back to the body.
    try s.keys("\x17k:");
    try expectEqual(a, try s.focused());
    try expectEqual((try s.where("body"))[1], (try s.cursor()).?[1]);
    try s.expect(s.at("/pane/{d}/body", .{a}), "body\n");
}

/// The jump tests' session: a pane a letter of `order`, A and B each a file
/// of 100 lines, C a Zerox of A, O the +Help output (no file behind it),
/// and the jumplist `order`, a letter a place, each letter's n-th place its
/// line 1 + 40n ("ABABA" is A1 B1 A41 B41 A81): each made by moving its
/// pane's dot there and giving it the keyboard, as a jump does (a new
/// pane's first, where it opens). The shell the session started with is
/// closed after, its places with it.
const Jumps = struct {
    s: Session,
    ids: [4]u32 = @splat(0),

    const letters = "ABCO";

    fn init(order: []const u8) !Jumps {
        var t: Jumps = .{ .s = try Session.initTerm(std.testing.allocator) };
        errdefer t.s.deinit();
        const s = &t.s;
        const shell = try s.focused();
        var seen: [4]u32 = @splat(0);
        for (order) |letter| {
            const which = std.mem.indexOfScalar(u8, letters, letter).?;
            if (t.ids[which] == 0) t.ids[which] = switch (letter) {
                'O' => o: {
                    try s.write(s.at("/pane/{d}/exec", .{shell}), "Help\n");
                    break :o try s.focused();
                },
                else => made: {
                    // C is A's twin, and A C's when C came first.
                    const twin = t.ids[if (letter == 'A') 2 else if (letter == 'C') 0 else 1];
                    if (letter != 'B' and twin != 0) {
                        try s.write(s.at("/pane/{d}/exec", .{twin}), "Zerox\n");
                        break :made try s.focused();
                    }
                    const n = try s.newPane();
                    try s.write(s.at("/pane/{d}/name", .{n}), if (letter == 'B') "/b.txt\n" else "/a.txt\n");
                    try s.write(s.at("/pane/{d}/body", .{n}), std.mem.asBytes(&@as([100][4]u8, @splat("row\n".*))));
                    break :made n;
                },
            };
            const n = t.ids[which];
            try s.write(s.at("/pane/{d}/addr", .{n}), s.at("{d}\n", .{1 + 40 * seen[which]}));
            try s.write(s.at("/pane/{d}/ctl", .{n}), "dot=addr\n");
            try s.write("/focus", s.at("{d}\n", .{n}));
            seen[which] += 1;
        }
        try s.write(s.at("/pane/{d}/ctl", .{shell}), "delete\n");
        return t;
    }

    /// Where the keyboard is: its pane's letter and the dot's line, `A50`.
    fn here(t: *Jumps) ![]const u8 {
        const s = &t.s;
        const n = try s.focused();
        const at, _ = try s.range(s.at("/pane/{d}/dot", .{n}));
        const body = try s.read(s.at("/pane/{d}/body", .{n}));
        const which = std.mem.indexOfScalar(u32, &t.ids, n).?;
        return s.at("{c}{d}", .{ letters[which], std.mem.count(u8, body[0..at], "\n") + 1 });
    }

    const Way = enum { key, leader, builtin };

    /// Steps back or on until the list ends that way, as it says; the
    /// places landed on, "A50 A10 B10".
    fn walk(t: *Jumps, way: Way, back: bool) ![]const u8 {
        const s = &t.s;
        var out: []const u8 = "";
        for (0..64) |_| {
            const before = try t.here();
            switch (way) {
                .key => try s.keys(if (back) "\x0f" else "\u{F017}i"),
                .leader => try s.keys(if (back) " jo" else " ji"),
                .builtin => try s.write("/exec", if (back) "Back\n" else "Forward\n"),
            }
            const now = try t.here();
            if (std.mem.eql(u8, before, now)) break;
            out = if (out.len == 0) now else s.at("{s} {s}", .{ out, now });
        } else return error.NoEnd;
        try std.testing.expect(std.mem.indexOf(u8, try s.screen(), if (back) "nothing further back" else "nothing further on") != null);
        return out;
    }
};

test "modes: Ctrl-o keeps to the focused file, A41 then A1, and leaves it only once it runs out that way; Ctrl-i mirrors it" {
    var t = try Jumps.init("BABABA");
    defer t.s.deinit();
    // B81, B41 passed over, kept in their places: A has nothing older than
    // A1, so the step after it is the nearest place of any file, B1.
    try std.testing.expectEqualStrings("A41 A1 B1", try t.walk(.key, true));
    // Forward is the mirror, from B1 in B: B's own places first, then A81,
    // the newest, where the Backs started.
    try std.testing.expectEqualStrings("B41 B81 A81", try t.walk(.key, false));
}

test "modes: Ctrl-i retraces a run of Ctrl-o inside one file step for step, back to where it began" {
    var t = try Jumps.init("ABABA");
    defer t.s.deinit();
    // A1 B1 A41 B41 A81 from A81: nothing older than A1 at all.
    try std.testing.expectEqualStrings("A41 A1", try t.walk(.key, true));
    try std.testing.expectEqualStrings("A41 A81", try t.walk(.key, false));
    // One back, one on: the same place, whichever were passed over.
    try t.s.keys("\x0f");
    try std.testing.expectEqualStrings("A41", try t.here());
    try t.s.keys("\u{F017}i");
    try std.testing.expectEqualStrings("A81", try t.here());
    // And the steps made no places of their own.
    try std.testing.expectEqualStrings("A41 A1", try t.walk(.key, true));
}

test "modes: from a pane with no file, Ctrl-o and Ctrl-i step through every place" {
    var t = try Jumps.init("OAOBO");
    defer t.s.deinit();
    // O81 keeps to nothing: B1, the next older of all. From B, nothing of
    // B is older, so O41; from O, A1; from A, O1.
    try std.testing.expectEqualStrings("B1 O41 A1 O1", try t.walk(.key, true));
    try std.testing.expectEqualStrings("A1 O41 B1 O81", try t.walk(.key, false));
}

test "modes: Ctrl-o in a file shown in two panes keeps to its own pane first, then the file in the other" {
    // C is A's file in a second pane: C1 B1 A1 C41 A41.
    var t = try Jumps.init("CBACA");
    defer t.s.deinit();
    // From A41: A1 in this pane, over the nearer C41; then none of A's own
    // is older, so the file's in C, C1, over B1.
    try std.testing.expectEqualStrings("A1 C1", try t.walk(.key, true));
    // From C1 in C: C41, its own, then the file's newest, A41.
    try std.testing.expectEqualStrings("C41 A41", try t.walk(.key, false));
}

test "modes: Back and Forward take the same steps from Ctrl-o and Ctrl-i, SPC j o and SPC j i, and the builtins" {
    for ([_]Jumps.Way{ .key, .leader, .builtin }) |way| {
        var t = try Jumps.init("BABABA");
        defer t.s.deinit();
        try std.testing.expectEqualStrings("A41 A1 B1", try t.walk(way, true));
        try std.testing.expectEqualStrings("B41 B81 A81", try t.walk(way, false));
    }
}

test "modes: Ctrl-o and Ctrl-i drop the selections, select mode and the extra cursors, and land where the place was left" {
    const rows = std.mem.asBytes(&@as([97][4]u8, @splat("row\n".*)));
    var s = try Session.initFile(std.testing.allocator, "alpha beta\ngamma delta\nepsilon zeta\n" ++ rows);
    defer s.deinit();
    const n = try s.focused();
    const dot = s.at("/pane/{d}/dot", .{n});
    // A place on line 3, at its eighth column (byte 30), then line 60.
    try s.write(s.at("/pane/{d}/addr", .{n}), "#30\n");
    try s.write(s.at("/pane/{d}/ctl", .{n}), "dot=addr\n");
    try s.keys("60G");
    // Each step lands on the cursor the place was left with.
    var back_to: u32 = 30;
    for ([_][]const u8{ "\x0f", "\u{F017}i" }) |key| {
        // A line selected, a second cursor under it, select mode on.
        try s.keys("xCv");
        try std.testing.expectEqualStrings("select", try mode(&s, n));
        const leaving = (try s.range(dot))[1] - 1; // the cursor: its last character
        try s.keys(key);
        try std.testing.expectEqualStrings("normal", try mode(&s, n));
        try std.testing.expectEqual(back_to, (try s.range(dot))[0]);
        back_to = leaving;
        try s.expect(s.at("/pane/{d}/sel", .{n}), "");
        // One cursor: a Z typed goes in once.
        try s.keys("iZ\x1b");
        try expectEqual(@as(usize, 1), std.mem.count(u8, try s.read(s.at("/pane/{d}/body", .{n})), "Z"));
        try s.keys("u");
    }
    // No place further on: said, and the selection left as it was.
    try s.keys("x");
    const sel = try s.read(s.at("/pane/{d}/sel", .{n}));
    try s.keys("\u{F017}i");
    try std.testing.expect(std.mem.indexOf(u8, try s.screen(), "nothing further on") != null);
    try s.expect(s.at("/pane/{d}/sel", .{n}), sel);
}

test "modes: hopping between two panes by Esc, window mode or a click makes no places, so one Ctrl-o goes back across and the next has nowhere to go" {
    var s = try Session.initFile(std.testing.allocator, std.mem.asBytes(&@as([100][4]u8, @splat("row\n".*))));
    defer s.deinit();
    const doc = try s.focused();
    try s.keys("\u{F015}n"); // a shell under the doc
    const shell = try s.focused();
    if (std.mem.indexOf(u8, try s.read(s.at("/pane/{d}/ctl", .{shell})), "mode:tty") != null) try s.keys("\x02");
    for (0..8) |_| {
        const was = try s.focused();
        try s.keys("\x1b");
        try expectEqual(if (was == doc) shell else doc, try s.focused());
    }
    for (0..8) |_| {
        const want = if (try s.focused() == doc) shell else doc;
        try s.keys(if (want == shell) " wj\n" else " wk\n");
        try expectEqual(want, try s.focused());
    }
    const doc_row = (try s.where("row"))[1];
    const shell_row = (try s.where("Term Save Mode"))[1] + 1;
    for (0..8) |_| {
        const other = if (try s.focused() == doc) shell else doc;
        const row = if (other == doc) doc_row else shell_row;
        try s.write("/mousein", s.at("m 10 {d} 1\nm 10 {d} 0\n", .{ row, row }));
        try expectEqual(other, try s.focused());
    }
    const before = try s.focused();
    try s.keys("\x0f");
    try std.testing.expect(before != try s.focused());
    const after = try s.focused();
    try s.keys("\x0f");
    try expectEqual(after, try s.focused());
    try std.testing.expect(std.mem.indexOf(u8, try s.screen(), "nothing further back") != null);
}