connection.model(GradleProject).
                    addProgressListener(listener, EnumSet.of(OperationType.GENERIC, OperationType.TASK)).get()
        }
        then:
        gradleProject
        def buildModelOperation = listener.operation("Build model 'org.gradle.tooling.model.GradleProject' for root project 'root'")
        def tasks = buildModelOperation.descendants {
            it.descriptor.displayName.startsWith("Realize task")

import org.gradle.integtests.tooling.fixture.ToolingApiSpecification
import org.gradle.tooling.model.GradleProject

@TargetGradleVersion(">=3.2")
class BuildFinishedCrossVersionSpec extends ToolingApiSpecification {

    def "model builders are executed before buildFinished hook"() {
        when:
        def project = loadToolingModel(GradleProject)

        then:
        fetchedBeforeBuildFinished(project)
    }

        }
    }

    def "closed project build dependencies are executed on build"() {
        setup:
        def eclipseRuntime = eclipseRuntime([gradleProject(child1, false), gradleProject(child2)])
        def modelBuilder = createBuilder()

        when:
        modelBuilder.buildAll("org.gradle.tooling.model.eclipse.RunClosedProjectBuildDependencies", eclipseRuntime, project)

    }

    def "custom project dependencies are replaced when project is closed"() {
        setup:
        def eclipseRuntime = eclipseRuntime([gradleProject(child1, false), gradleProject(child2), gradleProject(child3)])
        def modelBuilder = createEclipseModelBuilder()

        when:

        then:
        def rootTasks = eclipseProject.gradleProject.tasks.collect { it.name }

        EclipseProject api = eclipseProject.children.find { it.name == "api" }
        def apiTasks = api.gradleProject.tasks.collect { it.name }

        EclipseProject impl = eclipseProject.children.find { it.name == "impl" }
        def implTasks = impl.gradleProject.tasks.collect { it.name }

import org.gradle.tooling.model.GradleProject

class ToolingApiModelCrossVersionSpec extends ToolingApiSpecification {
    def "receives progress while the model is building"() {
        file('build.gradle') << '''
System.out.println 'this is stdout'
System.err.println 'this is stderr'
'''

        when:
        def progress = withModel(GradleProject.class).progressMessages
        progress.removeLast()

        when:
        def originalModel = fetchModel(GradleProject)

        then:
        fixture.assertNoConfigurationCache()

        when:
        executer.withArguments(ENABLE_CLI)
        def model = fetchModel(GradleProject)

        then:
        fixture.assertStateStored {
            modelsCreated(":", GradleProject, IsolatedGradleProjectInternal)

        getProjectDir() >> new File('foo')
    }
    final DefaultModelBuilder<GradleProject> builder = new DefaultModelBuilder<GradleProject>(GradleProject, asyncConnection, parameters)

    def "requests model from consumer connection"() {
        ResultHandlerVersion1<GradleProject> adaptedHandler
        ResultHandler<GradleProject> handler = Mock()
        GradleProject result = Mock()

        when:
        builder.get(handler)

        given:
        file('build.gradle')  << """
description = System.in.text
"""
        when:
        GradleProject model = (GradleProject) withConnection { ProjectConnection connection ->
            def model = connection.model(GradleProject.class)
            model.standardInput = new ByteArrayInputStream("Cool project".bytes)
            model.get()
        }

        then:

            .setProjectDirectory(project.getProjectDir());

        gradleProject.getBuildScript().setSourceFile(project.getBuildFile());

        if (realizeTasks) {
            List<LaunchableGradleTask> tasks = buildTasks(gradleProject, project.getTasks());
            gradleProject.setTasks(tasks);
        }

        return gradleProject;
    }