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[]

                }
            }
            targets {
                all {
                    testTask.configure {
                        testClassesDirs += sharedArchTestClasses.filter { it.isDirectory }
                        classpath += sourceSets.main.get().output.classesDirs

                    runtimeClasspath += output + compileClasspath
                }
            }

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

            task jacocoIntegrationTestReport(type: JacocoReport) {

            }

            task othertestsTest(type:Test){
                ${configureTestFramework}
                classpath = sourceSets.othertests.runtimeClasspath
                testClassesDirs = sourceSets.othertests.output.classesDirs
            }
        """.stripIndent()

        and:
        file("src/othertests/java/SomeTestClass.java") << """
            ${testFrameworkImports}

        setupPreconditionTesting()
    }
}

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

                <tr>
                    <td>Name</td>
                    <td>Default with <literal>java</literal> plugin</td>
                </tr>
            </thead>
            <tr>
                <td>testClassesDirs</td>
                <td><literal>project.sourceSets.test.output.classesDirs</literal></td>
            </tr>
            <tr>
                <td>classpath</td>

     *     testClassesDirs = sourceSets.integrationTest.output.classesDirs
     *     classpath = sourceSets.integrationTest.runtimeClasspath
     * }
     * </pre>
     *
     * @param testClassesDirs All test class directories to be used.
     * @since 4.0
     */
    public void setTestClassesDirs(FileCollection testClassesDirs) {
        this.testClassesDirs = testClassesDirs;
    }

    /**

}
// end::java-release-flag[]

// tag::integ-test-task[]
val integrationTest = task<Test>("integrationTest") {
    description = "Runs integration tests."
    group = "verification"

    testClassesDirs = sourceSets["intTest"].output.classesDirs
    classpath = sourceSets["intTest"].runtimeClasspath
    shouldRunAfter("test")

    useJUnitPlatform()

    testLogging {
        events("passed")
    }

            def otherTests = tasks.register('otherTests', Test) {
                binaryResultsDirectory = file("bin")
                classpath = files('blahClasspath')
                testClassesDirs = files("blah")
                ${configureTestFramework}
            }

            tasks.register('testReport', TestReport) {
                testResults.from(test, otherTests)

            delete(remoteProject.map { it.outputDirectory })
        }
    }

    fun SmokeTest.configureForSmokeTest(remoteProjectOutputFiles: Any? = null) {
        group = "Verification"
        testClassesDirs = smokeTestSourceSet.output.classesDirs
        classpath = smokeTestSourceSet.runtimeClasspath
        maxParallelForks = 1 // those tests are pretty expensive, we shouldn't execute them concurrently