// artifact repository. We always check whether the schema has a more strongly typed
            // version of an attribute and use that one instead to apply its disambiguation rules.
            Attribute<?> schemaAttribute = schema.getAttribute(extraAttribute.getName());
            if (schemaAttribute != null) {
                extraAttributesArray[i] = schemaAttribute;
            }

        // Often times, collections of candidates will themselves differ even though their attributes are the same.
        // Disambiguating two different candidate lists which map to the same attribute lists in reality performs
        // the same work, so instead we cache disambiguation results based on the attributes being disambiguated.
        // The result of this is a list of indices into the original candidate list from which the

    boolean mustValidateLockState();

    /**
     * Returns the set of locking constraints found.
     * Note that an empty set can mean either that lock state was not defined or that lock state is an empty set.
     * Disambiguation can be done by calling {@link #mustValidateLockState()}.
     *
     * @return The set of module versions to lock.
     * @see #mustValidateLockState()
     */
    Set<ModuleComponentIdentifier> getLockedDependencies();

        if (!attributesWithDisambiguationRules.isEmpty()) {
            printHeader(() -> message("Disambiguation Rules"));
            writeDescription("The following Attributes have disambiguation rules defined.");
            newLine();
            try {
                depth++;

        8        | 10       | false
        8        | 11       | false
    }

    @Unroll("disamgiguates when consumer=#consumer and candidates=#candidates chooses=#expected")
    def "check disambiguation rules"() {
        MultipleCandidatesResult details = Mock()

        when:
        disambiguationRules.execute(details)

        then:
        1 * details.getCandidateValues() >> candidates

 *
 * Gradle has long assumed that, by default, consumers of a maven repository require the _runtime_ variant
 * of the published library.
 * The following disambiguation rule encodes this assumption for the case where a java library is published
 * with variants using Gradle module metadata. This will allow us to migrate to consuming the new module

        expect:
        matcher.matches([candidate1, candidate2, candidate3, candidate4, candidate5], requested, explanationBuilder) == [candidate1, candidate3, candidate4, candidate5]
    }

    def "applies disambiguation rules and selects intersection of best matches for each attribute"() {
        given:
        def matcher = new DefaultAttributeMatcher(schema)

        def usage = Attribute.of('usage', String)

    def 'module metadata fetched through a settings useModule properly uses Java ecosystem'() {
        given:

        // Create module that will match only if compatibility and disambiguation rules are in place
        mavenRepo.module('test', 'dep', '1.0')
            .variant("runtime", ["org.gradle.usage": "java-runtime", 'org.gradle.dependency.bundling': 'embedded'])

        // Currently builds all file dependencies
        executed ":lib:classes", ":lib:utilClasses", ":lib:utilDir", ":lib:utilJar", ":ui:classes", ":app:resolve"
    }

    def "applies consumers compatibility and disambiguation rules when selecting variant"() {
        buildFile << """
class BuildTypeCompatibilityRule implements AttributeCompatibilityRule<String> {
    void execute(CompatibilityCheckDetails<String> details) {

					tt := t
					for _, x := range list {
						// We visit all entries for which the script was not
						// defined, including the ones where the region was not
						// defined. This allows for proper disambiguation within
						// regions.
						if x.flags&scriptInFrom == 0 && t.RegionID.Contains(Region(x.region)) {
							tt.RegionID = Region(x.region)
							tt.setUndefinedScript(Script(x.script))