*/
  public static <V extends @Nullable Object> ListenableFuture<V> listenInPoolThread(
      Future<V> future, Executor executor) {
    checkNotNull(executor);
    if (future instanceof ListenableFuture) {
      return (ListenableFuture<V>) future;
    }
    return new ListenableFutureAdapter<>(future, executor);
  }

  /**
   * An adapter to turn a {@link Future} into a {@link ListenableFuture}. This will wait on the

  }

  private void parallelDrainQueue(int threadCount) {
    ExecutorService executor = Executors.newFixedThreadPool(threadCount);
    for (int i = 0; i < threadCount; i++) {
      executor.execute(() -> {
        try {
          drainQueue();
        } catch (Exception e) {
          e.printStackTrace();
        }
      });
    }
    executor.shutdown();
  }

  private void drainQueue() throws Exception {

  private static AsyncCallable<Integer> asyncAdd(
      final ListenableFuture<Integer> future, final int delta, final Executor executor) {
    return new AsyncCallable<Integer>() {
      @Override
      public ListenableFuture<Integer> call() throws Exception {
        return Futures.transform(future, add(delta), executor);
      }
    };
  }

  private static final class LongHolder {
    long count;
  }

    assertEquals(0, numCalls.get());
    reject.set(false);
    executor.execute(task);
    assertEquals(1, numCalls.get());
  }

  /*
   * Under Android, MyError propagates up and fails the test?
   *
   * TODO(b/218700094): Does this matter to prod users, or is it just a feature of our testing

      assertEquals(Service.State.STOPPING, state());
      shutdownCalled++;
    }

    @Override
    protected Executor executor() {
      return executor;
    }

    @Override
    public void tearDown() throws Exception {
      executor.shutdown();
    }
  }

    super(identifier, executor, Dispatcher.legacyAsync(), LoggingHandler.INSTANCE);
  }

  /**
   * Creates a new AsyncEventBus that will use {@code executor} to dispatch events.
   *
   * @param executor Executor to use to dispatch events. It is the caller's responsibility to shut
   *     down the executor after the last event has been posted to this event bus.

class RelayTest {
  @TempDir
  var tempDir: File? = null
  private val executor = Executors.newCachedThreadPool(threadFactory("RelayTest"))
  private val metadata: ByteString = "great metadata!".encodeUtf8()
  private lateinit var file: File

  @BeforeEach
  fun setUp() {
    file = File(tempDir, "test")
  }

  @AfterEach
  fun tearDown() {
    executor.shutdown()
  }

  @Test
  fun singleSource() {

import com.google.common.util.concurrent.AbstractFutureBenchmarks.Facade;
import com.google.common.util.concurrent.AbstractFutureBenchmarks.Impl;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.Executor;

/** Measures the size of AbstractFuture implementations. */
public class AbstractFutureFootprintBenchmark {

  enum State {
    NOT_DONE,
    FINISHED,
    CANCELLED,
    FAILED
  }

   */
  public static <V extends @Nullable Object> ListenableFuture<V> listenInPoolThread(
      Future<V> future, Executor executor) {
    checkNotNull(executor);
    if (future instanceof ListenableFuture) {
      return (ListenableFuture<V>) future;
    }
    return new ListenableFutureAdapter<>(future, executor);
  }

  /**
   * An adapter to turn a {@link Future} into a {@link ListenableFuture}. This will wait on the

      /** The future that represents the next execution of this task. */
      @GuardedBy("lock")
      @CheckForNull
      private SupplantableFuture cancellationDelegate;

      ReschedulableCallable(
          AbstractService service, ScheduledExecutorService executor, Runnable runnable) {
        this.wrappedRunnable = runnable;
        this.executor = executor;
        this.service = service;
      }