import java.io.Serializable;

public class TellGradleToRunSyncTasks implements BuildAction<Void>, Serializable {

    @Override
    public Void execute(BuildController controller) {
            controller.getModel(RunEclipseSynchronizationTasks.class);
        return null;
    }

        given:
        buildFile << """
buildDir = 'custom/dir'
"""

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

        then:
        project.buildDirectory == file('custom/dir')
    }

    def "implicit/placeholder tasks are visible from tooling api"() {
        file("settings.gradle") << """
            include "subproject"
        """

        when:
        GradleProject project = withConnection { it.getModel(GradleProject.class) }

        then:
        project.tasks*.name.containsAll rootProjectImplicitTasks
        project.findByPath(":subproject").tasks*.name.containsAll implicitTasks
    }

        connector.forProjectDirectory(new File("."));

        ProjectConnection connection = connector.connect();
        try {
            // Load the model for the project
            GradleProject project = connection.getModel(GradleProject.class);
            System.out.println("Project: " + project.getName());
            System.out.println("Tasks:");
            for (Task task : project.getTasks()) {

    def "provide Gradle user home information on BuildEnvironment"() {
        file("build.gradle")

        when:
        def buildEnvironment = withConnection { ProjectConnection connection ->
            connection.getModel(BuildEnvironment.class)
        }

        then:
        buildEnvironment != null
        buildEnvironment.gradle.gradleUserHome != null
        buildEnvironment.gradle.gradleUserHome == toolingApi.gradleUserHomeDir

    @Override
    public List<Task> execute(BuildController controller) {
        return controller.getBuildModel().getEditableBuilds().stream()
            .map(build -> controller.getModel(build.getRootProject(), BuildInvocations.class))
            .flatMap(invocations -> invocations.getTasks().stream())
            .collect(toList());
    }

import org.gradle.tooling.BuildController;

public class FetchUnknownModel implements BuildAction<CustomModel> {
    public CustomModel execute(BuildController controller) {
        return controller.getModel(CustomModel.class);
    }

import org.gradle.tooling.model.build.BuildEnvironment;

public class FetchBuildEnvironment implements BuildAction<BuildEnvironment> {
    public BuildEnvironment execute(BuildController controller) {
        return controller.getModel(BuildEnvironment.class);
    }

        def inInstance = System.in

        buildFile << """
            task hey
        """

        when:
        GradleProject model = toolingApi.withConnection { ProjectConnection connection -> connection.getModel(GradleProject.class) }

        then:
        model.tasks.find { it.name == 'hey' }
        System.out.is(outInstance)
        System.err.is(errInstance)
        System.in.is(inInstance)
    }

        List<String> model = new ArrayList<String>();
        for (GradleBuild included: controller.getBuildModel().getIncludedBuilds()) {
            EclipseProject project = controller.getModel(included.getRootProject(), EclipseProject.class);
            model.add(project.getName());
        }
        return model;
    }