}

    static String testedVariant() {
        def variant
        if (GradleMetadataResolveRunner.gradleMetadataPublished) {
            variant = 'api'
        } else {
            if (GradleMetadataResolveRunner.useIvy()) {
                variant = 'default'
            } else {
                variant = 'compile'
            }
        }
        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'

        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'

            return variants;
        }
        ImmutableList.Builder<ComponentVariant> builder = new ImmutableList.Builder<>();
        if (variants != null) {
            builder.addAll(variants);
        }
        for (MutableComponentVariant variant : newVariants) {

project :A FAILED
   Failures:
      - Could not resolve project :A.
        Creating consumable variants is explained in more detail at https://docs.gradle.org/${GradleVersion.current().version}/userguide/declaring_dependencies.html#sec:resolvable-consumable-configs.
          - Unable to find a matching variant of project :A:
              - No variants exist.

project :A FAILED
\\--- conf
"""

        when:

  func.return
}

// CHECK-LABEL: func @variant
func.func @variant(%arg: tensor<!tf_type.variant>) {
  // CHECK: tf.ZerosLike
  // CHECK-SAME: T = !corert.variant
  %0 = "tf.ZerosLike"(%arg) {device = "/device:CPU:0", T = !tf_type.variant} : (tensor<!tf_type.variant>) -> tensor<!tf_type.variant>
  func.return
}

// Checks that TF quantized attrs are lowered to the corert types

        if (failure.getRequestedAttributes().isEmpty()) {
            formatter.node("Unable to find a matching variant of " + targetVariantText);
        } else {
            formatter.node("No matching variant of " + targetVariantText + " was found. The consumer was configured to find " + describer.describeAttributeSet(failure.getRequestedAttributes().asMap()) + " but:");
        }

import org.gradle.api.artifacts.component.ComponentIdentifier;

/**
 * Identifies a variant of a component by component identifier and variant name.
 *
 * @since 6.0
 */
public interface ComponentVariantIdentifier {

    /**
     * Returns the component identifier.
     */
    ComponentIdentifier getId();

    /**
     * Returns the variant name.
     */
    String getVariantName();

        "changing project library variant metadata"            | "-DprojectLibAttrValue=new-value"
        "changing unselected project library variant metadata" | "-DprojectUnselectedLibAttrValue=new-value"
        "changing included library variant metadata"           | "-DcompositeLibAttrValue=new-value"
        "changing external library variant metadata"           | "-DexternalLibAttrValue=new-value"
    }

This allows a multi-variant plugin that depends on other plugins to access their APIs, which are exclusively provided in their version-specific variants.

This snippet makes the <<#plugin-with-variants,plugin variant `gradle7` defined above>> consume the matching variants of its dependencies on other multi-variant plugins:

====
include::sample[dir="snippets/developingPlugins/pluginWithVariants/kotlin",files="build.gradle.kts[tags=consume-plugin-variant]"]