}

def integrationTest = sourceSets.create('integrationTest')

configurations[integrationTest.implementationConfigurationName].extendsFrom(configurations.testImplementation)
configurations[integrationTest.runtimeOnlyConfigurationName].extendsFrom(configurations.testRuntimeOnly)

tasks.named("test") {
    useJUnitPlatform()
}

def integrationTestJarTask = tasks.register(sourceSets.integrationTest.jarTaskName, Jar) {

        def resourcefile2 = new File('file5')
        def resourcefile3 = new File('file6')
        def sourceSet = sourceSet(sourcefile1, sourcefile2, sourcefile3)
        def sourceSet3 = resourceSet(resourcefile1, resourcefile2, resourcefile3)
        sourceSets.addAll(sourceSet, sourceSet3)

        when:
        exeBinary.inputs >> sourceSets

        then:

                    }
                }
            }
        """

        file('b/build.gradle') << """
            sourceSets {
                functionalTest
            }

            java {
                registerFeature('feature') {
                    usingSourceSet(sourceSets.functionalTest)
                }
            }
        """

        when:
        run 'eclipse'

plugins {
    id("java")
}

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'junit:junit:4.13'
}

buildDir = 'target'
sourceSets.main.java.destinationDirectory.set(new File(buildDir, 'main-classes'))

        given:
        buildFile << """
            apply plugin: "java"
            apply plugin: "antlr"

            ${mavenCentralRepository(GROOVY)}

            sourceSets.main {
                antlr {}
            }
            sourceSets.main {
                antlr({} as Action)
            }
        """

        expect:
        succeeds 'help'
    }

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

description = "Tests are checking Gradle behavior during IDE synchronization process"

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

addDependenciesAndConfigurations("smokeIde")

val smokeIdeTestImplementation: Configuration by configurations

    // (and not longer the output of compileJava)
    classpath = sourceSets.main.get().compileClasspath
}
tasks.named<AbstractCompile>("compileJava") {
    // Java also depends on the result of Groovy compilation
    // (which automatically makes it depend of compileGroovy)
    classpath += files(sourceSets.main.get().groovy.classesDirectory)
}

        buildFile << """
            sourceSets {
                customTest
            }

            dependencies {
                customTestImplementation 'junit:junit:${version}'
            }

            tasks.create('customTest', Test) {
                classpath = sourceSets.customTest.runtimeClasspath
                testClassesDirs = sourceSets.customTest.output.classesDirs
                options {

apply plugin: "java"

sourceSets {
    taglet
}

dependencies {
    if (Jvm.current().toolsJar) {
        tagletImplementation files(Jvm.current().toolsJar)
    }
}

javadoc {
    dependsOn tagletClasses
    options {
        locale = 'de_DE'
        breakIterator = true
        taglets 'LocaleAwareTaglet'
        tagletPath sourceSets.taglet.java.destinationDirectory.get().asFile
    }

plugins {
    id('java-library')
}

sourceSets {
    integTest
}

tasks.register("integTest", Test) {
    classpath = sourceSets.integTest.runtimeClasspath
    testClassesDirs = sourceSets.integTest.output.classesDirs
}

// tag::integTest[]
tasks.named('integTest') {
    inputs.property("operatingSystem") {
        System.getProperty("os.name")
    }
}
// end::integTest[]

// tag::distributionPathInput[]