Add test verifying global auto-flush accumulation across tables

The test covers the scenario where rows are written to multiple tables
interleaved (t1, t2, t1, t2, ...) to confirm that auto-flush counts
rows globally rather than per-table. A bug was reported where auto-flush
seemed to trigger on each table switch instead of accumulating the
configured total number of rows.

The new test (testAutoFlushAccumulatesRowsAcrossAllTables) uses
autoFlushRows=5 with bytes and interval checks disabled, writes 4
interleaved rows across two tables, and asserts:
- No flush happens on any of the 4 rows (including table switches)
- pendingRowCount reflects the total across all tables
- The 5th row triggers the flush by hitting the global row threshold

The test confirms the code is correct: QwpWebSocketSender accumulates
rows globally via pendingRowCount and shouldAutoFlush() checks that
counter against autoFlushRows, with no flush logic in table().

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: mtopolnik

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

@@ -41,10 +41,59 @@
  *   <li>{@code reset()} discards all pending state, not just the current table buffer.</li>
  *   <li>Cached timestamp column references are invalidated during flush operations,
  *       preventing stale writes through freed {@code ColumnBuffer} instances.</li>
+ *   <li>Auto-flush accumulates rows globally across all tables rather than flushing
+ *       per-table on each table switch.</li>
  * </ul>
  */
 public class QwpWebSocketSenderStateTest extends AbstractTest {
 
+    @Test
+    public void testAutoFlushAccumulatesRowsAcrossAllTables() throws Exception {
+        assertMemoryLeak(() -> {
+            // autoFlushRows=5; bytes and interval are disabled to isolate the row-count check.
+            // The test verifies that switching tables does NOT trigger a flush — flush fires
+            // only when the TOTAL pending-row count reaches the configured threshold.
+            QwpWebSocketSender sender = QwpWebSocketSender.createForTesting(
+                    "localhost", 0, 5, 0, 0L, 1
+            );
+            try {
+                setField(sender, "connected", true);
+                setField(sender, "inFlightWindow", new InFlightWindow(1, InFlightWindow.DEFAULT_TIMEOUT_MS));
+
+                // Write 4 rows interleaved between t1 and t2.
+                // None of these should trigger auto-flush (4 < 5 = autoFlushRows).
+                sender.table("t1").longColumn("x", 1).at(1, ChronoUnit.MICROS);
+                sender.table("t2").longColumn("y", 1).at(1, ChronoUnit.MICROS);
+                sender.table("t1").longColumn("x", 2).at(2, ChronoUnit.MICROS);
+                sender.table("t2").longColumn("y", 2).at(2, ChronoUnit.MICROS);
+
+                // All 4 rows must still be buffered — switching tables must not flush.
+                QwpTableBuffer t1 = sender.getTableBuffer("t1");
+                QwpTableBuffer t2 = sender.getTableBuffer("t2");
+                Assert.assertEquals("t1 should have 2 buffered rows (no premature flush)",
+                        2, t1.getRowCount());
+                Assert.assertEquals("t2 should have 2 buffered rows (no premature flush)",
+                        2, t2.getRowCount());
+                Assert.assertEquals("pendingRowCount must reflect all 4 rows across both tables",
+                        4, sender.getPendingRowCount());
+
+                // The 5th row hits the global threshold and triggers auto-flush.
+                // The flush fails because client is null, confirming that flush
+                // was triggered by the row-count threshold, not by the table switch.
+                boolean flushTriggered = false;
+                try {
+                    sender.table("t1").longColumn("x", 3).at(3, ChronoUnit.MICROS);
+                } catch (Exception expected) {
+                    flushTriggered = true;
+                }
+                Assert.assertTrue("auto-flush must be triggered on the 5th row", flushTriggered);
+            } finally {
+                setField(sender, "connected", false);
+                sender.close();
+            }
+        });
+    }
+
     @Test
     public void testCachedTimestampColumnInvalidatedDuringFlush() throws Exception {
         assertMemoryLeak(() -> {