"""

        when:
        configurationCacheRun "build"

        then:
        assertStateStored()
        result.assertTasksExecuted(":compileJava", ":processResources", ":classes", ":jar", ":compileTestJava", ":processTestResources", ":testClasses", ":test", ":assemble", ":check", ":build")
        result.assertTasksNotSkipped(":jar", ":assemble", ":build")
        def jarFile = file("build/libs/somelib.jar")

digraph javaTestConfigurations {

    rankdir = BT;
    node [fontname="Sans", shape=box, style=filled, fillcolor=chartreuse];
    edge [fontname="Sans"];

    /* tasks */
    compileTestJava [fillcolor=darkslategray1, fontname="Courier New"]
    test [fillcolor=darkslategray1, fontname="Courier New"]

    testCompileClasspath [fillcolor=lightblue]
    testRuntimeClasspath [fillcolor=lightblue]

    /* configurations */

        when:
        succeeds 'compileTestJava'

        then:
        def skippedJars = getSkippedJars(compileClasspathPackaging)
        def producedJars = [':jar', ':testFixturesJar'] - skippedJars
        executedAndNotSkipped(
                ":compileJava",
                ":compileTestFixturesJava",
                ":compileTestJava",
                *producedJars
        )

        when:
        runWithToolchainConfigured(someJdk)
        runWithToolchainConfigured(someJdk)

        then:
        outputContains("Task :compileJava UP-TO-DATE")
        outputContains("Task :compileTestJava UP-TO-DATE")
        outputContains("Task :test UP-TO-DATE")
    }

    def "compile and test not up-to-date once toolchain changed"() {
        def someJdk = AvailableJavaHomes.differentVersion

                    assert !classFiles.empty
                }
            }
        """

        when:
        ExecutionResult result = succeeds('verifyTestKitJars', 'compileTestJava')

        then:
        result.assertTaskNotSkipped(':compileTestJava')
    }

    def "gradleApi dependency API does not include test-kit JAR"() {
        when:
        buildFile << """
            dependencies {

        then:
        succeeds("test")
        executedAndNotSkipped(":compileJava", ":processResources", ":compileTestJava", ":test")

        when:
        sourceFile.text = "class Thing { static public int FLAG = 1; }"

        then:
        buildTriggeredAndSucceeded()
        executedAndNotSkipped(":compileJava", ":compileTestJava", ":test")
        skipped(":processResources")

        when:

}

description = "A set of generic services and utilities."

gradlebuildJava.usedInWorkers()

/**
 * Use Java 8 compatibility for Unit tests, so we can test Java 8 features as well
 */
tasks.named<JavaCompile>("compileTestJava") {
    options.release = 8
}

/**
 * Use Java 8 compatibility for JMH benchmarks
 */
tasks.named<JavaCompile>("jmhCompileGeneratedClasses") {
    options.release = 8
}

        """
        consumingModuleInfo('exports consumer')
        consumingModuleClass()
        testModuleInfo('requires consumer', 'requires junit')
        testModuleClass()

        when:
        succeeds ':compileTestJava'

        then:
        javaClassFile('module-info.class').exists()
        javaClassFile('consumer/MainModule.class').exists()
        classFile('java', 'test', 'module-info.class').exists()

> Task :compileJava
> Task :processResources
> Task :classes
> Task :compileTestJava
> Task :processTestResources
> Task :testClasses

> Task :test

PersonTest > canConstructAPersonWithAName() PASSED

> Task :compileIntTestJava
> Task :processIntTestResources
> Task :intTestClasses

> Task :integrationTest

PersonIntTest > canConstructAPersonWithAName() PASSED

> Task :check

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

// tag::patchArgs[]
def moduleName = "org.gradle.sample"
def patchArgs = ["--patch-module", "$moduleName=${tasks.compileJava.destinationDirectory.asFile.get().path}"]
tasks.named('compileTestJava') {
    options.compilerArgs += patchArgs
}
tasks.named('test') {
    jvmArgs += patchArgs
}
// end::patchArgs[]

tasks.test.useJUnitPlatform()
dependencies {