}

    private static void assertAttributes(GradleModuleMetadata.Variant variant, Map<String, Object> expected) {
        assert variant.attributes.size() == expected.size()
        expected.each { attribute, value ->
            assert variant.attributes.containsKey(attribute)
            assert variant.attributes[attribute] == value
        }
    }

    void assertNoDependencies() {

    private final String libraryName;
    private final String variant;

    public DefaultLibraryBinaryDependencySpec(String projectPath, String libraryName, String variant) {
        if (libraryName == null || projectPath == null || variant == null) {
            throw new IllegalDependencyNotation("A direct library binary dependency must have all of project, library name and variant specified.");
        }
        this.libraryName = libraryName;

/**
 * The result of successfully resolving a component variant.
 *
 * @since 3.5
 */
public interface ResolvedVariantResult {
    /**
     * The component which owns this variant.
     *
     * @return the component identifier of this variant
     * @since 6.8
     */
    ComponentIdentifier getOwner();

    /**
     * The attributes associated with this variant.
     */
    AttributeContainer getAttributes();

        then:
        gmmMetadata.parsedModuleMetadata.variant("apiElements") {
            noMoreDependencies()
        }
        gmmMetadata.parsedModuleMetadata.variant("runtimeElements") {
            noMoreDependencies()
        }
        gmmMetadata.parsedModuleMetadata.variant("custom") {
            dependency('log4j:log4j:1.2.17').exists()
            noMoreDependencies()
        }

class VariantAspectExtractionIntegrationTest extends AbstractIntegrationSpec {
    def "variant annotation on property with illegal type raises error"() {
        buildFile << """
        @Managed
        interface SampleBinary extends BinarySpec {
            @Variant
            Integer getVariantProp()
            void setVariantProp(Integer variant)
        }
        class Rules extends RuleSource {
            @ComponentType

        /**
         * Executes the underlying action if the supplied variant matches.
         *
         * @param variant the variant metadata, used to check if the rule applies
         * @param subject the subject of the rule
         */
        public void maybeExecute(VariantResolveMetadata variant, T subject) {
            if (variantName == null || variantName.equals(variant.getName())) {
                delegate.execute(subject);

    func.return %4, %6 : tensor<!tf_type.variant>, tensor<!tf_type.variant>
  }
  // CHECK-LABEL: @funcB_renamed
  func.func private @funcB_renamed(%arg0: tensor<i64> {tf._user_specified_name = "args_0"}) -> tensor<!tf_type.variant> attributes {tf._original_func_name = "funcB", tf._tf_data_function = true, tf.signature.is_stateful} {

    )

    def "returns project-only resolver when version mapping is disabled and variant is not resolution-backed"() {
        given:
        def variant = nonResolutionBacked()
        def versionMappingStrategy = versionMappingStrategy(false)

        expect:
        with(factory.createCoordinateResolvers(variant, versionMappingStrategy).get()) {

    }

    def "defaults to the external dependencies variant (#bundling)"() {
        given:
        repository {
            'org:transitive:1.0'()
            'org:producer:1.0' {
                variant('api') {
                    dependsOn('org:transitive:1.0')
                    attribute Bundling.BUNDLING_ATTRIBUTE.name, 'external'
                }
                variant('runtime') {

    }

    /**
     * In general, default extends all configurations such that you get 'everything' when depending on default.
     * If a variant is optional, however it is not included.
     * If a variant represents the Java API variant, it is also not included, because the Java Runtime variant already includes everything
     * (including both also works but would lead to some duplication, that might break backwards compatibility in certain cases).