server.processNextFrame()
    client.listener.assertClosing(1000, "Hello!")
    server.listener.assertClosing(1000, "Hi!")
    client.webSocket!!.finishReader()
    server.webSocket!!.finishReader()
    client.listener.assertClosed(1000, "Hello!")
    server.listener.assertClosed(1000, "Hi!")
    taskFaker.runTasks()
    assertThat(client.closed).isTrue()

  val dispatcher = Dispatcher(executor)
  val listener = RecordingEventListener()
  var client =
    clientTestRule.newClientBuilder()
      .dns { throw UnknownHostException() }
      .dispatcher(dispatcher)
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()

  @BeforeEach
  fun setUp() {
    dispatcher.maxRequests = 20
    dispatcher.maxRequestsPerHost = 10
    listener.forbidLock(dispatcher)
  }

  @Test

    peer.play()

    // Play it back.
    val connection =
      Http2Connection.Builder(true, TaskRunner.INSTANCE)
        .socket(peer.openSocket())
        .pushObserver(Http2ConnectionTest.IGNORE)
        .listener(realConnection)
        .build()
    connection.start(sendConnectionPreface = false)

    // verify the peer received the ACK
    val ackFrame = peer.takeFrame()

          client -> "$okHttpName $peerName"
          else -> "MockWebServer $peerName"
        }
      this.source = source
      this.sink = sink
    }

    fun listener(listener: Listener) =
      apply {
        this.listener = listener
      }

    fun pushObserver(pushObserver: PushObserver) =
      apply {
        this.pushObserver = pushObserver
      }

  /** Uses [request] to connect a new web socket. */
  override fun newWebSocket(
    request: Request,
    listener: WebSocketListener,
  ): WebSocket {
    val webSocket =
      RealWebSocket(
        taskRunner = taskRunner,
        originalRequest = request,
        listener = listener,
        random = Random(),
        pingIntervalMillis = pingIntervalMillis.toLong(),

    listener.removeUpToEvent(ConnectionAcquired::class.java)
    listener.removeUpToEvent(ResponseFailed::class.java)
    listener.removeUpToEvent(ConnectionReleased::class.java)
    listener.removeUpToEvent(ConnectionAcquired::class.java)
    listener.removeUpToEvent(ConnectionReleased::class.java)
    listener.removeUpToEvent(CallEnd::class.java)
  }

  @Test
  fun recoverWhenRetryOnConnectionFailureIsTrue_HTTP2() {

    return EventSource.Factory { request, listener ->
      val actualRequest =
        if (request.header("Accept") == null) {
          request.newBuilder().addHeader("Accept", "text/event-stream").build()
        } else {
          request
        }

      RealEventSource(actualRequest, listener).apply {
        connect(callFactory)
      }
    }
  }

  @JvmStatic

  private var protocol: Protocol?,
  private var source: BufferedSource?,
  private var sink: BufferedSink?,
  private val pingIntervalMillis: Int,
  internal val connectionListener: ConnectionListener,
) : Http2Connection.Listener(), Connection, ExchangeCodec.Carrier {
  private var http2Connection: Http2Connection? = null

  internal val lock: ReentrantLock = ReentrantLock()

  // These properties are guarded by [lock].

  /**

   * [requestBodyOpen], [responseBodyOpen], and [expectMoreExchanges].
   *
   * This will release the connection if it is still held.
   *
   * It will also notify the listener that the call completed; either successfully or
   * unsuccessfully.
   *
   * If the call was canceled or timed out, this will wrap [e] in an exception that provides that

    peer: MockHttp2Peer,
    pushObserver: PushObserver = IGNORE,
    listener: Http2Connection.Listener = Http2Connection.Listener.REFUSE_INCOMING_STREAMS,
  ): Http2Connection {
    val connection =
      Http2Connection.Builder(true, TaskRunner.INSTANCE)
        .socket(peer.openSocket())
        .pushObserver(pushObserver)
        .listener(listener)
        .build()
    connection.start(sendConnectionPreface = false)