private final ActionExecutionSpecFactory actionExecutionSpecFactory;
    private final Instantiator instantiator;
    private final IsolationScheme<WorkAction<?>, WorkParameters> isolationScheme = new IsolationScheme<>(Cast.uncheckedCast(WorkAction.class), WorkParameters.class, WorkParameters.None.class);
    private final CachedClasspathTransformer classpathTransformer;
    private final File baseDir;
    private final ProjectCacheDir projectCacheDir;

        nativeDir = new File(executer.gradleUserHomeDir, 'native')
        executer.withArguments(systemProperties.collect { it.toString() })
        buildFile << """
            import org.gradle.workers.WorkParameters

            tasks.register("doWork", WorkerTask)

            abstract class WorkerTask extends DefaultTask {
                @Inject
                abstract WorkerExecutor getWorkerExecutor()

            import ${TaskAction.name}
            import ${WorkAction.name}
            import ${WorkParameters.name}
            import ${WorkQueue.name}
            import ${WorkerExecutor.name}
            ${snippets.imports}

            public abstract class SneakyAction implements WorkAction<WorkParameters.None> {
                @Inject
                protected abstract ExecOperations getExecOperations();

import org.gradle.internal.reflect.DefaultTypeValidationContext;
import org.gradle.util.internal.TextUtil;
import org.gradle.work.DisableCachingByDefault;
import org.gradle.workers.WorkAction;
import org.gradle.workers.WorkParameters;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.Opcodes;

import java.io.File;
import java.io.IOException;
import java.lang.annotation.Annotation;

                    workerExecutor.noIsolation().submit(SomeWork) { }
                    workerExecutor.await()
                }
            }

            abstract class SomeWork implements WorkAction<WorkParameters.None> {
                void execute() {
                    Thread.sleep(50)
                }
            }

            allprojects {
                task run(type: SubmitsAndWaits)
            }

        }
        buildFile << """
            import java.util.concurrent.CountDownLatch
            import java.util.concurrent.TimeUnit
            import org.gradle.workers.WorkParameters

            task block(type: WorkerTask) {
                timeout = Duration.ofMillis($TIMEOUT)
            }

            abstract class WorkerTask extends DefaultTask {

                @Inject

            import org.gradle.internal.service.ServiceRegistryBuilder
            import org.gradle.internal.service.scopes.GradleUserHomeScopeServices
            import org.gradle.workers.WorkParameters
            import org.gradle.workers.WorkAction
            import org.gradle.internal.instrumentation.agent.AgentStatus
            import org.gradle.cache.scopes.GlobalScopedCacheBuilderFactory

Class <org.gradle.vcs.SourceControl> is not annotated with @ServiceScope in (SourceControl.java:0)

    }

    private ProgressEvents.Operation runBuildWithWorkerAction() {
        buildFile << """
            import org.gradle.workers.*
            abstract class MyWorkerAction implements WorkAction<WorkParameters.None>{
                @Override public void execute() {
                    // Do nothing
                }
            }
            task runInWorker {
                doLast {

                    it.params = [ name ]
                }
            }
        }
        """
    }

    private defineGradleWorkAction() {
        """
        interface WorkActionParams extends WorkParameters {
            Property<String> getName()
        }
        abstract class TestWorkAction implements WorkAction<WorkActionParams> {
            public void execute() {