consumingModuleClass()

        when:
        succeeds ':classes'

        then:
        executed(':compileJava', ':compileJava9')
        javaClassFile('consumer/MainModule.class').exists()
        classFile('java9', 'main', 'module-info.class').exists()
    }

        }
        succeeds 'test'
        getClassMajorVersion(javaClassFile("Thing.class")) == TestJavaClassUtil.getClassVersion(toJavaVersion(version))
        getClassMajorVersion(classFile ( "java", "test", "ThingTest.class")) == TestJavaClassUtil.getClassVersion(toJavaVersion(version))

        where:

        // Remove the project completely
        remoteProjectDir.deleteDir()

        when:
        withBuildCache().run "compileJava"
        then:
        skipped ":compileJava"
        javaClassFile("Hello.class").exists()
    }

    def "compile task gets loaded from cache when source is moved to another directory"() {
        def remoteProjectDir = file("remote-project")

                    RequiredByGroovy.printSomething()
                }
            }
        """
        file('src/main/groovy/UsesJava.groovy').makeOlder()
        def compiledJavaClass = javaClassFile('RequiredByGroovy.class')
        def compiledGroovyClass = groovyClassFile('UsesJava.class')

        when:
        withBuildCache().run ':compileJava', ':compileGroovy'

        then:

            Thread.sleep(100)
            count--
        }
        sendEOT()

        then:
        cancelsAndExits()

        when:
        def classloader = new URLClassLoader([javaClassFile("").toURI().toURL()] as URL[])

        then:
        assert classloader.loadClass('Thing').getDeclaredFields()*.name == ["CHANGED"]
    }

    @UnsupportedWithConfigurationCache(because = "taskGraph.afterTask")

apply plugin: 'java'

${mavenCentralRepository()}

dependencies {
    compileOnly 'commons-logging:commons-logging:1.2'
}
"""

        when:
        run('compileJava')

        then:
        javaClassFile('Test.class').exists()
    }

    def "production compile only dependencies not visible to tests"() {
        given:
        file('src/test/java/Test.java') << """
import org.apache.commons.logging.Log;

                }
            }
        """

        succeeds "test"
        then:
        executedAndNotSkipped ":test"
        javaClassFile("com/Example/Foo.class").assertIsFile()
        javaClassFile("com/example/Foo.class").assertDoesNotExist()
    }

    def "implementation dependencies should not leak into compile classpath of consumer"() {

                    RequiredByScala.printSomething()
                }
            }
        """
        file('src/main/scala/UsesJava.scala').makeOlder()
        def compiledJavaClass = javaClassFile('RequiredByScala.class')
        def compiledScalaClass = scalaClassFile('UsesJava.class')

        when:
        withBuildCache().run ':compileJava', compilationTask

        then:

            exports com.acme;
        }'''

        when:
        succeeds 'test'

        then:
        noExceptionThrown()

        and:
        classFormat(javaClassFile('module-info.class')) == 53
        classFormat(classFile('java', 'test', 'MyTest.class')) == 53
    }

    def "test task does not hang if maxParallelForks is greater than max-workers (#maxWorkers)"() {

    TestFile file(Object... path) {
        if (path.length == 1 && path[0] instanceof TestFile) {
            return path[0] as TestFile
        }
        getTestDirectory().file(path)
    }

    TestFile javaClassFile(String fqcn) {
        classFile("java", "main", fqcn)
    }

    TestFile groovyClassFile(String fqcn) {
        classFile("groovy", "main", fqcn)
    }

    TestFile scalaClassFile(String fqcn) {