This is even more true for Android projects that include Kotlin source code (and therefore use the `kotlin-android` plugin).

== Disambiguation

This guide is about Gradle’s build cache, but you may have also heard about the https://developer.android.com/studio/build/build-cache[Android build cache].
These are different things.

When dependencies are resolved, a set of attributes are requested and Gradle finds the best fitting variant(s) for each component in the dependency graph.
Compatibility and disambiguation rules can be implemented for an attribute to express compatibility between values (e.g. Java 8 is compatible with Java 11, but Java 11 should be preferred if the requested version is 11 or higher).

    - org.gradle.libraryelements
    - org.gradle.plugin.api-version
    - org.gradle.usage

--------------------------------------------------
Disambiguation Rules
--------------------------------------------------
Description = The following Attributes have disambiguation rules defined.

    - org.gradle.category
    - org.gradle.dependency.bundling
    - org.gradle.jvm.environment
    - org.gradle.jvm.version

    }
    name_parts.emplace_back(sanitized_name);
    name_parts.emplace_back(kFiletypeSuffix);

    // Build a filename such that it contains function names and pass names for
    // easy disambiguation.
    const std::string filename = tsl::io::JoinPath(
        dump_dir_, absl::StrJoin(name_parts.begin(), name_parts.end(), "."));

    // Open the file for dumping. Failures are logged instead of being

"""
        when:
        succeeds "resolve"

        then:
        output.count("Minifying") == 1
        output.count('minified=true')
        output.count('Sizing') == 0
    }

    def "disambiguation leverages schema rules before doing it size based"() {
        given:
        createDirs("child")
        settingsFile << """
include('child')
"""
        buildFile << """

import org.gradle.util.TestUtil
import spock.lang.Specification
/**
 * Tests attribute matching against configurations and their variants in the context of the JVM ecosystem.
 * Here, we apply the JVM ecosystem compatibility and disambiguation rules and verify that given a set of
 * requested attributes, the proper variant is selected.
 * <p>
 * This test aims to mirror the actual variant selection process within Gradle, specifically when one project

        def someJar = project.tasks.create('someJar', Jar)
        someJar.destinationDirectory.get().asFile == project.libsDirectory.get().asFile
    }

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

        when:
        def best = schema.matcher().selectionSchema.disambiguate(attr, "bar", candidates)

        then:
        best == ["bar"] as Set
    }

    def "returns null when no disambiguation rules and requested is not one of the candidate values"() {
        def attr = Attribute.of(String)

        given:
        schema.attribute(attr)
        def candidates = ["foo", "bar"] as Set

        'Thing'      | 'objects.named(Thing, "free")' | 'objects.named(Thing, "paid")'
        'OtherThing' | 'new OtherThing(name: "free")' | 'new OtherThing(name: "paid")'
    }

    def "compatibility and disambiguation rules can be defined by consuming build"() {
        given:
        createDirs("a", "b", "includedBuild")
        file('settings.gradle') << """
            include 'a', 'b'
            includeBuild 'includedBuild'

                }
            }
        """

        buildFile << """
            plugins {
                // This plugin is needed in order to get the proper AttributeSchema compatibility/disambiguation
                // rules. Once we understand this reproducer better, we can likely construct a graph that does not
                // need these resolution rules.
                id("org.jetbrains.kotlin.jvm") version "1.9.20"