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

    }

    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:

        when:
        def originalModel = fetchModel(GradleProject)

        then:
        fixture.assertNoConfigurationCache()

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

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

        when: "GradleProject is requested directly"
        GradleProject project = getGradleProjectWithProjectConnection(rootDir, GradleProject)

        then: "Get the GradleProject model for the root project"
        assertProject(project, rootMulti, ':', 'B', null, [':x', ':y'])

        when: "EclipseProject is requested"
        GradleProject projectFromEclipseProject = getGradleProjectWithProjectConnection(rootDir, EclipseProject)

            setStreamedValueListener(listener2)
        }

        then:
        fixture.assertStateLoaded()

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

        and:

    def "ProjectConnection provides identified models for single project build"() {
        when:
        def gradleProject = getModelWithProjectConnection(rootSingle, GradleProject)
        def model = getModelWithProjectConnection(rootSingle, modelType)

        then:
        assertSameIdentifiers(gradleProject, model)

        where:
        modelType << modelsHavingGradleProjectIdentifier
    }

        }
    }

    private static void withGradleProject(def gradleProject) {
        gradleProject.buildDirectory
        gradleProject.path
        gradleProject.buildScript.sourceFile
        gradleProject.buildDirectory
        gradleProject.name
        gradleProject.projectDirectory
        gradleProject.description
        gradleProject.tasks.collect {
            it.name
            it.project

            .setChildren(children);

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

        for (DefaultGradleProject child : children) {
            child.setParent(gradleProject);
        }

        if (realizeTasks) {
            List<LaunchableGradleProjectTask> tasks = collectTasks(gradleProject, (TaskContainerInternal) project.getTasks());
            gradleProject.setTasks(tasks);
        }