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)

        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"() {

        outputContains("Running pmd with toolchain '${Jvm.current().javaHome.absolutePath}'.")
    }

    Jvm setupExecutorForToolchains() {
        Jvm jdk = AvailableJavaHomes.getDifferentVersion()
        withInstallations(jdk)
        return jdk
    }

    private void writeBuildFile() {
        buildFile << """
            plugins {
                id 'groovy'
                id 'java'
                id 'pmd'

    def kotlinVersion = System.getProperty("integTest.kotlinVersion")

    def setup() {
        executer.beforeExecute {
            args("-Dorg.gradle.unsafe.suppress-gradle-api=true")
            withInstallations(jvm)
        }

        file("src/test/java/org/example/PublishedApiTestPluginTest.java") << pluginTestJava()
    }

    def "can compile Java code against public API"() {

        generator.addWarning()
        generator.save()
        possibleFileLocations.put(generator.sourceFile.absolutePath, 1)

        when:
        executer.withArguments("--info")
        withInstallations(AvailableJavaHomes.getJdk(JavaVersion.VERSION_1_8))
        succeeds(":compileJava")

        then:
        outputContains(DiagnosticToProblemListener.FORMATTER_FALLBACK_MESSAGE)

    def "test can install an irreplaceable SecurityManager"() {
        given:
        executer
            .withStackTraceChecksDisabled()
            .withToolchainDetectionEnabled()
        withInstallations(AvailableJavaHomes.getAvailableJvms())
        buildFile << """
            plugins {
                id("java")
            }
            ${javaPluginToolchainVersion(11)}