test(qwp): assert slot distinctness, not wrapper identity, in pool borrow tests

SenderPool.borrow() allocates a fresh PooledSender wrapper on every call,
so assertNotSame on the wrappers is unconditionally true and proves
nothing -- it stays green even if the pool double-lends a single slot to
concurrent borrowers. Commits d6bdbdf and e77b4fc fixed this exact
pattern in testBrokenSenderIsNotReturnedToPool and
SenderPoolErrorSafetyTest via slotOf(); two more instances remained.

SenderPoolTest.testPoolBuildsRequestedNumberOfSenders: compare the
underlying slots pairwise via slotOf() and assert totalSize() == 3, so
the test actually verifies what its name claims -- three concurrent
borrowers each hold their own sender.

SenderPoolSfTest.testTwoConcurrentSfSendersGetDistinctSlots: the slot-dir
assertions prove the pool created two slots on disk, but not that the two
borrowed handles wrap different ones; replace the vacuous wrapper
comparison with slotOf() distinctness (helper added, mirroring
SenderPoolTest and SenderPoolErrorSafetyTest).

QueryImplResetTest's assertNotSame on leases is left as-is: it is an
intentional contract pin (fresh lease wrapper per borrow) paired with the
load-bearing assertSame on the shared QueryImpl.

Author: bluestreak01

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

@@ -108,7 +108,12 @@ public void testTwoConcurrentSfSendersGetDistinctSlots() throws Exception {
                     PooledSender a = pool.borrow();
                     PooledSender b = pool.borrow();
                     try {
-                        Assert.assertNotSame("two borrows must be distinct wrappers", a, b);
+                        // borrow() allocates a fresh PooledSender wrapper on every
+                        // call, so comparing the wrappers is vacuously true.
+                        // Distinctness of the two borrowed senders lives in the
+                        // underlying slots (mirrors SenderPoolTest.slotOf usage).
+                        Assert.assertNotSame("two borrows must hold distinct slots",
+                                slotOf(a), slotOf(b));
                         Assert.assertTrue("slot default-0 must exist", Files.exists(slot("default-0")));
                         Assert.assertTrue("slot default-1 must exist", Files.exists(slot("default-1")));
                         Assert.assertEquals("exactly two slot dirs", 2, countSlotDirs());
@@ -1947,6 +1952,16 @@ private static Object getField(Object target, String name) throws Exception {
         return f.get(target);
     }
 
+    // Reads the package-private PooledSender.slot -- the identity that the pool
+    // actually recycles. Wrapper identity is useless for aliasing checks because
+    // borrow() allocates a fresh wrapper every call (mirrors SenderPoolTest and
+    // SenderPoolErrorSafetyTest).
+    private static Object slotOf(PooledSender pooledWrapper) throws Exception {
+        Field f = PooledSender.class.getDeclaredField("slot");
+        f.setAccessible(true);
+        return f.get(pooledWrapper);
+    }
+
     private static void invokeDiscardBroken(SenderPool pool, PooledSender ps) throws Exception {
         Method m = SenderPool.class.getDeclaredMethod("discardBroken", PooledSender.class);
         m.setAccessible(true);

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

@@ -196,14 +196,25 @@ public void testExhaustionTimeoutThrows() {
     }
 
     @Test
-    public void testPoolBuildsRequestedNumberOfSenders() {
+    public void testPoolBuildsRequestedNumberOfSenders() throws Exception {
         try (SenderPool pool = new SenderPool(DEAD_HTTP_CONFIG, 3, 3, 1_000, Long.MAX_VALUE, Long.MAX_VALUE)) {
             Sender a = pool.borrow();
             Sender b = pool.borrow();
             Sender c = pool.borrow();
-            Assert.assertNotSame(a, b);
-            Assert.assertNotSame(b, c);
-            Assert.assertNotSame(a, c);
+            // borrow() allocates a fresh PooledSender wrapper on every call, so
+            // comparing the wrappers is vacuously true -- it would stay green
+            // even if the pool double-lent a single slot to all three borrowers.
+            // The property this test exists for -- three concurrent borrowers
+            // each hold their own sender -- lives in the underlying slots, so
+            // compare those (same reasoning as testBrokenSenderIsNotReturnedToPool).
+            Object slotA = slotOf(a);
+            Object slotB = slotOf(b);
+            Object slotC = slotOf(c);
+            Assert.assertNotSame("a and b must not share a slot", slotA, slotB);
+            Assert.assertNotSame("b and c must not share a slot", slotB, slotC);
+            Assert.assertNotSame("a and c must not share a slot", slotA, slotC);
+            Assert.assertEquals("pool must build exactly the requested number of senders",
+                    3, pool.totalSize());
             a.close();
             b.close();
             c.close();