public void testParse_writeExpirationSeconds() {
    CacheBuilderSpec spec = parse("expireAfterWrite=10s");
    assertEquals(SECONDS, spec.writeExpirationTimeUnit);
    assertEquals(10L, spec.writeExpirationDuration);
    assertCacheBuilderEquivalence(
        CacheBuilder.newBuilder().expireAfterWrite(10L, SECONDS), CacheBuilder.from(spec));
  }

  public void testParse_writeExpirationRepeated() {
    assertThrows(

          t: Throwable,
          response: Response?,
        ) {
          t.printStackTrace(System.out)
          latch.countDown()
        }
      },
    )

    check(latch.await(30, TimeUnit.SECONDS)) { "Timed out waiting for test $number to finish." }
    val endNanos = System.nanoTime()
    val tookMs = TimeUnit.NANOSECONDS.toMillis(endNanos - startNanos.get())
    println("Took ${tookMs}ms")
  }

  }

  public void testTimeToLive_setTwice() {
    CacheBuilder<Object, Object> builder =
        CacheBuilder.newBuilder().expireAfterWrite(3600, SECONDS);
    assertThrows(IllegalStateException.class, () -> builder.expireAfterWrite(3600, SECONDS));
  }

  @GwtIncompatible // Duration
  public void testTimeToLive_setTwice_duration() {
    CacheBuilder<Object, Object> builder =

  @Test
  fun timeoutCall() {
    runTest {
      server.enqueue(
        MockResponse.Builder()
          .bodyDelay(5, TimeUnit.SECONDS)
          .body("abc")
          .build(),
      )

      val call = client.newCall(request)

      try {
        withTimeout(1.seconds) {
          call.executeAsync().use {
            withContext(Dispatchers.IO) {
              it.body.string()
            }

  public ConfigureTimeouts() throws Exception {
    client = new OkHttpClient.Builder()
        .connectTimeout(5, TimeUnit.SECONDS)
        .writeTimeout(5, TimeUnit.SECONDS)
        .readTimeout(5, TimeUnit.SECONDS)
        .callTimeout(10, TimeUnit.SECONDS)
        .build();
  }

  public void run() throws Exception {
    Request request = new Request.Builder()

    exec.execute(task);
    runLatch.await();
    taskLatch.countDown();

    ExecutionException e = assertThrows(ExecutionException.class, () -> task.get(5, SECONDS));
    assertEquals(IllegalStateException.class, e.getCause().getClass());

    assertTrue(listenerLatch.await(5, SECONDS));
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
  }

  public void testListenerCalledOnCancelFromNotRunning() throws Exception {

                              barrier.await(1, SECONDS);

                              // WAIT #2
                              barrier.await(1, SECONDS);
                              assertTrue(executor.isShutdown());
                              assertFalse(executor.isTerminated());

                              // WAIT #3
                              barrier.await(1, SECONDS);
                              return null;

    assertTrue(limiter.tryAcquire(0, SECONDS));
    assertFalse(limiter.tryAcquire(0, SECONDS));
    assertFalse(limiter.tryAcquire(0, SECONDS));
    stopwatch.sleepMillis(100);
    assertFalse(limiter.tryAcquire(0, SECONDS));
  }

  public void testTryAcquire_someWaitAllowed() {
    RateLimiter limiter = RateLimiter.create(5.0, stopwatch);
    assertTrue(limiter.tryAcquire(0, SECONDS));

    assertTrue(limiter.tryAcquire(0, SECONDS));
    assertFalse(limiter.tryAcquire(0, SECONDS));
    assertFalse(limiter.tryAcquire(0, SECONDS));
    stopwatch.sleepMillis(100);
    assertFalse(limiter.tryAcquire(0, SECONDS));
  }

  public void testTryAcquire_someWaitAllowed() {
    RateLimiter limiter = RateLimiter.create(5.0, stopwatch);
    assertTrue(limiter.tryAcquire(0, SECONDS));

    var throttleBytesPerPeriod: Long = mockResponse.throttleBytesPerPeriod
    throttleBytesPerPeriod = mockResponse.throttleBytesPerPeriod
    var throttlePeriod: Long = mockResponse.getThrottlePeriod(TimeUnit.SECONDS)
    mockResponse = mockResponse.setBodyDelay(0L, TimeUnit.SECONDS)
    val bodyDelay: Long = mockResponse.getBodyDelay(TimeUnit.SECONDS)