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

    private int count
    private final TestExecutor executor;

    TestManagedExecutor(TestExecutor executor) {
        this.executor = executor
    }

    void execute(Runnable command) {
        lock.lock()
        try {
            count++
        } finally {
            lock.unlock()
        }

        executor.execute {
            try {
                command.run()

    def processor = Mock(InitScriptProcessor)
    def executor = new TestBuildOperationRunner()
    def gradle = Mock(GradleInternal)
    def startParameter = Stub(StartParameterInternal)
    def resourceLoader = Stub(TextFileResourceLoader)
    def handler = new InitScriptHandler(processor, executor, resourceLoader)

    def setup() {
        _ * gradle.startParameter >> startParameter
    }

        }
      }
    }
  }

  /**
   * 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++;
    }
  }

    "Counts how often a successful export from TF Dialect to Executor Dialect "
    "is",
    "status");

constexpr char kExportSuccess[] = "success";
constexpr char kExportFailed[] = "failed";

namespace {

void AddTfDialectToExecutorPasses(OpPassManager &pm) {
  pm.addPass(mlir::TF::CreateTFRegionControlFlowToFunctional());

  // First, we need to convert from functional, to executor dialect.
  pm.addNestedPass<FuncOp>(