messageBuffer.readAndWriteUnsafe(maskCursor!!)
        maskCursor.seek(0L)
        toggleMask(maskCursor, maskKey)
        maskCursor.close()
      }
    }

    sinkBuffer.write(messageBuffer, dataSize)
    sink.emit()
  }

  override fun close() {
    messageDeflater?.close()
  }

# Number of days of inactivity before an Issue or Pull Request becomes stale
daysUntilStale: 30

# Number of days of inactivity before an Issue or Pull Request with the stale label is closed.
# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
daysUntilClose: 15

# Only issues or pull requests with all of these labels are check if stale. Defaults to `[]` (disabled)
onlyLabels: []

    }
  }

  @Throws(IOException::class)
  fun flush() {
    this.withLock {
      if (closed) throw IOException("closed")
      sink.flush()
    }
  }

  @Throws(IOException::class)
  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1)

     *
     * @see jcifs.SmbPipeHandle#close()
     */
    @Override
    public synchronized void close () throws CIFSException {
        boolean wasOpen = isOpen();
        this.open = false;
        if ( this.input != null ) {
            this.input.close();
            this.input = null;
        }

        if ( this.output != null ) {
            this.output.close();
            this.output = null;

	}
	_, err = writer.Write([]byte("aaaaaaaaaa"))
	if err != nil {
		t.Fatal(err)
	}
	_, err = writer.Write([]byte("aaaaa"))
	if err != nil {
		t.Fatal(err)
	}
	if bw, ok := writer.(io.Closer); ok {
		bw.Close()
	}

	reader := newBitrotReader(disk, nil, volume, filePath, 35, bitrotAlgo, bitrotWriterSum(writer), 10)
	b := make([]byte, 10)
	if _, err = reader.ReadAt(b, 0); err != nil {
		t.Fatal(err)
	}

Shubhendu <******@****.***> 1716419234 +0530

   * most [BufferedSource] instances, but not of [Buffer].
   */
  private fun responseBody(content: String): ResponseBody {
    val data = Buffer().writeUtf8(content)
    val source: Source =
      object : Source {
        var closed = false

        override fun close() {
          closed = true
        }

        override fun read(

}

// Close all the readers.
func closeBitrotReaders(rs []io.ReaderAt) {
	for _, r := range rs {
		if r != nil {
			if br, ok := r.(io.Closer); ok {
				br.Close()
			}
		}
	}
}

// Close all the writers.
func closeBitrotWriters(ws []io.Writer) {
	for _, w := range ws {
		if w != nil {
			if bw, ok := w.(io.Closer); ok {
				bw.Close()
			}
		}
	}

    protected abstract FileEntry[] getResults ();


    /**
     * 
     */
    protected synchronized void doClose () throws CIFSException {
        // otherwise already closed
        if ( !this.closed ) {
            this.closed = true;
            try {
                doCloseInternal();
            }
            finally {
                this.next = null;
                this.treeHandle.release();

	return &fakeNs{closed: &atomic.Bool{}, fd: fd, inode: inode}
}

// Fd returns the file descriptor
func (f *fakeNs) Fd() uintptr {
	return f.fd
}

func (f *fakeNs) Inode() uint64 {
	return f.inode
}

// Close simulates closing the file descriptor and returns nil for no error
func (f *fakeNs) Close() error {
	f.closed.Store(true)
	return nil
}

func fakeFs() fs.FS {