public static void configureSchema(AttributesSchema attributesSchema, final ObjectFactory objectFactory) {
        configureUsage(attributesSchema, objectFactory);
        configureLibraryElements(attributesSchema, objectFactory);
        configureBundling(attributesSchema);
        configureTargetPlatform(attributesSchema);
        configureTargetEnvironment(attributesSchema);

    private final String status;
    private final AttributesSchemaInternal attributesSchema;

    public LocalComponentGraphResolveMetadata(
        ModuleVersionIdentifier moduleVersionId,
        ComponentIdentifier componentId,
        String status,
        AttributesSchemaInternal attributesSchema
    ) {
        this.moduleVersionId = moduleVersionId;
        this.componentId = componentId;

        @SuppressWarnings("unchecked") Attribute<Object> key = (Attribute<Object>) attribute;
        return new ReportAttribute(key, null, getDisambiguationPrecedence(attribute, attributesSchema).orElse(null));
    }

    private Optional<Integer> getDisambiguationPrecedence(Attribute<?> attribute, AttributesSchema attributesSchema) {

    def transformedVariantFactory = Mock(TransformedVariantFactory)
    def dependenciesResolverFactory = Mock(TransformUpstreamDependenciesResolverFactory)
    def attributeMatcher = Mock(AttributeMatcher)
    def attributesSchema = Mock(AttributesSchemaInternal) {
        withProducer(_) >> attributeMatcher
        getConsumerDescribers() >> []
        getFailureDescribers(_) >> []
    }

        delegate.createArtifactResolutionQuery()

    override fun attributesSchema(configureAction: Action<in AttributesSchema>): AttributesSchema =
        delegate.attributesSchema(configureAction)

    override fun getAttributesSchema(): AttributesSchema =
        delegate.attributesSchema

    override fun getArtifactTypes(): ArtifactTypeContainer =
        delegate.artifactTypes

    }

    public void configureSchema(AttributesSchemaInternal attributesSchema) {
        configureCategoryDisambiguationRule(attributesSchema);
        attributesSchema.addFailureDescriber(IncompatibleGraphVariantFailure.class, TargetJVMVersionOnLibraryTooNewFailureDescriber.class);
    }

    private void configureCategoryDisambiguationRule(AttributesSchema attributesSchema) {

        toComponent.getCandidatesForGraphVariantSelection().variants.addAll([toFooVariant, toBarVariant])
        attributesSchema.attribute(Attribute.of('key', String))
        attributesSchema.attribute(Attribute.of('extra', String))

        expect:
        dep.selectVariants(variantSelector, attributes(queryAttributes), toComponent, attributesSchema, [] as Set).variants.name as Set == [expected] as Set

        where:

    }

    @Override
    public AttributesSchema attributesSchema(Action<? super AttributesSchema> configureAction) {
        configureAction.execute(attributesSchema);
        return attributesSchema;
    }

    @Override
    public AttributesSchema getAttributesSchema() {
        return attributesSchema;
    }

    private void configureSchema() {
        attributesSchema.attribute(ARTIFACT_TYPE_ATTRIBUTE);
    }

    private final VersionParser versionParser;
    private final AttributesSchemaInternal attributesSchema;

    DefaultVersionedComponentChooser(VersionComparator versionComparator, VersionParser versionParser, ComponentSelectionRulesInternal componentSelectionRules, AttributesSchema attributesSchema) {
        this.versionComparator = versionComparator;
        this.versionParser = versionParser;

import org.gradle.util.GradleVersion;

public class GradlePluginVariantsSupport {

    public static void configureSchema(AttributesSchemaInternal attributesSchema) {
        AttributeMatchingStrategy<GradlePluginApiVersion> strategy = attributesSchema.attribute(GradlePluginApiVersion.GRADLE_PLUGIN_API_VERSION_ATTRIBUTE);
        strategy.getCompatibilityRules().add(TargetGradleVersionCompatibilityRule.class);