*
     * @param message the detail message (which is saved for later retrieval by the {@link #getMessage()} method).
     * @param cause the cause (which is saved for later retrieval by the {@link #getCause()} method).
     *              (A {@code null} value is permitted, and indicates that the cause is nonexistent or unknown.)
     */
    public CrawlerSystemException(final String message, final Throwable cause) {

import org.jspecify.annotations.Nullable;

/**
 * {@link Error} variant of {@link java.util.concurrent.ExecutionException}. As with {@code
 * ExecutionException}, the error's {@linkplain #getCause() cause} comes from a failed task,
 * possibly run in another thread. That cause should itself be an {@code Error}; if not, use {@code
 * ExecutionException} or {@link UncheckedExecutionException}. This allows the client code to

     *
     * @param message the detail message. The detail message is saved for later retrieval by the {@link #getMessage()} method.
     * @param cause the cause (which is saved for later retrieval by the {@link #getCause()} method).
     *              (A {@code null} value is permitted, and indicates that the cause is nonexistent or unknown.)
     */
    public ExtractException(final String message, final Throwable cause) {

    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type) {
        try {
            return Optional.of(container.lookup(type));
        } catch (ComponentLookupException e) {
            if (e.getCause() instanceof NoSuchElementException) {
                return Optional.empty();
            }
            throw new LookupException(e);
        }
    }

    @Override

    WrapperException(Throwable t) {
      super(t);
    }
  }

  private static void rethrow(ExecutionException e) throws ExecutionException {
    Throwable wrapper = e.getCause();
    if (wrapper instanceof WrapperException) {
      Throwable cause = wrapper.getCause();
      if (cause instanceof RuntimeException) {
        throw (RuntimeException) cause;
      } else if (cause instanceof Error) {
        throw (Error) cause;
      }

        } catch (java.lang.reflect.InvocationTargetException e) {
            // We expect this to fail, but it should be a CIFSException, not a NullPointerException
            assertTrue(e.getCause() instanceof CIFSException);
            assertTrue(e.getCause().getMessage().contains("Failed to create multi-channel transport"));
        }
    }

    @Test
    @DisplayName("MultiChannelManager should shutdown cleanly")
    void testShutdown() {

                }
            });
        } catch (RuntimeException e) {
            if (e.getCause() instanceof PluginResolutionException pluginResolutionException) {
                throw pluginResolutionException;
            }
            if (e.getCause() instanceof PluginContainerException pluginContainerException) {
                throw pluginContainerException;
            }

        // When
        SmbException finalException = new SmbException("Final error", intermediateCause);

        // Then
        assertEquals(intermediateCause, finalException.getCause());
        assertEquals(rootCause, finalException.getCause().getCause());
    }

    @Test
    @DisplayName("Should handle null message gracefully")
    void testNullMessage() {
        // When/Then
        assertDoesNotThrow(() -> {

    @Test
    void testHandleExceptionLoopInCause() {
        // Some broken exception that does return "this" as getCause
        AtomicReference<Throwable> causeRef = new AtomicReference<>(null);
        Exception cause2 = new RuntimeException("loop") {
            @Override
            public synchronized Throwable getCause() {
                return causeRef.get();
            }
        };
        causeRef.set(cause2);

    assertTrue(future.isDone());
    assertThat(tryInternalFastPathGetFailure(future)).isNull();
    CancellationException e = assertThrows(CancellationException.class, () -> future.get());
    assertThat(e.getCause()).isNotNull();
  }

  public void testCancel_notDoneInterrupt() throws Exception {
    Future<?> future = newFutureInstance();
    assertTrue(future.cancel(true));
    assertTrue(future.isCancelled());