}
      };

  @BeforeExperiment
  void setUp() throws Exception {
    executorService =
        new ThreadPoolExecutor(
            NUM_THREADS,
            NUM_THREADS,
            Long.MAX_VALUE,
            SECONDS,
            new ArrayBlockingQueue<Runnable>(1000));
    executorService.prestartAllCoreThreads();
    AtomicInteger integer = new AtomicInteger();

  @StartStop
  private val server = MockWebServer()

  private var client =
    clientTestRule
      .newClientBuilder()
      .cache(Cache(fileSystem, "/cache/".toPath(), Long.MAX_VALUE))
      .build()

  @Test
  fun trailersHttp1() {
    trailers(Protocol.HTTP_1_1)
  }

  @Test
  fun trailersHttp2() {
    trailers(Protocol.HTTP_2)
  }

        new Function<Supplier<Boolean>, Supplier<Boolean>>() {
          @Override
          public Supplier<Boolean> apply(Supplier<Boolean> supplier) {
            return Suppliers.memoizeWithExpiration(supplier, Long.MAX_VALUE, NANOSECONDS);
          }
        };
    testSupplierThreadSafe(memoizer);
  }

  @J2ktIncompatible
  @GwtIncompatible // Thread
  public void testMemoizedSupplierThreadSafe() throws Throwable {

  private inline fun <T : Any> ResponseBody.consumeSource(
    consumer: (BufferedSource) -> T,
    sizeMapper: (T) -> Int,
  ): T {
    val contentLength = contentLength()
    if (contentLength > Int.MAX_VALUE) {
      throw IOException("Cannot buffer entire body for content length: $contentLength")
    }

    val bytes = source().use(consumer)
    val size = sizeMapper(bytes)

    val contentLength = response.headersContentLength()
    if (contentLength == -1L) return
    val body = newFixedLengthSource(response.request.url, contentLength)
    body.skipAll(Int.MAX_VALUE, MILLISECONDS)
    body.close()
  }

  /** An HTTP request body. */
  private inner class KnownLengthSink : Sink {
    private val timeout = ForwardingTimeout(socket.sink.timeout())

        }
    }

    @Nested
    @DisplayName("Test Implementation Tests")
    class TestImplementationTests {

        @ParameterizedTest
        @ValueSource(bytes = { -1, 0, 1, 3, 7, Byte.MAX_VALUE, Byte.MIN_VALUE })
        @DisplayName("Should handle various information class values")
        void testVariousInformationClassValues(byte classValue) {

     */
    @Test
    public void testSecurityBufferIntegerOverflow() {
        byte[] buffer = createBasicNegotiateResponseBuffer();

        // Set security buffer offset close to Integer.MAX_VALUE to test overflow protection
        SMBUtil.writeInt2(32767, buffer, 56); // Large offset (will be added to header start)
        SMBUtil.writeInt2(1000, buffer, 58); // Some length

        int result = SMBUtil.readInt4(buffer, 0);
        assertEquals((int) (input & 0xFFFFFFFFL), result);
    }

    @ParameterizedTest
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 0x123456789ABCDEF0L })
    void testWriteReadInt8RoundTrip(long input) {
        byte[] buffer = new byte[8];
        SMBUtil.writeInt8(input, buffer, 0);
        long result = SMBUtil.readInt8(buffer, 0);

        // Assert
        assertNotNull(transPeekNamedPipe);
        assertNull(transPeekNamedPipe.name);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, -1, Integer.MAX_VALUE, Integer.MIN_VALUE, 0xFFFF })
    @DisplayName("Constructor should handle various FID values")
    void testConstructorWithVariousFids(int fid) {
        // Act

  }

  @Test
  fun authenticator() {
    var authenticator: Authenticator = Authenticator { route, response -> TODO() }
  }

  @Test
  fun cache() {
    val cache = Cache(File("/cache/"), Integer.MAX_VALUE.toLong())
    cache.initialize()
    cache.delete()
    cache.evictAll()
    val urls: MutableIterator<String> = cache.urls()
    val writeAbortCount: Int = cache.writeAbortCount()