plan0.tcpConnectThrowable = IOException("boom 0!")
    val plan1 = routePlanner.addPlan()
    plan1.tcpConnectThrowable = IOException("boom 1!")

    taskRunner.newQueue().execute("connect") {
      assertFailsWith<IOException> {
        finder.find()
      }.also { expected ->
        assertThat(expected).hasMessage("boom 0!")
        assertThat(expected.suppressed.single()).hasMessage("boom 1!")
      }
    }

   * exception goes to the uncaught exception handler.
   */
  private fun interceptorThrowsRuntimeExceptionAsynchronous(network: Boolean) {
    val boom = RuntimeException("boom!")
    addInterceptor(network) { chain: Interceptor.Chain? -> throw boom }
    val executor = ExceptionCatchingExecutor()
    client =
      client
        .newBuilder()
        .dispatcher(Dispatcher(executor))
        .build()

            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"));
        }
    }

        .exhaustResponse()
    server.enqueue(
      MockResponse
        .Builder()
        .clearHeaders()
        .addHeader("h1", "v1")
        .addHeader("h2", "v2")
        .trailers(headersOf("trailers", "boom"))
        .socketHandler(body)
        .build(),
    )
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )

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

  )
  fun throwingOnFailLogs() {
    webServer.enqueue(
      MockResponse
        .Builder()
        .code(200)
        .body("Body")
        .build(),
    )
    val e = RuntimeException("boom")
    clientListener.setNextEventDelegate(
      object : WebSocketListener() {
        override fun onFailure(
          webSocket: WebSocket,
          t: Throwable,
          response: Response?,