/**
 * Base for all checked exceptions used by this library
 *
 *
 * These should only occur under very rare circumstances.
 *
 * @author mbechler
 *
 */
public class RuntimeCIFSException extends RuntimeException {

    /**
     *
     */
    private static final long serialVersionUID = -2611196678846438579L;

    /**
     * Constructs a runtime CIFS exception with no detail message.
     */

      reversedList = reversedList.next;
    }
  }

  /**
   * Submits the given runnable to the given {@link Executor} catching and logging all {@linkplain
   * RuntimeException runtime exceptions} thrown by the executor.
   */
  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  private static void executeListener(Runnable runnable, Executor executor) {
    try {

     * Verifies behavior when close throws an exception.
     */
    @Test
    void testClose_throwsException() {
        doThrow(new RuntimeException("Failed to close")).when(smbTree).close();

        assertThrows(RuntimeException.class, () -> smbTree.close(), "Should propagate exception when close fails");
    }

    /**
     * Test for AutoCloseable functionality.

        if (t instanceof Exception exception && !(t instanceof RuntimeException)) {
            eventCatapult.fire(ExecutionEvent.Type.ProjectFailed, currentSession, null, exception);
        }

        // reactor failure modes
        if (t instanceof RuntimeException || !(t instanceof Exception)) {
            // fail fast on RuntimeExceptions, Errors and "other" Throwables

    try {
      super.testKeySetRemoveAllNullFromEmpty();
    } catch (RuntimeException tolerated) {
      // GWT's HashMap.keySet().removeAll(null) doesn't throws NPE.
    }
  }

  @Override
  public void testEntrySetRemoveAllNullFromEmpty() {
    try {
      super.testEntrySetRemoveAllNullFromEmpty();
    } catch (RuntimeException tolerated) {
      // GWT's HashMap.entrySet().removeAll(null) doesn't throws NPE.

    Boolean expectedResult = null;
    RuntimeException expectedRuntimeException = null;
    try {
      expectedResult = expected.apply(input);
    } catch (RuntimeException e) {
      expectedRuntimeException = e;
    }

    Boolean actualResult = null;
    RuntimeException actualRuntimeException = null;
    try {
      actualResult = actual.apply(input);

  @Test
  fun throwingOnOpenFailsImmediately() {
    webServer.enqueue(
      MockResponse
        .Builder()
        .webSocketUpgrade(serverListener)
        .build(),
    )
    val e = RuntimeException()
    clientListener.setNextEventDelegate(
      object : WebSocketListener() {
        override fun onOpen(
          webSocket: WebSocket,
          response: Response,
        ): Unit = throw e
      },

     *            The algorithm (refer to the Javadoc of {@link MessageDigest} for available algorithms).
     *            Must not be {@literal null} or an empty string.
     * @return {@link MessageDigest}
     * @throws RuntimeException
     *             If a {@link NoSuchAlgorithmException} occurs
     */
    public static MessageDigest getInstance(final String algorithm) {
        assertArgumentNotEmpty("algorithm", algorithm);

        try {

 * callers to determine which specific requests failed and why.
 *
 * @since 4.0.0
 */
@Experimental
public class BatchRequestException extends RuntimeException {

    private final List<RequestResult<?, ?>> results;

    /**
     * Constructs a new BatchRequestException with the specified message and results.
     *
     * @param <REQ> The type of the request

 * When a task is {@linkplain Thread#interrupt interrupted}, execution of subsequent tasks
 * continues. See {@link QueueWorker#workOnQueue} for details.
 *
 * <p>{@code RuntimeException}s thrown by tasks are simply logged and the executor keeps trucking.
 * If an {@code Error} is thrown, the error will propagate and execution will stop until it is
 * restarted by a call to {@link #execute}.
 */