val tunnelRequest =
      when {
        route.requiresTunnel() -> createTunnelRequest(route)
        else -> null
      }

    return ConnectPlan(
      taskRunner = taskRunner,
      connectionPool = connectionPool,
      readTimeoutMillis = readTimeoutMillis,
      writeTimeoutMillis = writeTimeoutMillis,
      socketConnectTimeoutMillis = socketConnectTimeoutMillis,
      socketReadTimeoutMillis = socketReadTimeoutMillis,

          override val source = Buffer()

          override fun cancel() {
          }
        }

      val result =
        RealConnection(
          taskRunner = taskRunner,
          connectionPool = connectionPool,
          route = route,
          rawSocket = JavaNetSocket(),
          javaNetSocket = socket,
          handshake = null,
          protocol = Protocol.HTTP_2,
          socket = bufferedSocket,

      }
    }.also { expected ->
      assertEquals(cancelMode == INTERRUPT, Thread.interrupted())
    }
    responseBody.close()
    assertEquals(if (connectionType == H2) 1 else 0, client.connectionPool.connectionCount())
  }

  @Test
  fun cancelAndFollowup() {
    val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
    server.enqueue(
      MockResponse
        .Builder()
        .body(

  urls: List<String>,
  client: OkHttpClient,
) {
  try {
    for (url in urls) {
      sendRequest(client, url)
    }
  } finally {
    client.dispatcher.executorService.shutdownNow()
    client.connectionPool.evictAll()
  }
}

private fun buildClient(vararg specs: ConnectionSpec): OkHttpClient =
  OkHttpClient
    .Builder()
    .connectionSpecs(listOf(*specs))
    .build()

private fun sendRequest(

   * [Call.request] is a redirect to a different host.
   *
   * If the [Call] is able to reuse an existing pooled connection, this method will not be invoked.
   * See [ConnectionPool].
   */
  open fun dnsStart(
    call: Call,
    domainName: String,
  ) {
  }

  /**
   * Invoked immediately after a DNS lookup.
   *
   * This method is invoked after [dnsStart].

        client = bootstrapClient,
        http2Only = true,
        workingOnly = true,
        getOnly = true,
      )
    runBatch(dnsProviders, names)
  } finally {
    bootstrapClient.connectionPool.evictAll()
    bootstrapClient.dispatcher.executorService.shutdownNow()
    bootstrapClient.cache?.close()
  }

    val request = Request.Builder().url(server.url("/")).build()

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

    client.connectionPool.evictAll()
    assertEquals(0, client.connectionPool.connectionCount())

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

    assertEquals(2, sessionIds.size)

}

suspend fun main() {
  val publicSuffixListGenerator = PublicSuffixListGenerator()

  try {
    publicSuffixListGenerator.import()
  } finally {
    publicSuffixListGenerator.client.run {
      connectionPool.evictAll()
      dispatcher.executorService.shutdownNow()
    }
  }

 *
 * Typically instances of this class are created, connected and exercised automatically by the HTTP
 * client. Applications may use this class to monitor HTTP connections as members of a
 * [connection pool][ConnectionPool].
 *
 * Do not confuse this class with the misnamed `HttpURLConnection`, which isn't so much a connection
 * as a single request/response exchange.
 *
 * ## Modern TLS
 *

	public final fun certificatePinner ()Lokhttp3/CertificatePinner;
	public final fun connectTimeoutMillis ()I
	public final fun connectionPool ()Lokhttp3/ConnectionPool;
	public final fun connectionSpecs ()Ljava/util/List;
	public final fun cookieJar ()Lokhttp3/CookieJar;
	public final fun dispatcher ()Lokhttp3/Dispatcher;
	public final fun dns ()Lokhttp3/Dns;