}
            }
        """

        when:
        withInstallations(jdk8, jdk11).run scaladoc

        then:
        executedAndNotSkipped scaladoc

        when:
        withInstallations(jdk8, jdk11).run scaladoc
        then:
        skipped scaladoc

        when:
        withInstallations(jdk8, jdk11).run scaladoc, '-Pchanged', '--info'
        then:

                ${vendor ? "vendor = JvmVendorSpec.matching('${jdkMetadata.vendor.rawVendor}')" : ""}
            }.getOrNull()
        """

        when:
        withInstallations(jdkMetadata).run ':help'

        then:
        executedAndNotSkipped ':help'

        where:
        description                                 | languageVersion | vendor

            }
        """

        file('src/main/java/MyClass.java') << """
            public class MyClass {}
        """

        withInstallations(AvailableJavaHomes.jdk11).succeeds 'compileJava'

        then:
        outputContains('Hello World')
    }

        configureProjectWithJavaPlugin(compileWithVersion)

        configureLauncher(jdkOther)
        configureExecutable(jdkCurrent)

        when:
        withInstallations(jdkCurrent, jdkOther).runAndFail(":test")

        then:
        failureDescriptionStartsWith("Execution failed for task ':test'.")

        writeJvmCriteria(otherJvm)
        captureJavaHome()
        executer.withArgument("-Porg.gradle.java.installations.auto-detect=false")

        expect:
        withInstallations(otherJvm).succeeds("help")
        assertDaemonUsedJvm(otherJvm)
    }

    @Requires(IntegTestPreconditions.JavaHomeWithDifferentVersionAvailable)

        def otherJdk = AvailableJavaHomes.differentVersion
        writeJvmCriteria(otherJdk)
        captureJavaHome()

        when:
        withInstallations(otherJdk).succeeds()

        then:
        assertDaemonUsedJvm(otherJdk)
        wasForked()
        daemons.daemon.stops()
    }

        when:
        projectDir(producer)
        withInstallations(currentJdk, otherJdk)
        executer.withJavaHome(higherVersion.javaHome)
        succeeds 'publish'

        then:
        pluginModule.assertPublished()
        pluginMarker.assertPublished()
        pluginModule.artifact([:]).assertPublished()

        when:
        projectDir(consumer)
        withInstallations(currentJdk, otherJdk)

        Assume.assumeNotNull(jdk)
        Assume.assumeTrue(GroovyCoverage.supportsJavaVersion(MultiVersionIntegrationSpec.version, jdk.javaVersion))

        executer.beforeExecute {
            withInstallations(jdk)
        }
    }

    abstract Jvm computeJdkForTest()

    @Override
    String compilerConfiguration() {
        javaPluginToolchainVersion(jdk)
    }

    @Override

    Jvm jdk

    def setup() {
        jdk = computeJdkForTest()
        Assume.assumeNotNull(jdk)
        executer.beforeExecute {
            withInstallations(jdk)
        }

        configureJavaPluginToolchainVersion(jdk)
    }

    abstract Jvm computeJdkForTest()

        given:
        def otherJvm = AvailableJavaHomes.differentVersion
        writeJvmCriteria(otherJvm)
        captureJavaHome()

        expect:
        withInstallations(otherJvm).succeeds("help")
        assertDaemonUsedJvm(otherJvm)
    }

    def "Given daemon toolchain criteria that doesn't match installed ones When executing any task Then fails with the expected message"() {