onFailure(e, responseTime);
                if (e instanceof CIFSException) {
                    throw (CIFSException) e;
                }
                throw new CIFSException("Circuit breaker operation failed", e);
            }
        } finally {
            activeRequests.decrementAndGet();
            if (semaphoreAcquired) {

        doThrow(thrown).when(trace).connect(loc);

        // Act & Assert: both UnknownHostException and IOException should become CIFSException (SmbException)
        CIFSException ex = assertThrows(CIFSException.class, () -> trace.connectWrapException(loc));
        assertTrue(ex.getMessage() != null && ex.getMessage().contains("Failed to connect to server"));
        assertSame(thrown, ex.getCause());

 */
package jcifs.smb;

import java.util.Arrays;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSException;
import jcifs.internal.smb2.lease.DirectoryCacheScope;
import jcifs.internal.smb2.lease.DirectoryLeaseManager;
import jcifs.internal.smb2.lease.Smb2LeaseKey;
import jcifs.internal.smb2.lease.Smb2LeaseState;

/**

import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.CIFSException;
import jcifs.ResourceFilter;
import jcifs.SmbConstants;
import jcifs.SmbResource;

@ExtendWith(MockitoExtension.class)
class ShareEnumIteratorTest {

    @Mock
    ResourceFilter filter;

            }

            this.fp = 0L;
        } catch (final CIFSException e) {
            throw SmbException.wrap(e);
        }
    }

    /**
     * @return
     * @throws SmbException
     */
    synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {
        // ensure file is open
        if (this.handle == null || !this.handle.isValid()) {

     * @param challenge the server challenge (may be null for some auth types)
     * @return authentication response data
     * @throws CIFSException if authentication fails
     */
    byte[] authenticate(CIFSContext context, byte[] challenge) throws CIFSException;

    /**
     * Gets the session key after successful authentication
     *
     * @return the session key or null if not available
     */

import java.net.URL;
import java.net.UnknownHostException;
import java.util.Objects;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.Address;
import jcifs.CIFSContext;
import jcifs.CIFSException;
import jcifs.DfsReferralData;
import jcifs.NetbiosAddress;
import jcifs.RuntimeCIFSException;
import jcifs.SmbConstants;
import jcifs.SmbResourceLocator;
import jcifs.internal.util.StringUtil;

    void testInitSecContextInvalidTokenType(byte firstByte) throws Exception {
        SpnegoContext ctx = newContext();

        // Invalid first byte should be rejected by token parsing
        CIFSException ex = assertThrows(CIFSException.class, () -> ctx.initSecContext(new byte[] { firstByte }, 0, 1));
        assertEquals("Invalid token", ex.getMessage());

        // Ensure mechContext was not engaged due to early failure

        assertNull(ex.getMessage(), "Default message should be null");
        assertNull(ex.getCause(), "Default cause should be null");
        assertTrue(ex instanceof CIFSException, "Should be a CIFSException");
        assertTrue(ex instanceof IOException, "Should be an IOException");
    }

    @Test
    @DisplayName("Should create SpnegoException with message")
    void testWithMessage() {

        assertEquals(SMBProtocolDowngradeException.class.getName(), ex.toString());

        // Assert - type hierarchy: subclass of CIFSException and IOException
        assertTrue(ex instanceof jcifs.CIFSException, "Should extend CIFSException");
        assertTrue(ex instanceof IOException, "Should be an IOException (checked)");
    }

    @ParameterizedTest(name = "Message-only ctor preserves message: [{0}]")