*/
  public <T extends @Nullable Object> ListenableFuture<T> submitAsync(
      AsyncCallable<T> callable, Executor executor) {
    checkNotNull(callable);
    checkNotNull(executor);
    TaskNonReentrantExecutor taskExecutor = new TaskNonReentrantExecutor(executor, this);
    AsyncCallable<T> task =
        new AsyncCallable<T>() {
          @Override

        }

        @Override
        public void stop() {
            ManagedExecutor executor;
            lock.lock();
            try {
                executor = this.executor;
            } finally {
                lock.unlock();
            }
            if (executor != null) {
                executor.stop();
            }
        }

        public void add(C command) {

    abstract TestClassExecutionResult assertFailedToExecute(TestExecutionResult testResult, String testClassName)

    String getStableEnvironmentDependencies() {
        return testFrameworkDependencies
    }

    def "executes tests in the correct environment"() {
        given:
        file('src/test/java/org/gradle/OkTest.java') << """
            package org.gradle;

            import java.io.File;
            import java.io.PrintStream;

import java.util.Collection;
import java.util.concurrent.Executor;
import java.util.concurrent.locks.Lock;

class ExpectAllRequestsThenReleaseAll extends ExpectMaxNConcurrentRequestsThenRelease {
    ExpectAllRequestsThenReleaseAll(Lock lock, int testId, Duration timeout, WaitPrecondition previous, Collection<? extends ResourceExpectation> expectations, Executor executor) {

import java.util.Collection;
import java.util.concurrent.Executor;
import java.util.concurrent.locks.Lock;

public class ExpectMaxNRequestsThenReleaseOne extends ExpectMaxNConcurrentRequestsThenRelease {
    public ExpectMaxNRequestsThenReleaseOne(Lock lock, int testId, Duration timeout, int maxConcurrent, WaitPrecondition previous, Collection<? extends ResourceExpectation> expectedRequests, Executor executor) {

        @Override
        public void connectStreams(Process process, String processName, Executor executor) {
            inputHandler.connectStreams(process, processName, executor);
            outputHandler.connectStreams(process, processName, executor);
        }

        @Override
        public void start() {
            inputHandler.start();
            outputHandler.start();

        }
      }
    }
  }

  /**
   * Checks if the executor has been shut down and increments the running task count.
   *
   * @throws RejectedExecutionException if the executor has been previously shutdown
   */
  private void startTask() {
    synchronized (lock) {
      if (shutdown) {
        throw new RejectedExecutionException("Executor already shutdown");
      }
      runningTasks++;
    }
  }

    public RunBuildAction(
        BuildActionExecutor<BuildActionParameters, ClientBuildRequestContext> executor, StartParameterInternal startParameter, GradleLauncherMetaData clientMetaData, long startTime,
        BuildActionParameters buildActionParameters, ServiceRegistry sharedServices, Stoppable stoppable) {
        this.executor = executor;
        this.startParameter = startParameter;
        this.clientMetaData = clientMetaData;

            class CustomPlugin implements Plugin<Project> {
                private final WorkerExecutor executor

                @Inject
                CustomPlugin(WorkerExecutor executor) {
                    this.executor = executor
                }

                void apply(Project p) {
                    println(executor != null ? "got it" : "NOT IT")

                    // is not generated

    private final ConsumerActionExecutor actionExecutor;
    private final ManagedExecutor executor;
    private final ServiceLifecycle lifecycle;

    public DefaultAsyncConsumerActionExecutor(ConsumerActionExecutor actionExecutor, ExecutorFactory executorFactory) {
        this.actionExecutor = actionExecutor;
        executor = executorFactory.create("Connection worker");