}
                        continue;
                    }

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

     *
     * @return the securityMode
     */
    public int getSecurityMode() {
        return this.securityMode;
    }

    @Override
    public boolean isSigningEnforced() {
        return (getSecurityMode() & Smb2Constants.SMB2_NEGOTIATE_SIGNING_REQUIRED) != 0;
    }

    /**
     * Gets the client capabilities flags.
     *
     * @return the capabilities
     */

        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

    @Override
    public boolean isValid(final CIFSContext tc, final SmbNegotiationRequest req) {
        if (!isReceived() || getStatus() != 0) {
            return false;
        }

        if (req.isSigningEnforced() && !isSigningEnabled()) {
            log.debug("Signing is enforced but server does not allow it");
            return false;
        }

        if (getDialectRevision() == Smb2Constants.SMB2_DIALECT_ANY) {

            // Create transport with multi-channel specific settings
            // Multi-channel transports should use signing consistently with the main session
            boolean forceSigning = context.getConfig().isSigningEnforced();

            SmbTransportImpl transport = new SmbTransportImpl(context, serverUniAddress, port, localAddress, localPort, forceSigning);

            // Ensure the transport is connected and ready

            final boolean forceSigning) {
        this.transportContext = tc;

        this.signingEnforced = forceSigning || this.getContext().getConfig().isSigningEnforced();
        this.sessionExpiration = System.currentTimeMillis() + tc.getConfig().getSessionTimeout();

        this.address = address;
        this.port = port;
        this.localAddr = localAddr;