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> {

        .build(),
    ) // Slow connection 1KiB/second.
    server.enqueue(
      MockResponse(body = body),
    )
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofMillis(500)) // Half a second to read something.
        .build()

    // Make a call expecting a timeout reading the response body.
    val call1 = client.newCall(Request(server.url("/")))
    val response1 = call1.execute()

    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:

      MockResponse
        .Builder()
        .headersDelay(2, TimeUnit.SECONDS)
        .build(),
    )
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofMillis(250))
        .build()
    val call =
      client.newCallWithListener(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )

        .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")

    server.enqueue(MockResponse(body = "success!"))
    client =
      client
        .newBuilder()
        .proxySelector(proxySelector)
        .readTimeout(Duration.ofMillis(100))
        .connectTimeout(Duration.ofMillis(100))
        .build()
    val request = Request.Builder().url("http://android.com/").build()
    executeSynchronously(request)
      .assertCode(200)
      .assertBody("success!")

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

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

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