* Implementations must quickly dispatch callbacks to avoid creating a bottleneck.
 *
 * While [onReset] may occur at any time, the following callbacks are expected in order,
 * correlated by stream ID.
 *
 *  * [onRequest]
 *  * [onHeaders] (unless canceled)
 *  * [onData] (optional sequence of data frames)
 *
 * As a stream ID is scoped to a single HTTP/2 connection, implementations which target multiple

        }

        List<Exception> exceptionList = null;
        try {
            int count = 0;
            while (count < maxRetryCount) {
                if (listener != null) {
                    listener.onRequest(this, request, count);
                }

                try {
                    return client.execute(request);
                } catch (final MaxLengthExceededException e) {
                    throw e;

    }
  }

  /** Returns once all stream actions complete successfully. */
  fun awaitSuccess() {
    val futureTask =
      results.poll(5, TimeUnit.SECONDS)
        ?: throw AssertionError("no onRequest call received")
    futureTask.get(5, TimeUnit.SECONDS)
  }

        @Override
        public void onRequestStart(final FaultTolerantClient client, final RequestData request) {
            startCount++;
        }

        @Override
        public void onRequest(final FaultTolerantClient client, final RequestData request, final int count) {
            requestCount++;
            requestUrl = request.getUrl();
            requestMethod = request.getMethod().toString();
        }

        writeSynResetLater(streamId, ErrorCode.PROTOCOL_ERROR)
        return
      }
      currentPushRequests.add(streamId)
    }
    pushQueue.execute("$connectionName[$streamId] onRequest") {
      val cancel = pushObserver.onRequest(streamId, requestHeaders)
      ignoreIoExceptions {
        if (cancel) {
          writer.rstStream(streamId, ErrorCode.CANCEL)
          this.withLock {

    @Synchronized fun takeEvent(): Any {
      while (events.isEmpty()) {
        wait()
      }
      return events.removeAt(0)
    }

    @Synchronized override fun onRequest(
      streamId: Int,
      requestHeaders: List<Header>,
    ): Boolean {
      assertThat(streamId).isEqualTo(2)
      events.add(requestHeaders)
      notifyAll()
      return false
    }

    val request = Request(server1.url("/"))

    server1.enqueue(MockResponse(200))
    server2.enqueue(MockResponse(200))
    server2.enqueue(MockResponse(200))

    println("\n\nRequest to ${server1.inetSocketAddress}")
    executeSynchronously(request)
      .assertSuccessful()
      .assertCode(200)

    println("server1.requestCount ${server1.requestCount}")

	_ = x[OpDisconnectClientMux-7]
	_ = x[OpDisconnectServerMux-8]
	_ = x[OpMuxClientMsg-9]
	_ = x[OpMuxServerMsg-10]
	_ = x[OpUnblockSrvMux-11]
	_ = x[OpUnblockClMux-12]
	_ = x[OpAckMux-13]
	_ = x[OpRequest-14]
	_ = x[OpResponse-15]
	_ = x[OpDisconnect-16]
	_ = x[OpMerged-17]
}

	// Only Stateful streams has flow control.
	OpUnblockClMux

	// OpAckMux acknowledges a mux was created.
	OpAckMux

	// OpRequest is a single request + response.
	// MuxID is returned in response.
	OpRequest

	// OpResponse is a response to a single request.
	// FlagPayloadIsErr is used to signify that the payload is a string error converted to byte slice.

    val frResponse = client.newCall(frRequest).execute()
    assertThat(frResponse.body.string()).isEqualTo("A")
    val enRequest =
      Request.Builder()
        .url(url)
        .header("Accept-Language", "en-US")
        .build()
    val enResponse = client.newCall(enRequest).execute()
    assertThat(enResponse.body.string()).isEqualTo("B")
  }

  @Test