import java.io.Serializable;

public class LoadEclipseModel implements BuildAction<EclipseProject>, Serializable {

    @Override
    public EclipseProject execute(BuildController controller) {
        return controller.getModel(EclipseProject.class);
    }

import java.io.Serializable;

public class TellGradleToRunSyncTasks implements BuildAction<Void>, Serializable {

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

        assertEquals(elevateWord3.getTags().get(0), settings.elevateWord().get()[2].getTags().get(0));
        assertEquals(elevateWord3.getRoles().get(0), settings.elevateWord().get()[2].getRoles().get(0));
    }

    @Test
    public void test_delete() {
        ElevateWord elevateWord1 =

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

        }
    }

    RemoteRepository getRemoteRepository(org.eclipse.aether.repository.RemoteRepository repository);

    Node getNode(org.eclipse.aether.graph.DependencyNode node);

    Node getNode(org.eclipse.aether.graph.DependencyNode node, boolean verbose);

    @Nonnull
    Artifact getArtifact(@Nonnull org.eclipse.aether.artifact.Artifact artifact);

    @Nonnull

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

    }

    def "querying for non-existing child #vfsSpec.searchedPath finds nothings (#vfsSpec)"() {
        setupTest(vfsSpec)

        when:
        def resultRoot = initialRoot.getNode(searchedPath, CASE_SENSITIVE)
        then:
        !resultRoot.present
        interaction { noMoreInteractions() }

        where: