assertEquals(0x01, dst[descrEnd]);
        assertEquals(0x00, dst[descrEnd + 1]);

        // Verify maxDataCount (16384)
        assertEquals(16384, SMBUtil.readInt2(dst, descrEnd + 2));

        // Verify serverTypes
        assertEquals(serverTypes, SMBUtil.readInt4(dst, descrEnd + 4));

        // Verify domain (should be uppercase)
        int domainStart = descrEnd + 8;

        assertEquals(getField(cmd, "fid"), SMBUtil.readInt2(buffer, 0));
        assertEquals(getField(cmd, "typeOfLock"), buffer[2]);
        assertEquals(getField(cmd, "newOpLockLevel"), buffer[3]);
        assertEquals(getField(cmd, "timeout"), (long) SMBUtil.readInt4(buffer, 4));
        assertEquals(1, SMBUtil.readInt2(buffer, 8));
        assertEquals(1, SMBUtil.readInt2(buffer, 10));
    }

    /**

        }

        final int ver = SMBUtil.readInt4(mic, 0);
        if (ver != 1) {
            throw new SmbUnsupportedOperationException("Invalid signature version");
        }

        final MessageDigest mac = Crypto.getHMACT64(sk);
        final int seq = SMBUtil.readInt4(mic, 12);
        mac.update(mic, 12, 4); // sequence

        this.allow = buf[bi] == (byte) 0x00;
        bi++;
        this.flags = buf[bi++] & 0xFF;
        final int size = SMBUtil.readInt2(buf, bi);
        bi += 2;
        this.access = SMBUtil.readInt4(buf, bi);
        bi += 4;
        this.sid = new SID(buf, bi);
        return size;
    }

    void appendCol(final StringBuffer sb, final String str, final int width) {

            // Verify structure
            assertEquals(48, SMBUtil.readInt2(buffer, 0)); // Structure size
            assertEquals(1, SMBUtil.readInt2(buffer, 2)); // Lock count

            // Verify lock sequence (bits 4-7 are sequence number, bits 0-27 are index)
            int lockSequence = SMBUtil.readInt4(buffer, 4);
            assertEquals(0, lockSequence); // Default values

        // Verify search attributes (masked with 0x37)
        assertEquals(0x37, SMBUtil.readInt2(buffer, 0));

        // Verify max items
        assertEquals(100, SMBUtil.readInt2(buffer, 2));

        // Verify flags (should be 0x00)
        assertEquals(0x00, SMBUtil.readInt2(buffer, 4));

        // Verify information level (SMB_FILE_BOTH_DIRECTORY_INFO)

        ServerMessageBlock.writeInt2(0x1234, buffer, 0);
        assertEquals(0x1234, ServerMessageBlock.readInt2(buffer, 0));
    }

    @Test
    void testInt4ReadWrite() {
        byte[] buffer = new byte[4];
        ServerMessageBlock.writeInt4(0x12345678, buffer, 0);
        assertEquals(0x12345678, ServerMessageBlock.readInt4(buffer, 0));
    }

    @Test
    void testInt8ReadWrite() {
        byte[] buffer = new byte[8];

    @MethodSource("int32Provider")
    @DisplayName("readParameterWordsWireFormat correctly decodes 32-bit offset")
    void testReadParameterWords(int expectedInt, byte[] bytes) {
        // The implementation reads via SMBUtil.readInt4 which returns an int
        // When assigned to a long field, it gets sign-extended
        int readLen = response.readParameterWordsWireFormat(bytes, 0);

        assertEquals(22, bytesEncoded);

        // Verify encoded data
        assertEquals(expectedAllocationSize, SMBUtil.readInt8(destinationBuffer, dstIndex));
        assertEquals(expectedEndOfFile, SMBUtil.readInt8(destinationBuffer, dstIndex + 8));
        assertEquals(expectedNumberOfLinks, SMBUtil.readInt4(destinationBuffer, dstIndex + 16));
        assertEquals(1, destinationBuffer[dstIndex + 20]); // deletePending

        // Verify structure size (should be 24)
        assertEquals(24, SMBUtil.readInt2(buffer, offset));

        // Verify Reserved1 (2 bytes at offset+2, should be 0)
        assertEquals(0, SMBUtil.readInt2(buffer, offset + 2));

        // Verify Reserved2 (4 bytes at offset+4, should be 0)
        assertEquals(0, SMBUtil.readInt4(buffer, offset + 4));