webSocket.close(1000, reason)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("reason.size() > 123: $reason")
    }
    webSocket.close(1000, null)
    serverListener.assertClosing(1000, "")
    server.close(1000, null)
    clientListener.assertClosing(1000, "")
    clientListener.assertClosed(1000, "")
    serverListener.assertClosed(1000, "")
  }

  @Test

        assertTrue(entry.hasChanges());
        assertTrue(entry.getChildren().isEmpty());
    }

    @Test
    public void testExpiration() {
        // Set a very short max age
        entry.setMaxAge(100); // 100ms

        assertFalse(entry.isExpired());
        assertFalse(entry.needsRefresh());

        // Wait for expiration
        try {
            Thread.sleep(150);

    server.webSocket!!.close(1000, "Hello!")
    client.processNextFrame()
    client.listener.assertClosing(1000, "Hello!")
    assertThat(client.webSocket!!.close(1000, "Bye!")).isTrue()
    client.webSocket!!.finishReader()
    taskFaker.runTasks()
    client.listener.assertClosed(1000, "Hello!")
    server.processNextFrame()
    server.listener.assertClosing(1000, "Bye!")
    server.webSocket!!.finishReader()

        thread.start();
        thread.join(1000);

        String output = thread.getOutput();
        String[] lines = output.split("\n");

        assertTrue("Buffer should be limited to 10 items", lines.length <= 10);
        assertTrue("Last lines should be kept", output.contains("line15"));
    }

    public void test_run_maxBufferSizeConstant() {
        assertEquals(1000, InputStreamThread.MAX_BUFFER_SIZE);
    }

    assertEquals("0.000 ns", stopwatch.toString());
    ticker.advance(1);
    assertEquals("1.000 ns", stopwatch.toString());
    ticker.advance(998);
    assertEquals("999.0 ns", stopwatch.toString());
    ticker.advance(1);
    assertEquals("1.000 \u03bcs", stopwatch.toString());
    ticker.advance(1);
    assertEquals("1.001 \u03bcs", stopwatch.toString());
    ticker.advance(8998);

        searchRenderData.setAllRecordCount(0L);
        assertEquals(0L, searchRenderData.getAllRecordCount());

        // Test with positive values
        searchRenderData.setAllRecordCount(100L);
        assertEquals(100L, searchRenderData.getAllRecordCount());

        searchRenderData.setAllRecordCount(Long.MAX_VALUE);
        assertEquals(Long.MAX_VALUE, searchRenderData.getAllRecordCount());

    public void testReconnectExpiredHandle() throws Exception {
        // Create an expired handle
        HandleInfo expiredHandle = new HandleInfo("/test/file.txt", new HandleGuid(), new byte[16], HandleType.DURABLE_V2, 100, // 100ms timeout
                null);

        // Wait for expiration
        Thread.sleep(150);

        public Integer getSuggestUpdateRequestIntervalAsInteger() {
            return 1000;
        }

        @Override
        public Integer getSuggestUpdateDocPerRequestAsInteger() {
            return 100;
        }

        @Override
        public Integer getSuggestSourceReaderScrollSizeAsInteger() {
            return 1000;
        }

        @Override

        assertTrue("Test should complete quickly (duration: " + duration + "ms)", duration < 1000);
    }

    // Fast mock implementations to minimize overhead

    private static class FastMockIndexUpdateCallback implements IndexUpdateCallback {
        @Override
        public long getExecuteTime() {
            return 100L;
        }

        @Override
        public long getDocumentSize() {

            // Test common file system sizes
            long[] typicalSizes = { 1024L * 1024L * 1024L, // 1 GB
                    1024L * 1024L * 1024L * 10L, // 10 GB
                    1024L * 1024L * 1024L * 100L, // 100 GB
                    1024L * 1024L * 1024L * 1024L, // 1 TB
                    1024L * 1024L * 1024L * 1024L * 10L // 10 TB
            };

            for (long size : typicalSizes) {