def root = result.root
                assert root.id.projectName == 'root'
                assert root.variants.size() == 2
                def conf = root.variants.find { it.displayName == 'conf' }
                def other = root.variants.find { it.displayName == 'other' }
                assert conf != null
                assert other != null
            }
        """

    // CHECK: Cast
    // CHECK-SAME: (tensor<!tf_type.variant<tensor<2xf32>>>) -> tensor<!tf_type.variant<tensor<2xf32>>>
    %0 = "tf.Cast"(%arg0) {Truncate = false} : (tensor<!tf_type.variant<tensor<2xf32>>>) -> tensor<!tf_type.variant>
    %1 = "tf.Identity"(%0) : (tensor<!tf_type.variant>) -> tensor<!tf_type.variant>

 */
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 {

        given:
        repository {
            'org:testA:1.0' {
                variant('runtime') {
                    capability('org', 'testA', '1.0')
                    capability('cap')
                }
            }
            'org:testB:1.0' {
                variant('runtime') {
                    capability('org', 'testB', '1.0')
                    capability('cap')

 *
 * @since 5.2
 */
@HasInternalProtocol
public interface VariantVersionMappingStrategy {
    /**
     * Declares that this variant should use versions from the resolution
     * of a default configuration chosen by Gradle.
     */
    void fromResolutionResult();

    /**
     * Declares that this variant should use versions from the resolution

    }

    def "associating the same result to a variant multiple times does not cause duplicate results"() {
        given:
        def module = newModule()
        def dependency = newDependency()
        def variant = module.getVariant(1)

        when:
        module.addDependency(dependency)

        module.associateDependencyToVariant(dependency, variant)
        module.associateDependencyToVariant(dependency, variant)

        def variantDef = publications.variants.create("child")
        variantDef.attributes.attribute(Attribute.of("thing", String), "value")
        variantDef.artifacts.add(artifact)

        expect:
        def variants = getOutgoingVariants(publications)
        variants.size() == 1

        def child = variants.first()
        child.displayName.displayName == '<config> variant child'

    mainVariantImplementation[label=<main<i>Variant</i>Implementation>]
  }

  subgraph left {
    node[style=filled, fillcolor="#cfe2f3"]
    swiftCompileVariant -> nativeLinkVariant -> nativeRuntimeVariant [style=invis, weight=1000]

    swiftCompileVariant[label=<swiftCompile<i>Variant</i> (R)>]
    nativeLinkVariant[label=<nativeLink<i>Variant</i> (R)>]
    nativeRuntimeVariant[label=<nativeRuntime<i>Variant</i> (R)>]

        println "variants: " + artifacts.collect { it.variant.attributes }
    }
}
"""
        when:
        run 'show'

        then:
        outputContains("files: [a2.jar]")
        outputContains("variants: [{artifactType=jar, buildType=profile, flavor=tasty, usage=api}]")
    }

    def "applies producer's disambiguation rules when selecting variant"() {
        buildFile << """

- `dependencies`: optional. When missing the variant is assumed to have no dependencies. Must not be present when `available-at` is present.
- `files`: optional. When missing the variant is assumed to have no files. Must not be present when `available-at` is present.
- `capabilities`: optional. When missing, the variant is assumed to declare no specific capability.

### `attributes` value