* a disambiguation rule based on an order defined by the provided
     * {@link Comparator}.</p>
     *
     * <p>All provider values which are lower than or equal the consumer value are
     * compatible. When disambiguating, it will pick the highest compatible value.</p>
     *
     * @param comparator the comparator to use for compatibility and disambiguation
     */

import org.gradle.api.Action;
import org.gradle.api.ActionConfiguration;
import org.gradle.internal.HasInternalProtocol;

import java.util.Comparator;

/**
 * <p>A chain of disambiguation rules. By default the chain is empty and will not do any disambiguation.</p>
 *
 * <p>For a given set of rules, the execution is done <i>in order</i>, and interrupts as soon as a rule

        Usage.JAVA_RUNTIME           | JavaEcosystemSupport.DEPRECATED_JAVA_RUNTIME_JARS      | true
    }

    @Issue("gradle/gradle#8700")
    def "check usage disambiguation rules (consumer=#consumer, candidates=#candidates, selected=#preferred)"() {
        given:
        JavaEcosystemSupport.UsageDisambiguationRules rules = new JavaEcosystemSupport.UsageDisambiguationRules(

// The Go 1.18 frontend failed to disambiguate instantiations of
// different, locally defined generic types with the same name.
//
// The unified frontend also exposed the scope-disambiguation mangling
// to end users in reflect data.

package main

import (
	"reflect"
)

func one() any { type T[_ any] int; return T[int](0) }
func two() any { type T[_ any] int; return T[int](0) }

}

type NegMult struct{}

func (NegMult) Multiply(a, b int) int {
	for i := 0; i < 1000; i++ {
		sink++
	}
	return -1 * a * b
}

// N.B. Different types than AddFunc to test intra-line disambiguation.
type MultFunc func(int64, int64) int64

func MultFn(a, b int64) int64 {
	for i := 0; i < 1000; i++ {
		sink++
	}
	return a * b
}

func NegMultFn(a, b int64) int64 {
	for i := 0; i < 1000; i++ {

        2 * attributeMatcher.matches(_, _, _) >> [variant, otherVariant]
        2 * attributeMatcher.isMatching(_, _, _) >> true
        0 * consumerProvidedVariantFinder._
    }

    def 'does not perform schema disambiguation against a single transform result'() {
        given:
        def transformed = Mock(ResolvedArtifactSet)
        def variants = [variant]
        def transformedVariants = transformedVariants(variants)

            // 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();

        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