streamId: Int,
  ) {
    if (streamId == 0) throw IOException("PROTOCOL_ERROR: TYPE_DATA streamId == 0")

    // TODO: checkState open or half-closed (local) or raise STREAM_CLOSED
    val inFinished = flags and FLAG_END_STREAM != 0
    val gzipped = flags and FLAG_COMPRESSED != 0
    if (gzipped) {
      throw IOException("PROTOCOL_ERROR: FLAG_COMPRESSED without SETTINGS_COMPRESS_DATA")
    }

package okhttp3.internal.http2

/** http://tools.ietf.org/html/draft-ietf-httpbis-http2-17#section-7 */
enum class ErrorCode constructor(
  val httpCode: Int,
) {
  /** Not an error!  */
  NO_ERROR(0),

  PROTOCOL_ERROR(1),

  INTERNAL_ERROR(2),

  FLOW_CONTROL_ERROR(3),

  SETTINGS_TIMEOUT(4),

  STREAM_CLOSED(5),

  FRAME_SIZE_ERROR(6),

  REFUSED_STREAM(7),

  CANCEL(8),

    frame.writeInt(ErrorCode.PROTOCOL_ERROR.httpCode)
    reader.nextFrame(
      requireSettings = false,
      object : BaseTestHandler() {
        override fun rstStream(
          streamId: Int,
          errorCode: ErrorCode,
        ) {
          assertThat(streamId).isEqualTo(expectedStreamId)
          assertThat(errorCode).isEqualTo(ErrorCode.PROTOCOL_ERROR)
        }
      },
    )
  }

   */
  @Throws(IOException::class)
  fun checkLowercase(name: ByteString): ByteString {
    for (i in 0 until name.size) {
      if (name[i] in 'A'.code.toByte()..'Z'.code.toByte()) {
        throw IOException("PROTOCOL_ERROR response malformed: mixed case name: ${name.utf8()}")
      }
    }
    return name
  }

    // Release the threads.
    writerQueue.shutdown()
    pushQueue.shutdown()
    settingsListenerQueue.shutdown()
  }

  private fun failConnection(e: IOException?) {
    close(ErrorCode.PROTOCOL_ERROR, ErrorCode.PROTOCOL_ERROR, e)
  }

  /**
   * Sends any initial frames and starts reading frames from the remote peer. This should be called
   * after [Builder.build] for all new connections.
   *

          3,
          'B'.code,
          'a'.code,
          'R'.code,
        ),
      ).readHeaders()
    }.also { expected ->
      assertThat(expected.message).isEqualTo(
        "PROTOCOL_ERROR response malformed: mixed case name: Foo",
      )
    }
  }

  @Test
  fun emptyHeaderName() {
    hpackWriter!!.writeByteString("".encodeUtf8())
    assertBytes(0)

    peer.sendFrame().settings(Settings())
    peer.acceptFrame() // ACK
    peer.acceptFrame() // SYN_STREAM 3
    peer.acceptFrame() // SYN_STREAM 5
    peer.sendFrame().goAway(3, ErrorCode.PROTOCOL_ERROR, EMPTY_BYTE_ARRAY)
    peer.acceptFrame() // PING
    peer.sendFrame().ping(true, Http2Connection.AWAIT_PING, 0)
    peer.acceptFrame() // DATA STREAM 3
    peer.play()

    // Play it back.

    val executeAtNanos = System.nanoTime()
    assertFailsWith<StreamResetException> {
      call.execute()
    }.also { expected ->
      assertThat(expected.message).isEqualTo(
        "stream was reset: PROTOCOL_ERROR",
      )
    }
    val elapsedUntilFailure = System.nanoTime() - executeAtNanos
    assertThat(TimeUnit.NANOSECONDS.toMillis(elapsedUntilFailure).toDouble())
      .isCloseTo(1000.0, 250.0)