@HasInternalProtocol
public interface VersionMappingStrategy {
    /**
     * Configures the version mapping strategy for all variants
     * @param action the configuration action
     */
    void allVariants(Action<? super VariantVersionMappingStrategy> action);

    /**
     * Configures the version mapping strategy for the variant which matches the provided
     * attribute value.
     * @param attribute the attribute to find

The following rules are enforced:

* Variant names must be unique,
* Each variant must have at least <<variant_attributes.adoc#variant_attributes,one attribute>>,
* Two variants cannot have the <<variant_model.adoc#understanding-variant-selection,exact same attributes and capabilities>>,
* If there are dependencies, at least one, across all variants, must carry <<rich_versions.adoc#rich-version-constraints,version information>>.

 *
 * <p>Features are classified by their capabilities. Each variant of a feature provides at least
 * the same set of capabilities as the feature itself. Since all variants of a feature are derived
 * from the same sources, they all expose the same API or "content" and thus provide the same
 * capabilities. Some variants may expose additional capabilities than those of its owning feature,
 * for example with fat jars.</p>

        super.assertPublished()

        // Verify Gradle metadata particulars
        assert mavenModule.parsedModuleMetadata.variants*.name as Set == ['apiElements', 'runtimeElements'] as Set
        assert mavenModule.parsedModuleMetadata.variant('apiElements').files.empty
        assert mavenModule.parsedModuleMetadata.variant('runtimeElements').files.empty

        // Verify POM particulars
        assert mavenModule.parsedPom.packaging == 'pom'

public interface GraphSelectionCandidates {

    /**
     * Returns the set of variants to select from during attribute matching, or an empty list of this
     * component does not support attribute matching.
     */
    List<? extends VariantGraphResolveState> getVariantsForAttributeMatching();

    /**
     * Returns the variant to use when attribute-based variant selection is not enabled.
     */
    @Nullable

            type = "other"
        }
        String variants = result.variants.collect { variant ->
            "variant:${formatVariant(variant)}"
        }.join('@@')
        "[$type][id:${result.id}][mv:${result.moduleVersion}][reason:${formatReason(result.selectionReason as ComponentSelectionReasonInternal)}][$variants]"
    }

    protected String formatVariant(ResolvedVariantResult variant) {

        }
    }

    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)) {

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

    @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()

import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * Static utility to verify a set of variants each have a unique identity in terms of attributes and capabilities.
 */
public class VariantIdentityUniquenessVerifier {

    /**
     * Build a report of all possible variant uniqueness failures for the given configurations.
     */