}
    }

    private static class RunnableExecutorPair {
      final Runnable runnable;
      final Executor executor;

      RunnableExecutorPair(Runnable runnable, Executor executor) {
        this.runnable = runnable;
        this.executor = executor;
      }

      void execute() {
        try {
          executor.execute(runnable);
        } catch (RuntimeException e) {

      Runnable runnable, @ParametricNullness V result) {
    return new ListenableFutureTask<>(runnable, result);
  }

  ListenableFutureTask(Callable<V> callable) {
    super(callable);
  }

  ListenableFutureTask(Runnable runnable, @ParametricNullness V result) {
    super(runnable, result);
  }

  @Override
  public void addListener(Runnable listener, Executor exec) {

                  + runnable
                  + " with executor "
                  + executor,
              e);
    }
  }

  private static final class RunnableExecutorPair {
    final Runnable runnable;
    final Executor executor;
    @Nullable RunnableExecutorPair next;

    RunnableExecutorPair(

   */
  @SuppressWarnings({"InlineLambdaConstant", "UnnecessaryLambda"})
  private static final Runnable EMPTY_RUNNABLE = () -> {};

  /** Returns a {@link Runnable} instance that does nothing when run. */
  public static Runnable doNothing() {
    return EMPTY_RUNNABLE;
  }

  private Runnables() {}

  }

  private static class ForwardingRunnable implements Runnable {

    private final Runnable runnable;

    ForwardingRunnable(Runnable runnable) {
      this.runnable = runnable;
    }

    @Override
    public void run() {
      runnable.run();
    }

    @Override
    public String toString() {
      return runnable.toString();
    }
  }

  private interface Adder {

  }

  public void testToString() {
    Runnable[] currentTask = new Runnable[1];
    Executor delegate =
        new Executor() {
          @Override
          public void execute(Runnable task) {
            currentTask[0] = task;
            task.run();
            currentTask[0] = null;
          }

          @Override
          public String toString() {

      }
    }

    private static class RunnableExecutorPair {
      final Runnable runnable;
      final Executor executor;

      RunnableExecutorPair(Runnable runnable, Executor executor) {
        this.runnable = runnable;
        this.executor = executor;
      }

      void execute() {
        try {
          executor.execute(runnable);
        } catch (RuntimeException e) {

  enum WorkerRunningState {
    /** Runnable is not running and not queued for execution */
    IDLE,
    /** Runnable is not running, but is being queued for execution */
    QUEUING,
    /** runnable has been submitted but has not yet begun execution */
    QUEUED,
    RUNNING,
  }

  /** Underlying executor that all submitted Runnable objects are run on. */
  private final Executor executor;

   * @throws UncheckedExecutionException if {@code runnable} throws a {@code RuntimeException}
   * @throws ExecutionError if {@code runnable} throws an {@code Error}
   * @since 22.0
   */
  void runWithTimeout(Runnable runnable, long timeoutDuration, TimeUnit timeoutUnit)
      throws TimeoutException, InterruptedException;

  /**
   * Invokes a specified Runnable, timing out after the specified time limit. If the target method

    }

    @Override
    public T call() throws Exception {
      return delegate.call();
    }
  }

  private static final class WrappedRunnable implements Runnable {
    private final Runnable delegate;

    WrappedRunnable(Runnable delegate) {
      this.delegate = delegate;
    }

    @Override
    public void run() {
      delegate.run();
    }
  }