}

    def "getting a worker daemon does not assume client use"() {
        when:
        factory.getWorker(requirement);

        then:
        0 * clientsManager._
    }

    def "new client is created when daemon is executed and no idle clients found"() {
        when:
        factory.getWorker(requirement).execute(spec)

        then:
        1 * clientsManager.reserveIdleClient(options) >> null

        1 * executionQueue.submit(_) >> { args -> task = args[0] }

        when:
        task.getExecution().run()

        then:
        1 * workerDaemonFactory.getWorker(_) >> worker
        1 * worker.execute(_, _) >> { spec, buildOperation ->
            assert spec.implementationClass == TestExecutable.class
            return new DefaultWorkResult(true, null)
        }
    }

        this.buildOperationRunner = buildOperationRunner;
        this.workerDaemonClientCancellationHandler = workerDaemonClientCancellationHandler;
    }

    @Override
    public BuildOperationAwareWorker getWorker(WorkerRequirement workerRequirement) {
        return new AbstractWorker(buildOperationRunner) {
            @Override

        this.actionExecutionSpecFactory = actionExecutionSpecFactory;
        this.instantiatorFactory = instantiatorFactory;
    }

    @Override
    public BuildOperationAwareWorker getWorker(WorkerRequirement workerRequirement) {
        return new AbstractWorker(buildOperationRunner) {
            @Override

    @Override
    WorkerProcessBuilder sharedPackages(Iterable<String> packages);

    @Override
    WorkerProcessBuilder sharedPackages(String... packages);

    Action<? super WorkerProcessContext> getWorker();

    void setImplementationClasspath(List<URL> implementationClasspath);

    void setImplementationModulePath(List<URL> implementationModulePath);

    void enableJvmMemoryInfoPublishing(boolean shouldPublish);

    public void setWorkerExecutor(WorkerExecutor workerExecutor) {
        this.workerExecutor = workerExecutor;
    }

    @Override
    public BuildOperationAwareWorker getWorker(WorkerRequirement workerRequirement) {
        final WorkerExecutor workerExecutor = this.workerExecutor;
        final ClassLoader contextClassLoader = ((FixedClassLoaderWorkerRequirement) workerRequirement).getContextClassLoader();

                gradleUserHomeDir.getAbsolutePath(),
                (MultiChoiceAddress) serverAddress,
                workerId,
                displayName,
                processBuilder.getWorker(),
                processBuilder.getNativeServicesMode()
            );

            // Serialize the worker config, this is consumed by SystemApplicationClassLoaderWorker

    public WorkerProcessBuilder worker(Action<? super WorkerProcessContext> action) {
        this.action = action;
        return this;
    }

    @Override
    public Action<? super WorkerProcessContext> getWorker() {
        return action;
    }

    @Override
    public JavaExecHandleBuilder getJavaCommand() {
        return javaCommand;
    }

    @Override
    public LogLevel getLogLevel() {

        WorkItemExecution execution = new WorkItemExecution(spec.getDisplayName(), () -> {
            try {
                BuildOperationAwareWorker worker = workerFactory.getWorker(workerRequirement);
                return worker.execute(spec, currentBuildOperation);
            } catch (Throwable t) {
                throw new WorkExecutionException(spec.getDisplayName(), t);
            }

// Wait for the given workers to exit & clean up.
func waitForWorkerExit(t *testing.T, m *manager, workerPaths []probeKey) error {
	for _, w := range workerPaths {
		condition := func() (bool, error) {
			_, exists := m.getWorker(w.podUID, w.containerName, w.probeType)
			return !exists, nil
		}
		if exited, _ := condition(); exited {
			continue // Already exited, no need to poll.
		}
		t.Logf("Polling %v", w)