/*
         * Cast to ExecutionException to satisfy our nullness checker, which (unsoundly but
         * *usually* safely) assumes that getCause() returns non-null on an ExecutionException.
         */
        CombinedFuture.this.setException(((ExecutionException) error).getCause());
      } else if (error instanceof CancellationException) {
        cancel(false);
      } else {
        CombinedFuture.this.setException(error);

        assertNull(exception.getMessage());
    }

    @Test
    public void test_getCause() {
        // Test that getCause returns null (no cause set in constructor)
        UserRoleLoginException exception = new UserRoleLoginException(RootAction.class);
        assertNull(exception.getCause());
    }

    @Test
    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        try {

    try {
      method.invoke(wrapper, getParameterValues(method));
      fail(method + " failed to throw exception as is.");
    } catch (InvocationTargetException e) {
      if (exception != e.getCause()) {
        throw new RuntimeException(e);
      }
    } catch (IllegalAccessException e) {
      throw new AssertionError(e);
    }
  }

  private static <T> void testEquals(

      return future.get();
    } catch (InterruptedException e) {
      currentThread().interrupt();
      throw newWithCause(exceptionClass, e);
    } catch (ExecutionException e) {
      wrapAndThrowExceptionOrError(e.getCause(), exceptionClass);
      throw new AssertionError();
    }
  }

  /** Implementation of {@link Futures#getChecked(Future, Class, long, TimeUnit)}. */
  @CanIgnoreReturnValue
  @ParametricNullness

        // Then
        assertEquals(original.getErrorCode(), retry.getErrorCode());
        assertEquals(original.getMessage(), retry.getMessage());
        assertEquals(original.getCause(), retry.getCause());
        assertNotNull(retry.getContext());
    }

    @Test
    @DisplayName("Should format message correctly")
    void testMessageFormatting() {
        // With custom message

                        }
                        return value;
                    });
                } catch (final ExecutionException e) {
                    if (e.getCause() instanceof KeyNotFoundException) {
                        return null;
                    }
                    return super.get(propertyKey);
                }
            }
        };
    }

          try {
            String result = Uninterruptibles.getUninterruptibly(currentFuture.get());
            finalResults.add(result);
          } catch (ExecutionException e) {
            finalResults.add(e.getCause());
          } catch (CancellationException e) {
            finalResults.add(CancellationException.class);
          } finally {
            awaitUnchecked(barrier);
          }
        };

    super(key, value);
    this.cause = checkNotNull(cause);
  }

  /** Returns the cause for which the entry was removed. */
  public RemovalCause getCause() {
    return cause;
  }

  /**
   * Returns {@code true} if there was an automatic removal due to eviction (the cause is neither
   * {@link RemovalCause#EXPLICIT} nor {@link RemovalCause#REPLACED}).
   */

    waitingThread.start();
    waitingThread.interrupt();
    ExecutionException expected = assertThrows(ExecutionException.class, wasInterrupted::get);
    assertTrue(expected.getCause().toString(), expected.getCause() instanceof InterruptedException);
  }

  public void testMakeUninterruptible_timedGetZeroTimeoutAttempted()
      throws TimeoutException, ExecutionException {

     *
     * @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 CurlException(final String message, final Throwable cause) {