assertThat(chain.connectTimeoutMillis()).isEqualTo(100)
        chain.proceed(chain.request())
      }
    client =
      client
        .newBuilder()
        .connectTimeout(Duration.ofSeconds(5))
        .addInterceptor(interceptor1)
        .addInterceptor(interceptor2)
        .build()
    val request1 =
      Request
        .Builder()
        .url("http://" + TestUtil.UNREACHABLE_ADDRESS_IPV4)

    builder = builder.callTimeout(Duration.ofSeconds(0L))
    builder = builder.connectTimeout(0L, TimeUnit.SECONDS)
    builder = builder.connectTimeout(Duration.ofSeconds(0L))
    builder = builder.readTimeout(0L, TimeUnit.SECONDS)
    builder = builder.readTimeout(Duration.ofSeconds(0L))
    builder = builder.writeTimeout(0L, TimeUnit.SECONDS)
    builder = builder.writeTimeout(Duration.ofSeconds(0L))

  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  public void testSuppliersNullChecks() throws Exception {
    new ClassSanityTester()
        .setDefault(Duration.class, Duration.ofSeconds(1))
        .forAllPublicStaticMethods(Suppliers.class)
        .testNulls();
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection

      client
        .newBuilder()
        .build()
        .routeDatabase,
    )
    assertSame(
      client.routeDatabase,
      client
        .newBuilder()
        .callTimeout(Duration.ofSeconds(5))
        .build()
        .routeDatabase,
    )

    // logically different scope of client for route db
    assertNotSame(
      client.routeDatabase,
      client
        .newBuilder()

  public void testTimeToLive_negative_duration() {
    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder();
    assertThrows(
        IllegalArgumentException.class, () -> builder.expireAfterWrite(Duration.ofSeconds(-1)));
  }

  @SuppressWarnings("ReturnValueIgnored")
  public void testTimeToLive_small() {
    CacheBuilder.newBuilder().expireAfterWrite(1, NANOSECONDS).build(identityLoader());
    // well, it didn't blow up.

  public void testTimeToLive_negative_duration() {
    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder();
    assertThrows(
        IllegalArgumentException.class, () -> builder.expireAfterWrite(Duration.ofSeconds(-1)));
  }

  @SuppressWarnings("ReturnValueIgnored")
  public void testTimeToLive_small() {
    CacheBuilder.newBuilder().expireAfterWrite(1, NANOSECONDS).build(identityLoader());
    // well, it didn't blow up.

    server.enqueue(MockResponse.Builder().onResponseStart(Stall).build())
    server.enqueue(MockResponse(body = "A"))
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofSeconds(1))
        .build()

    // Make a call expecting a timeout reading the response headers.
    val call1 = client.newCall(Request(server.url("/")))
    assertFailsWith<SocketTimeoutException> {

    ExecutorService executor = newFixedThreadPool(1);
    requestInterruptIn(500);
    executor.execute(new SleepTask(10000));
    executor.shutdown();
    assertFalse(awaitTerminationUninterruptibly(executor, Duration.ofSeconds(1)));
    assertFalse(executor.isTerminated());
    assertInterrupted();
  }

  public void testTryAwaitTerminationUninterruptiblyLongTimeUnit_success() {
    ExecutorService executor = newFixedThreadPool(1);

        .throttleBody(1, 750, TimeUnit.MILLISECONDS)
        .build(),
    )

    // First request: time out after 1s.
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofSeconds(1))
        .build()
    executeSynchronously("/a").assertBody("abc")

    // Second request: time out after 250ms.
    client =
      client
        .newBuilder()