}

    /**
     * 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) {
        return withInstallations([jvm] + rest.toList())
    }

        Jvm current = current();
        return jvm.getJavaHome().equals(current.getJavaHome()) ? current : jvm;
    }

    /**
     * Constructs JVM details by inspecting the current JVM.
     */
    Jvm(OperatingSystem os) {

import org.gradle.internal.jvm.JavaInfo;
import org.gradle.internal.jvm.Jvm;
import org.gradle.internal.jvm.inspection.CachingJvmMetadataDetector;
import org.gradle.internal.jvm.inspection.DefaultJavaInstallationRegistry;
import org.gradle.internal.jvm.inspection.DefaultJvmMetadataDetector;
import org.gradle.internal.jvm.inspection.JvmInstallationMetadata;
import org.gradle.internal.jvm.inspection.JvmInstallationProblemReporter;

        }

        expect:
        def jvm = new Jvm(os, installDir, "1.8.0", 8)
        def jvm2 = new Jvm(os, installDir, "1.8.0", 8)
        Matchers.strictlyEquals(jvm, jvm2)
    }

    def "Returns current JVM when located using Java home dir"() {
        expect:
        def current = Jvm.current()
        def jvm = Jvm.forHome(current.javaHome)

        jvm.is(current)
    }

    /**
     * Configures the target JVM version. For producers of a library, it's in general
     * a better idea to rely on inference which will calculate the target JVM version
     * lazily, for example calling {@code JvmLanguageUtilities#useDefaultTargetPlatformInference(Configuration, TaskProvider)}.
     * For consumers, it makes sense to specify a specific version of JVM they target.
     *
     * @param version the Java version

        }
        return Collections.emptySet();
    }

    private Set<InstallationLocation> findInstallationsInRegistry() {
        final Stream<String> openJdkInstallations = findOpenJDKs();
        final Stream<String> jvms = Lists.newArrayList(
            "SOFTWARE\\JavaSoft\\JDK",
            "SOFTWARE\\JavaSoft\\Java Development Kit",
            "SOFTWARE\\JavaSoft\\Java Runtime Environment",

Each process, or "runtime", applies different constraints to the code that runs in that process.
For example, each process has different supported JVMs and a different set of services available for dependency injection.

            final Reader output = executeJavaHome();
            return parse(output);
        } catch (ExecException e) {
            String errorMessage = "Java Toolchain auto-detection failed to find local MacOS system JVMs";
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug(errorMessage, e);
            } else {
                LOGGER.info(errorMessage);
            }
        }
        return Collections.emptySet();

link:{javadocPath}/org/gradle/jvm/toolchain/JvmVendorSpec.html[`JvmVendorSpec`] has a list of well-known JVM vendors recognized by Gradle.
The advantage is that Gradle can handle any inconsistencies across JDK versions in how exactly the JVM encodes the vendor information.

====

        ])
        result.size() == 1
    }

    def "can parse output with no installations"() {
        given:
        def output = """
Unable to find any JVMs matching version "(null)".
Matching Java Virtual Machines (0):

Default Java Virtual Machines (0):

No Java runtime present, try --request to install.
"""
        when: