gradle.lifecycle.afterProject { println("lifecycle: gradle.lifecycle.afterProject '\${it.path}'") }

            // register eager callbacks
            gradle.allprojects { println("lifecycle: gradle.allprojects '\${it.path}'") }
            gradle.beforeProject { println("lifecycle: gradle.beforeProject '\${it.path}'") }
            gradle.afterProject { println("lifecycle: gradle.afterProject '\${it.path}'") }

        given:
        settingsFile << """
            include('a')
            include('b')
        """
        withSomeToolingModelBuilderPluginInBuildSrc()
        buildFile << """
            allprojects {
                plugins.apply('java-library')
            }
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModelFails()

        this.features = features;
    }

    @Override
    public void beforeProject(Action<? super Project> action) {
        // Preserve behavior when Isolated Projects is not enabled:
        // - `allprojects` executes eagerly before any project has been evaluated, allowing its effects
        //   to be observable from other eager configuration blocks (e.g., `subprojects { ... }`).

                    project.allprojects.each { p ->
                        p.configurations.compileClasspath.files()
                    }
                    return ["result"]
                }
            }

            project.services.get(ToolingModelBuilderRegistry.class).register(new MyModelBuilder())

            allprojects {
                apply plugin: 'java-library'
            }

    def "jdkName property from idea module model is available in the tooling API"() {
        given:
        settingsFile << "\ninclude 'root', 'child1', 'child2', 'child3'"
        buildFile << """
            allprojects {
                apply plugin: 'idea'
                apply plugin: 'java'
            }

            idea {
                module {
                    jdkName = 'MyJDK1'
                }
            }

    @ToBeFixedForIsolatedProjects(because = "allprojects")
    def "init script can inject configuration into the root project and all projects"() {
        given:
        createDirs("a", "b")
        settingsFile << "include 'a', 'b'"

        and:
        file("init.gradle") << """
allprojects {
    task worker
}
rootProject {
    task root(dependsOn: allprojects*.worker)
}
        """

        when:

    @ToBeFixedForIsolatedProjects(because = "allprojects")
    def "can exclude task from main build when buildSrc is present"() {
        file("buildSrc/build.gradle").createFile()
        createDirs("lib")
        settingsFile """
            include "lib"
        """
        buildFile """
            allprojects {
                task thing {
                    doLast {}
                }

        google()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:$androidPluginVersion'
        classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion'
    }
}

allprojects {
    repositories {
        mavenCentral()
        google()
    }

        then:
        0 * buildProjectRegistry.allProjects
        _ * executionPlan.addEntryTasks({ args -> assert args.size() == 0 })
        _ * executionPlan.addEntryTask({ args -> assert args.size() == 0 })
    }

    def "sets test filter with information from #requestType"() {
        setup:
        _ * buildProjectRegistry.allProjects >> [projectState]

------------------------------------------------------------
Project ':api' - The shared API for the application
------------------------------------------------------------

allprojects: [project ':api']
ant: org.gradle.api.internal.project.DefaultAntBuilder@12345
antBuilderFactory: org.gradle.api.internal.project.DefaultAntBuilderFactory@12345
artifacts: org.gradle.api.internal.artifacts.dsl.DefaultArtifactHandler_Decorated@12345