consumingModuleInfo('requires moda')
        consumingModuleClass('moda.ModaClass')

        when:
        succeeds ':compileJava'

        then:
        javaClassFile('module-info.class').exists()
        javaClassFile('consumer/MainModule.class').exists()
    }

    def "compiles a non-module using the classpath"() {
        given:
        publishJavaModule('moda')

        then:
        fails ':compileJava'

        when:
        consumingModuleInfo('requires moda')
        succeeds ':compileJava'

        then:
        javaClassFile('module-info.class').exists()
        javaClassFile('consumer/MainModule.class').exists()
    }

    def "detects change from library to module"() {
        when:
        publishJavaLibrary('moda')
        consumingModuleInfo('requires moda')

        testModuleClass('org.junit.Assert.assertNull(consumer.MainModule.class.getModule().getName())')

        when:
        succeeds ':test'

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

        consumingModuleInfo('requires producer')
        consumingModuleClass('producer.ProducerClass')

        when:
        succeeds ':compileJava'

        then:
        javaClassFile('module-info.class').exists()
        javaClassFile('consumer/MainModule.class').exists()
    }

    def "compiles a non-module using the classpath"() {
        given:
        producingModuleInfo()
        producingModuleClass()

        buildFile << 'compileJava.include "**/Person*.java"'

        when:
        succeeds("compileJava")

        then:
        javaClassFile("compile/test/Person.class").exists()
        javaClassFile("compile/test/Person2.class").exists()
        !javaClassFile("Bar.class").exists()
    }

    def "can use annotation processor"() {
        given:
        buildFile << """
            dependencies {

        outputContains("Compiling with toolchain '${jdk.javaHome.absolutePath}'.")
        outputContains("Compiling with JDK Java compiler API.")
        javaClassFile("com/example/Foo.class").exists()
        javaClassFile("com/example/Bar.class").exists()

        where:
        javaVersion             | deprecationMessage

        outputContains("sourceCompatibility: '${earlierJdk.javaVersion}'")
        outputContains("targetCompatibility: '${earlierJdk.javaVersion}'")
        classJavaVersion(javaClassFile("Foo.class")) == earlierJdk.javaVersion

        where:
        forkOption   | configure                                        | appendPath
        "java home"  | { "options.forkOptions.javaHome = file('$it')" } | ''

        compileJava {
            options.fork = ${forkMode}
        }
        """
        when:
        executer.withJavaHome(jreJavaHome.absolutePath).withTasks("compileJava").run().output
        then:
        javaClassFile("org/test/JavaClazz.class").exists()

        where:
        forkMode << [true, false]
    }

    @Requires(UnitTestPreconditions.Windows)

        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()
        classFile('java', 'test', 'consumer/test/MainModuleTest.class').exists()
    }

    }

    def "can download missing jdk automatically"() {
        when:
        result = executer
                .withTasks("compileJava")
                .run()

        then:
        javaClassFile("Foo.class").assertExists()
        assertJdkWasDownloaded()
    }

    def "clean destination folder when downloading toolchain"() {
        when: "build runs and doesn't have a local JDK to use for compilation"