@Test
  fun readRequestExamplesWithoutHuffman() {
    firstRequestWithoutHuffman()
    hpackReader!!.readHeaders()
    checkReadFirstRequestWithoutHuffman()
    secondRequestWithoutHuffman()
    hpackReader!!.readHeaders()
    checkReadSecondRequestWithoutHuffman()
    thirdRequestWithoutHuffman()
    hpackReader!!.readHeaders()
    checkReadThirdRequestWithoutHuffman()
  }

  @Test
  fun readFailingRequestExample() {

      throw IOException("Expected a SETTINGS frame but was ${formattedType(type)}")
    }

    when (type) {
      TYPE_DATA -> readData(handler, length, flags, streamId)
      TYPE_HEADERS -> readHeaders(handler, length, flags, streamId)
      TYPE_PRIORITY -> readPriority(handler, length, flags, streamId)
      TYPE_RST_STREAM -> readRstStream(handler, length, flags, streamId)

      /**
       * Read `byteCount` bytes of headers from the source stream. This implementation does not
       * propagate the never indexed flag of a header.
       */
      @Throws(IOException::class)
      fun readHeaders() {
        while (!source.exhausted()) {
          val b = source.readByte() and 0xff
          when {
            b == 0x80 -> {
              // 10000000
              throw IOException("index == 0")

      val responseBuilder =
        Response
          .Builder()
          .protocol(statusLine.protocol)
          .code(statusLine.code)
          .message(statusLine.message)
          .headers(headersReader.readHeaders())

      return when {
        expectContinue && statusLine.code == HTTP_CONTINUE -> {
          null
        }

        statusLine.code == HTTP_CONTINUE -> {

   */
  @Throws(IOException::class)
  fun processNextFrame() {
    check(!closed) { "closed" }

    readHeader()
    if (isControlFrame) {
      readControlFrame()
    } else {
      readMessageFrame()
    }
  }

  @Throws(IOException::class, ProtocolException::class)
  private fun readHeader() {
    if (receivedCloseFrame) throw IOException("closed")

    if (result == null) {
      result = readHeader()
      peekedHeader = result
    }

    if (result.isEndOfData) return null

    return result
  }

  /**
   * Consume the next header in the stream and return it. If there is no header to read because we
   * have reached a limit, this returns [END_OF_DATA].
   */
  internal fun readHeader(): DerHeader {
    require(peekedHeader == null)

			return nil, err
		}
		if _, err := tryReadFull(tr.r, tr.blk[:tr.pad]); err != nil {
			return nil, err
		}
		tr.pad = 0

		hdr, rawHdr, err := tr.readHeader()
		if err != nil {
			return nil, err
		}
		if err := tr.handleRegularFile(hdr); err != nil {
			return nil, err
		}
		format.mayOnlyBe(hdr.Format)

		// Check for PAX/GNU special headers and files.

        .writeByte(0b11111111)
        .writeByte(0b11111111)
        .writeByte(0b11111111)
        .writeByte(0b11111111)

    val derReader = DerReader(buffer)

    val header = derReader.readHeader()
    assertThat(header.length).isEqualTo(Long.MAX_VALUE)
  }

  @Test fun `decode length overflowing Long`() {
    val buffer =
      Buffer()
        .writeByte(0b00000010)