macros.put("NDEBUG", null)

    // Define a compiler options
    compilerArgs.add '-W3'

    // Define toolchain-specific compiler options
    compilerArgs.addAll toolChain.map { toolChain ->
        if (toolChain in [ Gcc, Clang ]) {
            return ['-O2', '-fno-access-control']
        } else if (toolChain in VisualCpp) {
            return ['/Zi']
        }
        return []
    }
}

  - ${toolChain.instanceDisplayName}:
      - The specified installation directory '${file('does-not-exist')}' does not appear to contain a Visual Studio installation.""")
    }

    def "tool chain is not available when SDK install is not available"() {
        when:
        buildFile << """
model {
    toolChains {
        ${toolChain.id} {
            windowsSdkDir "does-not-exist"

 * under the License.
 */
package org.apache.maven.toolchain;

import org.apache.maven.execution.MavenSession;

/**
 * Component for use by the <code>maven-toolchains-plugin</code> only.
 * It provides API: <ol>
 * <li>to retrieve every toolchains available in user settings,</li>
 * <li>to store chosen toolchain into build context for later use by toolchain-aware plugins.</li>
 * </ol>
 *
 * @since 2.0.9

            return new OtoolBinaryInfo(file, toolChain.runtimeEnv)
        }
        if (OperatingSystem.current().isWindows()) {
            if (toolChain.meets(ToolChainRequirement.GCC)) {
                return new DumpbinGccProducedBinaryInfo(file, toolChain.runtimeEnv)
            }
            return new DumpbinBinaryInfo(file)
        }
        return new ReadelfBinaryInfo(file, toolChain.runtimeEnv)
    }

import org.gradle.internal.jvm.Jvm
import org.gradle.jvm.toolchain.JavaLanguageVersion
import org.gradle.jvm.toolchain.internal.JavaToolchain
import org.gradle.util.TestUtil
import spock.lang.Specification

class DefaultJavaCompileSpecFactoryTest extends Specification {

    def "produces correct spec with fork=#fork, executable=#executable, toolchain=#toolchain"() {

import org.gradle.nativeplatform.toolchain.Swiftc;
import org.gradle.nativeplatform.toolchain.SwiftcPlatformToolChain;
import org.gradle.nativeplatform.toolchain.internal.ExtendableToolChain;
import org.gradle.nativeplatform.toolchain.internal.NativeLanguage;
import org.gradle.nativeplatform.toolchain.internal.PlatformToolProvider;
import org.gradle.nativeplatform.toolchain.internal.ToolType;

import org.gradle.nativeplatform.toolchain.internal.MutableCommandLineToolContext;
import org.gradle.nativeplatform.toolchain.internal.OutputCleaningCompiler;
import org.gradle.nativeplatform.toolchain.internal.Stripper;
import org.gradle.nativeplatform.toolchain.internal.SymbolExtractor;
import org.gradle.nativeplatform.toolchain.internal.SystemLibraries;

        def root = rootCause(e)
        root.message.startsWith(targetVersion >= GradleVersion.version("8.8") ?
            'No matching toolchain could be found in the locally installed toolchains' :
            'No locally installed toolchains match')
    }

    def rootCause(Exception e) {
        def ex = e
        while (ex.cause != null) {
            ex = ex.cause
        }
        ex
    }

plugins {
    id("org.gradle.toolchains.foojay-resolver") version("0.8.0")
}

import org.gradle.api.Plugin
import org.gradle.api.initialization.Settings
import org.gradle.jvm.toolchain.JavaToolchainResolver
import org.gradle.jvm.toolchain.JavaToolchainResolverRegistry
import java.net.URI
import java.util.Optional
import javax.inject.Inject

apply<MadeUpPlugin>()

// tag::toolchain-management[]
toolchainManagement {
    jvm { // <1>

 * under the License.
 */
package org.apache.maven.toolchain;

import java.util.Map;

import org.apache.maven.toolchain.model.ToolchainModel;

/**
 * a private contract between the toolchains plugin and the components.
 */
public interface ToolchainPrivate extends Toolchain {

    /**
     * Let the toolchain decide if it matches requirements defined
     * in the toolchain plugin configuration.