this.workspace = workspace;
    }

    @Override
    public EclipseProject execute(BuildController controller) {
        if (workspace != null) {
            return controller.getModel(EclipseProject.class, EclipseRuntime.class, new EclipseRuntimeAction(workspace));
        }
        return controller.getModel(EclipseProject.class);
    }

        project.eclipse.project.natures = ['nature.a', 'nature.b']
        def modelBuilder = createEclipseModelBuilder()

        when:
        def eclipseModel = modelBuilder.buildAll("org.gradle.tooling.model.eclipse.EclipseProject", project)

        then:
        eclipseModel.projectNatures.collect { it.id } == ['nature.a', 'nature.b']
    }

    def "nature list independent from project hierarchy"() {
        setup:

import org.gradle.tooling.BuildAction;
import org.gradle.tooling.BuildController;
import org.gradle.tooling.model.eclipse.EclipseProject;

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

import org.gradle.tooling.IntermediateResultHandler;
import org.gradle.tooling.model.eclipse.EclipseProject;

public class CustomResultHandler implements IntermediateResultHandler<EclipseProject> {

    public EclipseProject result;

    @Override
    public void onComplete(EclipseProject result) {
        this.result = result;
    }

    }

    private static def taskExecuted(ByteArrayOutputStream out, String taskPath) {
        out.toString().contains("> Task $taskPath")
    }

    Collection<EclipseProject> collectProjects(EclipseProject parent) {
        return parent.children.collect { collectProjects(it) }.flatten() + [parent]
    }

    EclipseWorkspace eclipseWorkspace(List<EclipseWorkspaceProject> projects) {

gradle.projectsEvaluated {
    ${mavenCentralRepository()}
}
dependencies {
    ${implementationConfiguration} 'commons-lang:commons-lang:2.5'
}
"""

        when:
        EclipseProject project = loadToolingModel(EclipseProject)

        then:
        project.classpath[0].file.name == 'commons-lang-2.5.jar'
    }

import org.gradle.util.internal.ConfigureUtil;

/**
 * Models the generation/parsing/merging capabilities.
 * <p>
 * For examples see docs for {@link org.gradle.plugins.ide.eclipse.model.EclipseProject}
 * or {@link org.gradle.plugins.ide.idea.model.IdeaProject} and others.
 */
public class FileContentMerger {

    private MutableActionSet whenMerged = new MutableActionSet();

                       }
                   }
               }
            }
        """

        when:
        EclipseProject project = loadToolingModel(EclipseProject)
        def attributes = project.classpath[0].classpathAttributes

        then:
        attributes.find { it.name == 'customkey' && it.value == 'whenMerged'}
    }

repositories {
	flatDir dirs: file("${repoDir.toURI()}")
}

dependencies {
	${implementationConfiguration} "some:lib:1.0"
}
        """

        when:
        EclipseProject project = loadToolingModel(EclipseProject)

        then:
        project.classpath[0].file != null
        project.classpath[0].source == null
        project.classpath[0].javadoc == null
    }

        given:
        plugins.each { plugin -> buildFile << "apply plugin: '${plugin}'\n" }
        settingsFile << "rootProject.name = 'root'"

        when:
        EclipseProject rootProject = loadToolingModel(EclipseProject)
        def natures = rootProject.projectNatures.collect{ it.id }

        then:
        if (plugins.contains('ear') && targetVersion < GradleVersion.version("8.0") ) {