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

import javax.annotation.Nullable;
import javax.inject.Inject;
import java.util.Objects;

public abstract class DefaultToolchainSpec implements JavaToolchainSpecInternal {

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

            .map(javaToolchain -> toolFactory.create(JavadocTool.class, javaToolchain));
    }

    private DefaultToolchainSpec configureToolchainSpec(Action<? super JavaToolchainSpec> config) {
        DefaultToolchainSpec toolchainSpec = objectFactory.newInstance(DefaultToolchainSpec.class);
        config.execute(toolchainSpec);
        return toolchainSpec;
    }

package org.gradle.jvm.toolchain.internal;

import org.gradle.internal.jvm.Jvm;
import org.gradle.jvm.toolchain.JavaLanguageVersion;

import javax.inject.Inject;

public abstract class CurrentJvmToolchainSpec extends DefaultToolchainSpec {

    @Inject
    public CurrentJvmToolchainSpec() {
        getLanguageVersion().set(JavaLanguageVersion.of(Jvm.current().getJavaVersion().getMajorVersion()));

        // disallow changing property values

import org.gradle.api.plugins.internal.DefaultJavaPluginExtension
import org.gradle.api.tasks.SourceSetContainer
import org.gradle.jvm.toolchain.JavaLanguageVersion
import org.gradle.jvm.toolchain.internal.DefaultToolchainSpec
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.gradle.util.TestUtil
import org.junit.Rule
import spock.lang.Specification

import org.gradle.api.model.ObjectFactory;

import javax.inject.Inject;
import java.io.File;
import java.util.Objects;

public abstract class SpecificInstallationToolchainSpec extends DefaultToolchainSpec {

    public static class Key implements JavaToolchainSpecInternal.Key {

        private final File javaHome;

        public Key(File javaHome) {
            this.javaHome = javaHome;
        }

import org.gradle.util.TestUtil
import spock.lang.Specification

class DefaultToolchainSpecTest extends Specification {
    JavaToolchainSpec createSpec() {
        TestUtil.objectFactory().newInstance(DefaultToolchainSpec)
    }

    def "spec key implements equals"() {
        given:
        def spec11 = createSpec()
        def spec12 = createSpec()
        def spec11Vendor1 = createSpec()

import org.gradle.util.TestUtil
import spock.lang.Specification

class JavaToolchainInputTest extends Specification {
    JavaToolchainSpec createSpec() {
        TestUtil.objectFactory().newInstance(DefaultToolchainSpec)
    }

    def "optional properties are using defaults"() {
        given:
        def baseSpec = createSpec()
        def diffSpec = createSpec()

        configureArchiveDefaults(project);
    }

    @SuppressWarnings("deprecation")
    private DefaultJavaPluginExtension addExtensions(final Project project) {
        DefaultToolchainSpec toolchainSpec = objectFactory.newInstance(DefaultToolchainSpec.class);
        SourceSetContainer sourceSets = (SourceSetContainer) project.getExtensions().getByName("sourceSets");

import org.gradle.internal.jvm.DefaultModularitySpec;
import org.gradle.jvm.component.internal.JvmSoftwareComponentInternal;
import org.gradle.jvm.toolchain.JavaToolchainSpec;
import org.gradle.jvm.toolchain.internal.DefaultToolchainSpec;
import org.gradle.jvm.toolchain.internal.JavaToolchainSpecInternal;
import org.gradle.testing.base.plugins.TestingBasePlugin;
import org.gradle.util.internal.CollectionUtils;

import javax.annotation.Nullable;

        def javaHome = new File(temporaryFolder, jdk).tap { mkdirs() }
        def metadata = detector.getMetadata(testLocation(javaHome))

        when:
        def spec = TestUtil.objectFactory().newInstance(DefaultToolchainSpec)
        spec.getLanguageVersion().set(JavaLanguageVersion.of(javaVersion.getMajorVersion()))
        spec.getVendor().set(vendor)
        spec.getImplementation().set(implementation)

        then: