copyTo(outputStream);
        } finally {
            outputStream.close();
        }
    }

    @Override
    @Deprecated
    public int getMode() {
        DeprecationLogger.deprecateMethod(FileTreeElement.class, "getMode()")
            .replaceWith("getPermissions()")
            .willBeRemovedInGradle9()
            .withUpgradeGuideSection(8, "unix_file_permissions_deprecated")

        assert lockOptions.getMode() == Exclusive;
        this.initializationAction = initializationAction;
        this.onOpenAction = onOpenAction;
        this.onCloseAction = onCloseAction;
        assert lockOptions.getMode() == Exclusive;
        this.cacheDisplayName = cacheDisplayName;
        this.lockTarget = lockTarget;

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