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 {
    SettableFuture<String> future = SettableFuture.create();

      throws InterruptedException, ExecutionException {
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

    assertTrue(latch.await(5, SECONDS));
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

    assertEquals(expectedValue, future.get());
  }

  public void testCancelledFuture() throws InterruptedException, ExecutionException {
    assertTrue(future.isDone());

      // we should get an ExecutionException; if we call getUnchecked(), we should get an
      // UncheckedExecutionException.
      int mod = i % 3;
      if (mod == 0 || mod == 2) {
        assertThat(result.get(i)).isInstanceOf(ExecutionException.class);
        assertThat((ExecutionException) result.get(i)).hasCauseThat().isSameInstanceAs(e);
      } else {

        // Git revision range syntax is part of git, not the shell; pass as-is.
        return getStdoutLines(new String[] {"git", "diff", "--name-only", commit + "^1.." + commit});
    }

    private static List<String> branchesOf(String commit) throws IOException, InterruptedException, ExecutionException {

    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 {
    SettableFuture<String> future = SettableFuture.create();

    AbstractFuture<String> future =
        new AbstractFuture<String>() {
          {
            setException(failure);
          }
        };

    ExecutionException ee1 = getExpectingExecutionException(future);
    ExecutionException ee2 = getExpectingExecutionException(future);

    // Ensure we get a unique execution exception on each get
    assertThat(ee1).isNotSameInstanceAs(ee2);

        throws ExecutionException, InterruptedException {
      assertTaskWrapped(tasks);
      lastMethodCalled = "invokeAny";
      return inline.submit(Iterables.get(tasks, 0)).get();
    }

    @Override
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
        throws ExecutionException, InterruptedException, TimeoutException {

    assertThat(future.toString()).endsWith("[status=FAILURE, cause=[" + exception + "]]");

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

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

    assertThat(future.toString()).endsWith("[status=FAILURE, cause=[" + exception + "]]");

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

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

    AbstractFuture<String> future =
        new AbstractFuture<String>() {
          {
            setException(failure);
          }
        };

    ExecutionException ee1 = getExpectingExecutionException(future);
    ExecutionException ee2 = getExpectingExecutionException(future);

    // Ensure we get a unique execution exception on each get
    assertThat(ee1).isNotSameInstanceAs(ee2);