assertEquals(message, exception.getMessage());
        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);
        assertNull(exception.getCause());
    }

    @Test
    public void test_constructor_withNullMessage() {
        // Test with null message
        ResultOffsetExceededException exception = new ResultOffsetExceededException(null);

    Assert.assertTrue(countDownLatch.await(1L, SECONDS));

    try {
      Assert.assertEquals(expectedData, future.get());
    } catch (ExecutionException e) {
      throw e.getCause();
    }
  }

  /**
   * Verify that the listener completes in a reasonable amount of time, and Asserts that the future
   * throws an {@code ExecutableException} and that the cause of the {@code ExecutableException} is

    Throwable cause;
    while ((cause = throwable.getCause()) != null) {
      throwable = cause;

      if (throwable == slowPointer) {
        throw new IllegalArgumentException("Loop in causal chain detected.", throwable);
      }
      if (advanceSlowPointer) {
        slowPointer = slowPointer.getCause();
      }

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

    }

    @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

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

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

                new ClUnsupportedOperationException("hoge", new NullPointerException());
        assertThat(clUnsupportedOperationException.getMessage(), is("hoge"));
        assertThat(clUnsupportedOperationException.getCause(), instanceOf(NullPointerException.class));
    }

    /**
     * Test method for
     * {@link org.codelibs.core.exception.ClUnsupportedOperationException#SUnsupportedOperationException(java.lang.Throwable)}
     * .

    ExecutionException expected = assertThrows(ExecutionException.class, () -> getDone(future));
    assertThat(expected.getCause()).isEqualTo(exception);

    expected = assertThrows(ExecutionException.class, () -> getDoneFromTimeoutOverload(future));
    assertThat(expected.getCause()).isEqualTo(exception);
  }

  public void testImmediateFailedFuture_cancellationException() throws Exception {

    ExecutionException expected = assertThrows(ExecutionException.class, () -> getDone(future));
    assertThat(expected.getCause()).isEqualTo(exception);

    expected = assertThrows(ExecutionException.class, () -> getDoneFromTimeoutOverload(future));
    assertThat(expected.getCause()).isEqualTo(exception);
  }

  public void testImmediateFailedFuture_cancellationException() throws Exception {