runtimeClasspath += output + compileClasspath
                }
            }

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

            task jacocoIntegrationTestReport(type: JacocoReport) {
                executionData integrationTest

    }
}

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

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

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

                </tr>
            </thead>
            <tr>
                <td>testClassesDirs</td>
                <td><literal>project.sourceSets.test.output.classesDirs</literal></td>
            </tr>
            <tr>
                <td>classpath</td>
                <td><literal>project.sourceSets.test.runtimeClasspath</literal></td>
            </tr>
            <tr>

// 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")
    }
}

            }

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

            gradlePlugin {
                testSourceSets sourceSets.functionalTest
            }
        """

                id("java-base")
            }

            sourceSets {
                sources
            }

            task verify {
                assert sourceSets.sources.output.classesDirs instanceof ConfigurableFileCollection
            }
        """

        expect:
        succeeds "verify"
    }

        }
    }

    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

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

            check {
                dependsOn test2
            }

            dependencies {
                ${getTestFrameworkDependencies('test')}

                b.propertyAssignment(null, "testClassesDirs", buildScriptBuilder.propertyExpression(functionalTestSourceSet, "output.classesDirs"), true);
                b.propertyAssignment(null, "classpath", buildScriptBuilder.propertyExpression(functionalTestSourceSet, "runtimeClasspath"), true);
                b.methodInvocation(null, "useJUnitPlatform");