)
    val response = call.execute()
    assertThat(response.code).isEqualTo(200)
    response.body.close()
    val connectionAcquired = listener.removeUpToEvent<ConnectionAcquired>()
    assertThat(connectionAcquired.call).isSameAs(call)
    assertThat(connectionAcquired.connection).isNotNull()
  }

  @Test
  fun noConnectionFoundOnFollowUp() {
    server.enqueue(
      MockResponse

    assertThat(clientTestRule.recordedConnectionEventTypes()).containsExactly(
      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",
      "NoNewExchanges",
      "ConnectionReleased",
      "ConnectionClosed",
      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",
      "ConnectionReleased",
    )
  }

  @Test
  fun http2OneBadHostOneGoodNoRetryOnConnectionFailureFastFallback() {

  override fun connectionConnectEnd(
    connection: Connection,
    route: Route,
  ) {
    poolConnectionListener.connectEnd(connection, route, call)
  }

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

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

      .execute()
      .close()

    assertThat(listener.recordedEventTypes()).containsExactly(
      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",
      "ConnectionReleased",
      "ConnectionAcquired",
      "ConnectionReleased",
    )
  }

  @Test
  @Throws(IOException::class)
  fun successfulEmptyH2CallEventSequence() {
    enableTls()

   * to the [Call.request] is a redirect to a different address.
   */
  open fun connectionAcquired(
    call: Call,
    connection: Connection,
  ) {
  }

  /**
   * Invoked after a connection has been released for the `call`.
   *
   * This method is always invoked after [connectionAcquired].
   *
   * This can be invoked more than 1 time for a single [Call]. For example, if the response to the

    delegate.connectFailed(call, inetSocketAddress, proxy, protocol, ioe)
  }

  override fun connectionAcquired(
    call: Call,
    connection: Connection,
  ) {
    logWithTime("connectionAcquired: $connection")

    delegate.connectionAcquired(call, connection)
  }

  override fun connectionReleased(
    call: Call,
    connection: Connection,
  ) {

      client =
        OkHttpClient
          .Builder()
          .eventListenerFactory(
            clientTestRule.wrap(
              object : EventListener() {
                override fun connectionAcquired(
                  call: Call,
                  connection: Connection,
                ) {
                  socketClass = connection.socket().javaClass.name
                }
              },

  }

  data class ConnectionClosed(
    override val timestampNs: Long,
    override val connection: Connection,
  ) : ConnectionEvent()

  data class ConnectionAcquired(
    override val timestampNs: Long,
    override val connection: Connection,
    val call: Call,
  ) : ConnectionEvent()

  data class ConnectionReleased(
    override val timestampNs: Long,

      .assertLogMatch(Regex("""connectStart: ${url.host}/.+ DIRECT"""))
      .assertLogMatch(Regex("""connectEnd: http/1.1"""))
      .assertLogMatch(
        Regex(
          """connectionAcquired: Connection\{${url.host}:\d+, proxy=DIRECT hostAddress=${url.host}/.+ cipherSuite=none protocol=http/1\.1\}""",
        ),
      ).assertLogMatch(Regex("""requestHeadersStart"""))

    protocol: Protocol?,
    ioe: IOException,
  ) = logEvent(ConnectFailed(System.nanoTime(), call, inetSocketAddress, proxy, protocol, ioe))

  override fun connectionAcquired(
    call: Call,
    connection: Connection,
  ) = logEvent(ConnectionAcquired(System.nanoTime(), call, connection))

  override fun connectionReleased(
    call: Call,
    connection: Connection,