*
     *     when:
     *     withInstallations(jvm1, jvm2).run(":task")
     * </pre>
     */
    AbstractIntegrationSpec withInstallations(Jvm jvm, Jvm... rest) {
        return withInstallations([jvm] + rest.toList())
    }

    AbstractIntegrationSpec withInstallations(List<Jvm> jvms) {
        def installationPaths = jvms.collect { it.javaHome.absolutePath }.join(",")

                }
                setJvmArgs(['-version'])
                mainClass = 'None'
            }
        """

        when:
        withInstallations(jdk).run(":run", "--info")

        then:
        executedAndNotSkipped(":run")
        outputContains("Command: ${jdk.javaHome.absolutePath}")

        where:

        // Test up-to-date checks
        when:
        withInstallations(jdk, otherJdk).run(":compileJava")
        then:
        skipped(":compileJava")

        when:
        withInstallations(jdk, otherJdk).run(":compileJava", "-Pchanged")
        then:
        executedAndNotSkipped(":compileJava")

        when:
        withInstallations(jdk, otherJdk).run(":compileJava", "-Pchanged")
        then:

        when:
        withInstallations(jdk17).succeeds(":compileJava")
        then:
        executedAndNotSkipped(":compileJava")
        classJavaVersion(javaClassFile("Main.class")) == JavaVersion.VERSION_11

        // Running with JVM 17 works, because the required Java 15 API is available at runtime
        when:
        withInstallations(jdk17).succeeds(":run")
        then:

            }
        """

        when:
        withInstallations(jdk8, jdk11).run 'compileScala'

        then:
        executedAndNotSkipped ':compileScala'

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

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

                public void test() {}
            }
        """

        when:
        withInstallations(jdkMetadata).run(task)
        def events = toolchainEvents(task)
        then:
        executedAndNotSkipped(task)
        assertToolchainUsages(events, jdkMetadata, tool)

        when:
        withInstallations(jdkMetadata).run(task)
        events = toolchainEvents(task)
        then:
        skipped(task)

                                }
                            }
                        }
                    }
                }
            }
        """

        when:
        withInstallations(Jvm.current(), otherJvm).succeeds("check")

        then:
        result.assertTaskExecuted(":test")
        result.assertTaskExecuted(":testOtherJdk")
    }

        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()
    }