*
   * <p>Prefer this method instead of manually casting an exception's cause. For example, {@code
   * (IOException) e.getCause()} throws a {@link ClassCastException} that discards the original
   * exception {@code e} if the cause is not an {@link IOException}, but {@code
   * Throwables.getCauseAs(e, IOException.class)} keeps {@code e} as the {@link
   * ClassCastException}'s cause.
   *

   *
   * <p>Prefer this method instead of manually casting an exception's cause. For example, {@code
   * (IOException) e.getCause()} throws a {@link ClassCastException} that discards the original
   * exception {@code e} if the cause is not an {@link IOException}, but {@code
   * Throwables.getCauseAs(e, IOException.class)} keeps {@code e} as the {@link
   * ClassCastException}'s cause.
   *

      throw e;
    } catch (ExecutionException e) {
      wrapAndThrowRuntimeExecutionExceptionOrError(e.getCause());
      throw new AssertionError();
    }
  }

  private static Exception throwCause(Exception e, boolean combineStackTraces) throws Exception {
    Throwable cause = e.getCause();
    if (cause == null) {
      throw e;
    }
    if (combineStackTraces) {

    RemovalNotification<Object, Object> notification = listener.remove();
    assertSame(key, notification.getKey());
    assertSame(computed, notification.getValue());
    assertSame(RemovalCause.SIZE, notification.getCause());
    assertTrue(listener.isEmpty());
    checkEmpty(cache);
  }

  public void testGet_expireAfterWrite() {
    Object computed = new Object();
    LoadingCache<Object, Object> cache =

    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

    assertTrue(future.isDone());
    assertNull(tryInternalFastPathGetFailure(future));
    CancellationException e = assertThrows(CancellationException.class, () -> future.get());
    assertNotNull(e.getCause());
  }

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

    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 {

    runLatch.await();
    taskLatch.countDown();

    ExecutionException e =
        assertThrows(ExecutionException.class, () -> task.get(5, TimeUnit.SECONDS));
    assertEquals(IllegalStateException.class, e.getCause().getClass());

    assertTrue(listenerLatch.await(5, TimeUnit.SECONDS));
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
  }

    ListenableFuture<String> chain = buildChainingFuture(badInput);
    ExecutionException e = assertThrows(ExecutionException.class, () -> chain.get());
    assertSame(RuntimeException.class, e.getCause().getClass());
  }

  /** Proxy to throw a {@link RuntimeException} out of the {@link #get()} method. */
  public static class BadFuture extends SimpleForwardingListenableFuture<Integer> {

      assertTrue("setUp should have run", setUpRan.get());
      try {
        return method.invoke(map, args);
      } catch (InvocationTargetException e) {
        throw e.getCause();
      } catch (IllegalAccessException e) {
        throw newLinkageError(e);
      }
    }
  }

  /** Verifies that {@code setUp} and {@code tearDown} are called in all map test cases. */