* @param buffer the source byte array
     * @param bufferIndex the starting index in the source array
     * @return the time value in milliseconds since January 1, 1970 UTC
     */
    public static long readUTime(final byte[] buffer, final int bufferIndex) {
        return (readInt4(buffer, bufferIndex) & 0xFFFFFFFFL) * 1000L;
    }

    /**

        return 0;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    public String toString() {

  }

  private fun ByteString.zstdCompress(): ByteString {
    val result = Buffer()
    result.zstdCompress().buffer().use {
      it.write(this@zstdCompress)
    }
    return result.readByteString()
  }

  private fun ByteString.gzipCompress(): ByteString {
    val result = Buffer()
    (result as Sink).gzip().buffer().use {
      it.write(this@gzipCompress)
    }
    return result.readByteString()

     *
     * Changes in between these calls (as long as the file is open) are buffered by the server, so iteratively calling
     * this method should provide all changes (size of that buffer can be adjusted through
     * {@link jcifs.Configuration#getNotifyBufferSize()}).
     * If the server cannot fulfill the request because the changes did not fit the buffer
     * it will return an empty list of changes.
     *

    public void transferInitiated(TransferEvent transferEvent) {
        listener.transferInitiated(wrap(transferEvent));
    }

    @Override
    public void transferProgress(TransferEvent transferEvent, byte[] buffer, int length) {
        Long transferred;
        synchronized (transfers) {
            transferred = transfers.get(transferEvent.getResource());
            if (transferred == null) {

        final byte[] buffer = this.getContext().getBufferCache().getBuffer();
        try {
            // synchronize around encode and write so that the ordering for SMB1 signing can be maintained
            synchronized (this.outLock) {
                final int n = smb.encode(buffer, 4);
                Encdec.enc_uint32be(n & 0xFFFF, buffer, 0); /* 4 byte session message header */

	}
	if b != '\n' {
		cr.err = errMalformedEncoding
		return n, cr.err
	}

	if cap(cr.buffer) < size {
		cr.buffer = make([]byte, size)
	} else {
		cr.buffer = cr.buffer[:size]
	}

	// Now, we read the payload and compute its SHA-256 hash.
	_, err = io.ReadFull(cr.reader, cr.buffer)
	if err == io.EOF && size != 0 {
		err = io.ErrUnexpectedEOF
	}
	if err != nil && err != io.EOF {

    }

    @Override
    int readTrailerWireFormat(final InputStream in, final byte[] buffer, int bufferIndex) throws IOException {
        if (in.read(buffer, bufferIndex, length) != length) {
            throw new IOException("unexpected EOF reading netbios retarget session response");
        }
        final int addr = readInt4(buffer, bufferIndex);
        bufferIndex += 4;

    @Test
    void testReadParameterWordsWireFormat() {
        // Given
        SmbComTreeDisconnect smbComTreeDisconnect = new SmbComTreeDisconnect();
        byte[] buffer = new byte[10];

        // When
        int result = smbComTreeDisconnect.readParameterWordsWireFormat(buffer, 0);

        // Then
        assertEquals(0, result, "readParameterWordsWireFormat should return 0");
    }

    /**

	}
	if buffered := wr.Buffered(); buffered != wantBuffered {
		t.Fatalf("Buffered = %v; want %v", buffered, wantBuffered)
	}
}

func BenchmarkReaderCopyOptimal(b *testing.B) {
	// Optimal case is where the underlying reader implements io.WriterTo
	srcBuf := bytes.NewBuffer(make([]byte, 8192))
	src := NewReader(srcBuf)
	dstBuf := new(bytes.Buffer)
	dst := onlyWriter{dstBuf}