import org.gradle.workers.IsolationMode;
import org.gradle.workers.WorkerConfiguration;
import org.gradle.workers.WorkerExecutor;

import javax.inject.Inject;
import java.io.File;

public class WorkerTask extends DefaultTask {
    private int outputSize = 1;
    private File outputDir = new File(getProject().getBuildDir(), getName());
    private IsolationMode isolationMode = IsolationMode.NONE;

    @Inject

            @Override
            public void execute(WorkerTask workerTask) {
                workerTask.setIsolationMode(IsolationMode.PROCESS);
            }
        });

        project.getTasks().withType(WorkerTask.class, new Action<WorkerTask>() {
            @Override
            public void execute(WorkerTask workerTask) {

            tasks.withType(WorkerTask) { task ->
                isolationMode = 'processIsolation'
                // Force a new daemon to be used
                additionalForkOptions = {
                    it.systemProperty("foobar", task.name)
                }
            }
            task startDaemon1(type: WorkerTask)
            task startDaemon2(type: WorkerTask)
            task startDaemon3(type: WorkerTask)

        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()

                @TaskAction
                void executeTask() {

    def setup() {
        prepareTaskTypeUsingWorker()
        withRunnableClassInBuildSrc()
        buildFile << """
            task runInWorker(type: WorkerTask)
        """
    }

    def "reports typed work item progress events as descendants of tasks"() {
        when:
        def events = runBuild("runInWorker", EnumSet.allOf(OperationType))

        then:

    def "worker not timeout"() {
        given:
        def gradleUserHome = file("home").absoluteFile
        buildFile << """
            task doWorkInWorker(type: WorkerTask) {
                gradleUserHome = file("${escapeString(gradleUserHome)}")
            }
        """
        buildFile """
            import org.gradle.cache.scopes.ScopedCacheBuilderFactory

            def runAllInWorkers = tasks.register("runAllInWorkers")
            for (int i = 0; i < $workerCount; i++) {
                def projectCounter = i
                def runInWorker = tasks.register("runInWorker" + i, WorkerTask) {
                    isolationMode = 'processIsolation'
                    workActionClass = AlternateWorkAction.class
                    additionalForkOptions = {

            import java.util.concurrent.TimeUnit
            import org.gradle.workers.WorkParameters

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

            abstract class WorkerTask extends DefaultTask {

                @Inject
                abstract WorkerExecutor getWorkerExecutor()

                @TaskAction