import com.google.common.util.concurrent.AbstractFuture.TrustedFuture;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for {@link AbstractFuture} that use a non-{@link TrustedFuture} for {@link
 * AbstractFuture#setFuture} calls.
 */
@GwtCompatible
@NullUnmarked
public class UntrustedInputFutureTest extends AbstractAbstractFutureTest {
  @Override
  AbstractFuture<Integer> newDelegate() {

            executor.execute(runnable);
          }
        };
    Future<?> future = newFutureInstance();
    future
        .getClass()
        .getMethod(
            "setFuture",
            future.getClass().getClassLoader().loadClass(ListenableFuture.class.getName()))
        .invoke(future, badFuture);
    CancellationException expected = assertThrows(CancellationException.class, () -> future.get());

            executor.execute(runnable);
          }
        };
    Future<?> future = newFutureInstance();
    future
        .getClass()
        .getMethod(
            "setFuture",
            future.getClass().getClassLoader().loadClass(ListenableFuture.class.getName()))
        .invoke(future, badFuture);
    CancellationException expected = assertThrows(CancellationException.class, () -> future.get());

        () -> {
          if (taskFuture.isDone()) {
            // Since the value of oldFuture can only ever be immediateFuture(null) or setFuture of
            // a future that eventually came from immediateFuture(null), this doesn't leak
            // throwables or completion values.
            newFuture.setFuture(oldFuture);
          } else if (outputFuture.isCancelled() && taskExecutor.trySetCancelled()) {

    public void run() {
      // This prevents cancellation from propagating because we don't call setFuture(delegate) until
      // delegate is already done, so calling cancel() on this future won't affect it.
      @RetainedLocalRef ListenableFuture<V> localDelegate = delegate;
      if (localDelegate != null) {
        setFuture(localDelegate);
      }
    }

    @Override
    protected @Nullable String pendingToString() {

       * even with the above null checks.)
       */
      timeoutFutureRef = null;
      if (delegate.isDone()) {
        timeoutFuture.setFuture(delegate);
      } else {
        try {
          @RetainedLocalRef ScheduledFuture<?> timer = timeoutFuture.timer;
          timeoutFuture.timer = null; // Don't include already elapsed delay in delegate.toString()

       *   either this Future was cancelled (which we ruled out with the isCancelled check above),
       *   or it had already failed. (It couldn't have completed *successfully* or even had
       *   setFuture called on it: Neither of those can happen until we've finished processing all
       *   the completed inputs. And we're still processing at least one input, the one that
       *   triggered handleException.)
       *

   *   <li>{@link Cancellation} terminal state, {@code cancel} was called.
   *   <li>{@link Failure} terminal state, {@code setException} was called.
   *   <li>{@link DelegatingToFuture} intermediate state, {@code setFuture} was called.
   *   <li>{@link #NULL} terminal state, {@code set(null)} was called.
   *   <li>Any other non-null value, terminal state, {@code set} was called with a non-null
   *       argument.
   * </ul>
   */

   *   <li>{@link Cancellation} terminal state, {@code cancel} was called.
   *   <li>{@link Failure} terminal state, {@code setException} was called.
   *   <li>{@link DelegatingToFuture} intermediate state, {@code setFuture} was called.
   *   <li>{@link #NULL} terminal state, {@code set(null)} was called.
   *   <li>Any other non-null value, terminal state, {@code set} was called with a non-null
   *       argument.
   * </ul>
   */

@GwtCompatible
public abstract class FluentFuture<V extends @Nullable Object>
    extends GwtFluentFutureCatchingSpecialization<V> {

  /**
   * A less abstract subclass of AbstractFuture. This can be used to optimize setFuture by ensuring
   * that {@link #get} calls exactly the implementation of {@link AbstractFuture#get}.
   */
  abstract static class TrustedFuture<V extends @Nullable Object> extends FluentFuture<V>