Smb2LogoffRequest req = newRequest();
        int base = Smb2Constants.SMB2_HEADER_LENGTH + 4; // structure size
        int expected = ((base + 7) / 8) * 8; // expected 8-byte alignment

        // Act
        int actual = req.size();

        // Assert
        assertEquals(expected, actual, "size() must be 8-byte aligned");
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 5 })

    private static final int FILE_NOTIFY_CHANGE_EA = 0x00000080;
    private static final int FILE_NOTIFY_CHANGE_SECURITY = 0x00000100;
    private static final int FILE_NOTIFY_CHANGE_STREAM_NAME = 0x00000200;
    private static final int FILE_NOTIFY_CHANGE_STREAM_SIZE = 0x00000400;
    private static final int FILE_NOTIFY_CHANGE_STREAM_WRITE = 0x00000800;

        int actualInfoLevel = SMBUtil.readInt2(buffer, 2);
        assertEquals(0x0101, actualInfoLevel);

        // Check reserved bytes (should be 0)
        int reserved = SMBUtil.readInt2(buffer, 4);
        assertEquals(0, reserved);
    }

    @DisplayName("Test writeParametersWireFormat with different FIDs")
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 0xFFFF, 0x8000, 0x7FFF })

    /*
     * This trick allows us to avoid having separate states for "first four ints" and "all other
     * four int chunks."  The state we want after the first four bytes is
     *
     * crc0 = ~int0
     * crc1 = int1
     * crc2 = int2
     * crc3 = int3
     *
     * ...so we set crc0 so that computeForWord(crc0) = -1 and xoring it with the first int

        assertEquals(0x56, buffer[2] & 0xFF);
        assertEquals(0x78, buffer[3] & 0xFF);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 255, 256, 65535, 65536, Integer.MAX_VALUE })
    @DisplayName("Should handle boundary values")
    void testBoundaryValues(int value) {
        // Given
        byte[] buffer = new byte[4];

        // When
        Encdec.enc_uint32le(value, buffer, 0);

            assertEquals(expectedSize, request.size());
        }

        @ParameterizedTest
        @DisplayName("Should calculate size for various data lengths")
        @ValueSource(ints = { 0, 1, 7, 8, 100, 512, 1024, 4096, 65536 })
        void testSizeWithVariousDataLengths(int dataLength) {

        }
    }

    @ParameterizedTest
    @ValueSource(ints = { NtStatus.NT_STATUS_SUCCESS, NtStatus.NT_STATUS_PENDING, NtStatus.NT_STATUS_ACCESS_DENIED,
            NtStatus.NT_STATUS_INVALID_PARAMETER })
    @DisplayName("Should handle various status codes")
    void testVariousStatusCodes(int status) {
        response.setStatusForTest(status);
        assertEquals(status, response.getErrorCode());

//	LFMOV fimm ',' freg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	MOVD	$0.1, F2 // MOVD $(0.10000000000000001), F2

//	LFMOV freg ',' freg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	MOVD	F1, F2

//	LFMOV freg ',' addr
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	MOVD	F2, foo<>+3(SB)
	MOVD	F2, 16(R1)
	MOVD	F2, (R1)

//
// store ints and bytes
//
//	LMOVV rreg ',' addr

    private static byte[] buildIoctlResponseBody(int ctlCode, byte[] fileId, int inputCount, byte[] inputBytes, int outputCount,
            byte[] outputBytes, int ioctlFlags) {
        final int headerLen = 64; // SMB2 header is 64 bytes
        final int bodyFixed = 48; // body size minus 1 for structure size field overlap
        final int payloadStart = headerLen + bodyFixed;
        final int bodyLen = bodyFixed + inputCount + outputCount;

    @MethodSource("knownCodeMessagePairs")
    void lookup_returns_expected_message_for_known_codes(int code, String expectedMessage) {
        // Valid inputs: each known code must map to its documented message
        assertEquals(expectedMessage, lookupMessage(code).orElse(null));
    }

    @ParameterizedTest
    @ValueSource(ints = { -1, Integer.MIN_VALUE, Integer.MAX_VALUE })