}

    return copy(certificatePinner = newCertificatePinner)
  }

  override fun withConnectionPool(connectionPool: ConnectionPool): Interceptor.Chain {
    check(exchange == null) { "connectionPool can't be adjusted in a network interceptor" }

    return copy(connectionPool = connectionPool)
  }

  override fun call(): Call = call

  override fun request(): Request = request

    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("/"))

    }

    object ConnectionPoolOverride : Override<ConnectionPool> {
      override fun Interceptor.Chain.value(): ConnectionPool = connectionPool

      override fun Interceptor.Chain.withOverride(value: ConnectionPool): Interceptor.Chain = withConnectionPool(value)

      override fun OkHttpClient.Builder.withOverride(value: ConnectionPool): OkHttpClient.Builder = connectionPool(value)

      }
    }

    return references.size
  }

  fun scheduleCloser() {
    cleanupQueue.schedule(cleanupTask)
  }

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

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

    uncaughtException
      .also { uncaughtException = null }

  fun ensureAllConnectionsReleased() {
    testClient?.let {
      val connectionPool = it.connectionPool

      connectionPool.evictAll()
      if (connectionPool.connectionCount() > 0) {
        // Minimise test flakiness due to possible race conditions with connections closing.

          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,

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

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

    val proxyAuthenticator: Authenticator = client.proxyAuthenticator()
    val authenticator: Authenticator = client.authenticator()
    val connectionPool: ConnectionPool = client.connectionPool()
    val dns: Dns = client.dns()
    val followSslRedirects: Boolean = client.followSslRedirects()
    val followRedirects: Boolean = client.followRedirects()

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

  @Volatile
  internal var eventListener: EventListener = client.eventListenerFactory.create(this)

  private val timeout =
    object : AsyncTimeout() {