// tag::custom-test-source-set[]
plugins {
    id 'groovy'
    id 'java-gradle-plugin'
}

def functionalTest = sourceSets.create('functionalTest')
def functionalTestTask = tasks.register('functionalTest', Test) {
    group = 'verification'
    testClassesDirs = sourceSets.functionalTest.output.classesDirs
    classpath = sourceSets.functionalTest.runtimeClasspath
    useJUnitPlatform()
}

tasks.named("check") {

        sourceSet.scala.srcDirs == [project.file("src/custom/scala")] as Set
    }

    def addsCompileTaskForNewSourceSet() {
        when:
        project.sourceSets.create('custom')
        SourceSet customSourceSet = project.sourceSets.custom
        def task = project.tasks['compileCustomScala']

        then:
        task instanceof ScalaCompile

repositories {
    mavenCentral()
}

sourceSets {
    create("intTest")
}

dependencies {
    "intTestImplementation"("junit:junit:4.13")
    "intTestRuntimeOnly"("org.ow2.asm:asm:7.1")
}

// tag::jar[]
tasks.register<Jar>("intTestJar") {
    from(sourceSets["intTest"].output)
}
// end::jar[]

// tag::javadoc[]
tasks.register<Javadoc>("intTestJavadoc") {
    source(sourceSets["intTest"].allJava)

                def testFile = file("${'$'}buildDir/${'$'}name")
                dependsOn(sourceSets.main.output)
                doFirst {
                    project.javaexec {
                        assert !(delegate instanceof ExtensionAware)
                        classpath(sourceSets.main.output.classesDirs)
                        mainClass = 'org.gradle.TestMain'

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

            check.dependsOn functionalTest

            gradlePlugin {
                pluginSourceSet sourceSets.custom
                testSourceSets sourceSets.functionalTest
            }
        """

    def "registerFeature can be used when there is no main SourceSet"() {
        given:
        buildFile << """
            apply plugin: 'java-base'

            sourceSets {
               main211 {}
               main212 {}
            }
            java {
               registerFeature('scala211') {
                  usingSourceSet(sourceSets.main211)
               }

        file("build.gradle") << """
apply plugin: "groovy-base"

sourceSets {
    custom
}

${mavenCentralRepository()}

dependencies {
    customImplementation "$dependency"
}

task groovydoc(type: Groovydoc) {
    classpath = sourceSets.custom.runtimeClasspath
}

task verify {
    def compileCustomGroovyClasspath = compileCustomGroovy.groovyClasspath

// tag::extraProperties[]
plugins {
    id 'java-library'
}

ext {
    springVersion = "3.1.0.RELEASE"
    emailNotification = "******@****.***"
}

sourceSets.all { ext.purpose = null }

sourceSets {
    main {
        purpose = "production"
    }
    test {
        purpose = "test"
    }
    plugin {
        purpose = "production"
    }
}

tasks.register('printProperties') {

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

            task jacocoIntegrationTestReport(type: JacocoReport) {
                executionData integrationTest
                sourceSets sourceSets.main
            }

                            .text(sourceSet.implementationConfigurationName)
                        mRenderer.textOutput.println()
                    }
                }
            }

            tasks.register("sourceSets", SourceSetTasks) {}
        """

        when:
        run 'sourceSets'

        then:
        outputContains 'Compile configuration name: implementation'