// Arrange: filter delegates to isDirectory which may throw SmbException
        SmbFileFilter filter = f -> f.isDirectory();
        SmbException boom = new SmbException("io error");
        when(smbFile.isDirectory()).thenThrow(boom);

        // Act + Assert
        SmbException thrown = assertThrows(SmbException.class, () -> filter.accept(smbFile));
        assertEquals("io error", thrown.getMessage());

            public SmbTreeHandleImpl connect(SmbResourceLocatorImpl loc) throws SmbException {
                throw new SmbException("boom");
            }
        };
        SmbException ex3 = assertThrows(SmbException.class, () -> c3.connectWrapException(loc));
        assertEquals("boom", ex3.getMessage());
    }

    @Test
    @DisplayName("ensureDFSResolved returns early for SmbComClose requests")

            when(src.getContext()).thenReturn(ctx);

            // Force failure before any stream construction
            when(src.openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenThrow(new SmbException("boom"));

            SmbTreeHandleImpl sh = newTreeHandle(false); // force non-SMB2 path to avoid server-side branch
            SmbTreeHandleImpl dh = newTreeHandle(false);

    val requestBody =
      object : RequestBody() {
        override fun contentType(): MediaType? = null

        override fun writeTo(sink: BufferedSink) {
          throw IOException("boom") // Despite this exception, 'sink' is healthy.
        }
      }

    val callA =
      client.newCall(
        Request(
          url = server.url("/"),
          body = requestBody,
        ),

        when(tree.send(any(Smb2IoctlRequest.class), eq(RequestParam.NO_RETRY))).thenThrow(new SmbException("boom"));

        IOException ex = assertThrows(IOException.class, stream::available, "Should convert SmbException to IOException");
        assertTrue(ex.getMessage().contains("boom"));
    }

    @Test
    @DisplayName("ensureTreeConnected delegates to handle")

            SmbException se = new SmbException("x", new jcifs.util.transport.TransportException(new InterruptedException("boom")));
            IOException ioe = SmbFileInputStream.seToIoe(se);
            assertTrue(ioe instanceof InterruptedIOException);
            assertTrue(ioe.getMessage().contains("boom"));
        }
    }

     * is present.
     */
    @Test
    @DisplayName("toString with root cause contains stack trace")
    void testToStringWithRootCause() {
        RuntimeException cause = new RuntimeException("boom");
        SmbException ex = new SmbException(0, cause);
        assertTrue(ex.toString().contains("RuntimeException"), "String representation must include the root cause stack trace");
    }

    /**

        // First call throws, second accepts
        when(filter.accept(any())).thenThrow(new CIFSException("boom")).thenReturn(true);

        ShareEnumIterator it = new ShareEnumIterator(parent, entries.iterator(), filter);

        assertTrue(it.hasNext());
        SmbResource res = it.next();
        assertNotNull(res);

    val call = client.newCall(request)
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("success")
  }

  /**
   * Tests that use this will fail unless boot classpath is set. Ex. `-Xbootclasspath/p:/tmp/alpn-boot-8.0.0.v20140317`
   */
  private fun enableProtocol(protocol: Protocol) {
    enableTls()
    client =
      client
        .newBuilder()

        void testResolveWeakCIFSExceptionIsIgnored() throws Exception {
            SID sid = new SID("S-1-5-21-1-2-3");
            doThrow(new CIFSException("boom")).when(mockResolver).resolveSids(any(), anyString(), any());
            sid.initContext("srv", mockCtx);

            // Accessor should swallow CIFSException and proceed
            sid.getType();