frame.write(headerBlock, headerBlock.size / 2)
    frame.write(padding)

    // Write the continuation frame, specifying no more frames are expected.
    writeMedium(frame, headerBlock.size.toInt())
    frame.writeByte(Http2.TYPE_CONTINUATION)
    frame.writeByte(FLAG_END_HEADERS)
    frame.writeInt(expectedStreamId and 0x7fffffff)
    frame.writeAll(headerBlock)

    val value = CharArray(4096)
    Arrays.fill(value, '!')
    val headerBlock = headerEntries("cookie", String(value))
    hpackWriter!!.writeHeaders(headerBlock)
    bytesIn.writeAll(bytesOut)
    hpackReader!!.readHeaders()
    assertThat(hpackReader!!.headerCount).isEqualTo(0)
    assertThat(hpackReader!!.getAndResetHeaderList()).isEqualTo(headerBlock)
  }

  /**

      inFinished: Boolean,
      streamId: Int,
      associatedStreamId: Int,
      headerBlock: List<Header>,
    ) {
      check(type == -1)
      this.type = Http2.TYPE_HEADERS
      this.inFinished = inFinished
      this.streamId = streamId
      this.associatedStreamId = associatedStreamId
      this.headerBlock = headerBlock
    }

    override fun data(
      inFinished: Boolean,
      streamId: Int,

        BlockStore.Factory factory = new BlockStore.Factory() {
            @Override
            public Object create(Class<? extends BlockPayload> type) {
                if (type == HeaderBlock.class) {
                    return new HeaderBlock();
                }
                if (type == IndexBlock.class) {
                    return new IndexBlock();
                }
                if (type == DataBlock.class) {

  @Test fun readNameValueBlockDropsForbiddenHeadersHttp2() {
    val headerBlock =
      headersOf(
        ":status",
        "200 OK",
        ":version",
        "HTTP/1.1",
        "connection",
        "close",
      )
    val request = Request.Builder().url("http://square.com/").build()
    val response = readHttp2HeadersList(headerBlock, Protocol.HTTP_2).request(request).build()
    val headers = response.headers

    streamId: Int,
    source: BufferedSource,
    length: Int,
  ) {
    fail("")
  }

  override fun headers(
    inFinished: Boolean,
    streamId: Int,
    associatedStreamId: Int,
    headerBlock: List<Header>,
  ) {
    fail("")
  }

  override fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    fail("")
  }

  override fun settings(
    clearPrevious: Boolean,

    fun readHttp2HeadersList(
      headerBlock: Headers,
      protocol: Protocol,
    ): Response.Builder {
      var statusLine: StatusLine? = null
      val headersBuilder = Headers.Builder()
      for (i in 0 until headerBlock.size) {
        val name = headerBlock.name(i)
        val value = headerBlock.value(i)
        if (name == RESPONSE_STATUS_UTF8) {

      headerBlockLength -= 5 // account for above read.
    }
    headerBlockLength = lengthWithoutPadding(headerBlockLength, flags, padding)
    val headerBlock = readHeaderBlock(headerBlockLength, padding, flags, streamId)

    handler.headers(endStream, streamId, -1, headerBlock)
  }

  @Throws(IOException::class)
  private fun readHeaderBlock(
    length: Int,
    padding: Int,
    flags: Int,
    streamId: Int,

          smallestHeaderTableSizeSetting = Integer.MAX_VALUE
          writeInt(maxDynamicTableByteCount, PREFIX_5_BITS, 0x20)
        }

        for (i in 0 until headerBlock.size) {
          val header = headerBlock[i]
          val name = header.name.toAsciiLowercase()
          val value = header.value
          var headerIndex = -1
          var headerNameIndex = -1

    }
  }

  @Throws(IOException::class)
  fun headers(
    outFinished: Boolean,
    streamId: Int,
    headerBlock: List<Header>,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      hpackWriter.writeHeaders(headerBlock)

      val byteCount = hpackBuffer.size
      val length = minOf(maxFrameSize.toLong(), byteCount)