copy.variants.size() == 3
        copy.variants[0].name == "api"
        copy.variants[0].files.size() == 2
        copy.variants[1].name == "runtime"
        copy.variants[1].files.size() == 1
        copy.variants[2].name == "link"
        copy.variants[2].files.empty

        def immutable3 = copy.asImmutable()
        immutable3.variants.size() == 3
        immutable3.variants[0].name == "api"

            baseVariant = immutableMetadata.getConfiguration('runtime')
        }

        then:
        variants.size() == initialVariantCount + 1
        variants.last().name == 'new-variant'
        variants.last().attributes == baseVariant.attributes
        variants.last().capabilities == baseVariant.capabilities

        def variants = pluginModule.parsedModuleMetadata.variants
        variants.size() == 4
        variants[0].name == "apiElements"
        variants[0].attributes['color'] == 'blue'
        variants[1].name == "runtimeElements"
        variants[1].attributes['color'] == 'blue'
        variants[2].name == "alternateApiElements"
        variants[2].attributes['color'] == 'green'

====

== Making variants published as classified jars explicit ==

While in the previous example, all variants, "main variants" and optional features, were packaged in one jar file, it is common to publish certain variants as separate files.
In particular, when the variants are mutual exclusive — i.e. they are *not* feature variants, but different variants offering alternative choices.

        toComponent.getCandidatesForGraphVariantSelection().variants.addAll(toConfig)

        expect:
        dep.selectVariants(variantSelector, attributes([:]), toComponent, attributesSchema, [] as Set).variants == [toConfig]
    }

    @Unroll("selects variant '#expected' from target component (#scenario)")
    def "selects the variant from target component that matches the attributes"() {

                .map(variant -> resolveStateFor(variant).asVariant())
                .collect(Collectors.toList())
        );
        this.idGenerator = idGenerator;
        this.selectableVariantResults = graphMetadata.getVariantsForGraphTraversal().stream()
            .flatMap(variant -> variant.getVariants().stream())
            .map(variant -> new DefaultResolvedVariantResult(
                getId(),

        The only attribute distinguishing these variants is 'shape'. Add this attribute to the consumer's configuration to resolve the ambiguity:
          - Value: 'round' selects variant: 'blueRoundElements'
          - Value: 'square' selects variant: 'blueSquareElements'
          - Value: 'triangle' selects variant: 'blueTriangleElements'""")

        if (variantMetadataRules.getAdditionalVariants().isEmpty()) {
            return variants;
        }
        Map<String, VariantGraphResolveMetadata> variantsByName;
        ImmutableList.Builder<VariantGraphResolveMetadata> builder = new ImmutableList.Builder<>();
        if (variants.isPresent()) {

        def variant = Stub(VariantGraphResolveState)
        variant.toString() >> name
        variant.name >> name
        def configuration = Stub(ConfigurationGraphResolveState)
        component.getConfiguration(name) >> configuration
        configuration.name >> name
        configuration.toString() >> name
        configuration.asVariant() >> variant
        configuration.metadata >> metadata

        return conf;
    }

    /**
     * Ensures the target variant matches the request attributes and is consumable. This needs to be called
     * for variants that are selected by means other than attribute matching.
     *
     * Note: This does not need to be called for variants selected via attribute matching, since
     * attribute matching ensures selected variants are compatible with the requested attributes.
     */