// limitations under the License.

[[variant_attributes]]
= Working with Variant Attributes

As explained in the section on <<variant_model.adoc#sec:variant-aware-matching,variant aware matching>>, attributes give semantics to variants and are used by Gradle's dependency management engine to select the best matching variant.

As a user of Gradle, attributes are often hidden as implementation details.

    }

    public List<AssessedCandidate> assessResolvedVariants(List<? extends ResolvedVariant> resolvedVariants) {
        return resolvedVariants.stream()
            .map(variant -> assessCandidate(variant.asDescribable().getCapitalizedDisplayName(), variant.getCapabilities(), variant.getAttributes().asImmutable()))
            .sorted(Comparator.comparing(AssessedCandidate::getDisplayName))
            .collect(Collectors.toList());
    }

    %2 = "tf.Identity"(%1) : (tensor<!tf_type.variant<tensor<f32>>>) -> (tensor<!tf_type.variant<tensor<f32>>>)
    "tf.Identity"(%2) : (tensor<!tf_type.variant<tensor<f32>>>) -> (tensor<!tf_type.variant<tensor<f32>>>)
    tf_device.return
  }) {cluster_attr = "cluster_attr"} : () -> ()
  func.return
}

        defaultBuildComponentIdentifier.libraryName == 'myLib'
        defaultBuildComponentIdentifier.variant == 'api'
        defaultBuildComponentIdentifier.displayName == /project ':myPath' library 'myLib' variant 'api'/
        defaultBuildComponentIdentifier.toString() == /project ':myPath' library 'myLib' variant 'api'/
    }

    def "is instantiated with null project constructor parameter value"() {
        when:

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

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

           metadata = ""} : (tensor<*x!tf_type.variant>) -> tensor<!tf_type.variant>
  %5 = "tf.BatchDatasetV2"(%4, %0, %1) {device = "",
           output_shapes = [#tf_type.shape<>],
           output_types = [i32],
           parallel_copy = false,
           metadata = ""} : (tensor<!tf_type.variant>, tensor<i64>, tensor<i1>) -> tensor<!tf_type.variant>
  func.return %5 : tensor<!tf_type.variant>
}

        // We request sources for a variant that does not have sources.
        // We should not fail, since variant reselection allows no matching variants.
        "without-sources" | "[]"
        // We request sources for a variant that has sources and expect those sources to be reselected.
        "with-sources"    | "[\"producer-1.0-with-sources-sources.jar\"]"
    }

Variant jarElements
--------------------------------------------------

Capabilities
    - org.test:producer:1.0 (default capability)
Attributes
    - shared = shared-value
    - unique = jar-value
Artifacts
    - producer-jar.txt

--------------------------------------------------
Variant javadocElements
--------------------------------------------------

  } : (tensor<!tf_type.variant>) -> tensor<!tf_type.variant>

  func.return %0 : tensor<!tf_type.variant>
// CHECK: "tf.MapDataset"(

        then:
        outputContains '''
Maven publication 'maven' pom metadata warnings (silence with 'suppressPomMetadataWarningsFor(variant)'):
  - Variant apiElements:
      - Declares capability org:foo:1.0 which cannot be mapped to Maven'''
        outputContains '''
  - Variant runtimeElements:
      - Declares capability org:bar:1.0 which cannot be mapped to Maven