return chooseSpecFromCompileOptions(toolchainJavaHome);
        }

        if (!toolchain.isCurrentJvm()) {
            return getForkingSpec(toolchainJavaHome, toolchain.getLanguageVersion().asInt());
        }

        return getDefaultSpec();
    }

    private T chooseSpecFromCompileOptions(File fallbackJavaHome) {
        File forkJavaHome = compileOptions.getForkOptions().getJavaHome();

    }

    private final int version;

    private DefaultJavaLanguageVersion(int version) {
        this.version = version;
    }

    @Override
    public int asInt() {
        return version;
    }

    @Override
    public String toString() {
        if (version < 5) {
            return String.format("1.%d", version);
        }
        return Integer.toString(version);

     * <p>
     * Given the type used, this method returns the simple version even for versions lower than 5.
     *
     * @return the version number
     * @see #toString()
     */
    int asInt();

    /**
     * Return this version as a String, "14" for Java 14.
     * <p>
     * This method will return {@code 1.<version>} when the version is lower than 5.
     *
     * @since 6.8

                    // Access toolchain related information
                    def compileJavaVersion = project.tasks.compileJava.javaCompiler.get().metadata.languageVersion.asInt()
                    return new ToolchainModel(path: project.path, javaVersion: compileJavaVersion);
                }
            }
        """
    }

    @TargetGradleVersion(">=8.1")

            encoder.writeNullableString(context.uid);
            encoder.writeString(context.javaHome.getPath());
            encoder.writeSmallInt(context.javaVersion.asInt());
            encoder.writeString(context.daemonRegistryDir.getPath());
            encoder.writeBoolean(context.pid != null);
            if (context.pid != null) {
                encoder.writeLong(context.pid);

        this.requestedJvmBasedOnJavaHome = requestedJvmBasedOnJavaHome;
    }

    public void applyDefaultsFor(JavaLanguageVersion javaVersion) {
        if (javaVersion.asInt() >= 9) {
            Set<String> jpmsArgs = new LinkedHashSet<>(ALLOW_ENVIRONMENT_VARIABLE_OVERWRITE);
            jpmsArgs.addAll(JpmsConfiguration.GRADLE_DAEMON_JPMS_ARGS);
            jvmOptions.jvmArgs(jpmsArgs);

        init.javaVersion = "11"

        when:
        def version = init.getJavaLanguageVersion(userQuestions, buildInitializer)

        then:
        version.asInt() == 11
    }

    def "gets useful error when requesting invalid Java target"() {
        given:
        def userQuestions = Mock(UserQuestions)
        def buildInitializer = Mock(BuildInitializer)

        def filter = createSpec()
        filter.languageVersion.set(JavaLanguageVersion.of(8))
        def toolchain = queryService.findMatchingToolchain(filter).get()

        then:
        toolchain.languageVersion.asInt() == 8
        toolchain.getInstallationPath().toString() == systemSpecificAbsolutePath("/path/8.0.242.hs-adpt")
    }

    def "returns failing provider if no toolchain matches"() {
        given:

        TypeID::get<TF::ApproximateEqualOp>(),
        TypeID::get<TF::ApproxTopKOp>(),
        TypeID::get<TF::ArgMaxOp>(),
        TypeID::get<TF::ArgMinOp>(),
        TypeID::get<TF::AsinhOp>(),
        TypeID::get<TF::AsinOp>(),
        TypeID::get<TF::Atan2Op>(),
        TypeID::get<TF::AtanhOp>(),
        TypeID::get<TF::BatchMatMulV2Op>(),
        TypeID::get<TF::BatchMatMulV3Op>(),
        TypeID::get<TF::BatchToSpaceOp>(),

    }

    // Many strategies for hashing are possible. This might suffice for now.
    int coercedHash = Hashing.murmur3_32_fixed().hashLong(addressAsLong).asInt();

    // Squash into 224/4 Multicast and 240/4 Reserved space (i.e. 224/3).
    coercedHash |= 0xe0000000;

    // Fixup to avoid some "illegal" values. Currently the only potential