"Expected at least Stats.BYTES = %s remaining , got %s",
        BYTES,
        buffer.remaining());
    return new Stats(
        buffer.getLong(),
        buffer.getDouble(),
        buffer.getDouble(),
        buffer.getDouble(),
        buffer.getDouble());
  }

  private static final long serialVersionUID = 0;

        this.maxDataCount = maxDataCount;
    }

    /**
     * Sets the transaction buffer
     * @param buffer
     *            the transaction buffer to use
     */
    public void setBuffer(final byte[] buffer) {
        this.txn_buf = buffer;
    }

    /**
     * Releases and returns the transaction buffer
     * @return the txn_buf
     */
    public byte[] releaseBuffer() {

        bufferIndex += 8;
        this.lastAccessTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.lastWriteTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.changeTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.extFileAttributes = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

package jcifs.internal.dfs;

import java.nio.charset.StandardCharsets;

import jcifs.Encodable;
import jcifs.internal.util.SMBUtil;

/**
 * DFS (Distributed File System) referral request buffer encoder.
 * Creates encoded request buffers for DFS referral requests, specifying the maximum
 * referral level and target path for which DFS resolution is requested.
 *
 * @author mbechler
 */

                    + execution.getGoal());
            buffer.a(' ').strong('(' + execution.getExecutionId() + ')');
        }

        if (project != null) {
            buffer.a(" on project ");
            buffer.project(project.getArtifactId());
        }

        if (cause != null) {
            buffer.a(": ").failure(cause.getMessage());
        }

        return buffer.toString();
    }

     *
     * @param buffer the buffer containing the message data
     * @param bufferIndex the starting offset in the buffer
     * @return the number of bytes read
     */
    protected int readHeaderWireFormat(final byte[] buffer, final int bufferIndex) {
        this.command = buffer[bufferIndex + SmbConstants.CMD_OFFSET];
        this.errorCode = SMBUtil.readInt4(buffer, bufferIndex + SmbConstants.ERROR_CODE_OFFSET);

        .Builder()
        .body(
          Buffer()
            .write(ByteArray(responseBodySize)),
        ).throttleBody(64 * 1024, 125, MILLISECONDS) // 500 Kbps
        .build(),
    )
    val call = client.newCall(Request(server.url("/")))
    val response = call.execute()
    cancelLater(call, 500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)
    assertFailsWith<IOException> {

    protected int readSetupWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    protected int readParametersWireFormat(final byte[] buffer, int bufferIndex, final int len) {
        final int start = bufferIndex;

        setStatus(SMBUtil.readInt2(buffer, bufferIndex));
        bufferIndex += 2;
        this.converter = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

            byte[] innerDigest = "inner_digest".getBytes();
            byte[] expectedOutput = "output_data".getBytes();
            byte[] buffer = new byte[expectedOutput.length + 10]; // Buffer with extra space

            when(mockMd5.digest()).thenReturn(innerDigest);
            when(mockMd5.digest(buffer, 0, expectedOutput.length)).thenAnswer(invocation -> {
                byte[] b = invocation.getArgument(0);

    }

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

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

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