}
    }

    static ScopeMapping scopeForVariant(SoftwareComponentVariant variant) {
        if (variant instanceof MavenPublishingAwareVariant) {
            return ((MavenPublishingAwareVariant) variant).getScopeMapping();
        }
        // TODO: Update native plugins to use maven-aware variants so we can remove this.
        String name = variant.getName();
        if ("api".equals(name) || "apiElements".equals(name)) {

            ComponentWalker.walkComponent(root, componentsMap, (variant, coordinates) -> {
                if (result.put(variant.getName(), coordinates) != null) {
                    throw new InvalidUserDataException(String.format(
                        "Found multiple variants with name '%s' in component '%s' of project '%s'",
                        variant.getName(), root.getName(), identityPath
                    ));

import org.gradle.api.provider.Provider;
import org.gradle.internal.HasInternalProtocol;

/**
 * The capabilities requested for a dependency. This is used in variant-aware dependency
 * management, to select only variants which provide the requested capabilities. By
 * default, Gradle will only look for variants which provide the "implicit" capability,
 * which corresponds to the GAV coordinates of the component. If the user calls methods

        pom.scopes.isEmpty()

        and: "does not appear as a variant in Gradle Module metadata"
        GradleModuleMetadata gmm = new GradleModuleMetadata(file("build/repo/com/acme/root/1.3/root-1.3.module"))
        !gmm.variants.any { it.name == "testFixturesApiElements" }
        !gmm.variants.any { it.name == "testFixturesRuntimeElements" }
        gmm.variants.size() == 2
    }

    }

    static String testedVariant() {
        def variant
        if (GradleMetadataResolveRunner.gradleMetadataPublished) {
            variant = 'api'
        } else {
            if (GradleMetadataResolveRunner.useIvy()) {
                variant = 'default'
            } else {
                variant = 'compile'
            }
        }
        variant
    }

        List<? extends MutableComponentVariant> variants = metadata.getMutableVariants();
        if (variants == null || variants.isEmpty()) {
            return;
        }
        for (MutableComponentVariant variant : ImmutableList.copyOf(variants)) {
            AttributeValue<String> entry = variant.getAttributes().findEntry(MavenImmutableAttributesFactory.CATEGORY_ATTRIBUTE);

        require(candidates.variants.size == 1)
        val variant = candidates.variants.first()
        return when (val spec = transforms[variant.attributes.asImmutable()]) {
            null -> {
                // no mapping for extension, so it can be discarded
                if (matchingOnArtifactFormat) {

        then:
        1 * apiElements.getOutgoing() >> outgoing
        1 * outgoing.getVariants() >> variants
        1 * variants.maybeCreate('classes') >> variant
        1 * variant.getAttributes() >> attrs
        1 * variant.artifactsProvider(_) >> {
            def artifacts = it[0].create()
            assert artifacts.size() == 1
            PublishArtifact artifact = artifacts[0]

This allows a multi-variant plugin that depends on other plugins to access their APIs, which are exclusively provided in their version-specific variants.

This snippet makes the <<#plugin-with-variants,plugin variant `gradle7` defined above>> consume the matching variants of its dependencies on other multi-variant plugins:

====
include::sample[dir="snippets/developingPlugins/pluginWithVariants/kotlin",files="build.gradle.kts[tags=consume-plugin-variant]"]

    @RequiredFeature(feature = GradleMetadataResolveRunner.REPOSITORY_TYPE, value = "maven")
    def 'module metadata fetched through a settings useModule properly derives variants and subsequent project use of the dependency has access to derived variants'() {
        given:
        def module = mavenRepo.module('test', 'dep', '1.0').publish()