Pin the quarantine test on the rename failure

testQuarantineRenameFailurePreservesOriginalSlot counted the slot's .sfa
files BEFORE build(), then asserted the count was unchanged after the
failed rename. Recovery legitimately unlinks an empty never-rotated
hot-spare on the way in (SegmentRing drops a recovered segment whose
frameCount() is 0 with no torn tail), and whether SegmentManager had
provisioned one by then is a race -- so the assertion measured that race
rather than the rename. It failed 3 of 3 standalone runs, and inverted
(2 vs 3) under load.

Snapshot inside the quarantineAfterCloseHook instead: after the engine
closed, before the rename. That is exactly what "a failed rename
preserves the slot" means, and it is immune to the hot-spare race because
both counts observe the post-recovery state. Assert the snapshot is
non-zero as well, so the equality cannot pass vacuously on an empty slot.

The product was never at fault: the reclaimed segment holds no frames, and
close() unlinks nothing -- instrumenting quarantineTornSlot shows the same
segments before and after it. Mutating that method to delete a segment
during the failed rename still fails the test (expected 2, was 1), so it
continues to catch real destruction.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: glasstiger

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/DeltaDictRecoveryTest.java

@@ -471,7 +471,16 @@ public void testQuarantineRenameFailurePreservesOriginalSlot() throws Exception
         assertMemoryLeak(() -> {
             writeAndTearUnreplayableSlot();
             java.nio.file.Path slot = Paths.get(sfDir, "default");
-            int segmentCount = countSegmentFiles(slot);
+            // Snapshot when quarantine STARTS (after the engine closed, before the
+            // rename), not before build(). Recovery legitimately unlinks an empty
+            // never-rotated hot-spare on the way in (SegmentRing: frameCount()==0 and
+            // no torn tail), and whether SegmentManager provisioned one is a race --
+            // so a pre-build count measures that race, not this test's subject. What
+            // the rename failure must preserve is whatever the slot holds at the
+            // moment quarantine begins.
+            AtomicInteger atQuarantineStart = new AtomicInteger(-1);
+            Sender.LineSenderBuilder.setQuarantineAfterCloseHookForTest(
+                    () -> atQuarantineStart.set(countSegmentFiles(slot)));
             Sender.LineSenderBuilder.setQuarantineFilesFacadeForTest(new DelegatingFilesFacade() {
                 @Override
                 public int rename(String oldPath, String newPath) {
@@ -503,11 +512,16 @@ public int rename(String oldPath, String newPath) {
                 }
             } finally {
                 Sender.LineSenderBuilder.setQuarantineFilesFacadeForTest(null);
+                Sender.LineSenderBuilder.setQuarantineAfterCloseHookForTest(null);
             }
             Assert.assertTrue("rename failure must preserve the original slot directory",
                     java.nio.file.Files.isDirectory(slot));
+            // Guards the equality below against passing vacuously on an empty slot:
+            // 0 == 0 would "preserve every segment" while holding nothing.
+            Assert.assertTrue("quarantine must have started with data-bearing segments, saw: "
+                    + atQuarantineStart.get(), atQuarantineStart.get() > 0);
             Assert.assertEquals("rename failure must preserve every segment",
-                    segmentCount, countSegmentFiles(slot));
+                    atQuarantineStart.get(), countSegmentFiles(slot));
             Assert.assertFalse("failed rename must not leave a quarantine directory",
                     java.nio.file.Files.exists(Paths.get(sfDir, "default.unreplayable-0")));
         });