}

    @Test
    @DisplayName("Test isSigningEnforced returns false when signing is not enforced")
    void testIsSigningEnforcedReturnsFalse() {
        // Given
        when(negotiationRequest.isSigningEnforced()).thenReturn(false);

        // When
        boolean result = negotiationRequest.isSigningEnforced();

        // Then

            this.dialects = new String[] { "NT LM 0.12" };
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.SmbNegotiationRequest#isSigningEnforced()
     */
    @Override
    public boolean isSigningEnforced() {
        return this.signingEnforced;
    }

    @Override
    protected int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

            mockConfig.getPid();
            mockConfig.getMaxMpxCount();
            mockConfig.isSigningEnabled();
            mockConfig.isIpcSigningEnforced();
            mockConfig.isSigningEnforced();
            mockConfig.isEncryptionEnabled();
            mockConfig.isForceExtendedSecurity();
            mockConfig.getLmHostsFileName();
            mockConfig.getNetbiosScope();

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

 */
public interface SmbNegotiationRequest {

    /**
     * Checks whether SMB message signing is enforced by the client.
     *
     * @return whether SMB signing is enforced
     */
    boolean isSigningEnforced();

    @Override
    public boolean isSigningOptional() throws SmbException {
        return delegate.isSigningOptional();
    }

    @Override
    public boolean isSigningEnforced() throws SmbException {
        return delegate.isSigningEnforced();
    }

    @Override
    public byte[] getServerEncryptionKey() {
        return delegate.getServerEncryptionKey();
    }

    @Override

        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 whether signatures are enforced from either side
     * @throws SmbException if an error occurs checking signing status
     */
    boolean isSigningEnforced() throws SmbException;

    /**
     * Gets the server's encryption key for authentication.
     *
     * @return the encryption key used by the server
     */
    byte[] getServerEncryptionKey();

            return false;
        }

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