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[]

        }
    }

    private void writeSecondaryVariants(List<ReportSecondaryVariant> variants) {
        if (!variants.isEmpty()) {
            newLine();
            printSection("Secondary Variants (*)", () -> {
                variants.forEach(variant -> {
                    newLine();
                    writeSecondaryVariant(variant);
                });
            });
        }
    }

/**
 * This attribute describes the categories of variants for a given module.
 * <p>
 * Four values are found in published components:
 * <ul>
 *     <li>{@code library}: Indicates that the variant is a library, that usually means a binary and a set of dependencies</li>
 *     <li>{@code platform}: Indicates that the variant is a platform, that usually means a definition of dependency constraints</li>

				build.AddVariant(t.Variants())
				exact = false
				t = build.Make()
			}
			hasExtra = true
		} else if _, ok := t.Extension('u'); ok {
			// TODO: va may mean something else. Consider not considering it.
			// Strip all but the 'va' entry.
			old := t
			variant := t.TypeForKey("va")
			t = language.Tag{LangID: b, ScriptID: s, RegionID: r}
			if variant != "" {

        mainMetadata.variants.size() == 5
        def api = mainMetadata.variant("api")
        api.dependencies.empty
        api.files.size() == 1
        api.files[0].name == 'cpp-api-headers.zip'
        api.files[0].url == 'test-1.2-cpp-api-headers.zip'
        mainMetadata.variant("debugLink").availableAt.coords == "some.group:test_debug:1.2"