String packageName = "org.gradle.test"
        return new TestClass(name, packageName) {
            @Override
            TestClass writeToBuildFile() {
                workActionThatCreatesFiles.writeToBuildFile()
                super.writeToBuildFile()
                return this
            }

            @Override
            TestClass writeToBuildSrc() {

        where:
        isolationMode << ISOLATION_MODES
    }

    def "stdout, stderr and logging output of worker is redirected in #isolationMode"() {
        executionWithLogging.writeToBuildFile()

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

        when:

            """
        }

        parallelWorkAction.writeToBuildFile()
        alternateParallelWorkAction.writeToBuildFile()
        withMultipleActionTaskTypeInBuildScript()
    }

    def "multiple work items can be executed in parallel in #isolationMode (wait for results: #waitForResults)"() {
        given:

        def workerHomeDir = executer.gradleUserHomeDir.file("workers").getAbsolutePath()
        fixture.withWorkActionClassInBuildScript()
        workActionThatPrintsWorkingDirectory.writeToBuildFile()
        buildFile << """
            task runInWorker(type: WorkerTask) {
                isolationMode = 'processIsolation'
                workActionClass = ${workActionThatPrintsWorkingDirectory.name}.class

    def "can log many messages from action in a worker daemon"() {
        def buildOperations = new BuildOperationsFixture(executer, temporaryFolder)

        workActionThatProducesLotsOfOutput.writeToBuildFile()

        expect:
        succeeds("runInWorker")

        and:
        def operation = buildOperations.only(ExecuteWorkItemBuildOperationType)
        operation.displayName == "LotsOfOutputWorkAction"

            """
        }
    }

    def "produces a sensible error when there is a failure in the worker runnable in #isolationMode"() {
        def failureExecution = fixture.workActionThatFails.writeToBuildFile()
        fixture.withWorkActionClassInBuildSrc()

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

        """
        return workerClass
    }

    String getWorkActionWithNesting(String isolationMode, String nestedIsolationMode) {
        getFirstLevelExecution(nestedIsolationMode).writeToBuildFile()
        secondLevelExecution.writeToBuildFile()
        return """
            class NestingWorkerTask extends DefaultTask {

                @Internal
                final WorkerExecutor executor

                @Internal

class WorkerDaemonFailureLoggingIntegrationTest extends AbstractDaemonWorkerExecutorIntegrationSpec {
    def setup() {
        def workAction = fixture.getWorkActionThatCreatesFiles("NormalWorkAction")
        workAction.writeToBuildFile()
        fixture.withWorkActionClassInBuildScript()
        buildFile << """
            task runInWorker(type: WorkerTask) {
                isolationMode = 'processIsolation'

        and:
        assertDifferentDaemonsWereUsed("runInWorker1", "runInWorker2")
    }

    def "worker daemons are not reused when they fail unexpectedly"() {
        workerExecutorThatCanFailUnexpectedly.writeToBuildFile()
        buildFile << """
            task runInWorker1(type: WorkerTask) {
                isolationMode = 'processIsolation'
            }

            task runInWorker2(type: WorkerTask) {

    }

    def "includes failures in build operation in #isolationMode"() {
        given:
        fixture.withWorkActionClassInBuildSrc()
        fixture.workActionThatFails.writeToBuildFile()
        buildFile << """
            task runInWorker(type: WorkerTask) {
                isolationMode = $isolationMode
                workActionClass = WorkActionThatFails.class
            }
        """