* application. The tuning parameters in this pool are subject to change in future OkHttp releases.
 * Currently this pool holds up to 5 idle connections which will be evicted after 5 minutes of
 * inactivity.
 */
class ConnectionPool internal constructor(
  internal val delegate: RealConnectionPool,
) {
  internal constructor(
    maxIdleConnections: Int = 5,
    keepAliveDuration: Long = 5,
    timeUnit: TimeUnit = TimeUnit.MINUTES,

    assertConnectionNotReused(request, request)
  }

  @Test
  fun connectionsAreNotReusedIfPoolIsSizeZero() {
    client =
      client
        .newBuilder()
        .connectionPool(ConnectionPool(0, 5, TimeUnit.SECONDS))
        .build()
    server.enqueue(MockResponse(body = "a"))
    server.enqueue(MockResponse(body = "b"))
    val request = Request(server.url("/"))

    assert200Http2Response(execute(url), server.hostName)
    val sanUrl = url.newBuilder().host("san.com").build()
    assert200Http2Response(execute(sanUrl), "san.com")
    assertThat(client.connectionPool.connectionCount()).isEqualTo(1)
  }

  /**
   * Test connecting to an alternative host then common name, although only subject alternative
   * names are used if present no special consideration of common name.

          taskRunner = taskRunner,
          connectionPool = connectionPool,
          route = route,
          rawSocket = rawSocket,
          javaNetSocket = javaNetSocket!!,
          handshake = handshake,
          protocol = protocol!!,
          socket = socket,
          pingIntervalMillis = pingIntervalMillis,
          connectionListener = connectionPool.connectionListener,
        )

This logs task enqueues, starts, and finishes.

```
[2020-01-01 00:00:00] Q10000 scheduled after   0 µs: OkHttp ConnectionPool
[2020-01-01 00:00:00] Q10000 starting              : OkHttp ConnectionPool
[2020-01-01 00:00:00] Q10000 run again after 300 s : OkHttp ConnectionPool
[2020-01-01 00:00:00] Q10000 finished run in   1 ms: OkHttp ConnectionPool
[2020-01-01 00:00:00] Q10001 scheduled after   0 µs: OkHttp squareup.com applyAndAckSettings

      }
  }

  @Test
  fun connectionPool() {
    var connectionPool = ConnectionPool()
    connectionPool = ConnectionPool(0, 0L, TimeUnit.SECONDS)
    val idleConnectionCount: Int = connectionPool.idleConnectionCount()
    val connectionCount: Int = connectionPool.connectionCount()
    connectionPool.evictAll()
  }

  @Test
  fun connectionSpec() {

     * accessed by the connection closer task.
     */
    var concurrentCallCapacity: Int = 0
  }

  companion object {
    fun get(connectionPool: ConnectionPool): RealConnectionPool = connectionPool.delegate

    private var addressStatesUpdater =
      AtomicReferenceFieldUpdater.newUpdater(
        RealConnectionPool::class.java,
        Map::class.java,
        "addressStates",

  val originalRequest: Request,
  val forWebSocket: Boolean,
) : Call,
  Cloneable,
  Lockable {
  private val connectionPool: RealConnectionPool = client.connectionPool.delegate

  internal val eventListener: EventListener = client.eventListenerFactory.create(this)

  private val timeout =
    object : AsyncTimeout() {
      override fun timedOut() {

    assertThat(a.dispatcher).isNotNull()
    assertThat(a.connectionPool).isNotNull()
    assertThat(a.sslSocketFactory).isNotNull()
    assertThat(a.x509TrustManager).isNotNull()

    // Multiple clients share the instances.
    val b = client.newBuilder().build()
    assertThat(b.dispatcher).isSameAs(a.dispatcher)
    assertThat(b.connectionPool).isSameAs(a.connectionPool)
    assertThat(b.sslSocketFactory).isSameAs(a.sslSocketFactory)

  internal val taskRunner: TaskRunner = builder.taskRunner ?: TaskRunner.INSTANCE

  @get:JvmName("connectionPool")
  val connectionPool: ConnectionPool =
    builder.connectionPool ?: ConnectionPool(
      readTimeoutMillis = readTimeoutMillis,
      writeTimeoutMillis = writeTimeoutMillis,
      socketConnectTimeoutMillis = connectTimeoutMillis,