root.gradleProject.tasks.find { it.name == 'rootTask' && it.path == ':rootTask' && it.project == root.gradleProject }
        !root.gradleProject.tasks.find { it.name == 'implTask' }

        impl.gradleProject.tasks.find { it.name == 'implTask' && it.path == ':impl:implTask' && it.project == impl.gradleProject}
        !impl.gradleProject.tasks.find { it.name == 'rootTask' }
    }

import org.gradle.tooling.BuildAction;
import org.gradle.tooling.BuildController;
import org.gradle.tooling.model.GradleProject;
import org.gradle.tooling.model.gradle.BasicGradleProject;
import org.gradle.tooling.model.gradle.GradleBuild;

public class FetchGradleProjectForTarget implements BuildAction<GradleProject> {

    private final String targetProject;

    public FetchGradleProjectForTarget(String targetProject) {

                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)