private val serverListener = WebSocketRecorder("server")
  private val random = Random(0)
  private var client =
    clientTestRule
      .newClientBuilder()
      .writeTimeout(Duration.ofMillis(500))
      .readTimeout(Duration.ofMillis(500))
      .addInterceptor(
        Interceptor { chain: Interceptor.Chain ->
          val response = chain.proceed(chain.request())

    CountingSupplier countingSupplier = new CountingSupplier();

    Supplier<Integer> memoizedSupplier =
        Suppliers.memoizeWithExpiration(countingSupplier, Duration.ofMillis(75));

    checkExpiration(countingSupplier, memoizedSupplier);
  }

  @SuppressWarnings("DoNotCall")
  public void testMemoizeWithExpiration_longTimeUnitNegative() throws InterruptedException {

    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .build()
    val timeoutClient =
      client
        .newBuilder()
        .callTimeout(Duration.ofMillis(456))
        .build()
    val call = timeoutClient.newCall(request)
    assertThat(call.timeout().timeoutNanos())
      .isEqualTo(TimeUnit.MILLISECONDS.toNanos(456))
  }

  @Test
  fun timeoutWritingRequest() {

      MockResponse
        .Builder()
        .headersDelay(2, TimeUnit.SECONDS)
        .build(),
    )
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofMillis(250))
        .build()
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server!!.url("/"))
          .build(),
      )
    assertFailsWith<IOException> {

    ImmutableMap<Service, Duration> startupTimes = serviceManager.startupDurations();
    assertThat(startupTimes).hasSize(2);
    assertThat(startupTimes.get(a)).isAtLeast(Duration.ofMillis(150));
    assertThat(startupTimes.get(b)).isAtLeast(Duration.ofMillis(353));
  }

  public void testServiceStartupTimes_selfStartingServices() {
    // This tests to ensure that:

        .Builder()
        .body("Result")
        .build(),
    )
    val proxiedClient =
      OkHttpClient
        .Builder()
        .proxy(server.proxyAddress)
        .readTimeout(Duration.ofMillis(100))
        .build()
    val request = Request.Builder().url("http://android.com/").build()
    proxiedClient.newCall(request).execute().use { response ->
      assertThat(response.body.string()).isEqualTo("Result")

    }
    if (isLongTimeUnitBased(method)) {
      arguments.add(timeout.millis);
      arguments.add(TimeUnit.MILLISECONDS);
    }
    if (isDurationBased(method)) {
      arguments.add(Duration.ofMillis(timeout.millis));
    }
    try {
      Object result;
      doingCallLatch.countDown();
      try {
        result = method.invoke(monitor, arguments.toArray());
      } finally {

  @IgnoreJRERequirement
  public ImmutableMap<Service, Duration> startupDurations() {
    return ImmutableMap.copyOf(
        Maps.<Service, Long, Duration>transformValues(startupTimes(), Duration::ofMillis));
  }

  @Override
  public String toString() {
    return MoreObjects.toStringHelper(ServiceManager.class)
        .add("services", Collections2.filter(services, not(instanceOf(NoOpService.class))))

    ExecutorService executor = newFixedThreadPool(1);
    requestInterruptIn(500);
    executor.execute(new SleepTask(1000));
    executor.shutdown();
    assertTrue(awaitTerminationUninterruptibly(executor, Duration.ofMillis(LONG_DELAY_MS)));
    assertTrue(executor.isTerminated());
    assertInterrupted();
  }

  public void testTryAwaitTerminationUninterruptiblyDuration_failure() {

            }
            ftpClient.setAutodetectUTF8(autodetectEncoding);
            ftpClient.setConnectTimeout(connectTimeout);
            ftpClient.setDataTimeout(Duration.ofMillis(dataTimeout));
            ftpClient.setControlEncoding(controlEncoding);
            ftpClient.setBufferSize(bufferSize);
            if (passiveNatWorkaround) {