// Test reading parameters from a properly formatted buffer
        byte[] buffer = new byte[20];

        // Set up the buffer with test data
        // sid (2 bytes)
        buffer[0] = 0x01;
        buffer[1] = 0x00;
        // numEntries (2 bytes)
        buffer[2] = 0x05;
        buffer[3] = 0x00;
        // isEndOfSearch (2 bytes, bit 0 of first byte)
        buffer[4] = 0x01; // end of search = true
        buffer[5] = 0x00;

        byte[] buffer2 = testCache.getBuffer();

        // Then
        assertNotNull(buffer1, "First buffer should not be null");
        assertNotNull(buffer2, "Second buffer should not be null");
        assertEquals(1024, buffer1.length, "Buffer should have expected size");
        assertEquals(1024, buffer2.length, "Buffer should have expected size");

    /**
     * Creates a security descriptor by decoding from a byte buffer.
     *
     * @param buffer the byte buffer containing the security descriptor data
     * @param bufferIndex the starting offset in the buffer
     * @param len the length of data to decode
     * @throws IOException if an I/O error occurs during decoding
     */
    public SecurityDescriptor(final byte[] buffer, final int bufferIndex, final int len) throws IOException {

                bufferIndex += 2;
                pathOffset = readInt2(buffer, bufferIndex);
                bufferIndex += 2;
                altPathOffset = readInt2(buffer, bufferIndex);
                bufferIndex += 2;
                nodeOffset = readInt2(buffer, bufferIndex);
                bufferIndex += 2;

                path = readString(buffer, start + pathOffset, len, (flags2 & FLAGS2_UNICODE) != 0);

    /**
     * Creates a security descriptor by decoding from a byte buffer.
     *
     * @param buffer the byte buffer containing the security descriptor data
     * @param bufferIndex the starting offset in the buffer
     * @param len the length of data to decode
     * @throws IOException if an I/O error occurs during decoding
     */
    public SecurityDescriptor(final byte[] buffer, final int bufferIndex, final int len) throws IOException {

     *
     * @param buffer memory buffer to register
     * @param access access permissions
     */
    public RdmaMemoryRegion(ByteBuffer buffer, EnumSet<RdmaAccess> access) {
        this.buffer = buffer;
        this.accessFlags = access;
        this.localKey = generateLocalKey();
        this.remoteKey = generateRemoteKey();
        this.address = getBufferAddress(buffer);
        this.valid = true;
    }

        setPrivateField(cmd, "maxReferralLevel", 0x12AB);
        byte[] buffer = new byte[100];
        int len = cmd.writeParametersWireFormat(buffer, 0);
        assertTrue(len >= 2);
        // writeInt2 writes in little-endian format (LSB first)
        assertEquals(0xAB, buffer[0] & 0xFF);
        assertEquals(0x12, buffer[1] & 0xFF);
        // Check that the path is written after the referral level

        byte[] buffer = new byte[28];

        // Fill resume key with test pattern
        for (int i = 0; i < 24; i++) {
            buffer[i] = (byte) (i + 1);
        }

        // Add context length (reserved) - 4 bytes
        buffer[24] = 0x00;
        buffer[25] = 0x00;
        buffer[26] = 0x00;
        buffer[27] = 0x00;

        // Decode

    /**
     * Buffer type for server checksum signature.
     */
    int SERVER_CHECKSUM = 6;
    /**
     * Buffer type for privilege server (KDC) checksum signature.
     */
    int PRIVSVR_CHECKSUM = 7;

    /**
     * Buffer type for client name information.
     */
    int CLIENT_NAME_TYPE = 0xA;
    /**
     * Buffer type for constrained delegation information.
     */
    int CONSTRAINT_DELEGATIION_TYPE = 0xB;

        assertEquals(getField(cmd, "timeout"), (long) SMBUtil.readInt4(buffer, 4));
        assertEquals(1, SMBUtil.readInt2(buffer, 8));
        assertEquals(1, SMBUtil.readInt2(buffer, 10));
    }

    /**
     * Test that a large file lock (bit 0x10 set) is encoded and decoded correctly.
     */
    @ParameterizedTest
    @ValueSource(ints = { 0x10, 0x11 })