}
    }

    @Throws(IOException::class)
    private fun pushPromises(
      stream: Http2Stream,
      request: RecordedRequest,
      promises: List<PushPromise>,
    ) {
      for (pushPromise in promises) {
        val pushedHeaders = mutableListOf<Header>()
        pushedHeaders.add(Header(Header.TARGET_AUTHORITY, url(pushPromise.path).host))

    protocol = Protocol.get("")
  }

  @Test
  fun pushPromise() {
    val pushPromise: PushPromise = PushPromise("", "", headersOf(), MockResponse())
    val method: String = pushPromise.method
    val path: String = pushPromise.path
    val headers: Headers = pushPromise.headers
    val response: MockResponse = pushPromise.response
  }

  @Test
  fun queueDispatcher() {

  ) {
    setUp(protocol, mockWebServer)
    val pushPromise =
      PushPromise(
        "GET",
        "/foo/bar",
        headersOf("foo", "bar"),
        MockResponse(body = "bar"),
      )
    server.enqueue(
      MockResponse.Builder()
        .body("ABCDE")
        .addPush(pushPromise)
        .build(),
    )

    override fun priority(
      streamId: Int,
      streamDependency: Int,
      weight: Int,
      exclusive: Boolean,
    ) {
      throw UnsupportedOperationException()
    }

    override fun pushPromise(
      streamId: Int,
      associatedStreamId: Int,
      headerBlock: List<Header>,
    ) {
      this.type = Http2.TYPE_PUSH_PROMISE
      this.streamId = streamId

   * @param promisedStreamId server-initiated stream ID.  Must be an even number.
   * @param requestHeaders minimally includes `:method`, `:scheme`, `:authority`, and `:path`.
   */
  @Throws(IOException::class)
  fun pushPromise(
    streamId: Int,
    promisedStreamId: Int,
    requestHeaders: List<Header>,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      hpackWriter.writeHeaders(requestHeaders)

        writer.headers(outFinished, streamId, requestHeaders)
      } else {
        require(!client) { "client streams shouldn't have associated stream IDs" }
        // HTTP/2 has a PUSH_PROMISE frame.
        writer.pushPromise(associatedStreamId, streamId, requestHeaders)
      }
    }

    if (flushHeaders) {
      writer.flush()
    }

    return stream
  }

  @Throws(IOException::class)

  @Test fun doublePushPromise() {
    // Write the mocking script.
    peer.sendFrame().settings(Settings())
    peer.acceptFrame() // ACK
    peer.sendFrame().pushPromise(3, 2, headerEntries("a", "android"))
    peer.acceptFrame() // SYN_REPLY
    peer.sendFrame().pushPromise(3, 2, headerEntries("b", "banana"))
    peer.acceptFrame() // RST_STREAM
    peer.play()

    // Play it back.
    val connection = connect(peer)

//
// For simplicity, the server code merges "reserved (local)" into
// "half-closed (remote)". This is one less state transition to track.
// The only downside is that we send PUSH_PROMISEs slightly less
// liberally than allowable. More discussion here:
// https://lists.w3.org/Archives/Public/ietf-http-wg/2016JulSep/0599.html
//
// "reserved (remote)" is omitted since the client code does not