@CanIgnoreReturnValue
  @Override
  public boolean set(@ParametricNullness V value) {
    return super.set(value);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean setException(Throwable throwable) {
    return super.setException(throwable);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean setFuture(ListenableFuture<? extends V> future) {
    return super.setFuture(future);
  }

    assertThat(future.set(1)).isTrue();
    assertSuccessful(future, 1);
  }

  public void testFailed() throws Exception {
    Exception cause = new Exception();
    assertThat(future.setException(cause)).isTrue();
    assertFailed(future, cause);
  }

  public void testCanceled() throws Exception {
    assertThat(future.cancel(false /* mayInterruptIfRunning */)).isTrue();
    assertCancelled(future, false);

    return new UncheckedThrowingFuture<V>();
  }

  public void complete(RuntimeException e) {
    if (!super.setException(new WrapperException(checkNotNull(e)))) {
      throw new IllegalStateException("Future was already complete: " + this);
    }
  }

  public void complete(Error e) {
    if (!super.setException(new WrapperException(checkNotNull(e)))) {
      throw new IllegalStateException("Future was already complete: " + this);

     * thread immediately fails with the same exception:
     *
     * Thread1: calls setException(), which returns true, context switch before it can CAS
     * seenExceptionsField to its exception
     *
     * Thread2: calls setException(), which returns false, CASes seenExceptionsField to its
     * exception, and wrongly believes that its exception is new (leading it to logging it when it

    void afterRanInterruptiblySuccess(@ParametricNullness V result) {
      TrustedListenableFutureTask.this.set(result);
    }

    @Override
    void afterRanInterruptiblyFailure(Throwable error) {
      setException(error);
    }

    @Override
    String toPendingString() {
      return callable.toString();
    }
  }

  @WeakOuter
  private final class TrustedFutureInterruptibleAsyncTask

         *
         * @return A {@link Map} where keys are {@link Repository} instances and values are {@link Exception} instances.
         */
        Map<Repository, List<Exception>> getExceptions();

        /**
         * Returns the repository from which the artifact was resolved.
         *
         * @return The {@link Repository} instance.
         */
        Repository getRepository();

          });
      executor.execute(
          new Runnable() {
            @Override
            public void run() {
              future.setException(new IllegalArgumentException("failure"));
              if (!future.isDone()) {
                errorMessage.set("SetException call exited before future was complete.");
              }
            }
          });
      executor.execute(
          new Runnable() {

import org.apache.maven.api.annotations.Nonnull;

/**
 *
 * @since 4.0.0
 */
@Experimental
public interface VersionResolverResult extends Result<VersionResolverRequest> {

    @Nonnull
    List<Exception> getExceptions();

    @Nonnull
    Version getVersion();

    @Nonnull
    Optional<Repository> getRepository();

        if (result.hasExceptions()) {
            throw new ArtifactResolutionException(
                    "Unknown error during artifact resolution, " + request + ", " + result.getExceptions(),
                    request.getArtifact(),
                    request.getRemoteRepositories());
        }
    }

    private static <T> List<T> toList(Collection<T> items) {

       * class with a manual reference back to the "containing" class.)
       *
       * This has the nice-ish side effect of limiting reentrancy: run() calls
       * timeoutFuture.setException() calls run(). That reentrancy would already be harmless, since
       * timeoutFuture can be set (and delegate cancelled) only once. (And "set only once" is