}

    @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;
    }

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

 */
public interface SmbNegotiationRequest {

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

     *
     * @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 this.delegate.isSigningEnabled();
    }

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

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

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

    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