return this as AbstractIntegrationSpec
    }

    /**
     * Usage:
     * <pre>
     *     def jvm1 = Jvm.current()
     *     def jvm2 = AvailableJavaHomes.getDifferentVersion(jvm1.javaVersion)
     *
     *     when:
     *     withInstallations(jvm1, jvm2).run(":task")
     * </pre>
     */
    AbstractIntegrationSpec withInstallations(Jvm jvm, Jvm... rest) {

    def "forkOptions #option is ignored for Scala "() {
        def currentJdk = Jvm.current()
        def otherJdk = AvailableJavaHomes.getDifferentVersion()

        if (option == "executable") {
            buildFile << """
                compileScala {
                    options.fork = true

            }
        """
    }

    def "forkOptions #option is ignored for Groovy "() {
        def currentJdk = Jvm.current()
        def otherJdk = AvailableJavaHomes.getDifferentVersion()

        if (option == "executable") {
            buildFile << """
                compileGroovy {
                    options.fork = true

     */
    @Nullable
    public static Jvm getDifferentVersion() {
        return getSupportedJdk(element -> !element.getLanguageVersion().equals(Jvm.current().getJavaVersion()));
    }

    /**
     * Returns a JDK that has a different Java version to the current one, and which is supported by the Gradle version under test.
     */
    @Nullable
    public static Jvm getDifferentVersion(final Spec<? super JvmInstallationMetadata> filter) {

        then:
        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'

        Assume.assumeTrue(versionNumber in CodeNarcCoverage.getSupportedVersionsByJdk(javaVersion).collect { VersionNumber.parse(it) })
    }

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

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

               public void foo() {
               }
            }
        """
    }

    def "changing toolchain invalidates task"() {
        def jdk1 = Jvm.current()
        def jdk2 = AvailableJavaHomes.getDifferentVersion()

        buildFile << """
            plugins {
                id 'java'
            }

            javadoc {
                javadocTool = javaToolchains.javadocToolFor {

    fun `can use Java Toolchain to compile precompiled scripts`() {

        val currentJvm = Jvm.current()
        assumeNotNull(currentJvm)

        val newerJvm = AvailableJavaHomes.getDifferentVersion { it.languageVersion > currentJvm.javaVersion }
        assumeNotNull(newerJvm)

        val installationPaths = listOf(currentJvm!!, newerJvm!!)
            .joinToString(",") { it.javaHome.absolutePath }

        JvmInstallationMetadata jdkMetadata2 = AvailableJavaHomes.getJvmInstallationMetadata(AvailableJavaHomes.getDifferentVersion(jdkMetadata1.languageVersion))

        def minJdk = [jdkMetadata1, jdkMetadata2].min { it.languageVersion }
        def maxJdk = [jdkMetadata1, jdkMetadata2].max { it.languageVersion }

        file("build/reports/checkstyle/main.html").assertContents(containsClass("org.gradle.class2"))
    }

    Jvm setupExecutorForToolchains() {
        Jvm jdk = AvailableJavaHomes.getDifferentVersion(new Spec<JvmInstallationMetadata>() {
            @Override
            boolean isSatisfiedBy(JvmInstallationMetadata metadata) {