this.parent = parent;
        this.node = (XmlNode) parent.getNode();
        this.children = this.node.getChildren();
        if (startWith != null) {
            Xpp3Dom startWithNode = (Xpp3Dom) startWith.getNode();
            for (; filteredIndex < children.size(); filteredIndex++) {
                if (startWithNode.equals(children.get(filteredIndex))) {

        ProjectConnection connection = connector.connect();
        try {
            // Load the Eclipse model for the project
            EclipseProject project = connection.getModel(EclipseProject.class);
            System.out.println("Project: " + project.getName());
            System.out.println("Project directory: " + project.getProjectDirectory());
            System.out.println("Source directories:");

task publicTask {
  group = 'myGroup'
}
task privateTask {
}
"""

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

        then:
        gradleProject != null
        gradleProject.tasks.find { it.name.equals('publicTask') }.isPublic()

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

	GetOwner(pathname string) (int64, int64, error)
	// GetSELinuxSupport returns true if given path is on a mount that supports
	// SELinux.
	GetSELinuxSupport(pathname string) (bool, error)
	// GetMode returns permissions of the path.
	GetMode(pathname string) (os.FileMode, error)
	// GetSELinuxMountContext returns value of -o context=XYZ mount option on
	// given mount point.
	GetSELinuxMountContext(pathname string) (string, error)
}

// Windows does not support SELinux.
func (hu *HostUtil) GetSELinuxSupport(pathname string) (bool, error) {
	return false, nil
}

// GetMode returns permissions of the path.
func (hu *HostUtil) GetMode(pathname string) (os.FileMode, error) {
	info, err := os.Stat(pathname)
	if err != nil {
		return 0, err
	}
	return info.Mode(), nil
}

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