private set
    public var bodyDelayNanos: Long
      private set
    public var trailersDelayNanos: Long
      private set

    private val pushPromises_: MutableList<PushPromise>
    public val pushPromises: List<PushPromise>
      get() = pushPromises_.toList()

    private val settings_: Settings
    public val settings: Settings
      get() = Settings().apply { merge(settings_) }

    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() {

      }
    }

    @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))

  }

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

  @Test @Disabled
  fun recordedRequest() {

          assertThat(requestHeaders).isEqualTo(pushPromise)
        }
      },
    )
  }

  /** Headers are compressed, then framed.  */
  @Test fun pushPromiseThenContinuation() {
    val expectedPromisedStreamId = 11
    val pushPromise = largeHeaders()

    // Decoding the first header will cross frame boundaries.
    val headerBlock = literalHeaders(pushPromise)

    // Write the first headers frame.

	public final fun addInformationalResponse (Lmockwebserver3/MockResponse;)Lmockwebserver3/MockResponse$Builder;
	public final fun addPush (Lmockwebserver3/PushPromise;)Lmockwebserver3/MockResponse$Builder;
	public final fun body (Ljava/lang/String;)Lmockwebserver3/MockResponse$Builder;
	public final fun body (Lmockwebserver3/MockResponseBody;)Lmockwebserver3/MockResponse$Builder;

	public fun toString ()Ljava/lang/String;
	public final fun trailers (Lokhttp3/Headers;)V
	public final fun withPush (Lokhttp3/mockwebserver/PushPromise;)Lokhttp3/mockwebserver/MockResponse;
	public final fun withSettings (Lokhttp3/internal/http2/Settings;)Lokhttp3/mockwebserver/MockResponse;

    val headerBlockLength = lengthWithoutPadding(length - 4, flags, padding) // - 4 for readInt().
    val headerBlock = readHeaderBlock(headerBlockLength, padding, flags, streamId)
    handler.pushPromise(streamId, promisedStreamId, headerBlock)
  }

  @Throws(IOException::class)
  private fun readPing(
    handler: Handler,
    length: Int,
    flags: Int,
    streamId: Int,
  ) {

   networkInterceptors, pingIntervalMillis, protocols, proxy, proxyAuthenticator, proxySelector,
   readTimeoutMillis, retryOnConnectionFailure, socketFactory, sslSocketFactory, writeTimeoutMillis
 * **PushPromise**: headers, method, path, response
 * **Request**: body, cacheControl, headers, method, url
 * **Response**: body, cacheControl, cacheResponse, code, handshake, headers, message,

        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)