eclipse {
               classpath {
                   downloadJavadoc = true
               }
           }
        """

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

        then:
        attributes.find { it.name == 'javadoc_location' && it.value.contains('guava-18.0-javadoc.jar') }
    }

    def "EclipseProject with default java attributes"() {
        buildFile <<
        """apply plugin: 'java'
           apply plugin: 'eclipse'
        """

        when:
        EclipseProject project = loadToolingModel(EclipseProject)

        then:
        project.projectNatures.size() == 1
        project.projectNatures[0].id.contains('javanature')
        project.buildCommands.size() == 1

                id 'java-library'
            }

            dependencies {
                implementation project(':a')
            }
        """

        when:
        EclipseProject project = loadToolingModel(EclipseProject).children.find { it.gradleProject.path == ':b' }

        then:
        project.projectDependencies.size() == 1

        buildFile.text = '''
apply plugin: 'java'
description = 'this is a project'
'''
        settingsFile.text = 'rootProject.name = \"test project\"'

        when:
        IdeaProject project = loadToolingModel(IdeaProject)

        then:
        project.parent == null
        project.name == 'test project'
        project.description == null
        project.children.size() == 1

    def "returns false for old versions"() {
        setup:
        EclipseProject eclipseProject = loadToolingModel(EclipseProject)

        expect:
        !eclipseProject.hasAutoBuildTasks()
    }

    def "can query if Eclipse model contains tasks configured for auto-sync"() {
        when:
        EclipseProject eclipseProject = loadToolingModel(EclipseProject)

        then:
        !eclipseProject.hasAutoBuildTasks()

        when:
        GradleBuild model = loadToolingModel(GradleBuild)

        then:
        model.includedBuilds.empty
    }

    def "No included builds for single root project"() {
        singleProjectBuildInRootFolder("root")
        when:
        GradleBuild model = loadToolingModel(GradleBuild)

        then:
        model.includedBuilds.empty
    }

project(':impl') {
    eclipse.project.name = 'gradle-impl'
}
'''
        createDirs("api", "impl")
        file('settings.gradle').text = "include 'api', 'impl'"

        when:
        EclipseProject eclipseProject = loadToolingModel(EclipseProject)

        then:
        def children = eclipseProject.children.sort { it.name }
        EclipseProject api = children[0]
        assert api.name == 'gradle-api'

            settingsFile << """
                includeBuild '../buildC'
            """
        }
        def buildCDir = singleProjectBuildInSubfolder("buildC")

        when:
        GradleBuild rootBuild = loadToolingModel(GradleBuild)

        then:
        rootBuild.buildIdentifier.rootDir == rootDir
        rootBuild.rootProject.name == "root"
        rootBuild.includedBuilds.size() == 1

           eclipse {
               classpath {
                   containers 'classpathContainerPath'
               }
           }
        """

        when:
        EclipseProject project = loadToolingModel(EclipseProject)

        then:
        project.classpathContainers.find { it.path == 'classpathContainerPath' }.accessRules.isEmpty()
    }

    def "Has some access rules"() {
        buildFile <<

    }

    def "Has no access rules"() {
        buildFile << "apply plugin: 'java'"
        file('src/main/java').mkdirs()

        when:
        EclipseProject project = loadToolingModel(EclipseProject)
        EclipseSourceDirectory sourceDirectory = project.sourceDirectories.find { it.path == 'src/main/java' }

        then:
        sourceDirectory.accessRules.isEmpty()
    }