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

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

  @Test
  fun readFailingRequestExample() {

  protected fun testDecoder(story: Story) {
    for (testCase in story.cases) {
      val encoded = testCase.wire ?: continue
      bytesIn.write(encoded)
      hpackReader.readHeaders()
      assertSetEquals(
        "seqno=$testCase.seqno",
        testCase.headersList,
        hpackReader.getAndResetHeaderList(),
      )
    }
  }

  companion object {
    /**

  fun readLine(): String {
    val line = source.readUtf8LineStrict(headerLimit)
    headerLimit -= line.length.toLong()
    return line
  }

  /** Reads headers or trailers. */
  fun readHeaders(): Headers {
    val result = Headers.Builder()
    while (true) {
      val line = readLine()
      if (line.isEmpty()) break
      result.addLenient(line)
    }
    return result.build()
  }

      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)

      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 -> {
          state = STATE_READ_RESPONSE_HEADERS

          -1 -> throw ProtocolException("unexpected characters after boundary")
        }
      }

      // There's another part. Parse its headers and return it.
      val headers = HeadersReader(source).readHeaders()
      val partSource = PartSource()
      currentPart = partSource
      return Part(headers, partSource.buffer())
    }