import org.gradle.jvm.toolchain.JavaToolchainDownload;
import org.gradle.jvm.toolchain.JavaToolchainResolver;
import org.gradle.jvm.toolchain.JavaToolchainResolverRegistry;
import org.gradle.jvm.toolchain.JavaToolchainSpec;
import org.gradle.jvm.toolchain.internal.DefaultJavaToolchainRequest;
import org.gradle.jvm.toolchain.internal.JavaToolchainResolverRegistryInternal;

import org.gradle.nativeplatform.toolchain.internal.NativeLanguage;
import org.gradle.nativeplatform.toolchain.internal.NativeToolChainInternal;
import org.gradle.nativeplatform.toolchain.internal.NativeToolChainRegistryInternal;
import org.gradle.nativeplatform.toolchain.internal.PlatformToolProvider;
import org.gradle.nativeplatform.toolchain.internal.ToolType;
import org.gradle.util.internal.VersionNumber;

                        ToolchainPrivate toolchain = fact.createToolchain(model);
                        if (requirements == null || toolchain.matchesRequirements(requirements)) {
                            toolchains.add(toolchain);
                        }
                    } catch (MisconfiguredToolchainException ex) {
                        logger.error("Misconfigured toolchain.", ex);
                    }
                }

    /**
     * Builds the toolchains model from the configured toolchain files.
     *
     * @param userToolchainsFile The path to the toolchains file, may be <code>null</code> to disable parsing.
     * @return The toolchains model or <code>null</code> if no toolchain file was configured or the configured file does
     *         not exist.
     * @throws MisconfiguredToolchainException If the toolchain file exists but cannot be parsed.
     */

        return new ToolchainWrapper(toolchain);
    }

    private static class ToolchainWrapper implements Toolchain {
        private final org.apache.maven.toolchain.Toolchain toolchain;

        ToolchainWrapper(org.apache.maven.toolchain.Toolchain toolchain) {
            this.toolchain = toolchain;
        }

        @Override
        public String getType() {

        directories*.source == ["Maven Toolchains", "Maven Toolchains"]

        where:
        useProperty << [true, false]
    }

    def "supplies single path for a single toolchain with non-resolvable environment variable"(boolean useProperty) {
        given:
        def toolchains = mavenHome.createFile(new File("toolchains.xml"))
        toolchains.write('''<toolchains>
            <toolchain>
            <type>jdk</type>

    def helloWorldApp = new CHelloWorldApp()

    def setup() {
        buildFile << """
apply plugin: 'c'

model {
    toolChains {
        ${toolChain.buildScriptConfig}
    }
    components {
        main(NativeExecutableSpec) {
            binaries.all {
                lib library: 'hello', linkage: 'static'
            }
        }

        then:
        toolchain.isPresent()
        !toolchain.get().isFallbackToolchain()
        toolchain.get().languageVersion == JavaLanguageVersion.of(17)
        toolchain.get().getInstallationPath().toString() == currentJvm.location.absolutePath
    }

    def "returns fallback toolchain if filter is not configured"() {
        given:
        def currentJvm = locationFor("17")

        then:
        failureDescriptionStartsWith("Execution failed for task ':javadoc'.")
        failureHasCause("Toolchain from `executable` property does not match toolchain from `javadocTool` property")
    }

    def "fails on toolchain and executable mismatch (without java-base plugin)"() {
        def jdkCurrent = Jvm.current()
        def jdkOther = AvailableJavaHomes.differentVersion

import org.gradle.nativeplatform.platform.internal.OperatingSystemInternal
import org.gradle.nativeplatform.toolchain.internal.NativeLanguage
import org.gradle.nativeplatform.toolchain.internal.NativeToolChainInternal
import org.gradle.nativeplatform.toolchain.internal.NativeToolChainRegistryInternal
import org.gradle.nativeplatform.toolchain.internal.PlatformToolProvider
import org.gradle.util.UsesNativeServices