buildFile << """
            import org.gradle.workers.WorkParameters

            task doWork(type: WorkerTask)

            abstract class WorkerTask extends DefaultTask {
                @Inject
                abstract WorkerExecutor getWorkerExecutor()

                @TaskAction
                void doWork() {

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

    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 launcher = javaToolchains.launcherFor {
                languageVersion = JavaLanguageVersion.of(${version})
            }.get()
            task runInDaemon(type: WorkerTask) {
                isolationMode = 'processIsolation'
                additionalForkOptions = {
                    it.executable = launcher.executablePath.asFile
                }
            }
        """

            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

            $taskTypeUsingWorker
        """
    }

    String getTaskTypeUsingWorker() {
        return """
            import javax.inject.Inject
            import org.gradle.other.Foo

            class WorkerTask extends DefaultTask {
                @Internal
                def list = $list
                @Internal
                def outputFileDirPath = "${outputFileDirPath}/\${name}"
                @Internal