this.type = type;
        this.value = value;
    }

    @Override
    public T execute(BuildController controller) {
        controller.send(new CustomModel(value));
        return controller.getModel(type);
    }

import org.gradle.tooling.model.GradleTask;

public class FetchTaskAction implements BuildAction<GradleTask> {
    @Override
    public GradleTask execute(BuildController controller) {
        GradleProject project = controller.getModel(GradleProject.class);
        for (GradleTask task : project.getTasks()) {
            if (task.getName().equals("help")) {
                return task;
            }
        }

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

import org.gradle.tooling.BuildController;

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

        Map<String, Set<String>> model = new HashMap<String, Set<String>>();
        for (BasicGradleProject project: controller.getBuildModel().getProjects()) {
            BuildInvocations entryPointsForProject = controller.getModel(project, BuildInvocations.class);
            Set<String> selectorNames = new HashSet<String>();
            for (TaskSelector selector : entryPointsForProject.getTaskSelectors()) {

    task buildStuff
}
"""
    }

    def "can request GradleBuild model including projectDirectory"() {
        when:
        GradleBuild model = withConnection { connection -> connection.getModel(GradleBuild) }

        then:
        validateModel(model)
        model.projects*.projectDirectory == [projectDir, file('a'), file('b'), file('b/c')]
    }

    def validateModel(GradleBuild model) {

    }

    def "Eclipse model respects composite build substitutions in root build"() {
        given:
        compositeIncludedRoot()

        when:
        def model = withConnection {
            getModel(HierarchicalEclipseProject)
        }

        then:
        model.children[1].projectDependencies.size() == 1
        model.children[1].projectDependencies[0].path == 'sub-a'
    }

public class FetchEclipseProject implements BuildAction<EclipseProject> {
    @Override
    public EclipseProject execute(BuildController controller) {
        return controller.getModel(EclipseProject.class);
    }

import org.gradle.tooling.model.idea.IdeaProject;

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

import org.gradle.tooling.model.GradleProject;

public class ActionQueriesModelThatRequiresConfigurationPhase implements BuildAction<String> {
    @Override
    public String execute(BuildController controller) {
        controller.getModel(GradleProject.class);
        return "result";
    }