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

        withParameterMemberThatFailsSerialization()

        buildFile << """
            task runAgainInWorker(type: WorkerTask) {
                isolationMode = $isolationMode
                workActionClass = ${alternateExecution.name}.class
            }

            task runInWorker(type: WorkerTask) {
                isolationMode = $isolationMode
                foo = new FooWithUnserializableBar()

            include ":anotherProject"
        """

        buildFile << """
            def rootTask = tasks.create("runInWorker", WorkerTask) {
                isolationMode = $isolationMode
            }

            project(":anotherProject") {
                tasks.create("runInWorker2", WorkerTask) {
                    dependsOn rootTask
                    isolationMode = $isolationMode
                }
            }

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

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

        }
    }

    def "worker lifecycle is logged in #isolationMode"() {
        def workAction = fixture.workActionThatCreatesFiles.writeToBuildSrc()

        buildFile << """
            task runInWorker(type: WorkerTask) {
                isolationMode = $isolationMode
            }
        """.stripIndent()

        when:
        args("--debug")
        def gradle = executer.withTasks("runInWorker").start()

        then:

        buildFile << """
            import org.gradle.workers.internal.WorkerDaemonFactory

            task runInWorker1(type: WorkerTask) {
                isolationMode = 'processIsolation'
            }

            task runInWorker2(type: WorkerTask) {
                isolationMode = 'processIsolation'
                doFirst {

        fixture.withWorkActionClassInBuildScript()
        workActionThatPrintsWorkingDirectory.writeToBuildFile()
        buildFile << """
            task runInWorker(type: WorkerTask) {
                isolationMode = 'processIsolation'
                workActionClass = ${workActionThatPrintsWorkingDirectory.name}.class
            }
        """

        when:
        args("--info")

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

                    println "foo!"
                }
            """
        }

        fixture.withWorkActionClassInBuildScript()
        buildFile << """
            task runInWorker(type: WorkerTask) {
                isolationMode = 'processIsolation'
                workActionClass = ${workActionThatProducesLotsOfOutput.name}.class
            }
        """
    }