ListenableScheduledFuture<?> future = executorService.schedule(command, Duration.ofSeconds(12));

    assertThat(future.get()).isEqualTo("schedule");
    assertThat(recordedCommand).isSameInstanceAs(command);
    assertThat(recordedTimeUnit).isEqualTo(TimeUnit.NANOSECONDS);
    assertThat(Duration.ofNanos(recordedDelay)).isEqualTo(Duration.ofSeconds(12));
  }

  public void testScheduleCallable() throws Exception {

    String result = executorService.invokeAny(tasks, Duration.ofSeconds(7));

    assertThat(result).isEqualTo("invokeAny");
    assertThat(recordedTasks).isSameInstanceAs(tasks);
    assertThat(recordedTimeUnit).isEqualTo(NANOSECONDS);
    assertThat(Duration.ofNanos(recordedTimeout)).isEqualTo(Duration.ofSeconds(7));
  }

  public void testInvokeAll() throws Exception {

    CacheBuilder<Object, Object> builder =
        CacheBuilder.newBuilder().expireAfterWrite(java.time.Duration.ofSeconds(3600));
    assertThrows(
        IllegalStateException.class,
        () -> builder.expireAfterWrite(java.time.Duration.ofSeconds(3600)));
  }

  public void testTimeToIdle_negative() {
    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder();
    try {

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

        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)

  @SuppressWarnings("Java7ApiChecker") // includes test of Java 8+ API
  public void testSuppliersNullChecks() throws Exception {
    new ClassSanityTester()
        .setDefault(Duration.class, Duration.ofSeconds(1))
        .forAllPublicStaticMethods(Suppliers.class)
        .testNulls();
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection

  @SuppressWarnings("Java7ApiChecker") // includes test of Java 8+ API
  public void testSuppliersNullChecks() throws Exception {
    new ClassSanityTester()
        .setDefault(Duration.class, Duration.ofSeconds(1))
        .forAllPublicStaticMethods(Suppliers.class)
        .testNulls();
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection

      client.routeDatabase,
      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()

                enabled = true
                project.maxTestDistributionPartitionSecond?.apply {
                    preferredMaxDuration = Duration.ofSeconds(this)
                }
                distribution.maxRemoteExecutors = if (project.isPerformanceProject()) 0 else project.maxTestDistributionRemoteExecutors

  ) {
    setUp(protocol, mockWebServer)
    server.enqueue(MockResponse(socketPolicy = NoResponse))
    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> {