Fix vacuous broken-slot assertion in SenderPoolTest

testBrokenSenderIsNotReturnedToPool asserted assertNotSame(first,
second) on the two PooledSender wrappers. SenderPool.borrow() allocates
a fresh PooledSender on every call, so that comparison is unconditionally
true and proves nothing: it stays green whether or not the broken slot
was discarded. With the discard logic reverted the test failed only
incidentally, when second.close() re-threw on the recycled broken
delegate, masking the real intent.

Compare the underlying SenderSlot instead via the existing slotOf()
helper, mirroring testBorrowReturnRecyclesSameDecorator. The pool
recycles slots, not wrappers, so a broken slot leaking back to the next
borrower now surfaces as the same slot and fails the assertion directly.
The finally swallows the incidental close() exception so the assertion
result is what surfaces. Verified by injecting the bug (giveBack instead
of discardBroken on flush failure): the corrected assertion fails as a
clean Failure at the assertion line, and passes with correct code.

Also document the QueryWorker lost-dispatch coverage boundary in
QueryWorkerTest: the single-flight-reuse race fix has no deterministic
unit reproduction here because it needs the worker mid-runOn(client)
when the user thread re-dispatches, which requires a live query client.
That regression is guarded end-to-end by
QuestDBFacadeE2ETest.testSustainedMixedConcurrency in the parent repo;
testShutdownRacingDispatchMustNotStrandCaller covers only the adjacent
shutdown branch.

Author: bluestreak01

core/src/test/java/io/questdb/client/test/impl/QueryWorkerTest.java

@@ -39,6 +39,22 @@
 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;
 
+/**
+ * Unit tests for {@link QueryWorker}.
+ * <p>
+ * Coverage boundary: the lost-dispatch fix for the single-flight-reuse race
+ * (clearing {@code current} under {@code signalLock} at the moment of
+ * consumption rather than in a post-{@code runOn()} finally) has no
+ * deterministic unit reproduction here. Reproducing the clobber needs the
+ * worker to be mid-{@code runOn(client)} when the user thread re-dispatches on
+ * the same lease, which requires a live query client to drive
+ * {@code client.execute(...)} to its terminal callback. That regression is
+ * guarded end-to-end by {@code QuestDBFacadeE2ETest.testSustainedMixedConcurrency}
+ * in the parent questdb repo (more threads than pool slots, repeated
+ * submit/await per lease). {@link #testShutdownRacingDispatchMustNotStrandCaller()}
+ * below covers the adjacent but distinct shutdown-vs-dispatch branch only --
+ * reverting the lost-dispatch hunk would not fail it.
+ */
 public class QueryWorkerTest {
 
     /**

core/src/test/java/io/questdb/client/test/impl/SenderPoolTest.java

@@ -74,15 +74,16 @@ private static Object slotOf(Sender pooledWrapper) throws Exception {
     }
 
     @Test
-    public void testBrokenSenderIsNotReturnedToPool() {
+    public void testBrokenSenderIsNotReturnedToPool() throws Exception {
         // Borrowing, buffering a row, and then closing forces flush() against
-        // the unreachable address, which throws. The broken wrapper must not
-        // be returned to the pool: its delegate's buffer still holds the
-        // failed row, and on transports with terminal-failure semantics the
-        // delegate is also unusable. Either way, the next borrower must get
-        // a fresh wrapper.
+        // the unreachable address, which throws. The broken slot must not be
+        // returned to the pool: its delegate's buffer still holds the failed
+        // row, and on transports with terminal-failure semantics the delegate
+        // is also unusable. Either way, the next borrower must get a fresh
+        // slot, not the broken one.
         try (SenderPool pool = new SenderPool(DEAD_HTTP_CONFIG, 1, 1, 1_000, Long.MAX_VALUE, Long.MAX_VALUE)) {
             Sender first = pool.borrow();
+            Object firstSlot = slotOf(first);
             first.table("t").longColumn("v", 1).atNow();
             try {
                 first.close();
@@ -92,11 +93,23 @@ public void testBrokenSenderIsNotReturnedToPool() {
             }
             Sender second = pool.borrow();
             try {
-                Assert.assertNotSame("broken sender must not be handed back to next borrower",
-                        first, second);
+                // borrow() always hands out a FRESH PooledSender wrapper, so
+                // assertNotSame(first, second) on the wrappers is vacuously
+                // true and proves nothing -- it stays true whether or not the
+                // broken slot was discarded. What the pool recycles is the
+                // underlying slot, so a broken slot leaking back to the next
+                // borrower shows up as the SAME slot. Assert the slot differs.
+                Assert.assertNotSame("broken slot must not be handed back to next borrower",
+                        firstSlot, slotOf(second));
             } finally {
-                if (second != first) {
+                // On the failing path (broken slot recycled) second.close()
+                // re-throws, since its delegate's buffer still holds the
+                // failed row; swallow it so the assertion above is what
+                // surfaces rather than this incidental close() failure.
+                try {
                     second.close();
+                } catch (LineSenderException ignored) {
+                    // expected only when the regression is present
                 }
             }
         }