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

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

        then:
        gradle.waitForFinish()

        and:

        fixture.withWorkActionClassInBuildScript()

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

        expect:
        succeeds("runInWorker")

        and:
        assertWorkerExecuted("runInWorker")

        and:
        file("bar/foo").text == "foo"
        file("baz/foo").text == "foo"

        fixture.withWorkActionClassInBuildSrc()

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

        when:
        fails("runInWorker")

        then:
        failureHasCause("A failure occurred while executing ${failureExecution.name}")

            ${getWorkActionWithNesting("noIsolation", "noIsolation")}
            task runInWorker(type: NestingWorkerTask) {
                waitForChildren = true
            }
        """.stripIndent()

        when:
        succeeds("runInWorker")

        then:
        result.groupedOutput.task(':runInWorker').output.contains("Hello World")
    }

                }
            }

            task runInWorker(type: WorkerTask) {
                isolationMode = $isolationMode
            }
        """

        when:
        succeeds("runInWorker")

        then:
        assertWorkerExecuted("runInWorker")

        when:
        buildFile << """
            runInWorker {
                foo = new AnotherFoo()
            }

        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 taskOperation = events.operation("Task :runInWorker")
        taskOperation.assertIsTask()

        }.unique()
        taskOperations.size() == 2
        taskOperations.collect {it.displayName }.containsAll(['Task :runInWorker', 'Task :runInWorker2'])

        and:
        logOperations.every { operation -> operation.progress.size() == 1000 }

        and:
        assertSameDaemonWasUsed("runInWorker", "runInWorker2")
    }

            ProjectConnection connection ->
                connection.newBuild()
                    .forTasks('runInWorker')
                    .addProgressListener(events)
                    .run()
        }

        events.assertIsABuild()
        events.operation('Task :runInWorker').descendant('MyWorkerAction')
    }

        expect:
        executer.withStackTraceChecksDisabled()
        fails("runInWorker")

        and:
        def taskActionOperation = buildOperations.first(ExecuteTaskActionBuildOperationType) {
            it.displayName == "Execute executeTask for :runInWorker"
        }
        taskActionOperation != null
        def outputProgress = taskActionOperation.progress(StyledTextOutputEvent)

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

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

        then:
        gradle.waitForFinish()

        and: