return 0;
    }

    @Override
    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) throws SMBProtocolDecodingException {
        final int start = bufferIndex;

        int elemStart = start;

            Smb2LogoffResponse resp = newResponse();
            byte[] buffer = new byte[8];
            byte[] original = buffer.clone();

            // Act
            int written = resp.writeBytesWireFormat(buffer, index);

            // Assert
            assertEquals(0, written, "Should report 0 bytes written");
            assertArrayEquals(original, buffer, "Buffer must remain unchanged");
        }

        @Test

        ByteBuffer buffer = ByteBuffer.allocate(34);
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        buffer.putShort((short) 0); // dialectIndex
        buffer.put((byte) 0x0F); // securityMode (user, encrypted, sigs enabled, sigs required)
        buffer.putShort((short) 50); // maxMpxCount
        buffer.putShort((short) 10); // maxNumberVcs
        buffer.putInt(8192); // maxBufferSize

            // Given
            ByteBuffer buffer = ByteBuffer.allocate(32);
            buffer.order(ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(Long.MAX_VALUE);
            buffer.putLong(Long.MAX_VALUE);
            buffer.putLong(Long.MAX_VALUE);
            buffer.putInt(Integer.MAX_VALUE);
            buffer.putInt(Integer.MAX_VALUE);
            byte[] bufferArray = buffer.array();

            // When

    @Override
    public String toString() {
        StringBuilder buffer = new StringBuilder("ManagedVersionMap (" + size() + " entries)\n");
        Iterator<String> iter = keySet().iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            buffer.append(key).append('=').append(get(key));
            if (iter.hasNext()) {
                buffer.append('\n');
            }
        }

        @Test
        @DisplayName("Should decode buffer with zero values")
        void shouldDecodeBufferWithZeroValues() throws SMBProtocolDecodingException {
            // Given
            ByteBuffer buffer = ByteBuffer.allocate(24);
            buffer.order(ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(0L);
            buffer.putLong(0L);
            buffer.putInt(0);
            buffer.putInt(0);

import java.io.EOFException
import java.io.IOException
import java.net.ProtocolException
import okhttp3.internal.http1.HeadersReader
import okio.Buffer
import okio.BufferedSource
import okio.ByteString.Companion.encodeUtf8
import okio.Options
import okio.Source
import okio.Timeout
import okio.buffer

/**
 * Reads a stream of [RFC 2046][rfc_2046] multipart body parts. Callers read parts one-at-a-time

    }

    /**
     * Append content to the message buffer.
     *
     * @param value the content to append
     * @return the current builder
     */
    @Nonnull
    default MessageBuilder a(char[] value) {
        return append(String.valueOf(value));
    }

    /**
     * Append content to the message buffer.
     *
     * @param value the content to append

            writeLittleEndianInt(baos, PacConstants.PAC_VERSION); // version

            // Buffer 1: LOGON_INFO
            writeLittleEndianInt(baos, PacConstants.LOGON_INFO);
            writeLittleEndianInt(baos, 8); // minimal size
            writeLittleEndianLong(baos, 72); // offset (aligned)

            // Buffer 2: SERVER_CHECKSUM
            writeLittleEndianInt(baos, PacConstants.SERVER_CHECKSUM);

internal const val FRAGMENT_ENCODE_SET_URI = " \"#<>\\^`{|}"

internal fun Buffer.writeCanonicalized(
  input: String,
  pos: Int,
  limit: Int,
  encodeSet: String,
  alreadyEncoded: Boolean,
  strict: Boolean,
  plusIsSpace: Boolean,
  unicodeAllowed: Boolean,
  charset: Charset?,
) {
  var encodedCharBuffer: Buffer? = null // Lazily allocated.
  var codePoint: Int
  var i = pos
  while (i < limit) {