.addInitialSettings("custom.key1", "value1")
                .addInitialSettings("custom.key2", 42)
                .scrollTimeout("100s")
                .searchTimeout("50s")
                .indexTimeout("200s")
                .bulkTimeout("300s")
                .indicesTimeout("150s")
                .clusterTimeout("250s");

        SuggestSettings settings = builder.build(client, id);

      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);

      Route(
        factory.newAddress(uriHost = "1.2.3.4", uriPort = 1003),
        Proxy.NO_PROXY,
        InetSocketAddress(ipv4Address, 1003),
      ).toString(),
    ).isEqualTo("1.2.3.4:1003")
    assertThat(
      Route(
        factory.newAddress(uriHost = "example.com", uriPort = 1003),
        Proxy.NO_PROXY,
        InetSocketAddress(ipv4Address, 1003),
      ).toString(),
    ).isEqualTo("example.com at 1.2.3.4:1003")

    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);
    }

    return ImmutableList.of(
        Striped.readWriteLock(100),
        Striped.readWriteLock(256),
        Striped.lock(100),
        Striped.lock(256),
        Striped.custom(100, FAIR_LOCK_SUPPLER),
        Striped.custom(256, FAIR_LOCK_SUPPLER),
        Striped.semaphore(100, 1),
        Striped.semaphore(256, 1));
  }

    return ImmutableList.of(
        Striped.readWriteLock(100),
        Striped.readWriteLock(256),
        Striped.lock(100),
        Striped.lock(256),
        Striped.custom(100, FAIR_LOCK_SUPPLER),
        Striped.custom(256, FAIR_LOCK_SUPPLER),
        Striped.semaphore(100, 1),
        Striped.semaphore(256, 1));
  }

            byte[] buffer = new byte[256];

            // Encode multiple times
            for (int i = 0; i < 1000; i++) {
                int result = request.encode(buffer, 0);
                assertTrue(result > 0);
            }

            assertEquals(1000, request.getEncodeCallCount());
        }

        @Test
        @DisplayName("Should handle repeated size calls efficiently")

        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());