.assertHasLineNumber(3)
    }

    def "produces reasonable error message when Gradle.afterProject closure fails"() {
        when:
        settingsFile << """
    gradle.afterProject {
        throw new RuntimeException("afterProject failure")
    }
"""
        buildFile << """
    task test
"""
        then:
        fails('test')

        ["Gradle#beforeProject(Action)"     , "gradle.beforeProject new Action<Project>() { void execute(Project p) {} }"],
        ["Gradle#afterProject(Closure)"     , "gradle.afterProject {}"],
        ["Gradle#afterProject(Action)"      , "gradle.afterProject new Action<Project>() { void execute(Project p) {} }"],
        ["Gradle#projectsLoaded(Closure)"   , "gradle.projectsLoaded {}"],

lifecycle: <evaluating> ':'
lifecycle: <root>.subprojects ':a'
lifecycle: gradle.afterProject ':'
lifecycle: gradle.lifecycle.afterProject ':'
lifecycle: gradle.beforeProject ':a'
lifecycle: gradle.lifecycle.beforeProject ':a'
lifecycle: <evaluating> project ':a'
lifecycle: gradle.afterProject ':a'
lifecycle: gradle.lifecycle.afterProject ':a'
        """.trim()
    }

                log << "2: before $name $version"
            }
            gradle.lifecycle.afterProject {
                log << "1: after $name $version"
            }
            gradle.lifecycle.afterProject {
                log << "2: after $name $version"
            }
            gradle.lifecycle.afterProject {
                println log
            }
        '''

        def script = '''

    private
    val afterProject = mutableListOf<IsolatedProjectAction>()

    override fun beforeProject(action: IsolatedProjectAction) {
        // TODO:isolated encode Application instances as part of the Environment to avoid waste
        beforeProject.add(withUserCodeApplicationContext(action))
    }

    override fun afterProject(action: IsolatedProjectAction) {

    override fun beforeProject(action: Action<in Project>) =
        delegate.beforeProject(action)

    override fun afterProject(closure: Closure<Any>) =
        delegate.afterProject(closure)

    override fun afterProject(action: Action<in Project>) =
        delegate.afterProject(action)

    override fun settingsEvaluated(closure: Closure<Any>) =
        delegate.settingsEvaluated(closure)

     */
    void beforeProject(IsolatedAction<? super Project> action);

    /**
     * @see org.gradle.api.invocation.GradleLifecycle#afterProject(IsolatedAction)
     */
    void afterProject(IsolatedAction<? super Project> action);

    /**
     * Returns an isolated listener for the registered actions, if any. The listener makes it impossible for

// tag::after-evaluate[]
gradle.beforeProject { project ->
    project.ext.set("hasTests", false)
}

gradle.afterProject { project ->
    if (project.ext.has("hasTests") && project.ext.get("hasTests") as Boolean) {
        def projectString = project.toString()
        println "Adding test task to $projectString"
        project.task('test') {
            doLast {
                println "Running tests for $projectString"
            }
        }

                if (it.name == 'nested') {
                    testContainer.create("beforeProject")
                }
            }

            gradle.afterProject {
                if (it.name == 'nested') {
                    testContainer.create("afterProject")
                }
            }

            gradle.projectsEvaluated {
                testContainer.create("projectsEvaluated")
            }

            <tr>
                <td>removeProjectEvaluationListener</td>
            </tr>
            <tr>
                <td>beforeProject</td>
            </tr>
            <tr>
                <td>afterProject</td>
            </tr>
            <tr>
                <td>settingsEvaluated</td>
            </tr>
            <tr>
                <td>projectsEvaluated</td>
            </tr>
            <tr>