@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();

        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

                        }
                        continue;
                    }

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

            // 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 SmbTransportInternal trans, final SmbTreeImpl t, final DfsReferralData referral) throws CIFSException {
        if (log.isDebugEnabled() && trans.isSigningOptional() && !loc.isIPC() && !this.ctx.getConfig().isSigningEnforced()) {
            log.debug("Signatures for file enabled but not required " + this);
        }

        if (referral != null) {
            t.markDomainDfs();
        }

        try {

    /**
     *
     * Property {@code jcifs.smb.client.signingEnforced} (boolean, default false)
     *
     * @return whether to enforce SMB signing (for everything)
     */
    boolean isSigningEnforced();

    /**
     * Property {@code jcifs.smb.client.encryptionEnabled} (boolean, default false)
     *
     * This is an experimental option allowing to indicate support during protocol

        // 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.localPid;
    }

    @Override
    public boolean isSigningEnabled() {
        return this.signingPreferred;
    }

    @Override
    public boolean isSigningEnforced() {
        return this.signingEnforced;
    }

    @Override
    public boolean isIpcSigningEnforced() {
        return this.ipcSigningEnforced;
    }

    @Override

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