doLast { submitWorkItem("taskAction6", workActionClass) { isolationMode = 'classLoaderIsolation' } }
            }
        """
        blockingHttpServer.expectConcurrent("taskAction1")
        blockingHttpServer.expectConcurrent("taskAction2")
        blockingHttpServer.expectConcurrent("taskAction3")

        TaskProvider taskProvider2 = Mock()
        Function mapping1 = Mock()
        Function mapping2 = Mock()
        Action taskAction1
        Action taskAction2
        taskProvider1.configure(_) >> { Action action -> taskAction1 = action }
        taskProvider2.configure(_) >> { Action action -> taskAction2 = action }
        taskProvider1.flatMap(_) >> Mock(ProviderInternal)
        taskProvider2.flatMap(_) >> Mock(ProviderInternal)

        visitor.visitImplementation(task.getClass());

        List<InputChangesAwareTaskAction> taskActions = task.getTaskActions();
        for (InputChangesAwareTaskAction taskAction : taskActions) {
            visitor.visitImplementation(taskAction.getActionImplementation(classLoaderHierarchyHasher));
        }
    }

    @Override

        }

        @Override
        @TaskAction
        public void doStuff(InputChanges changes) {
            action.execute(changes);
        }
    }

    public static class TaskWithMultipleInputChangesActions extends DefaultTask {

        @TaskAction
        public void doStuff(InputChanges changes) {
        }

        @TaskAction
        public void doStuff2(InputChanges changes) {

            import ${Inject.name};
            import ${TaskAction.name};
            ${snippets.imports}

            public abstract class SneakyTask extends DefaultTask {
                @Inject
                protected abstract ExecOperations getExecOperations();

                public SneakyTask() {
                    ${snippets.body}
                }

                @TaskAction
                public void doNothing() {}

        """
        file("buildSrc/src/main/java/CustomTask.java") << """
            import org.gradle.api.GradleException;
            import org.gradle.api.tasks.TaskAction;

            public class CustomTask extends AbstractCustomTask {
                @TaskAction
                public void checkFiles() {
                    System.out.println("checking files");
                    if (getSourceFiles().isEmpty()) {

                @TaskAction void foo() {
                    def dir = outDir.get().asFile
                    assert new File(dir, 'baz').createNewFile()
                }
            }
            abstract class Bar extends DefaultTask {
                @InputFile abstract RegularFileProperty getInDir()
                @TaskAction void bar() {}
            }

        buildFile << """
            class MyTask extends DefaultTask {
                @Output${files ? "Files" : "Directories"} FileCollection out

                @TaskAction def exec() {
                    out.each { it${files ? ".text = 'data' + it.name" : ".mkdirs(); new File(it, 'contents').text = 'data' + it.name"} }
                }
            }

            task myTask(type: MyTask) {

        buildFile << """
            abstract class SomeTask extends DefaultTask {
                ${annotation}
                ${propertyImpl}

                @TaskAction
                void go() {
                    println "value: " + prop.get()
                }
            }

            task show(type: SomeTask) {
                def layout = project.layout

                @TaskAction
                void createOutput() {
                    outputDir.file("untracked.txt").get().asFile.text = "untracked"
                }
            }

            abstract class TrackedProducer extends DefaultTask {
                @OutputDirectory
                abstract DirectoryProperty getOutputDir()

                @TaskAction
                void createOutput() {