FutureTask<Boolean> interruptReporter = untimedInterruptReporter(future, false);

    runNInterruptsTest(times, future, interruptReporter);
  }

  private static void runTimedInterruptsTest(int times)
      throws InterruptedException, ExecutionException, TimeoutException {
    SettableFuture<String> future = SettableFuture.create();

    FutureTask<Boolean> interruptReporter = untimedInterruptReporter(future, false);

    runNInterruptsTest(times, future, interruptReporter);
  }

  private static void runTimedInterruptsTest(int times)
      throws InterruptedException, ExecutionException, TimeoutException {
    SettableFuture<String> future = SettableFuture.create();

  private fun serviceSocketTask(socket: BufferedSocket): FutureTask<Void> {
    return FutureTask<Void> {
      socket.source.use {
        socket.sink.use {
          while (true) {
            val action = actions.poll() ?: break
            action(socket)
          }
        }
      }
      return@FutureTask null
    }
  }

import java.util.concurrent.Executor;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.jspecify.annotations.Nullable;

/**
 * A {@link FutureTask} that also implements the {@link ListenableFuture} interface. Unlike {@code
 * FutureTask}, {@code ListenableFutureTask} does not provide an overrideable {@link

          protected Integer initialValue() {
            return 0;
          }
        };
    Runnable incrementTask = () -> threadLocalCount.set(threadLocalCount.get() + 1);

    FutureTask<@Nullable Void> otherTask =
        new FutureTask<>(
            () -> {
              Future<?> future = executor.submit(incrementTask);
              assertTrue(future.isDone());

      val existingTask = activeTask
      if (existingTask is AwaitIdleTask) {
        return existingTask.latch
      }
      for (futureTask in futureTasks) {
        if (futureTask is AwaitIdleTask) {
          return futureTask.latch
        }
      }

      // Don't delegate to schedule() because that enforces shutdown rules.
      val newTask = AwaitIdleTask()

          protected Integer initialValue() {
            return 0;
          }
        };
    Runnable incrementTask = () -> threadLocalCount.set(threadLocalCount.get() + 1);

    FutureTask<@Nullable Void> otherTask =
        new FutureTask<>(
            () -> {
              Future<?> future = executor.submit(incrementTask);
              assertTrue(future.isDone());

        (timeout == null) ? "untimed" : timeout,
        scenario,
        expectedOutcome);
  }

  @Override
  protected void runTest() throws Throwable {
    FutureTask<@Nullable Void> task = new FutureTask<>(this::runChosenTest, null);
    startThread(task::run);
    awaitUninterruptibly(doingCallLatch);
    long hangDelayMillis =
        (expectedOutcome == Outcome.HANG)

    assertFalse(waiter.isAlive());
  }

  public void testAwaitTerminated_failedService() throws Exception {
    ManualSwitchedService service = new ManualSwitchedService();
    FutureTask<IllegalStateException> waiter =
        new FutureTask<>(() -> assertThrows(IllegalStateException.class, service::awaitTerminated));
    new Thread(waiter).start();
    service.startAsync();
    service.notifyStarted();

    assertFalse(waiter.isAlive());
  }

  public void testAwaitTerminated_failedService() throws Exception {
    ManualSwitchedService service = new ManualSwitchedService();
    FutureTask<IllegalStateException> waiter =
        new FutureTask<>(() -> assertThrows(IllegalStateException.class, service::awaitTerminated));
    new Thread(waiter).start();
    service.startAsync();
    service.notifyStarted();