when:
        def gradleProjects = getGradleProjectsWithProjectConnectionUsingBuildModel(rootMulti, modelType)

        then:
        gradleProjects.size() == 3
        hasParentProject(gradleProjects, rootMulti, ':', 'B', [':x', ':y'])
        hasChildProject(gradleProjects, rootMulti, ':x', 'x', ':')
        hasChildProject(gradleProjects, rootMulti, ':y', 'y', ':')

import org.gradle.tooling.model.GradleProject;
import org.gradle.tooling.model.eclipse.EclipseProject;

class ModelStreamingBuildAction implements BuildAction<CustomModel> {
    @Override
    public CustomModel execute(BuildController controller) {
        EclipseProject eclipseProject = controller.getModel(EclipseProject.class);
        GradleProject gradleProject = controller.getModel(GradleProject.class);

        when:
        def gradleProjects = getModelsWithProjectConnection(rootMulti, GradleProject)
        def models = getModelsWithProjectConnection(rootMulti, modelType)

        then:
        assertSameIdentifiers(gradleProjects, models)

        where:
        modelType << modelsHavingGradleProjectIdentifier
    }

    private static void assertSameIdentifiers(def gradleProject, def model) {

import org.gradle.tooling.model.GradleProject;
import org.gradle.tooling.model.eclipse.EclipseProject;

class ModelStreamingBuildAction implements BuildAction<CustomModel> {
    @Override
    public CustomModel execute(BuildController controller) {
        EclipseProject eclipseProject = controller.getModel(EclipseProject.class);
        GradleProject gradleProject = controller.getModel(GradleProject.class);

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) {

        when:
        def originalModel = fetchModel(GradleProject)

        then:
        fixture.assertNoConfigurationCache()

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

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

            setStreamedValueListener(listener2)
        }

        then:
        fixture.assertStateLoaded()

        and:
        (model2.left as GradleProject).name == "hello-world"
        (model2.right as EclipseProject).gradleProject.name == "hello-world"

        and:

        }
    }

    private def findLaunchables(Collection<GradleProject> gradleProjects, String taskName) {
        collectGradleProjects(gradleProjects).collect { it.tasks }.flatten().findAll { GradleTask task -> task.path.contains(taskName) }
    }

    private def collectGradleProjects(Collection<GradleProject> projects, Collection<GradleProject> acc = []) {
        acc.addAll(projects)

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)