* Toolchains

 * {{{./toolchains.html}Toolchains descriptor reference}},

 * public API for toolchains-aware plugins: <<<ToolchainManager>>> component ({{{./apidocs/org/apache/maven/toolchain/ToolchainManager.html}javadoc}})
 with its <<<DefaultToolchainManager>>> implementation ({{{./xref/org/apache/maven/toolchain/DefaultToolchainManager.html}source}}),

 * limitations under the License.
 */

package org.gradle.api.testing.toolchains.internal;

import org.gradle.api.artifacts.Dependency;
import org.gradle.api.internal.tasks.testing.TestFramework;
import org.gradle.api.tasks.testing.Test;

import javax.inject.Inject;
import java.util.Collections;

/**
 * A toolchain for testing JVM projects.  Toolchains provide the dependencies and test framework for a given JVM testing ecosystem.
 *

     */
    String IS_STRICT = "org.apache.maven.toolchains.io.isStrict";

    /**
     * Reads the toolchains from the specified file.
     *
     * @param input The file to deserialize the toolchains from, must not be {@code null}.
     * @param options The options to use for deserialization, may be {@code null} to use the default values.
     * @return The deserialized toolchains, never {@code null}.

    /**
     * The vendor of the toolchain.
     * <p>
     * By default, toolchains from any vendor are eligible.
     * <p>
     * Note that the vendor can only be configured if the {@link #getLanguageVersion() language version} is configured as well.
     *
     * @since 6.8
     */
    Property<JvmVendorSpec> getVendor();

    /**
     * The virtual machine implementation of the toolchain.
     * <p>

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

import java.util.List;

import org.apache.maven.building.Problem;
import org.apache.maven.toolchain.model.PersistedToolchains;

/**
 * Collects the output of the toolchains builder.
 *
 * @since 3.3.0
 */
public interface ToolchainsBuildingResult {

    /**
     * Gets the assembled toolchains.
     *

 */

package org.gradle.api.toolchain.management;

import org.gradle.api.Incubating;
import org.gradle.api.plugins.ExtensionAware;

/**
 * Configures how toolchains are resolved.
 * <p>
 * <code>ToolchainManagement</code> is extended by plugins to support different ecosystems.
 * <p>
 * One option available at present is using the <code>jvm-toolchain-management</code> plugin, which

            DeprecationLogger.warnOfChangedBehaviour(
                    "Using a toolchain installed via auto-provisioning, but having no toolchain repositories configured",
                    "Consider defining toolchain download repositories, otherwise the build might fail in clean environments; " +
                        "see " + Documentation.userManual("toolchains", "sub:download_repositories").getUrl()
                )

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;

    }

    private static List<JvmToolchainMetadata> invalidToolchains(List<JvmToolchainMetadata> toolchains) {
        return toolchains.stream().filter(t -> !isValidToolchain(t)).collect(Collectors.toList());
    }

    private static List<JvmToolchainMetadata> validToolchains(Collection<JvmToolchainMetadata> toolchains) {

        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
    }