variant.dependencies[1].module == 'bar'
        variant.dependencies[1].version == null
        variant.dependencies[1].prefers == '2.0'
        variant.dependencies[1].strictly == null
        variant.dependencies[1].rejectsVersion == []

        variant.dependencies[2].group == 'org'
        variant.dependencies[2].module == 'baz'
        variant.dependencies[2].version == '3.0'

		} else {
			return false
		}
	case objabi.R_PCREL, objabi.R_PCRELDBL, objabi.R_CALL:
		elfrel := elf.R_390_NONE
		rVariant := ldr.RelocVariant(s, ri)
		isdbl := rVariant&sym.RV_TYPE_MASK == sym.RV_390_DBL
		// TODO(mundaym): all DBL style relocations should be
		// signalled using the variant - see issue 14218.
		switch r.Type {
		case objabi.R_PCRELDBL, objabi.R_CALL:
			isdbl = true
		}

    }

    @Override
    public ResolvedVariant resolveVariant(ComponentArtifactResolveMetadata component, VariantResolveMetadata variant, ExcludeSpec exclusions) {
        ImmutableList<? extends ComponentArtifactMetadata> sourceArtifacts = variant.getArtifacts();
        ImmutableList<ComponentArtifactMetadata> overrideArtifacts = maybeExcludeArtifacts(component, sourceArtifacts, exclusions);

     *
     * @param action the action to be executed on each variant.
     *
     * @since 4.5
     */
    void allVariants(Action<? super VariantMetadata> action);

    /**
     * Add a rule for adding a new empty variant to the component.
     *
     * @param name a name for the variant
     * @param action the action to populate the variant
     *
     * @since 6.0
     */

    }

    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() {

func.func @main(%arg0 : tensor<!tf_type.variant<tensor<2xi32>>>, %arg1: tensor<!tf_type.variant<tensor<*xi32>>>) -> tensor<!tf_type.variant<tensor<2xi32>>> {
  func.return %arg0 : tensor<!tf_type.variant<tensor<2xi32>>>
}

// CHECK:          func.func @main(%[[ARG0:.*]]: tensor<!tf_type.variant<tensor<2xi32>>>, %[[ARG1:.*]]: tensor<!tf_type.variant<tensor<*xi32>>>) -> tensor<!tf_type.variant<tensor<2xi32>>>

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

    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;

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

/**
 * 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();