}

    final SettableFuture<V> delegate = SettableFuture.create();

    @Override
    protected Future<V> delegate() {
      return delegate;
    }

    void set(V value) {
      delegate.set(value);
    }
  }

  private static final class RuntimeExceptionThrowingFuture<V> implements Future<V> {
    final CountDownLatch allowGetToComplete = new CountDownLatch(1);

    @Override

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

/**
 * Implementation of {@code Futures#withTimeout}.
 *

        TestHandleReconnector testReconnector = new TestHandleReconnector(mockManager, true);

        CompletableFuture<HandleInfo> future = testReconnector.reconnectHandle("/test/file.txt", new IOException("Network error"));

        HandleInfo result = future.get();
        assertNotNull(result);
        assertEquals(testHandle, result);

        verify(mockManager).completeReconnect("/test/file.txt", true);
    }

    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();

    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();

import java.util.concurrent.Future;
import org.jspecify.annotations.Nullable;

/** Emulation of Uninterruptibles in GWT. */
public final class Uninterruptibles {

  private Uninterruptibles() {}

  @CanIgnoreReturnValue
  public static <V extends @Nullable Object> V getUninterruptibly(Future<V> future)
      throws ExecutionException {
    try {
      return future.get();
    } catch (InterruptedException e) {

 * the License.
 */

package com.google.common.util.concurrent.internal;


/**
 * A future that, if it fails, may <i>optionally</i> provide access to the cause of the failure.
 *
 * <p>This class is used only for micro-optimization. Standard {@code Future} utilities benefit from
 * this optimization, so there is no need to specialize methods to return or accept this type

    /**
     * Contains the most recently submitted {@code Future}, which may be cancelled or updated,
     * always under a lock.
     */
    private static final class SupplantableFuture implements Cancellable {
      private final ReentrantLock lock;

      @GuardedBy("lock")
      private Future<@Nullable Void> currentFuture;

      SupplantableFuture(ReentrantLock lock, Future<@Nullable Void> currentFuture) {
        this.lock = lock;

  public void testScheduleRunnable() throws Exception {
    Runnable command = () -> {};

    ListenableScheduledFuture<?> future = executorService.schedule(command, Duration.ofSeconds(12));

    assertThat(future.get()).isEqualTo("schedule");
    assertThat(recordedCommand).isSameInstanceAs(command);
    assertThat(recordedTimeUnit).isEqualTo(NANOSECONDS);

              ((finalState & (CANCELLED | INTERRUPTED)) != 0)
                  ? new CancellationException("Future.cancel() was called.")
                  : t;
          releaseShared(finalState);
        } else if (getState() == COMPLETING) {
          // If some other thread is currently completing the future, block until
          // they are done so we can guarantee completion.
          acquireShared(-1);
        }