static final Future<String> FAILED_FUTURE_OTHER_THROWABLE =
      immediateFailedFuture(OTHER_THROWABLE);
  static final Error ERROR = new Error("mymessage");
  static final Future<String> FAILED_FUTURE_ERROR = immediateFailedFuture(ERROR);
  static final Future<String> RUNTIME_EXCEPTION_FUTURE =
      UncheckedThrowingFuture.throwingRuntimeException(RUNTIME_EXCEPTION);

          }

          @Override
          public void onFailure(Throwable t) {
            failureCalls[0]++;
          }
        };
    addCallback(future, callback, directExecutor());
    future.set(result);
    assertEquals(result, future.get());
    assertThat(successCalls[0]).isEqualTo(1);
    assertThat(failureCalls[0]).isEqualTo(0);
  }

  public void testOnSuccessThrowsError() throws Exception {

      Class<X> exceptionType,
      Function<? super X, ? extends V> fallback,
      Executor executor) {
    CatchingFuture<V, X> future = new CatchingFuture<>(input, exceptionType, fallback);
    input.addListener(future, rejectionPropagatingExecutor(executor, future));
    return future;
  }

  static <X extends Throwable, V extends @Nullable Object> ListenableFuture<V> create(
      ListenableFuture<? extends V> input,

 * result. (If you want such access, you may prefer {@link Futures#addCallback
 * Futures.addCallback}.) Still, direct {@code addListener} calls are occasionally useful:
 *
 * <pre>{@code
 * final String name = ...;
 * inFlight.add(name);
 * ListenableFuture<Result> future = service.query(name);
 * future.addListener(new Runnable() {
 *   public void run() {

            return taskDone;
          }
        };
    List<Future<Boolean>> futureList =
        executor.invokeAll(ImmutableList.of(task), 10, TimeUnit.MILLISECONDS);
    Future<Boolean> future = futureList.get(0);
    assertFalse(taskDone);
    assertTrue(future.isDone());
    assertThrows(CancellationException.class, () -> future.get());
  }

 * result.
 *
 * @since 20.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface AsyncCallable<V extends @Nullable Object> {
  /**
   * Computes a result {@code Future}. The output {@code Future} need not be {@linkplain
   * Future#isDone done}, making {@code AsyncCallable} suitable for asynchronous derivations.
   *
   * <p>Throwing an exception from this method is equivalent to returning a failing {@link

@GwtIncompatible
public class MockFutureListener implements Runnable {
  private final CountDownLatch countDownLatch;
  private final ListenableFuture<?> future;

  public MockFutureListener(ListenableFuture<?> future) {
    this.countDownLatch = new CountDownLatch(1);
    this.future = future;

    future.addListener(this, directExecutor());
  }

  @Override
  public void run() {
    countDownLatch.countDown();
  }

  /**

    assertFalse(future.isCancelled());

    ExecutorService executor = Executors.newSingleThreadExecutor();

    try {
      Future<Boolean> getResult = executor.submit(() -> future.get());

      // Release the future value.
      latch.countDown();

      assertTrue(getResult.get(10, SECONDS));
    } finally {
      executor.shutdownNow();
    }

    assertTrue(future.isDone());

        List<Future<ProjectSegment>> futures = new ArrayList<>();
        for (ProjectSegment projectBuild : projectBuildList) {
            final Future<ProjectSegment> buildFuture =
                    service.submit(new Outputter(threadOutputMuxer, projectBuild, lyrics.next()));
            futures.add(buildFuture);
        }

        for (Future<ProjectSegment> future : futures) {
            future.get();

    SettableFuture<Integer> future = SettableFuture.create();
    assertTrue(future.set(42));
    // Later attempts to set the future should return false.
    assertFalse(future.set(23));
    assertFalse(future.setException(new Exception("bar")));
    assertFalse(future.setFuture(SettableFuture.<Integer>create()));
    // Check that the future has been set properly.
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());