}

  override fun connectionAcquired(connection: Connection) {
    eventListener.connectionAcquired(call, connection)
  }

  override fun acquireConnectionNoEvents(connection: RealConnection) {
    call.acquireConnectionNoEvents(connection)
  }

  override fun releaseConnectionNoEvents(): Socket? {
    return call.releaseConnectionNoEvents()
  }

    route: Route,
  )

  fun connectFailed(
    route: Route,
    protocol: Protocol?,
    e: IOException,
  )

  fun connectionAcquired(connection: Connection)

  fun acquireConnectionNoEvents(connection: RealConnection)

  fun releaseConnectionNoEvents(): Socket?

  fun connectionReleased(connection: Connection)

  fun connectionConnectionAcquired(connection: RealConnection)

  }

  override fun connectFailed(
    route: Route,
    protocol: Protocol?,
    e: IOException,
  ) {
  }

  override fun connectionAcquired(connection: Connection) {
  }

  override fun acquireConnectionNoEvents(connection: RealConnection) {
  }

  override fun releaseConnectionNoEvents(): Socket? {
    return null
  }

  override fun connectionReleased(connection: Connection) {
  }

        .build()
    val call = client.newCall(Request(addressA.url)) as RealCall
    call.enterNetworkInterceptorExchange(call.request(), true, factory.newChain(call))
    c1.withLock { call.acquireConnectionNoEvents(c1) }

    // Running at time 50, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(50L)).isEqualTo(100L)
    assertThat(pool.connectionCount()).isEqualTo(1)

    this.withLock {
      this.requestBodyOpen = true
      this.responseBodyOpen = true
    }

    if (canceled) throw IOException("Canceled")
    return result
  }

  fun acquireConnectionNoEvents(connection: RealConnection) {
    connection.lock.assertHeld()

    check(this.connection == null)
    this.connection = connection
    connection.calls.add(CallReference(this, callStackTrace))
  }

    val pooled3 = routePlanner.planReusePooledConnection(this, routes)
    if (pooled3 != null) return pooled3.connection

    connection.withLock {
      connectionPool.put(connection)
      user.acquireConnectionNoEvents(connection)
    }

    user.connectionAcquired(connection)
    user.connectionConnectionAcquired(connection)
    return connection
  }

  override fun trackFailure(
    call: RealCall,

          when {
            requireMultiplexed && !connection.isMultiplexed -> false
            !connection.isEligible(address, routes) -> false
            else -> {
              connectionUser.acquireConnectionNoEvents(connection)
              true
            }
          }
        }
      if (!acquired) continue

      // Confirm the connection is healthy and return it.

HSPLokhttp3/internal/connection/RealCall$timeout$1;-><init>(Lokhttp3/internal/connection/RealCall;)V
HSPLokhttp3/internal/connection/RealCall;-><init>(Lokhttp3/OkHttpClient;Lokhttp3/Request;Z)V
HSPLokhttp3/internal/connection/RealCall;->acquireConnectionNoEvents(Lokhttp3/internal/connection/RealConnection;)V
HSPLokhttp3/internal/connection/RealCall;->callDone(Ljava/io/IOException;)Ljava/io/IOException;
HSPLokhttp3/internal/connection/RealCall;->enqueue(Lokhttp3/Callback;)V