def setup() {
        blockingServer.start()

        createDirs("a", "b")
        settingsFile << 'include "a", "b"'

        buildFile << """
            abstract class SerialPing extends DefaultTask {

                SerialPing() { outputs.upToDateWhen { false } }

                @TaskAction
                void ping() {
                    new URL("http://localhost:${blockingServer.port}/" + path).text

    def operations = new BuildOperationsFixture(executer, testDirectoryProvider)

    def setup() {
        buildFile """
            class UnspecifiedCacheabilityTask extends DefaultTask {
                @Input
                String message = "Hello World"
                @OutputFile
                File outputFile = new File(temporaryDir, "output.txt")

                @TaskAction

                import org.gradle.api.*;

                import javax.inject.Inject;

                class TaskA extends DefaultTask {
                    @Inject
                    public TaskA() { }
                }

                class TaskB extends DefaultTask {
                    @Inject
                    public TaskB() { }
                }

            import org.gradle.api.DefaultTask;
            import org.gradle.api.NonNullApi;
            import org.gradle.api.tasks.Nested;
            import org.gradle.api.tasks.OutputFile;
            import org.gradle.api.tasks.TaskAction;

            import java.io.File;

            @NonNullApi
            public class TaskWithActionProperty extends DefaultTask {

    import org.gradle.api.plugins.*
    import org.gradle.api.tasks.*
    import org.gradle.api.tasks.incremental.*
    import org.gradle.work.*

    abstract class BaseIncrementalTask extends DefaultTask {
        ${inputDirAnnotation}
        @InputDirectory
        abstract DirectoryProperty getInputDir()

        @Optional
        @OutputFile
        abstract RegularFileProperty getOutputFile()

            import org.gradle.api.*;
            import org.gradle.api.tasks.*;
            import org.gradle.work.*;

            @DisableCachingByDefault(because = "test task")
            public class MyTask extends DefaultTask {
                // Should be ignored because it's not a getter
                public void getVoid() {
                }

                // Should be ignored because it's not a getter

            import groovy.transform.CompileStatic

            plugins {
                id 'java'
            }

            ${mavenCentralRepository()}

            abstract class MyTask extends DefaultTask {
                @Inject
                public abstract ObjectFactory getObjectFactory()

                @Input
                $elementInitialization

                @TaskAction

    def "supports recursive types"() {
        groovyTaskSource << """
            import org.gradle.api.*
            import org.gradle.api.tasks.*

            class MyTask extends DefaultTask {
                @Nested
                Tree tree = new Tree(
                        left: new Tree([:]),
                        right: new Tree([:])
                    )

        when:
        task = project.tasks["buildArchives"]

        then:
        task instanceof DefaultTask
        task dependsOn(JvmConstants.JAR_TASK_NAME)

        when:
        task = project.tasks[JavaBasePlugin.BUILD_TASK_NAME]

        then:
        task instanceof DefaultTask
        task dependsOn(BasePlugin.ASSEMBLE_TASK_NAME, JavaBasePlugin.CHECK_TASK_NAME)

        when:

        succeeds("model")

        then:
        def tasksNode = ModelReportOutput.from(output).modelNode.tasks
        tasksNode.taskContainerTask.@type[0] == 'org.gradle.api.DefaultTask'
        tasksNode.standardTask.@type[0] == 'org.gradle.api.DefaultTask'
        tasksNode.newModelTask.@type[0] == 'org.gradle.api.Task'
        tasksNode.modelMapTask.@type[0] == 'org.gradle.api.Task'