finished.await()
        }

        then:
        models.size() == 3

        and:
        GradleProject gradleProject = models.get(0)
        gradleProject.name == "hello-world"

        and:
        EclipseProject eclipseModel = models.get(1)
        eclipseModel.gradleProject.name == "hello-world"

        and:
        CustomModel result = models.get(2)
        result.value == 42
    }

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

@TargetGradleVersion(">=6.1")
class GradleProjectBuilderOptionsCrossVersionSpec extends ToolingApiSpecification {

    def "realizes #description when fetching GradleProject with option value #optionDescription"() {
        buildFile << """
            tasks.create("a") {

        def buildFinishedHandler = new IntermediateResultHandlerCollector<EclipseProject>()
        def out = new ByteArrayOutputStream()
        def workspace = eclipseWorkspace([gradleProject("child1", false), gradleProject("child2")])
        when:
        withConnection { connection ->
            connection.action().projectsLoaded(new TellGradleToRunBuildDependencyTask(workspace), projectsLoadedHandler)

        this.uri = uri;
    }

    @Override
    public CustomModel execute(BuildController controller) {
        System.out.println("ACTION STARTED");
        GradleProject gradleProject = controller.getModel(GradleProject.class);
        controller.send(gradleProject);

        System.out.println("ACTION WAITING");
        try {
            uri.toURL().openConnection().getContentLength();
        } catch (IOException e) {

        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' }
    }

        when:
        EclipseProject model = withConnection { connection ->
            return connection.action(new LoadEclipseModel(eclipseWorkspace([
                gradleProject("a"),
                externalProject("a")
            ]))).run()
        }

        then:
        def projects = collectProjects(model)
        !projects.collect({ it.name }).contains("a")

            def launchables = findLaunchables(gradleProjects, taskName)
            assert launchables.size == 1
            def build = connection.newBuild()
            collectOutputs(build)
            build.forLaunchables(launchables[0]).run()
        }
    }

    private def findLaunchables(Collection<GradleProject> gradleProjects, String taskName) {

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

@TargetGradleVersion('>=6.8')
class CompositeBuildBuildActionExecuterCrossVersionSpec extends ToolingApiSpecification {

    def "can run task from included build when running a build action"() {
        given:

                }
            }
        """

        when:
        toolingApi.withConnection { ProjectConnection connection ->
            ModelBuilder<GradleProject> modelBuilder = connection.model(GradleProject.class)
            collectOutputs(modelBuilder)
            modelBuilder.forTasks([':other-build:sub:doSomething'])
            modelBuilder.get()
        }

        then:

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

        then:
        model3 instanceof GradleProject

        and:
        fixture.assertStateStored {
            projectConfigured(":buildSrc")
            modelsCreated(":", 2) // Requested `GradleProject` and intermediate `IsolatedGradleProject`
        }
        outputContains("configuring build")