@Test
    @DisplayName("isSigningOptional and isSigningEnforced reflect configuration")
    void signingModes() throws Exception {
        when(transport.isSigningOptional()).thenReturn(true);
        when(transport.isSigningEnforced()).thenReturn(false);

        assertTrue(transport.isSigningOptional());
        assertFalse(transport.isSigningEnforced());
        verify(transport).isSigningOptional();

        // Then
        assertNotNull(request);
        assertEquals(Smb2Constants.SMB2_NEGOTIATE_SIGNING_ENABLED, request.getSecurityMode());
        assertFalse(request.isSigningEnforced());
        assertTrue(request instanceof ServerMessageBlock2Request);
    }

    @Test
    @DisplayName("Should set DFS capability when enabled")
    void testDfsCapability() {
        // Given

    @Mock
    private Address address;

    private SmbTransportImpl transport;

    @BeforeEach
    void setUp() throws Exception {
        when(ctx.getConfig()).thenReturn(cfg);
        when(cfg.isSigningEnforced()).thenReturn(false);
        when(cfg.getSessionTimeout()).thenReturn(30_000);
        when(cfg.getResponseTimeout()).thenReturn(5_000);
        when(address.getHostAddress()).thenReturn("127.0.0.1");

        return this.delegate.isSigningEnabled();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Configuration#isSigningEnforced()
     */
    @Override
    public boolean isSigningEnforced() {
        return this.delegate.isSigningEnforced();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Configuration#isIpcSigningEnforced()
     */
    @Override

    void testEncryptionSecurityDelegation() {
        // Given
        when(mockDelegate.isEncryptionEnabled()).thenReturn(true);
        when(mockDelegate.isSigningEnabled()).thenReturn(false);
        when(mockDelegate.isSigningEnforced()).thenReturn(true);
        when(mockDelegate.isIpcSigningEnforced()).thenReturn(true);
        when(mockDelegate.isForceExtendedSecurity()).thenReturn(true).thenReturn(false);

        // When

        setField(session, "digest", null);
        when(transport.isSigningEnforced()).thenReturn(true);
        assertTrue(session.isSignatureSetupRequired());

        // Case 3: not enforced, rely on negotiate response flag
        when(transport.isSigningEnforced()).thenReturn(false);
        jcifs.internal.SmbNegotiationResponse nego = mock(jcifs.internal.SmbNegotiationResponse.class);

            return false;
        }

        if (req.isSigningEnforced() || this.server.signaturesRequired
                || this.server.signaturesEnabled && ctx.getConfig().isSigningEnabled()) {
            this.negotiatedFlags2 |= SmbConstants.FLAGS2_SECURITY_SIGNATURES;
            if (req.isSigningEnforced() || isSigningRequired()) {

                        }
                        continue;
                    }

                    if (!forceSigning && !tc.getConfig().isSigningEnforced() && conn.isSigningEnforced()
                            && !conn.getNegotiateResponse().isSigningRequired()) {
                        // if signing is not enforced, dont use connections that have signing enforced

        // When
        PropertyConfiguration testConfig = new PropertyConfiguration(props);

        // Then
        assertTrue(testConfig.isSigningEnforced());
        assertTrue(testConfig.isSigningEnabled());
        assertFalse(testConfig.isEncryptionEnabled());
    }

    @Test
    @DisplayName("Should handle invalid property values gracefully")

    private SmbTransportImpl transport;

    @BeforeEach
    void setUp() throws Exception {
        when(context.getConfig()).thenReturn(config);
        when(config.isSigningEnforced()).thenReturn(false);
        when(config.getSessionTimeout()).thenReturn(30_000);
        when(config.getResponseTimeout()).thenReturn(5_000);
        when(address.getHostAddress()).thenReturn("127.0.0.1");