// 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

        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

            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

        setPrivateField(response, "maxWriteSize", 65536);
        setPrivateField(response, "maxTransactSize", 65536);

        // Setup valid request
        when(mockRequest.isSigningEnforced()).thenReturn(false);
        when(mockRequest.getCapabilities()).thenReturn(Smb2Constants.SMB2_GLOBAL_CAP_DFS);
        when(mockRequest.getNegotiateContexts())

    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");

        assertEquals("", response.getServerData().oemDomainName);
    }

    @Test
    public void testIsValid() {
        SmbNegotiationRequest request = mock(SmbNegotiationRequest.class);
        when(request.isSigningEnforced()).thenReturn(true);
        response.getServerData().signaturesEnabled = true;

        assertTrue(response.isValid(mockContext, request));
        assertTrue(response.isSigningNegotiated());

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

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

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

    }

    @Test
    @DisplayName("Test security configuration getters")
    void testSecurityConfigurationGetters() {
        assertFalse(config.isSigningEnabled());
        assertFalse(config.isSigningEnforced());
        assertTrue(config.isIpcSigningEnforced());
        assertFalse(config.isEncryptionEnabled());
        assertFalse(config.isForceExtendedSecurity());
    }

    @Test