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

     * @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) {

                        log.debug("Invalid parameter error.", e);
                    }
                    return;
                }
                throw new CIFSException("Failed to resolve SIDs", e);
            } catch (final IOException e) {
                throw new CIFSException("Failed to resolve SIDs", e);
            }
        }
    }

    @Override

        }
    }

    /**
     * {@inheritDoc}
     *
     * @throws CIFSException if the URL is malformed or there is an error creating the SMB resource
     *
     * @see jcifs.CIFSContext#get(java.lang.String)
     */
    @Override
    public SmbResource get(final String url) throws CIFSException {
        try {
            return new SmbFile(url, this);
        } catch (final MalformedURLException e) {

                });
            } 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, () -> {

    /**
     *
     * @return this pipe's output stream
     * @throws CIFSException if an error occurs
     */
    @Override
    SmbPipeOutputStream getOutput() throws CIFSException;

    /**
     * Ensures that the tree connection is established and returns it.
     *
     * @return tree connection
     * @throws CIFSException if an error occurs connecting to the tree
     */

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

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;

import jcifs.BaseTest;
import jcifs.BufferCache;
import jcifs.CIFSException;
import jcifs.Configuration;
import jcifs.DfsResolver;
import jcifs.NameServiceClient;
import jcifs.SidResolver;
import jcifs.SmbPipeResource;
import jcifs.SmbResource;
import jcifs.SmbTransportPool;

     * @param lastWriteTime the last write time to set, or 0 to leave unchanged
     * @throws CIFSException if an error occurs while closing the file
     */
    void close(long lastWriteTime) throws CIFSException;

    /**
     * {@inheritDoc}
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close() throws CIFSException;

    /**
     * Releases this file handle without closing it
     *

    boolean isInUse();

    /**
     * Returns the current session key used for signing and encryption.
     *
     * @return the current session key
     * @throws CIFSException if the session key cannot be retrieved
     */
    byte[] getSessionKey() throws CIFSException;

    /**
     * Returns the SMB transport associated with this session.
     *
     * @return the transport for this session
     */