expectedOp('Project.afterEvaluate', 'nested gradle.afterProject(Closure)'),
            expectedOp('Project.afterEvaluate', 'nested nested gradle.afterProject(Closure)')
        ]
        def addProjectListeners = { String source ->
            """
            project.afterEvaluate {
                println "project.afterEvaluate(Closure) from $source"

    final AllPluginsValidation allPlugins = new AllPluginsValidation(this)

    void validatePlugins(@DelegatesTo(value = AllPluginsValidation, strategy = Closure.DELEGATE_FIRST) Closure<?> spec) {
        spec.delegate = allPlugins
        spec.resolveStrategy = Closure.DELEGATE_FIRST
        spec()
    }

    static interface ProjectBuildDirLocator {
        TestFile getBuildDir(String projectPath, TestFile projectRoot)
    }

    public void beforeEvaluate(Closure closure) {
        assertMutatingMethodAllowed("beforeEvaluate(Closure)");
        evaluationListener.add(new ClosureBackedMethodInvocationDispatch("beforeEvaluate", getListenerBuildOperationDecorator().decorate("Project.beforeEvaluate", Cast.<Closure<?>>uncheckedNonnullCast(closure))));
    }

    @Override
    public void afterEvaluate(Closure closure) {

        void test(String name, @DelegatesTo(value = TestEventSpec, strategy = Closure.DELEGATE_FIRST) Closure<?> spec)

        void testMethodSuite(String name, @DelegatesTo(value = TestEventSpec, strategy = Closure.DELEGATE_FIRST) Closure<?> spec)
    }

    class DefaultTestEventsSpec implements TestEventsSpec {

        eachElement(getRoot(), Actions.doNothing(), action, new HashSet<>());
    }

    @Override
    @SuppressWarnings("rawtypes")
    public void allDependencies(final Closure closure) {
        allDependencies(ConfigureUtil.configureUsing(closure));
    }

    @Override
    public Set<ResolvedComponentResult> getAllComponents() {
        final Set<ResolvedComponentResult> out = new LinkedHashSet<>();

    /**
     * <p>Adds a closure to call immediately before this project is evaluated.</p>
     *
     * @see Project#beforeEvaluate(Action)
     *
     * @param closure The closure to call.
     */
    void beforeEvaluate(Closure closure);

    /**
     * <p>Adds a closure to call immediately after this project is evaluated.</p>
     *

        }

        override fun beforeEvaluate(closure: Closure<*>) {
            onAccess("beforeEvaluate")
            delegate.beforeEvaluate(closure)
        }

        override fun afterEvaluate(closure: Closure<*>) {
            onAccess("afterEvaluate")
            delegate.afterEvaluate(closure)
        }

        override fun hasProperty(propertyName: String): Boolean {

    override fun beforeTask(closure: Closure<*>) {
        @Suppress("DEPRECATION")
        delegate.beforeTask(closure)
    }

    @Deprecated("Deprecated in Java")
    override fun beforeTask(action: Action<Task>) {
        @Suppress("DEPRECATION")
        delegate.beforeTask(action)
    }

    @Deprecated("Deprecated in Java")
    override fun afterTask(closure: Closure<*>) {

                    def sys = System
                    println("apply INSTANCE = " + sys.getProperty("INSTANCE"))

                    // Call from closure
                    def cl = { p ->
                        println("\$p CLOSURE = " + sys.getProperty("CLOSURE"))
                    }
                    cl("apply")

                    project.tasks.register("thing") { t ->
                        t.doLast {

        projectDir.file(path)
    }

    BuildTestFile populate(String projectName, @DelegatesTo(BuildTestFile) Closure cl) {
        new BuildTestFixture(projectDir).withBuildInSubDir().populate(projectName, cl)
    }

    TestFile singleProjectBuildInSubfolder(String projectName, @DelegatesTo(BuildTestFile) Closure cl = {}) {
        new BuildTestFixture(projectDir).withBuildInSubDir().singleProjectBuild(projectName, cl)
    }