}

  public void testCallWithTimeout_wrapsCheckedException() throws Exception {
    Exception exception = new SampleCheckedException();
    ExecutionException e =
        assertThrows(
            ExecutionException.class,
            () -> timeLimiter.callWithTimeout(callableThrowing(exception), DELAY_MS, MILLISECONDS));
    assertThat(e).hasCauseThat().isEqualTo(exception);
  }

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.DoNotMock;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.jspecify.annotations.Nullable;

/**
 * Imposes a time limit on method calls.
 *
 * @author Kevin Bourrillion

    throwException = true;

    // Start up the task and unblock the latch to finish the task.
    exec.execute(task);
    runLatch.await();
    taskLatch.countDown();

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

    assertTrue(listenerLatch.await(5, SECONDS));
    assertTrue(task.isDone());

   *       Futures#getUnchecked}.
   * </ul>
   *
   * @throws ExecutionException if the computation threw an exception
   * @throws CancellationException if the computation was cancelled
   */
  @CanIgnoreReturnValue
  @ParametricNullness
  public static <V extends @Nullable Object> V getUninterruptibly(Future<V> future)
      throws ExecutionException {
    boolean interrupted = false;
    try {
      while (true) {

  public void testFutureGetThrowsRuntimeException() throws Exception {
    BadFuture badInput = new BadFuture(immediateFuture(20));
    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. */

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

          .put(
              ConcurrentModificationException.class,
              e -> e instanceof ConcurrentModificationException)
          .put(ExecutionException.class, e -> e instanceof ExecutionException)
          .put(IllegalArgumentException.class, e -> e instanceof IllegalArgumentException)
          .put(IllegalStateException.class, e -> e instanceof IllegalStateException)

          .put(
              ConcurrentModificationException.class,
              e -> e instanceof ConcurrentModificationException)
          .put(ExecutionException.class, e -> e instanceof ExecutionException)
          .put(IllegalArgumentException.class, e -> e instanceof IllegalArgumentException)
          .put(IllegalStateException.class, e -> e instanceof IllegalStateException)

    ScheduledExecutorService executor = newScheduledThreadPool(1);
    try {
      FluentFuture<?> f =
          FluentFuture.from(SettableFuture.create()).withTimeout(0, SECONDS, executor);
      ExecutionException e = assertThrows(ExecutionException.class, () -> f.get());
      assertThat(e).hasCauseThat().isInstanceOf(TimeoutException.class);
    } finally {
      executor.shutdown();
    }
  }

  public void testFutureGetThrowsRuntimeException() throws Exception {
    BadFuture badInput = new BadFuture(immediateFuture(20));
    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. */