languageVersion = JavaLanguageVersion.of(compile11 ? ${jdk11.javaVersion.majorVersion} : ${jdk17.javaVersion.majorVersion})
                }
            }

            def run11 = providers.gradleProperty("run11").isPresent()
            run {
                javaLauncher = javaToolchains.launcherFor {

    private final DaemonParameters.Priority priority;
    private final NativeServicesMode nativeServicesMode;
    private final JavaLanguageVersion javaVersion;

    public DefaultDaemonContext(
        String uid,
        File javaHome,
        JavaLanguageVersion javaVersion,
        File daemonRegistryDir,
        Long pid,
        Integer idleTimeout,
        Collection<String> daemonOpts,

import org.gradle.jvm.toolchain.JavaLanguageVersion;
import org.gradle.jvm.toolchain.JavaToolchainSpec;
import org.gradle.jvm.toolchain.JvmImplementation;
import org.gradle.jvm.toolchain.JvmVendorSpec;

import java.util.function.Predicate;

public class JvmInstallationMetadataMatcher implements Predicate<JvmInstallationMetadata> {
    private final JavaLanguageVersion languageVersion;

import org.gradle.api.plugins.JavaPluginExtension
import org.gradle.jvm.toolchain.JavaLanguageVersion
import org.gradle.jvm.toolchain.JvmVendorSpec
// Using star import to workaround https://youtrack.jetbrains.com/issue/KTIJ-24390
import org.gradle.kotlin.dsl.*


internal
fun JavaPluginExtension.configureJavaToolChain() {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
        vendor = JvmVendorSpec.ADOPTIUM
    }

// tag::customToolchain[]
tasks.withType<JavaCompile>().configureEach {
    javaCompiler = javaToolchains.compilerFor {
        languageVersion = JavaLanguageVersion.of(8)
    }
}

tasks.register<Test>("testsOn17") {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

    id 'org.jetbrains.kotlin.jvm' version '1.9.23'
}

repositories {
    mavenCentral()
}

java {
    toolchain.languageVersion.set(JavaLanguageVersion.of(11))
}

tasks.test {
    useJUnitPlatform()
}

kotlin {
    jvmToolchain {
        languageVersion.set(JavaLanguageVersion.of(11))
    }
}

    def "optional properties are using defaults"() {
        given:
        def baseSpec = createSpec()
        def diffSpec = createSpec()
        baseSpec.languageVersion.set(JavaLanguageVersion.of(11))
        diffSpec.languageVersion.set(JavaLanguageVersion.of(11))
        def base = new JavaToolchainInput(baseSpec)
        def diff = new JavaToolchainInput(diffSpec)

        expect:
        base.languageVersion == diff.languageVersion

    public static class Key implements JavaToolchainSpecInternal.Key {
        private final JavaLanguageVersion languageVersion;
        private final JvmVendorSpec vendor;
        private final JvmImplementation implementation;

        public Key(@Nullable JavaLanguageVersion languageVersion, @Nullable JvmVendorSpec vendor, @Nullable JvmImplementation implementation) {

        """

        buildFile << """
            apply plugin: "java"

            java {
                toolchain {
                    languageVersion = JavaLanguageVersion.of(99)
                    vendor = JvmVendorSpec.matching("exotic")
                }
            }
        """

        file("src/main/java/Foo.java") << "public class Foo {}"

        when:

                launcher1 = javaToolchains.launcherFor {
                    languageVersion = JavaLanguageVersion.of(${jdkMetadata1.languageVersion.majorVersion})
                }
                launcher2 = javaToolchains.launcherFor {
                    languageVersion = JavaLanguageVersion.of(${jdkMetadata2.languageVersion.majorVersion})
                }
            }
        """

        when: