private var cacheRequestClosed = false

        @Throws(IOException::class)
        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {
          val bytesRead: Long
          try {
            bytesRead = source.read(sink, byteCount)
          } catch (e: IOException) {
            if (!cacheRequestClosed) {
              cacheRequestClosed = true

              private var totalBytesWritten: Long = 0
              private var completed = false

              override fun write(source: Buffer, byteCount: Long) {
                super.write(source, byteCount)
                totalBytesWritten += byteCount
                progressListener.update(totalBytesWritten, contentLength(), completed)
              }

              override fun close() {

    val name: String = headers.name(0)
    val value: String = headers.value(0)
    val names: Set<String> = headers.names()
    val values: List<String> = headers.values("")
    val byteCount: Long = headers.byteCount()
    val builder: Headers.Builder = headers.newBuilder()
    val multimap: Map<String, List<String>> = headers.toMultimap()
  }

  @Test
  fun headersBuilder() {

      source: Buffer,
      byteCount: Long,
    ) {
      val toRead = minOf(remainingByteCount, byteCount)
      if (toRead > 0L) {
        source.read(buffer, toRead)
      }
      val toSkip = byteCount - toRead
      if (toSkip > 0L) {
        source.skip(toSkip)
      }
      remainingByteCount -= toRead
      receivedByteCount += byteCount
    }

    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      while (left == 0) {
        source.skip(padding.toLong())
        padding = 0
        if (flags and FLAG_END_HEADERS != 0) return -1L
        readContinuationHeader()
        // TODO: test case for empty continuation header?
      }

      val read = source.read(sink, minOf(byteCount, left.toLong()))
      if (read == -1L) return -1L

     */
    @Override
    public int decode(final byte[] buffer, final int bufferIndex) throws SMBProtocolDecodingException {
        final int len = super.decode(buffer, bufferIndex);
        if (this.byteCount == 0) {
            // otherwise hasMore may not be correctly set
            readBytesWireFormat(buffer, len + bufferIndex);
        }
        nextElement();
        return len;
    }

    @Override

        SMBUtil.writeInt2(9, buf, 0); // structureSize
        buf[2] = (byte) errorContextCount; // ErrorContextCount
        // one reserved byte at position 3
        SMBUtil.writeInt4(bc, buf, 4); // ByteCount
        if (bc > 0 && errorData != null) {
            System.arraycopy(errorData, 0, buf, 8, bc);
        }
        return buf;
    }

    @Test

   * approximate size of HTTP/2 headers before they are compressed with HPACK. This value is
   * intended to be used as a metric: smaller headers are more efficient to encode and transmit.
   */
  fun byteCount(): Long {
    // Each header name has 2 bytes of overhead for ': ' and every header value has 2 bytes of
    // overhead for '\r\n'.
    var result = (namesAndValues.size * 2).toLong()

            this.parameterOffset = this.primarySetupOffset;

            // 2* setupCount
            this.parameterOffset += this.setupCount * 2;
            this.parameterOffset += 2; // ByteCount

            if (this.getCommand() == SMB_COM_TRANSACTION && !isResponse()) {
                this.parameterOffset += stringWireLength(this.name, this.parameterOffset);
            }

        .build()
    connection.start(sendConnectionPreface = false)
    val queues = taskRunner.activeQueues()
    assertThat(queues).hasSize(1)
  }

  private fun data(byteCount: Int): Buffer = Buffer().write(ByteArray(byteCount))

  private fun assertStreamData(
    expected: String?,
    source: Source?,
  ) {
    val actual = source!!.buffer().readUtf8()
    assertThat(actual).isEqualTo(expected)