assertEquals(100, info.sectPerAlloc);
        assertEquals(512, info.bytesPerSect);
        assertEquals(1000L * 100 * 512, info.getCapacity(), "Capacity calculation should be correct");
        assertEquals(500L * 100 * 512, info.getFree(), "Free space calculation should be correct");
    }

    /**
     * Tests the readDataWireFormat method with the SMB_QUERY_FS_SIZE_INFO information level.
     */
    @Test

        request.setOutputData(mockOutputData);

        assertNotNull(request);
    }

    @Test
    @DisplayName("Test size calculation without data")
    void testSizeWithoutData() {
        setupMockConfig();
        Smb2IoctlRequest request = new Smb2IoctlRequest(mockConfig, TEST_CONTROL_CODE);

        int size = request.size();

            });
        }
    }

    @Nested
    @DisplayName("Encoding Tests")
    class EncodingTests {

        @Test
        @DisplayName("encode should validate size calculation")
        void testEncodeValidSize() {
            byte[] buffer = new byte[1024];
            testRequest.setTestSize(64);
            testRequest.setTestLength(64);

    }

    @Test
    @DisplayName("Test size calculation with short filename")
    void testSizeWithShortFilename() {
        FileRenameInformation2 info = new FileRenameInformation2("test.txt", false);
        // 20 bytes fixed + 2 * 8 chars = 20 + 16 = 36
        assertEquals(36, info.size());
    }

    @Test
    @DisplayName("Test size calculation with long filename")
    void testSizeWithLongFilename() {

            try {
                // Exponential backoff with overflow protection - ensure safe calculation
                if (retryDelayMs > 0) {
                    // Safe calculation preventing overflow: use Math.max(0, retryCount - 1) and limit shift
                    int safeShift = Math.min(MAX_BACKOFF_SHIFT, Math.max(0, retryCount - 1));

                new ValidateNegotiateInfoRequest(DEFAULT_CAPABILITIES, defaultClientGuid, DEFAULT_SECURITY_MODE, defaultDialects);

        assertNotNull(request);
    }

    @Test
    @DisplayName("Test size calculation with multiple dialects")
    void testSizeWithMultipleDialects() {
        ValidateNegotiateInfoRequest request =

    @DisplayName("Test setFileName method with null")
    void testSetFileNameNull() {
        request = new Smb2QueryDirectoryRequest(mockConfig);

        request.setFileName(null);

        // Verify size calculation doesn't include filename
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 32;
        assertEquals(((expectedSize + 7) & ~7), request.size());
    }

    @Test

     * This method implements the Microsoft variant of the Kerberos ARCFOUR-HMAC-MD5 checksum.
     *
     * @param keyusage the Kerberos key usage number for this operation
     * @param key the encryption key to use for MAC calculation
     * @param data the data to calculate the MAC for
     * @return the calculated MAC bytes
     * @throws GeneralSecurityException if cryptographic operations fail
     */

        }
    }

    // Integration test with actual MD5 to verify HMAC calculation logic
    @Test
    void testHMACT64WithActualMD5() throws NoSuchAlgorithmException {
        // This test uses a real MD5 instance to verify the HMAC calculation logic
        // HMACT64 is a modified HMAC-MD5 where the key is truncated at 64 bytes

        assertEquals(20, bytesDecoded);

        // Verify capacity calculation: alloc * sectPerAlloc * bytesPerSect
        long expectedCapacity = alloc * sectPerAlloc * bytesPerSect;
        assertEquals(expectedCapacity, smbInfoAllocation.getCapacity());

        // Verify free space calculation: free * sectPerAlloc * bytesPerSect
        long expectedFree = free * sectPerAlloc * bytesPerSect;