apply plugin: 'java'
apply plugin: 'eclipse'

sourceSets.main.java.srcDirs.each { it.mkdirs() }
sourceSets.main.resources.srcDirs.each { it.mkdirs() }

configurations {
  someConfig
}

dependencies {
  someConfig files('foo.txt')
}

eclipse {

  pathVariables fooPathVariable: projectDir

  classpath {
    sourceSets = []

    plusConfigurations << configurations.someConfig

            ${mavenCentralRepository()}

            sourceSets {
                test2
            }

            test.${configureTestFramework}

            task test2(type: Test) {
                ${configureTestFramework}
                classpath = sourceSets.test2.runtimeClasspath
                testClassesDirs = sourceSets.test2.output.classesDirs
            }

            check {

fun Test.setupPreconditionTesting() {
    // We only want to execute our special tests
    // so we override what classes are going to run
    testClassesDirs = sourceSets.test.get().output.classesDirs
    // All test should have this project's "test" source set on their classpath
    classpath += sourceSets.test.get().output

    // These tests should not be impacted by the predictive selection
    extensions.findByType<DevelocityTestConfiguration>()?.apply {

                    @Override
                    public void execute(SourceSet sourceSet) {
                        if (sourceSet.getName().toLowerCase(Locale.ROOT).contains("test")) {
                            // source sets with 'test' in their name are marked as test on the Eclipse classpath
                            testSourceSetsConvention.add(sourceSet);

            components.addAll(testSuites.values());
        }

        renderer.renderComponents(components);

        ProjectSourceSet sourceSets = modelElement("sources", ProjectSourceSet.class);
        if (sourceSets != null) {
            renderer.renderSourceSets(sourceSets);
        }
        BinaryContainer binaries = modelElement("binaries", BinaryContainer.class);
        if (binaries != null) {

    def setup() {
        buildFile << """
            sourceSets {
                producer
            }
            java {
                registerFeature('producer') {
                    usingSourceSet(sourceSets.producer)
                }
            }
            dependencies {
                implementation(project(':')) {

        javaProjectUnderTest.writeBuildScript().writeSourceFiles()

        buildFile << """
            sourceSets.test.java.destinationDirectory.set(file("build/classes/test"))
        """

        succeeds "test"
    }

    @Override
    protected void moveFilesAround() {
        buildFile << """
            sourceSets.test.java.destinationDirectory.set(file("build/test-classes"))

import gradlebuild.performance.generator.tasks.RemoteProject

plugins {
    id("gradlebuild.internal.java")
}

val smokeTestSourceSet = sourceSets.create("smokeTest") {
    compileClasspath += sourceSets.main.get().output
    runtimeClasspath += sourceSets.main.get().output
}

addDependenciesAndConfigurations("smoke")

val smokeTestImplementation: Configuration by configurations

            def extraClasspath = files()
            task run(type: JavaExec) {
                classpath = sourceSets.main.runtimeClasspath
                classpath extraClasspath
                mainClass = "driver.Driver"
            }

            task runWithJavaExec {
                dependsOn sourceSets.main.runtimeClasspath
                doLast {
                    project.javaexec {

}
// end::wtp-with-xml[]

sourceSets {
    integTest
}

configurations {
    functional
}

eclipse {
    classpath {
        plusConfigurations += [configurations.functional]
    }
}

// tag::test-sources[]
eclipse {
    classpath {
        testSourceSets = testSourceSets.get() + [sourceSets.integTest]