assert result.variant instanceof org.gradle.api.internal.artifacts.result.DefaultResolvedVariantResult
                    assert result.variant.owner == result.id.componentIdentifier
                    assert result.variant.attributes.getAttribute(org.gradle.api.artifacts.type.ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE) == 'jar'

        // TODO Artifact names should be determined by the source variant. We shouldn't
        //      blindly "pass-through" the artifact file name.
        Set<ArtifactKey> seenArtifacts = new HashSet<>();
        return createSortedVariantsStream(component)
            .flatMap(variant -> variant.getArtifacts().stream())
            .filter(artifact -> {

    @Override
    MavenModule variant(String variant, Map<String, String> attributes) {
        createVariant(variant, attributes)
        return this
    }

    @Override
    MavenModule variant(String variant, Map<String, String> attributes, @DelegatesTo(value = VariantMetadataSpec, strategy = Closure.DELEGATE_FIRST) Closure<?> variantConfiguration) {
        def v = createVariant(variant, attributes)

// 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.

            def platform = mavenRepo.module("com.acme.foo", "platform", v)
            platform.assertPublished()
            platform.hasGradleMetadataRedirectionMarker()
            platform.parsedModuleMetadata.variant("apiElements") {
                constraint("com.acme.foo:core:$v") {
                    exists()
                }
                constraint("com.acme.foo:lib:$v") {
                    exists()
                }

	if changed {
		tt.RemakeString()
	}
	return makeTag(tt), err
}

// Compose creates a Tag from individual parts, which may be of type Tag, Base,
// Script, Region, Variant, []Variant, Extension, []Extension or error. If a
// Base, Script or Region or slice of type Variant or Extension is passed more
// than once, the latter will overwrite the former. Variants and Extensions are

        }
        if (variants != null) {
            for (ConfigurationVariantInternal variant : variants.withType(ConfigurationVariantInternal.class)) {
                visitor.visitChildVariant(variant.getName(), variant.getDisplayName(), variant.getAttributes().asImmutable(), variant.getArtifacts());
            }
        }
    }

    @Override
    public AttributeContainer getAttributes() {

            this.objectFactory = objectFactory;
        }

        @Override
        public ConfigurationVariant getConfigurationVariant() {
            return variant;
        }

        @Override
        public void skip() {
            skip = true;
        }

        @Override
        public void mapToOptional() {
            this.optional = true;
        }

        @Override

    }

    @Override
    public T variant(String variant, Map<String, String> attributes) {
        backingModule.variant(variant, attributes);
        return t();
    }

    @Override
    public T variant(String variant, Map<String, String> attributes, @DelegatesTo(value=VariantMetadataSpec.class, strategy=Closure.DELEGATE_FIRST) Closure<?> variantConfiguration) {
        backingModule.variant(variant, attributes, variantConfiguration);

    /**
     * Define a variant with attributes. Variants are only published when using {@link #withModuleMetadata()}.
     */
    MavenModule variant(String variant, Map<String, String> attributes)

    /**
     * Define a variant with attributes. Variants are only published when using {@link #withModuleMetadata()}.
     */