// Then
        assertNotNull(responseWithNull);
    }

    @Test
    @DisplayName("Should test encryption flag detection")
    void testEncryptionFlagDetection() throws SMBProtocolDecodingException {
        // Given - response with encryption flag set
        byte[] buffer = createValidResponseBuffer(0, 0x8000, 0, 0);

        // When
        response.readBytesWireFormat(buffer, 0);

    /**
     * Session flag indicating this is a null/anonymous session
     */
    public static final int SMB2_SESSION_FLAGS_IS_NULL = 0x2;

    /**
     * Session flag indicating data encryption is required for this session
     */
    public static final int SMB2_SESSION_FLAG_ENCRYPT_DATA = 0x4;

    private int sessionFlags;
    private byte[] blob;

    /**

    public static final String MVN_CMD = "mvn";
    public static final String MVN_NAME = "Maven";

    public static final String MVNENC_CMD = "mvnenc";
    public static final String MVNENC_NAME = "Maven Password Encrypting Tool";

    public static final String MVNSHELL_CMD = "mvnsh";
    public static final String MVNSHELL_NAME = "Maven Shell Tool";

    public static final String MVNUP_CMD = "mvnup";

     * Determines whether this session is currently in use.
     *
     * @return whether the session is in use
     */
    boolean isInUse();

    /**
     * Returns the current session key used for signing and encryption.
     *
     * @return the current session key
     * @throws CIFSException if the session key cannot be retrieved
     */
    byte[] getSessionKey() throws CIFSException;

    /**

        assertEquals("", serverData.oemDomainName);
    }

    @Test
    void testReadBytesWireFormat_NoDomainName() {
        // Scenario where byteCount is only the encryption key length
        serverData.capabilities = 0;
        serverData.encryptionKeyLength = 8;
        response.byteCount = 8;

        byte[] encryptionKey = "12345678".getBytes();

            }
        }

        return serverKeys.toArray(new KerberosKey[0]);
    }

    /**
     * Retrieves a specific Kerberos key by key type.
     *
     * @param keyType the encryption type of the key to retrieve
     * @return the KerberosKey with the specified type, or null if not found
     */
    public KerberosKey getKey(int keyType) {
        KerberosKey serverKey = null;

    /**
     * Share flag indicating that hash generation V2 is enabled for this share.
     */
    public static final int SMB2_SHAREFLAG_ENABLE_HASH_V2 = 0x4000;
    /**
     * Share flag indicating that encryption is required for this share.
     */
    public static final int SMB2_SHAREFLAG_ENCRYPT_DATA = 0x8000;
    /**
     * Share capability indicating DFS support.
     */

import org.mockito.MockedStatic;

class PacTest {

    private Map<Integer, KerberosKey> keys;

    @BeforeEach
    void setUp() {
        keys = new HashMap<>();
        // Use ARCFOUR-HMAC encryption type (23) which matches KERB_CHECKSUM_HMAC_MD5
        KerberosKey serverKey = new KerberosKey(new KerberosPrincipal("******@****.***"), "serverKey1234567".getBytes(),
                PacSignature.ETYPE_ARCFOUR_HMAC, 1);

        setPrivateField(response, "commonCapabilities", 0);
        assertFalse(response.isDFSSupported());
    }

    @Test
    @DisplayName("Should check encryption support")
    void testIsEncryptionSupported() throws Exception {
        // Given
        setPrivateField(response, "supportsEncryption", true);

        // Then

        assertEquals(invertibleCryptographer, provider.providePrimaryInvertibleCryptographer());
        assertEquals(md5, provider.providePrimaryOneWayCryptographer());
    }

    // Test encryption and decryption functionality
    public void test_invertibleCryptography() {
        // Test that invertible cryptography works correctly