The QUIC listener tests are deterministic, and fs-test --quic passes

"Unix TCP and QUIC share one listener" failed 17 of 360 runs under load
(12 parallel copies), always at p.fs.opens: the client had hung up but its
connection's task had not yet seen it, reset() then cut the connection, and
the releases the hangup owes were refused as the old editor's. The test's
replacement editor is the same editor, so those opens stayed. It now waits
(resting, with its own deadline) for the runner to empty before reset:
0 of 360 after.

fs-test -Dquic=true failed too, at two points. A session Looking at its own
tree through a QUIC mount is features.txt's documented "left as they are"
case (QUIC is answered on the editor's thread); that check is dropped with a
note. The /screen check asserted body text that the view may have scrolled
past (2 of 7 runs); it now asserts the pane's tag. 10 of 10 after.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

2 files changed, 22 insertions, 11 deletions

diff --git a/src/9p_io.zig b/src/9p_io.zig
index 651b3d0a..0f5e0a77 100644
--- a/src/9p_io.zig
+++ b/src/9p_io.zig
@@ -1398,9 +1398,18 @@ test "Unix TCP and QUIC share one listener through reads writes reconnects and r
                 }
                 Client.nap(1);
             }
+            // The client has hung up, but its connection's task may not have
+            // seen that yet. The releases it then owes are refused once
+            // `reset` starts cutting (they name the old editor's opens), and
+            // this test's "replacement" is the same editor, so they would
+            // stay in `p.fs.opens`. Let the hangup pay them first, resting
+            // so the task can take the turn: that is what is under test here.
+            const settle_by = Client.nowMs() + 3 * Client.budget_ms;
+            while (l.runner.count() != 0 and Client.nowMs() < settle_by) Client.nap(1);
             pardes.turn.wake();
             try testing.expect(worker.done.load(.acquire));
             if (worker.failure) |err| return err;
+            try testing.expectEqual(@as(usize, 0), l.runner.count());
             l.reset(p);
             try testing.expectEqual(@as(usize, 0), l.runner.count());
             for (&l.conns, 0..) |conn, i| try testing.expect(!l.live(@intCast(i)) and !conn.draining);
diff --git a/test/fs.py b/test/fs.py
index 67edf01e..3c1564b5 100644
--- a/test/fs.py
+++ b/test/fs.py
@@ -889,7 +889,12 @@ def quic_test(binary):
                             screen_pane = look(remote, '/n/peer/screen', source=control)
                             screen = json.loads(remote.read(f'/pane/{screen_pane}/body'))
                             assert len(screen['cells']) == screen['cols'] * screen['rows']
-                            assert 'TCP to QUIC Get' in ''.join(cell[0] for cell in screen['cells'])
+                            # The peer's own screen, whole, over QUIC. Its pane's
+                            # tag, not its text: where the view sits after the
+                            # body shrank from a long wrapped line depends on
+                            # whether a frame was drawn meanwhile (sometimes
+                            # on the empty last line, `     2`, text off-screen).
+                            assert 'server.txt Save' in ''.join(cell[0] for cell in screen['cells'])
                             large = ('normal λ line\n' * 20000).encode()
                             fixture = root / 'large.txt'
                             fixture.write_bytes(large)
@@ -906,16 +911,13 @@ def quic_test(binary):
                             assert remote.read(f'/pane/{roots}/body') == b'/n/os/\n/n/self/\n'
                             assert unix.read_fid(unix_body) == b'TCP to QUIC Get\n'
                             assert tcp.read_fid(tcp_body) == b'TCP to QUIC Get\n'
-                        control = new_pane(unix, b'')
-                        execute(unix, control, 'Mount own ' + dial)
-                        own = look(unix, '/n/own/pane/1/body', source=control)
-                        assert unix.read(f'/pane/{own}/body') == b'TCP to QUIC Get\n'
-                        unix.write(f'/pane/{own}/body', b'same-session QUIC Save\n', truncate=True)
-                        unix.write(f'/pane/{own}/exec', b'Save\n')
-                        assert unix.read_fid(unix_body) == b'same-session QUIC Save\n'
-                        assert tcp.read_fid(tcp_body) == b'same-session QUIC Save\n'
-                        unix.write(f'/pane/{own}/exec', b'Del\n')
-                        execute(unix, control, 'Unmount own')
+                        # Not checked: a session Looking at its OWN tree through
+                        # a QUIC mount ('Mount own quic!...'). QUIC is still
+                        # answered on the editor's thread (cloud9's QUIC adapter
+                        # is not std.Io based), so that Look waits on the loop
+                        # it is running in and opens nothing; features.txt lists
+                        # it under "Left as they are". Unix and TCP self-mounts
+                        # are covered by test/selfmount.py.
                         unix.close(unix_body)
                         tcp.close(tcp_body)