)
    )

    def "can determine version of current jvm"() {
        expect:
        detector.getJavaVersionMajor(Jvm.current()) == JavaVersion.current().majorVersionNumber
    }

    def "can determine version of java command for current jvm"() {
        expect:
        detector.getJavaVersionMajor(Jvm.current().getJavaExecutable().path) == JavaVersion.current().majorVersionNumber
    }

@ServiceScope(Scope.Global.class)
public interface JvmVersionDetector {
    /**
     * Probes the Java version for the given JVM installation.
     */
    int getJavaVersionMajor(JavaInfo jvm);

    /**
     * Probes the Java version for the given `java` command.
     */
    int getJavaVersionMajor(String javaCommand);

    }

    public void validate(JavaInfo resolvedJvm) {
        if (resolvedJvm == Jvm.current()) {
            return;
        }

        int javaVersionMajor = versionDetector.getJavaVersionMajor(resolvedJvm);
        UnsupportedJavaRuntimeException.assertUsingVersion("Gradle", 8, javaVersionMajor);
    }

    public DefaultJvmVersionDetector(JvmMetadataDetector detector) {
        this.detector = detector;
    }

    @Override
    public int getJavaVersionMajor(JavaInfo jvm) {
        return getVersionFromJavaHome(jvm.getJavaHome());
    }

    @Override
    public int getJavaVersionMajor(String javaCommand) {
        File executable = new File(javaCommand);
        File parentFolder = executable.getParentFile();

        super(message);
    }

    public static void assertUsingVersion(String component, int minVersion) throws UnsupportedJavaRuntimeException {
        Integer current = Jvm.current().getJavaVersionMajor();
        if (current == null || current >= minVersion) {
            return;
        }

    }

    public JvmImplementation getJvmImplementation() {
        return jvmImplementation;
    }

    public boolean isCompatibleWith(Jvm other) {
        Integer javaVersionMajor = other.getJavaVersionMajor();
        if (javaVersionMajor == null) {
            return false;
        }
        return isCompatibleWith(JavaLanguageVersion.of(javaVersionMajor));
    }

    @Override
    public String toString() {

            DefaultProcessForkOptions.getActualEnvironment(forkOptions)
        );
    }

    private int detectJavaVersion(String executable) {
        return jvmVersionDetector.getJavaVersionMajor(executable);
    }

        javaForkOptions.setWorkingDir(daemonWorkingDir);
        javaForkOptions.setExecutable(javaOptions.getExecutable());
        if (jvmVersionDetector.getJavaVersionMajor(javaForkOptions.getExecutable()) >= 9) {
            javaForkOptions.jvmArgs(JpmsConfiguration.GROOVY_JPMS_ARGS);
        } else {
            // In JDK 8 and below, we need to attach the 'tools.jar' to the classpath.

        return findExecutable(name);
    }

    /**
     * @return the major part of the java version if known, otherwise null
     */
    @Nullable
    public Integer getJavaVersionMajor() {
        return javaVersionMajor;
    }

    /**
     * @return the {@link JavaVersion} information
     */
    @Nullable
    public JavaVersion getJavaVersion() {

            // Either the TAPI client or org.gradle.java.home has been provided
            JavaLanguageVersion detectedVersion = JavaLanguageVersion.of(jvmVersionDetector.getJavaVersionMajor(daemonParameters.getRequestedJvmBasedOnJavaHome()));
            daemonParameters.applyDefaultsFor(detectedVersion);