@Override
  AbstractFuture<@Nullable Integer> newDelegate() {
    AbstractFuture<@Nullable Integer> future = new AbstractFuture<@Nullable Integer>() {};
    assertFalse(future instanceof TrustedFuture); // sanity check
    return future;
  }

  private final State<V> state;

  private ClosingFuture(ListenableFuture<V> future) {
    this(future, new CloseableList());
  }

  private ClosingFuture(ListenableFuture<V> future, CloseableList closeables) {
    this.state = new State<>(FluentFuture.from(future), closeables);
    FinalizableReference.register(this);
  }

  /**
   * Returns a future that finishes when this step does. Calling {@code get()} on the returned

  }

  /**
   * Waits until the given future {@linkplain Future#isDone is done}, invoking the garbage collector
   * as necessary to try to ensure that this will happen.
   *
   * @throws RuntimeException if timed out or interrupted while waiting
   */
  @SuppressWarnings("removal") // b/487687332
  public static void awaitDone(Future<?> future) {
    if (future.isDone()) {
      return;
    }

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.jspecify.annotations.Nullable;

/**
 * A {@link Future} which forwards all its method calls to another future. Subclasses should
 * override one or more methods to modify the behavior of the backing future as desired per the <a

   * java.util.Collections#emptySet}
   */
  NONE;

  private final Set<Feature<? super Collection>> implied;

  CollectionFeature(Feature<? super Collection>... implied) {
    this.implied = copyToSet(implied);
  }

  @Override
  public Set<Feature<? super Collection>> getImpliedFeatures() {
    return implied;
  }

  @Retention(RetentionPolicy.RUNTIME)

  /**
   * Returns an output {@code Future} to use in place of the given {@code input}. The output {@code
   * Future} need not be {@linkplain Future#isDone done}, making {@code AsyncFunction} suitable for
   * asynchronous derivations.
   *
   * <p>Throwing an exception from this method is equivalent to returning a failing {@code Future}.
   */

    }

    @Override
    public Iterable<E> order(List<E> insertionOrder) {
      return gen.order(insertionOrder);
    }
  }

  private static Set<Feature<?>> computeReserializedCollectionFeatures(Set<Feature<?>> features) {
    Set<Feature<?>> derivedFeatures = new HashSet<>(features);
    derivedFeatures.remove(SERIALIZABLE);
    derivedFeatures.remove(SERIALIZABLE_INCLUDING_VIEWS);
    return derivedFeatures;
  }

import com.google.common.collect.testing.DerivedCollectionGenerators.SortedSetSubsetTestSetGenerator;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.Feature;
import com.google.common.collect.testing.testers.CollectionAddAllTester;
import com.google.common.collect.testing.testers.CollectionAddTester;
import com.google.common.collect.testing.testers.SortedSetNavigationTester;

import com.google.common.collect.testing.DerivedCollectionGenerators.SortedSetSubsetTestSetGenerator;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.Feature;
import com.google.common.collect.testing.testers.CollectionAddAllTester;
import com.google.common.collect.testing.testers.CollectionAddTester;
import com.google.common.collect.testing.testers.SortedSetNavigationTester;

    Callable<String> callable = () -> expected;

    AsyncCallable<String> asyncCallable =
        Callables.asAsyncCallable(callable, newDirectExecutorService());

    ListenableFuture<String> future = asyncCallable.call();
    assertThat(future.get()).isEqualTo(expected);
  }

  @J2ktIncompatible
  @GwtIncompatible
  public void testAsAsyncCallable_exception() throws Exception {
    Exception expected = new IllegalArgumentException();