}

    @Test
    @DisplayName("Test isSigningEnabled returns true")
    void testIsSigningEnabledTrue() {
        // Arrange
        when(negotiationResponse.isSigningEnabled()).thenReturn(true);

        // Act
        boolean result = negotiationResponse.isSigningEnabled();

        // Assert
        assertTrue(result);
        verify(negotiationResponse).isSigningEnabled();
    }

    @Test

        ((ServerMessageBlock) resp).setUseUnicode(this.useUnicode);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.SmbNegotiationResponse#isSigningEnabled()
     */
    @Override
    public boolean isSigningEnabled() {
        return this.server.signaturesEnabled || this.server.signaturesRequired;
    }

    /**
     * {@inheritDoc}
     *

            mockConfig.getOemEncoding();
            mockConfig.getLocalTimezone();
            mockConfig.getPid();
            mockConfig.getMaxMpxCount();
            mockConfig.isSigningEnabled();
            mockConfig.isIpcSigningEnforced();
            mockConfig.isSigningEnforced();
            mockConfig.isEncryptionEnabled();
            mockConfig.isForceExtendedSecurity();

        return this.delegate.getMaxMpxCount();
    }

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

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

    void testEncryptionSecurityDelegation() {
        // Given
        when(mockDelegate.isEncryptionEnabled()).thenReturn(true);
        when(mockDelegate.isSigningEnabled()).thenReturn(false);
        when(mockDelegate.isSigningEnforced()).thenReturn(true);
        when(mockDelegate.isIpcSigningEnforced()).thenReturn(true);

     */
    DialectVersion getSelectedDialect();

    /**
     * Checks whether the server has SMB message signing enabled.
     *
     * @return whether the server has signing enabled
     */
    boolean isSigningEnabled();

    /**
     * Checks whether the server requires SMB message signing.
     *
     * @return whether the server requires signing
     */
    boolean isSigningRequired();

    /**

    public int getSendBufferSize() {
        return this.maxWriteSize;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.SmbNegotiationResponse#isSigningEnabled()
     */
    @Override
    public boolean isSigningEnabled() {
        return (this.securityMode & Smb2Constants.SMB2_NEGOTIATE_SIGNING_ENABLED) != 0;
    }

    /**
     * {@inheritDoc}
     *

        assertTrue(response.isSigningEnabled());
        assertFalse(response.isSigningRequired());
        assertFalse(response.isSigningNegotiated());

        // Test signing required
        setPrivateField(response, "securityMode", Smb2Constants.SMB2_NEGOTIATE_SIGNING_REQUIRED);
        assertFalse(response.isSigningEnabled());
        assertTrue(response.isSigningRequired());

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

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

    @Test
    @DisplayName("Should handle invalid property values gracefully")
    void testInvalidPropertyValues() throws CIFSException {

        assertNull(config.getLmHostsFileName());
    }

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