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

 */

package org.gradle.tooling.internal.consumer.converters;

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

/**
 * This is used for compatibility with clients <5.4
 */
public class EclipseProjectHasAutoBuildMixin {

    public EclipseProjectHasAutoBuildMixin(EclipseProject eclipseProject) {
    }

    public boolean hasAutoBuildTasks() {
        return false;
    }

           }

           project(':sub') {
               apply plugin: 'java'
           }
        """
    }

    def "Has no access rules"() {
        when:
        EclipseProject project = loadToolingModel(EclipseProject)
        EclipseProjectDependency projectDependency = project.projectDependencies.find { it.path.contains 'sub' }

        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:

    }

    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'}
    }

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

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
    }