assertThat(cacheControl.toString()).isEqualTo("")
    assertThat(cacheControl.noCache).isFalse()
    assertThat(cacheControl.noStore).isFalse()
    assertThat(cacheControl.maxAgeSeconds).isEqualTo(-1)
    assertThat(cacheControl.sMaxAgeSeconds).isEqualTo(-1)
    assertThat(cacheControl.isPublic).isFalse()
    assertThat(cacheControl.mustRevalidate).isFalse()
    assertThat(cacheControl.maxStaleSeconds).isEqualTo(-1)

    assertThat(pool.connectionCount()).isEqualTo(1)
    assertThat(c1.socket().isClosed).isFalse()

    // Running at time 60, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(60L)).isEqualTo(90L)
    assertThat(pool.connectionCount()).isEqualTo(1)
    assertThat(c1.socket().isClosed).isFalse()

    // Running at time 149, the pool returns that nothing can be evicted until time 150.

    assertThat(retryTlsHandshake(exception)).isFalse()
  }

  @Test fun nonRetryableSSLHandshakeException() {
    val exception =
      SSLHandshakeException("Certificate handshake exception").apply {
        initCause(CertificateException())
      }
    assertThat(retryTlsHandshake(exception)).isFalse()
  }

  @Test fun retryableSSLHandshakeException() {

    if (e.connection != null) {
      assertThat(Thread.holdsLock(e.connection), "Called with lock $${e.connection}")
        .isFalse()
    }
    for (lock in forbiddenLocks) {
      assertThat(Thread.holdsLock(lock), "Called with lock $lock")
        .isFalse()
    }

    if (enforceOrder) {
      checkForStartEvent(e)
    }

    eventSequence.offer(e)
  }

      )
    assertThat(verifier.verify("foo.com", session)).isFalse()
    assertThat(verifier.verify("a.foo.com", session)).isFalse()
    assertThat(verifier.verify("bar.com", session)).isFalse()
    assertThat(verifier.verify("a.bar.com", session)).isFalse()
    assertThat(verifier.verify("\u82b1\u5b50.co.jp", session)).isFalse()
    assertThat(verifier.verify("a.\u82b1\u5b50.co.jp", session)).isFalse()
  }

  @Test fun verifyWilcardCn() {

    assertThat(future.set(99)).isFalse();
    assertThat(future.setException(new IndexOutOfBoundsException())).isFalse();
    assertThat(future.setFuture(new AbstractFuture<Integer>() {})).isFalse();
    assertThat(future.setFuture(immediateFuture(99))).isFalse();
  }

  private static void assertCannotCancel(AbstractFuture<Integer> future) {
    assertThat(future.cancel(true)).isFalse();

    assertThat(cacheControl.isPrivate).isFalse()
    assertThat(cacheControl.isPublic).isFalse()
    assertThat(cacheControl.mustRevalidate).isFalse()
    assertThat(cacheControl.maxStaleSeconds).isEqualTo(-1)
    assertThat(cacheControl.minFreshSeconds).isEqualTo(-1)
    assertThat(cacheControl.onlyIfCached).isFalse()
    assertThat(cacheControl.mustRevalidate).isFalse()
  }

  @Test
  @Throws(Exception::class)

    assertThat(cookie.domain).isEqualTo("example.com")
    assertThat(cookie.path).isEqualTo("/")
    assertThat(cookie.secure).isFalse()
    assertThat(cookie.httpOnly).isFalse()
    assertThat(cookie.persistent).isFalse()
    assertThat(cookie.hostOnly).isFalse()
    assertThat(cookie.sameSite).isNull()
  }

  @Test fun newBuilder() {
    val cookie =
      parseCookie(0L, url, "c=d; Max-Age=1")!!

    testInstances += this

    assertThat(serverA.started).isTrue()
    assertThat(serverB.started).isTrue()
    assertThat(serverC.started).isFalse()

    assertThat(serverD.started).isTrue()
    assertThat(serverE.started).isTrue()
    assertThat(serverF.started).isFalse()
  }

  private companion object {
    val testInstances = CopyOnWriteArrayList<StartStopTest>()

    private val dispatcherD = ClosableDispatcher()

    Future<?> possiblyIgnoredError1 = serializer.submitAsync(thirdCallable, directExecutor());
    secondFuture.cancel(true);
    assertThat(secondCallable.called).isFalse();
    assertThat(thirdCallable.called).isFalse();
    firstFuture.set(null);
    assertThat(secondCallable.called).isFalse();
    assertThat(thirdCallable.called).isTrue();
  }

  public void testCancellationMultipleThreads() throws Exception {