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

            setStreamedValueListener(listener2)
        }

        then:
        fixture.assertStateLoaded()

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

        and:

            ${sync.callFromBuild("waiting")}
            task hey
        """

        when:
        GradleProject model = toolingApi.withConnection { ProjectConnection connection ->
            def handler = new BlockingResultHandler<GradleProject>(GradleProject)
            def builder = connection.model(GradleProject)
            builder.standardOutput = outInstance
            builder.standardError = errInstance

    }

    def "provide getGroup on Task using GradleProject shouldn't fail if group is null"() {
        file("build.gradle") << '''
task test1()
task test2()
'''

        when:
        def gradleProject = withConnection { ProjectConnection connection ->
            connection.getModel(GradleProject)
        }

        then:
        gradleProject != null
        gradleProject.tasks.findAll { it.name.startsWith('test') }.each {

        }
    }

    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)

    def "delegates to connection to run action"() {
        ResultHandlerVersion1<GradleProject> adaptedHandler
        ResultHandler<GradleProject> handler = Mock()
        GradleProject result = Mock()

        when:
        executer.run(handler)

        then:
        1 * asyncConnection.run(!null, !null) >> {args ->
            ConsumerAction<GradleProject> action = args[0]
            action.run(connection)

        this.linkedResources = linkedResources;
    }

    public DefaultGradleProject getGradleProject() {
        return gradleProject;
    }

    public DefaultEclipseProject setGradleProject(DefaultGradleProject gradleProject) {
        this.gradleProject = gradleProject;
        return this;
    }

    public List<DefaultEclipseProjectNature> getProjectNatures() {
        return projectNatures;
    }

import org.gradle.tooling.model.GradleProject;
import org.gradle.tooling.model.gradle.GradleBuild;

import java.util.ArrayList;
import java.util.List;

public class FetchIncludedGradleProjects implements BuildAction<List<GradleProject>> {

    @Override
    public List<GradleProject> execute(BuildController controller) {
        List<GradleProject> projects = new ArrayList<GradleProject>();

import org.gradle.tooling.model.GradleProject

class TaskDisplayNameCrossVersionSpec extends ToolingApiSpecification {
    def "can get task's display name"() {
        file('build.gradle') << '''
task a
task b { description = 'this is task b' }
'''

        when:
        GradleProject project = withConnection { connection -> connection.getModel(GradleProject.class) }

        then: