when(sidResolver.getServerSid(eq(null), anyString())).thenThrow(new CIFSException("Context cannot be null"));

        assertThrows(CIFSException.class, () -> sidResolver.getServerSid(null, testServerName));
    }

    @Test
    void testGetServerSid_NullServerName() throws CIFSException {
        when(sidResolver.getServerSid(any(CIFSContext.class), eq(null))).thenThrow(new CIFSException("Server name cannot be null"));

    }

    @Test
    @DisplayName("hasCapability(cap): propagates CIFSException on failure")
    void hasCapability_throws() throws Exception {
        // Arrange
        when(handle.hasCapability(anyInt())).thenThrow(new CIFSException("capability check failed"));

        // Act + Assert
        CIFSException ex = assertThrows(CIFSException.class, () -> handle.hasCapability(42));

        // Arrange
        NetbiosAddress inputAddress = mock(NetbiosAddress.class);
        when(nameServiceClient.getNbtAllByAddress(inputAddress)).thenThrow(new UnknownHostException("Host not found"));

        // Act & Assert
        assertThrows(UnknownHostException.class, () -> nameServiceClient.getNbtAllByAddress(inputAddress));

            when(locator.getURL()).thenReturn(anyUrlWithEmptyHost);
            // Simulate failure to find master browser (UnknownHost wrapped in CIFSException)
            when(locator.getAddress()).thenThrow(new CIFSException("no master", new UnknownHostException("MB")));

            // Act + Assert: the code maps this case to SmbUnsupportedOperationException

            // Given
            when(transportPool.getSmbTransport(context, "unknown.host", DEFAULT_PORT, false, false))
                    .thenThrow(new UnknownHostException("Unknown host"));

            // When & Then
            assertThrows(UnknownHostException.class,

        SmbFileHandleImpl handle = mock(SmbFileHandleImpl.class);
        SmbAuthException authEx = new SmbAuthException("denied");

        when(dest.openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenThrow(authEx) // first attempt fails with auth
                .thenReturn(handle); // second attempt succeeds

        // dest currently has READONLY attribute set

    /**
     * Test for unwrap() method throwing exception.
     * Verifies that unwrap can throw exceptions when appropriate.
     */
    @Test
    void testUnwrap_throwsException() {
        when(smbTree.unwrap(any())).thenThrow(new ClassCastException("Cannot unwrap to specified type"));

        assertThrows(ClassCastException.class, () -> smbTree.unwrap(CustomSmbTree.class),
                "Should throw ClassCastException when type is incompatible");

        when(trans1.unwrap(SmbTransportImpl.class)).thenReturn(trans1);
        when(trans1.ensureConnected()).thenThrow(firstException);
        doNothing().when(trans1).close();

        when(trans2.unwrap(SmbTransportImpl.class)).thenReturn(trans2);
        when(trans2.ensureConnected()).thenThrow(secondException);
        doNothing().when(trans2).close();

     * @throws CIFSException
     */
    @Test
    void testGetServerTimeZoneOffset_throwsCIFSException() throws CIFSException {
        when(smbTreeHandle.getServerTimeZoneOffset()).thenThrow(new CIFSException("Test Exception"));
        assertThrows(CIFSException.class, () -> smbTreeHandle.getServerTimeZoneOffset(),
                "getServerTimeZoneOffset() should throw CIFSException");
    }

    /**

        // Arrange
        SmbPipeOutputStream out = newStream();
        CIFSException boom = new CIFSException("tree-fail");
        when(handle.ensureTreeConnected()).thenThrow(boom);

        // Act + Assert
        CIFSException ex = assertThrows(CIFSException.class, out::ensureTreeConnected);
        assertEquals("tree-fail", ex.getMessage());