// When
        int size = request.size();

        // Then
        // Verify size includes SMB2_HEADER_LENGTH
        assertTrue(size >= Smb2Constants.SMB2_HEADER_LENGTH);

        // The actual calculation: (SMB2_HEADER_LENGTH + 4 + 7) & ~7
        int expectedBase = Smb2Constants.SMB2_HEADER_LENGTH + 4;
        int expectedAligned = (expectedBase + 7) & ~7;
        assertEquals(expectedAligned, size);
    }

            totalLen = Math.max(SMB2_HEADER_LENGTH + body.length, ctxOffsetFromHeader + ctxBytes.length);
        } else {
            totalLen = SMB2_HEADER_LENGTH + body.length;
        }
        byte[] packet = new byte[totalLen];
        System.arraycopy(header, 0, packet, 0, header.length);
        System.arraycopy(body, 0, packet, SMB2_HEADER_LENGTH, body.length);

 */
public final class Smb2Constants {

    /**
     *
     */
    private Smb2Constants() {
    }

    /**
     * SMB2 header length in bytes
     */
    public static final int SMB2_HEADER_LENGTH = 64;

    /**
     * SMB2 negotiate flag indicating signing is enabled
     */
    public static final int SMB2_NEGOTIATE_SIGNING_ENABLED = 0x0001;

    /**

        // When
        int size = request.size();

        // Then
        // Size should be aligned to 8 bytes: SMB2_HEADER_LENGTH + 4 bytes for cancel structure
        int expectedSize = ((Smb2Constants.SMB2_HEADER_LENGTH + 4 + 7) / 8) * 8;
        assertEquals(expectedSize, size, "Size calculation should be correct and 8-byte aligned");
    }

    @Test

        int shortSize = shortReq.size();
        int longSize = longReq.size();

        // Then
        // SMB2_HEADER_LENGTH + 8 + path.length() * 2 (UTF-16LE)
        int expectedShortSize = Smb2Constants.SMB2_HEADER_LENGTH + 8 + shortPath.length() * 2;
        int expectedLongSize = Smb2Constants.SMB2_HEADER_LENGTH + 8 + longPath.length() * 2;

        // size8 method aligns to 8-byte boundary

    @Nested
    @DisplayName("Size Tests")
    class SizeTests {

        @Test
        @DisplayName("Should return correct size")
        void testSize() {
            int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 4;
            // size8 rounds up to 8-byte boundary
            int expectedAlignedSize = (expectedSize + 7) & ~7;

            assertEquals(expectedAlignedSize, echoRequest.size());
        }

    void testSize() {
        // When
        int size = request.size();

        // Then
        // Size should be aligned to 8 bytes: SMB2_HEADER_LENGTH + 32
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 32;
        // The size8 method aligns to 8-byte boundary
        int alignedSize = (expectedSize + 7) & ~7;
        assertEquals(alignedSize, size);
    }

    @Test

    void testSizeWithoutData() {
        setupMockConfig();
        Smb2IoctlRequest request = new Smb2IoctlRequest(mockConfig, TEST_CONTROL_CODE);

        int size = request.size();

        // Base size: SMB2_HEADER_LENGTH (64) + 56 = 120, aligned to 8
        assertEquals(120, size);
    }

    @Test
    @DisplayName("Test size calculation with input data")
    void testSizeWithInputData() {
        setupMockConfig();

        request.encode(buffer, 0);

        // Then
        int bodyOffset = Smb2Constants.SMB2_HEADER_LENGTH;
        int securityBufferOffset = SMBUtil.readInt2(buffer, bodyOffset + 12);

        // The offset should point to the location after the fixed structure (relative to header start)
        int expectedOffset = Smb2Constants.SMB2_HEADER_LENGTH + 24;
        while ((expectedOffset % 8) != 0) {

        buildHeader(buf, headerStart, NtStatus.NT_STATUS_MORE_PROCESSING_REQUIRED, 0x0001, expectedSessionId);

        int bodyStart = headerStart + Smb2Constants.SMB2_HEADER_LENGTH;
        byte[] blob = new byte[] { 10, 20, 30, 40, 50 };
        int secBufOffset = Smb2Constants.SMB2_HEADER_LENGTH + 8; // directly after fixed part
        int sessionFlags = Smb2SessionSetupResponse.SMB2_SESSION_FLAGS_IS_GUEST;