* times with different variants (for example, the main component and its test fixtures). The dependencies
     * of each variant are different, but the {@link #getDependencies() method} doesn't give access to each
     * variant individual dependencies.
     *
     * <p>
     * The variant must be a {@linkplain #getVariants() selected variant} of this component.

The following statements must hold for the variants:

- Variant name must be unique per module
- Each variant must have at least one attribute
- Two variants cannot have the same attributes and capabilities
- If there is at least one dependency in any variant, at least one must carry version information

### `attributes` value

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

The {cpp} Application Plugin creates tasks based on the variants of the application component.
Read the <<building_cpp_projects.adoc#sec:introducing_build_variants-cpp,introduction to build variants>> for more information.
The following diagram shows the relationship between variant-dependent tasks.

.{cpp} Application Plugin variant-dependent task graph

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

The Swift Application Plugin creates tasks based on the variants of the application component.
Read the <<building_swift_projects.adoc#sec:introducing_build_variants-swift,introduction to build variants>> for more information.
The following diagram shows the relationship between variant-dependent tasks.

.Swift Application Plugin variant-dependent task graph

    /**
     * Define a variant with attributes. Variants are only published when using {@link #withModuleMetadata()}.
     */
    MavenModule variant(String variant, Map<String, String> attributes)

    /**
     * Define a variant with attributes. Variants are only published when using {@link #withModuleMetadata()}.
     */

        );
    }

    private void writeVariants() throws IOException {
        List<ModuleMetadataSpec.Variant> variants = metadata.variants;
        if (variants.isEmpty()) {
            return;
        }
        writeArray("variants", () -> {
            for (ModuleMetadataSpec.Variant variant : variants) {
                if (variant instanceof ModuleMetadataSpec.LocalVariant) {

    private final DomainObjectSet<SoftwareComponent> variants;

    public MainExecutableVariant(ObjectFactory objectFactory) {
        variants = objectFactory.domainObjectSet(SoftwareComponent.class);
    }

    @Override
    public String getName() {
        return "main";
    }

    @Override
    public Set<SoftwareComponent> getVariants() {
        return variants;
    }

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

The {cpp} Unit Test Plugin creates tasks based on the variants of the unit test component.
Read the <<building_cpp_projects.adoc#sec:introducing_build_variants-cpp,introduction to build variants>> for more information.
The following diagrams show the relationship between variant-dependent tasks.

.{cpp} Unit Test Plugin variant-dependent task graph

import java.util.List;
import java.util.Set;

/**
 * Immutable metadata for a component variant instance that is used to perform dependency graph resolution.
 *
 * <p>Note that this metadata does not provide any information about the available artifacts of this variants, as this may be expensive to resolve.
 * Information about the artifacts can be accessed via the methods of {@link ComponentGraphResolveState}.</p>

        long instanceId = decoder.readSmallLong();
        VariantGraphResolveState variant = variants.get(instanceId);
        if (variant == null) {
            throw new IllegalStateException("No variant with id " + instanceId + " found.");
        }
        return variant;
    }