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

[[sub:terminology_attribute]]
== Variant Attribute

Attributes are used to identify and select <<#sub:terminology_variant,variants>>.
A variant has one or more attributes defined, for example `org.gradle.usage=java-api`, `org.gradle.jvm.version=11`.

        mainMetadata.variants.size() == 5
        def api = mainMetadata.variant("api")
        api.dependencies.empty
        api.files.size() == 1
        api.files[0].name == 'cpp-api-headers.zip'
        api.files[0].url == 'test-1.2-cpp-api-headers.zip'
        mainMetadata.variant("debugLink").availableAt.coords == "some.group:test_debug:1.2"

    )

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

               - Variant javadoc provides com.google.code.gson:gson:2.8.5
               - Variant platform-compile provides com.google.code.gson:gson-derived-platform:2.8.5
               - Variant platform-runtime provides com.google.code.gson:gson-derived-platform:2.8.5
               - Variant runtime provides com.google.code.gson:gson:2.8.5
               - Variant sources provides com.google.code.gson:gson:2.8.5

    }

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

    }

    List<Variant> getVariants() {
        return variants
    }

    Variant variant(String name) {
        def matches = variants.findAll { it.name == name }
        assert matches.size() == 1 : "Variant '$name' not found in ${variants.name}"
        return matches.first()
    }

    Variant variant(String name, @DelegatesTo(value=Variant, strategy=Closure.DELEGATE_FIRST) Closure<Variant> action) {

        this.libraryName = Strings.emptyToNull(libraryName);
        this.variant = variant;
    }

    @Override
    public String getDisplayName() {
        String txt;
        if (Strings.isNullOrEmpty(libraryName)) {
            txt = "project '" + projectPath + "'";
        } else if (Strings.isNullOrEmpty(variant)) {
            txt = "project '" + projectPath + "' library '" + libraryName + "'";
        } else {

import javax.annotation.Nullable;

/**
 * Metadata for a basic variant of a component, that defines only artifacts and no dependencies.
 */
public interface VariantResolveMetadata extends VariantGraphResolveMetadata.Subvariant {
    @Override
    String getName();

    /**

        // Verify Gradle metadata particulars
        assert backingModule.parsedModuleMetadata.variants*.name as Set == ['apiElements', 'runtimeElements'] as Set
        assert backingModule.parsedModuleMetadata.variant('apiElements').files*.name == [backingModule.jarFile.name]
        assert backingModule.parsedModuleMetadata.variant('runtimeElements').files*.name == [backingModule.jarFile.name]
    }

    void assertNotPublished() {