val payload = Buffer()
    while (payload.completeSegmentByteCount() <= PAYLOAD_BYTE_MAX) {
      payload.writeByte('0'.code)
    }
    serverWriter.writeMessageFrame(OPCODE_BINARY, payload.snapshot())

    // Write directly to the unbuffered sink. This ensures it will become single frame.
    assertData("827e") // 'e' == 4-byte follow-up length.
    assertData(format("%04X", payload.completeSegmentByteCount()))

    server.enqueue(
      MockResponse.Builder()
        .addInformationalResponse(
          MockResponse(
            code = HTTP_EARLY_HINTS,
            headers = headersOf("Link", "</style.css>; rel=preload; as=style"),
          ),
        ).build(),
    )
    val request =
      Request(
        url = server.url("/"),
        body = "abc".toRequestBody("text/plain".toMediaType()),
      )

  }

  fun assertTextMessage(payload: String?) {
    assertThat(nextEvent()).isEqualTo(Message(string = payload))
  }

  fun assertBinaryMessage(payload: ByteString?) {
    assertThat(nextEvent()).isEqualTo(Message(payload))
  }

  fun assertPing(payload: ByteString) {
    assertThat(nextEvent()).isEqualTo(Ping(payload))
  }

  fun assertPong(payload: ByteString) {

    const val ENABLE_PUSH = 2

    /** Sender's maximum number of concurrent streams. */
    const val MAX_CONCURRENT_STREAMS = 4

    /** HTTP/2: Size in bytes of the largest frame payload the sender will accept. */
    const val MAX_FRAME_SIZE = 5

    /** HTTP/2: Advisory only. Size in bytes of the largest header list the sender will accept. */
    const val MAX_HEADER_LIST_SIZE = 6

  }

  @Test fun closeLengthOfOneThrows() {
    data.write("880100".decodeHex()) // Close with invalid 1-byte payload
    assertFailsWith<ProtocolException> {
      clientReader.processNextFrame()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Malformed close payload length of 1.")
    }
  }

  @Test fun closeCallsCallback() {

    // |R|                 Stream Identifier (31)                      |
    // +=+=============================================================+
    // |                   Frame Payload (0...)                      ...
    // +---------------------------------------------------------------+
    val length = source.readMedium()
    if (length > INITIAL_MAX_FRAME_SIZE) {

   * special values [PAYLOAD_SHORT] or [PAYLOAD_LONG].
   */
  internal const val PAYLOAD_BYTE_MAX = 125L

  /** Maximum length of close message in bytes. */
  internal const val CLOSE_MESSAGE_MAX = PAYLOAD_BYTE_MAX - 2

  /**
   * Value for [B1_MASK_LENGTH] which indicates the next two bytes are the unsigned length.
   */
  internal const val PAYLOAD_SHORT = 126

    Regex(
      buildString {
        append("^(?:")
        append(
          listOf(
            "Inaccessible trust store",
            "trustStore is",
            "Reload the trust store",
            "Reload trust certs",
            "Reloaded",
            "adding as trusted certificates",
            "Ignore disabled cipher suite",
            "Ignore unsupported cipher suite",

  }

  @Synchronized override fun onReadPing(payload: ByteString) {
    // Don't respond to pings after we've failed or sent the close frame.
    if (failed || enqueuedClose && messageAndCloseQueue.isEmpty()) return

    pongQueue.add(payload)
    runWriter()
    receivedPingCount++
  }

  @Synchronized override fun onReadPong(payload: ByteString) {
    // This API doesn't expose pings.

    )
    fun create(
      contentType: MediaType?,
      file: File,
    ): RequestBody = file.asRequestBody(contentType)

    /**
     * Returns a gzip version of the RequestBody, with compressed payload.
     * This is not automatic as not all servers support gzip compressed requests.
     *
     * ```
     * val request = Request.Builder().url("...")
     *  .addHeader("Content-Encoding", "gzip")