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'

            }
            this.variants.each { variant ->
                def actualVariant = actual.variants.find { it.name == variant.name }
                if (!actualVariant) {
                    errors << "Expected variant name $variant, but wasn't found in: $actual.variants.name"
                } else {
                    if (variant.attributes != actualVariant.attributes) {

        The only attribute distinguishing these variants is 'org.gradle.native.architecture'. Add this attribute to the consumer's configuration to resolve the ambiguity:
          - Value: 'x86-64' selects variant: 'natives-windows-runtime'

swift-application-variant-task-graph.png...

    def "expressing a preference for a variant with capabilities declared in a published modules does not evict unrelated variants"() {
        given:
        repository {
            'org:testB:1.0' {
                variant('runtime') {
                    capability('org', 'testB', '1.0')
                }
                variant('runtimeAlt') {
                    capability('org', 'testB', '1.0')

            .map(variant -> dependencyCoordinateResolverFactory
                .createCoordinateResolvers(variant, versionMappingStrategy)
                .map(resolvers -> getDependenciesForVariant(variant, resolvers, coordinates))
            ).collect(Collectors.toList());

        return new MergeProvider<>(parsedVariants).map(variants -> {

        then: "attributes are used during matching, the rule is applied on all variants"
        2 * attributesRule.execute(_)

        and: " we only apply the dependencies rule to the selected variant"
        1 * dependenciesRule.execute(_)
        1 * constraintsRule.execute(_)
        0 * _
    }

    def "treats ivy configurations as variants"() {
        given:
        def rule = Mock(Action)

        when:

 */
public class ModuleMetadataSpec {

    final Identity identity;
    final List<Variant> variants;
    final boolean mustIncludeBuildId;

    ModuleMetadataSpec(
        Identity identity,
        List<Variant> variants,
        boolean mustIncludeBuildId
    ) {
        this.identity = identity;
        this.variants = variants;
        this.mustIncludeBuildId = mustIncludeBuildId;
    }

    static class Identity {

            List<ResolvedVariantResult> variants = getArtifactVariants().get();
            List<RegularFile> files = getArtifactFiles().get();
            for (int index = 0; index < ids.size(); index++) {
                ComponentArtifactIdentifier id = ids.get(index);
                ResolvedVariantResult variant = variants.get(index);
                RegularFile file = files.get(index);

image::xctest-task-graph.png[]

[[sec:xctest_task_variants]]
=== Variant-dependent Tasks

The XCTest Plugin creates tasks based on the variants of the test component.
Read the <<building_swift_projects.adoc#sec:introducing_build_variants-swift,introduction to build variants>> for more information.
The following diagrams show the relationship between variant-dependent tasks.

.XCTest Plugin variant-dependent task graph
image::xctest-variant-task-graph.png[]