publishedModule.parsedPom.scopes.isEmpty()
        publishedModule.parsedModuleMetadata.variants*.name == ["usage"]
        with(publishedModule.parsedModuleMetadata.variant("usage")) { variant ->
            variant.files.empty
            variant.dependencies.empty
            variant.availableAt.coords == 'org.gradle.test:nested:1.9-SNAPSHOT'
            variant.availableAt.url == "../../nested/1.9-SNAPSHOT/nested-1.9-SNAPSHOT.module"
        }

        println "variants: " + artifacts.collect { it.variant.attributes }
    }
}
"""
        when:
        run 'show'

        then:
        outputContains("files: [a2.jar]")
        outputContains("variants: [{artifactType=jar, buildType=profile, flavor=tasty, usage=api}]")
    }

    def "applies producer's disambiguation rules when selecting variant"() {
        buildFile << """

It may also fail if the variant selection result is ambiguous, meaning that Gradle does not have enough information to select one of multiple mutual exclusive variants.
In that case, more information can be provided through <<#sub:terminology_attribute,variant attributes>>.
Examples of variants each Java components typically offers are _api_ and _runtime_ variants.
Others examples are JDK8 and JDK11 variants.

        for (SoftwareComponentVariant variant : softwareComponent.getUsages()) {
            checkVariant(variant);
            variants.add(dependencyCoordinateResolverFactory.createCoordinateResolvers(variant, versionMappingStrategy).map(resolvers ->
                new ModuleMetadataSpec.LocalVariant(
                    variant.getName(),
                    attributesFor(variant.getAttributes()),

 * <p>You can use this interface to associate artifacts with a configuration using the {@link #artifact(Object)} methods. You can also define several variants of the configuration's artifacts. Each variant represents a set of artifacts that form some mutually exclusive usage of the component.</p>
 *
 * <p>An implicit variant is defined for a configuration whenever any artifacts are attached directly to this object or inherited from another configuration.</p>
 *

    /**
     * Constructs a complete cacheable variant chain given a root transformed variant and the chain of variants
     * to apply to that root variant.
     *
     * @param stateChain The transform chain from the search state to apply to the root transformed variant.
     * @param root The root variant to apply the chain to.
     *
     * @return A variant chain representing the final transformed variant.
     */

        mainMetadata.variants.size() == 9
        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("debugSharedLink").availableAt.coords == "some.group:test_debug_shared:1.2"

        return conf;
    }

    /**
     * Ensures the target variant matches the request attributes and is consumable. This needs to be called
     * for variants that are selected by means other than attribute matching.
     *
     * Note: This does not need to be called for variants selected via attribute matching, since
     * attribute matching ensures selected variants are compatible with the requested attributes.
     */

    }

    @Override
    MavenModule adhocVariants() {
        variants.clear()
        this
    }

    private VariantMetadataSpec createVariant(String variant, Map<String, String> attributes) {
        def variantMetadata = new VariantMetadataSpec(variant, attributes)
        variants.removeAll { it.name == variant }
        variants.add(variantMetadata)
        return variantMetadata
    }

            .stream()
            .flatMap(variant -> variant.prepareForArtifactResolution().getArtifactVariants().stream())
            .map(variant -> new DefaultResolvedVariantResult(
                component.getId(),
                Describables.of(variant.getName()),
                component.getAttributeDesugaring().desugar(variant.getAttributes().asImmutable()),