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

[!GOOS:plan9] env PATH=

# check for invalid toolchain in go.mod
go mod init m
go mod edit -go=1.14 -toolchain=go1.22
! go version
stderr 'go: invalid toolchain: go1.22 is a language version but not a toolchain version \(go1.22.x\)'

rm go.mod
go mod init m
go mod edit -go=1.14 -toolchain=go1.21
! go version
stderr 'go: invalid toolchain: go1.21 is a language version but not a toolchain version \(go1.21.x\)'

rm go.mod

     * @return the toolchain selected by <code>maven-toolchains-plugin</code>
     */
    Toolchain getToolchainFromBuildContext(String type, MavenSession context);

    /**
     * Select all toolchains available in user settings matching the type and requirements,
     * independently from <code>maven-toolchains-plugin</code>.
     *
     * @param session the Maven session, must not be {@code null}

    def "can discover tool chain in environment"() {
        given:
        toolChain.initialiseEnvironment()

        and:
        buildFile << """
apply plugin: 'cpp'
model {
    toolChains {
        tc(${toolChain.implementationClass}) {
            // For software model builds, windows defaults to 32-bit target, so if we discard the toolchain init script,

import org.gradle.nativeplatform.toolchain.GccCommandLineToolConfiguration
import org.gradle.nativeplatform.toolchain.GccPlatformToolChain
import org.gradle.nativeplatform.toolchain.NativePlatformToolChain
import org.gradle.nativeplatform.toolchain.internal.NativeLanguage
import org.gradle.nativeplatform.toolchain.internal.PlatformToolProvider
import org.gradle.nativeplatform.toolchain.internal.ToolType

 * limitations under the License.
 */

package org.gradle.jvm.toolchain;

import com.google.common.base.MoreObjects;
import org.gradle.api.Describable;
import org.gradle.api.provider.Property;
import org.gradle.internal.HasInternalProtocol;

/**
 * Requirements for selecting a Java toolchain.
 * <p>
 * A toolchain is a JRE/JDK used by the tasks of a build.