*
     * @param action The action to execute.
     */
    void beforeProject(Action<? super Project> action);

     *
     * @param action The action to execute.
     * @see IsolatedAction for the requirements to isolated actions
     * @since 8.8
     */
    @Incubating
    void beforeProject(IsolatedAction<? super Project> action);

    /**
     * Adds an {@link IsolatedAction isolated action} to be called immediately after a project is evaluated.
     *
     * @param action The action to execute.

            problem("Build file 'a/build.gradle.kts': Project ':a' cannot access 'Project.buildDir' functionality on another project ':b'")
        }

        where:
        invocation      | accessedProjects
        "beforeProject" | [":b"]
        "afterProject"  | [":b"]
    }

    def "reports cross-project model access from a listener added to Gradle.projectsEvaluated"() {
        createDirs("a", "b")
        settingsFile << """

    }

    def "broadcasts before project evaluate events to closures"() {
        given:
        def called = false
        def closure = { called = true }

        when:
        gradle.beforeProject(closure)

        and:
        gradle.projectEvaluationBroadcaster.beforeEvaluate(null)

        then:
        called
    }

    def "broadcasts after project evaluate events to closures"() {

        given:
        withSomeToolingModelBuilderPluginInBuildSrc()
        settingsFile << """
            include("a")
            include("b")

            gradle.lifecycle.beforeProject {
                println("Callback before \$it")
            }
        """
        buildFile << """
            plugins.apply(my.MyPlugin)
        """
        file("a/build.gradle") << """

     * parameter.
     *
     * @param closure The closure to execute.
     */
    void beforeProject(Closure closure);

    /**
     * Adds an action to be called immediately before a project is evaluated.
     *
     * @param action The action to execute.
     * @since 3.4
     */
    void beforeProject(Action<? super Project> action);

    /**

 * This is similar to [ValidatePlugins] but instead of checking the plugins *written in* the current build,
 * it checks the plugins *applied to* the current build.
 */
gradle.beforeProject {
    val lifecycleTask = project.tasks.register("validateExternalPlugins")
    project.plugins.configureEach { configurePluginValidation(project, lifecycleTask, javaClass) }
}

fun configurePluginValidation(

@LeaksFileHandles
class SettingsScriptPluginIntegrationSpec extends AbstractPluginSpec {

    private void doConfigureSettingsPlugin() {
        publishSettingPlugin("""
settings.gradle.beforeProject { org.gradle.api.Project project ->
    project.tasks.register("customTask") {
        doLast {
            System.out.println("Executing task added by a 'Settings' plugin")
        }
    }
}
"""
        )

                @CompileDynamic
                void applyToAllProjects(Gradle gradle, Closure projectClosure) {
                    if (gradle.gradleVersion >= "8.8") {
                        gradle.lifecycle.beforeProject(projectClosure)
                    } else {
                        gradle.allprojects(projectClosure)
                    }
                }

                @CompileDynamic

                repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
            }

            include 'lib1', 'lib2'

        """

        buildFile << """
            gradle.beforeProject {
                println "Before project \$it"
            }
            subprojects {
                configurations {
                    conf
                }

                dependencies {