@Test
        @DisplayName("Should handle exception during close")
        void testClosePoolException() throws CIFSException {
            // Given
            when(transportPool.close()).thenThrow(new CIFSException("Close failed"));

            // When & Then
            assertThrows(CIFSException.class, () -> transportPool.close());
        }

        @Test
        @DisplayName("Should close pool multiple times")

package jcifs.config;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

import jcifs.CIFSException;
import jcifs.DialectVersion;

/**
 * Security configuration tests
 *
 * Verifies that default security settings are properly configured
 * according to SMB security best practices.
 */

                });
            } catch (CIFSException e) {
                // Expected
            }
        }

        assertEquals(State.OPEN, circuitBreaker.getState(), "Circuit should be OPEN");

        // Try to execute - should be blocked with CIFSException
        CIFSException exception = assertThrows(CIFSException.class, () -> {

        assertThrows(CIFSException.class, () -> {
            compressionService.compress(testData, CompressionService.COMPRESSION_LZNT1);
        });
    }

    @Test
    @DisplayName("Test unsupported algorithm decompression")
    public void testUnsupportedAlgorithmDecompression() {
        assertThrows(CIFSException.class, () -> {

            // If it doesn't throw, that's unexpected for localhost
            fail("Expected CIFSException for localhost multi-channel attempt");
        } catch (java.lang.reflect.InvocationTargetException e) {
            // We expect this to fail, but it should be a CIFSException, not a NullPointerException
            assertTrue(e.getCause() instanceof CIFSException);

    }

    // Error propagation: getSessionKey throws CIFSException
    @Test
    @DisplayName("getSessionKey throws CIFSException on failure")
    void getSessionKey_throws() throws CIFSException {
        doThrow(new CIFSException("session key failure")).when(session).getSessionKey();

        CIFSException ex = assertThrows(CIFSException.class, () -> session.getSessionKey());

     * @return the created context
     * @throws CIFSException if initialization fails
     */
    public PreauthIntegrityContext initializeSession(String sessionId, byte[] salt, int hashAlgorithm) throws CIFSException {
        if (sessionId == null || sessionId.isEmpty()) {
            throw new CIFSException("Session ID cannot be null or empty");
        }
        if (salt == null || salt.length < 16) {

    @DisplayName("ensureTreeConnected propagates CIFSException from handle")
    void ensureTreeConnected_propagatesException() throws Exception {
        // Arrange
        SmbPipeOutputStream out = newStream();
        CIFSException boom = new CIFSException("tree-fail");
        when(handle.ensureTreeConnected()).thenThrow(boom);

        // Act + Assert
        CIFSException ex = assertThrows(CIFSException.class, out::ensureTreeConnected);

        }
    }

    /**
     * @return the sessionKey
     * @throws CIFSException
     */
    @Override
    public byte[] getSessionKey() throws CIFSException {
        if (this.sessionKey == null) {
            throw new CIFSException("No session key available");
        }
        return this.sessionKey;
    }

    @Override

    /**
     * Closes the pool and all connections in it
     *
     * @return whether any transport was still in use
     *
     * @throws CIFSException if an error occurs during authentication
     *
     */
    boolean close() throws CIFSException;

    /**
     * Authenticate arbitrary credentials represented by the
     * <code>NtlmPasswordAuthentication</code> object against the domain controller