throw new RuntimeException(e);
                    }
                }
            }
        """
    }

    def "problems are emitted correctly from a worker when using #isolationMode"() {
        setupBuild(null)
        enableProblemsApiCheck()

        given:
        buildFile << """
            import javax.inject.Inject
            import org.gradle.test.ProblemWorkerTask

        then:
        gradle.waitForFinish()

        and:
        assertWorkItemsExecuted("item1", "item2", "item3")

        where:
        isolationMode << ISOLATION_MODES
    }

    def "all errors are reported when waiting on work submitted to a queue in #isolationMode"() {
        buildFile << """
            task runWork(type: WorkItemTask) {
                doLast {

import org.gradle.util.internal.TextUtil

class WorkerExecutorFixture {

    enum IsolationMode {
        NO_ISOLATION("no"),
        CLASSLOADER_ISOLATION("classLoader"),
        PROCESS_ISOLATION("process");

        private final String prefix

        IsolationMode(String prefix) {
            this.prefix = prefix
        }

        String getMethod() {

    }

    def "work can be submitted concurrently using #isolationMode"() {
        when:
        async {
            6.times {
                start {
                    thread.blockUntil.allStarted
                    WorkQueue queue = workerExecutor."${isolationMode}" Actions.doNothing()
                    queue.submit(TestExecution.class, Actions.doNothing())
                }

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

        when:
        args("--info")

                workerTask.setIsolationMode(IsolationMode.CLASSLOADER);
            }
        });

        project.getTasks().create("processIsolation", WorkerTask.class, new Action<WorkerTask>() {
            @Override
            public void execute(WorkerTask workerTask) {
                workerTask.setIsolationMode(IsolationMode.PROCESS);
            }
        });

        }
    }

    @LeaksFileHandles
    // TODO https://github.com/gradle/gradle-private/issues/1532
    def "timeout stops long running work items with #isolationMode isolation"() {
        given:
        if (isolationMode == 'process') {
            // worker starting threads can be interrupted during worker startup and cause a 'Could not initialise system classpath' exception.

                }
            """
        }

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

    @Issue("https://github.com/gradle/gradle/issues/10122")

        workerClass.action = """
            System.out.println(parameters.greeting.get())
        """
        return workerClass
    }

    String getWorkActionWithNesting(String isolationMode, String nestedIsolationMode) {
        getFirstLevelExecution(nestedIsolationMode).writeToBuildFile()
        secondLevelExecution.writeToBuildFile()
        return """

        workAction.writeToBuildFile()
        fixture.withWorkActionClassInBuildScript()
        buildFile << """
            task runInWorker(type: WorkerTask) {
                isolationMode = 'processIsolation'
                additionalForkOptions = { jvmArgs('--not-a-real-argument') }
                workActionClass = ${workAction.name}.class
            }
        """
    }