"src/integTest/java",
            "src/integTest/groovy",
            "src/integTest/resources"
        ]

        expectedOrder.each { testFile(it).mkdirs() }

        runEclipseTask """
apply plugin: "java"
apply plugin: "groovy"
apply plugin: "eclipse"

sourceSets {
    integTest {
        resources { srcDir "src/integTest/resources" }
        java { srcDir "src/integTest/java" }

        module.artifact(classifier: 'javadoc')
        module.publish()
        def jar = module.artifactFile
        def srcJar = module.artifactFile(classifier: 'sources')

        //when
        runEclipseTask """
apply plugin: 'java'
apply plugin: 'eclipse'

repositories {
    maven { url "${mavenRepo.uri}" }
    ${RepoScriptBlockUtil.mavenCentralRepositoryDefinition()}
}

dependencies {

        mavenRepo.module("gradle", "foo").publish()
        mavenRepo.module("gradle", "bar").publish()
        mavenRepo.module("gradle", "baz").publish()

        //when
        runEclipseTask """
apply plugin: 'java'
apply plugin: 'war'
apply plugin: 'eclipse-wtp'

configurations {
  configOne
  configTwo
}

repositories {
  maven { url "${mavenRepo.uri}" }
}

dependencies {

        def repoJar = mvnRepo.module("groupOne", "artifactTwo", "2.0").publish().artifactFile

        file('gradle/dependency-locks/compileClasspath.lockfile') << 'groupOne:artifactTwo:1.1'

        //when
        runEclipseTask """
apply plugin: 'java'
apply plugin: 'eclipse'

repositories {
    maven { url "${mvnRepo.uri}" }
}

configurations {
    compileClasspath {
        resolutionStrategy.activateDependencyLocking()

    @Test
    @ToBeFixedForConfigurationCache
    void "external dependency substituted with project dependency"() {
        createDirs("project1", "project2")
        runEclipseTask("include 'project1', 'project2'", """
allprojects {
    apply plugin: "java"
    apply plugin: "eclipse"
}

project(":project2") {
    dependencies {

import org.junit.Test

class EclipseEarIntegrationTest extends AbstractEclipseIntegrationTest {

    @Test
    @ToBeFixedForConfigurationCache
    void configuresEarWithoutJavaPlugin() {
        //when
        runEclipseTask """
apply plugin: 'ear'
apply plugin: 'eclipse'
"""

        //then
        assert file('.project').exists()
    }

dependencies {
    implementation fileTree(dir: "libs", includes: ["*.jar"])
}
        """

        def libsDir = file("libs")
        libsDir.mkdir()
        libsDir.createFile("foo.jar")

        // when:
        runEclipseTask(buildFile)

        // then:
        libEntriesInClasspathFileHaveFilenames("foo.jar")
    }

    @Test
    @Issue("GRADLE-2526")
    @ToBeFixedForConfigurationCache
    void overwritesDependentModules() {

import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.plugins.ide.AbstractIdeIntegrationTest

class AbstractEclipseIntegrationTest extends AbstractIdeIntegrationTest {
    protected ExecutionResult runEclipseTask(settingsScript = "rootProject.name = 'root'", buildScript) {
        runTask("eclipse", settingsScript, buildScript)
    }

    protected File getProjectFile(Map options) {
        getFile(options, ".project")
    }