) {
            DocumentedFailure.Builder builder = DocumentedFailure.builder();
            String advice = "Consider adding an additional attribute to one of the configurations to disambiguate them.";
            if (withTaskAdvice) {
                advice += "  Run the 'outgoingVariants' task for more details.";
            }

        configureReportsConventionMapping(task, baseName);
        configureToolchains(task);
    }

    @Override
    protected void beforeApply() {
        // Necessary to disambiguate the published variants of newer codenarc versions (including the default version)
        project.getPluginManager().apply(JvmEcosystemPlugin.class);
    }

        matcher.matches([candidate2, candidate4], requested, explanationBuilder) == [candidate4]
    }

    def "rule can disambiguate based on requested value"() {
        given:
        def matcher = new DefaultAttributeMatcher(schema)

        def usage = Attribute.of('usage', String)
        def rule = new AttributeDisambiguationRule<String>() {

        // 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
        // attributes-to-disambiguate are derived. When retrieving a result from the cache, we use the resulting
        // indices to index back into the original candidates list.

# that match the pattern but *not* the version.
#
# That only leaves two options: we can set the module to an arbitrary version
# (perhaps 'latest' or 'none'), or we can report an error and the let the user
# disambiguate. We would rather not choose arbitrarily, so we do the latter.
#
# TODO(#27899): Should we instead upgrade or downgrade to an arbitrary version?

! go get example.net/split/nested/...@v0.1.0

        }

        throw failureProcessor.noMatchingArtifactVariantFailure(schema, matcher, producer.asDescribable().getDisplayName(), componentRequested, variants);
    }

    /**
     * Attempt to disambiguate between multiple potential transform candidates. This first performs attribute matching on the {@code candidates}.

4. If several candidates are compatible and are compatible with an equal number of attributes, Gradle needs to disambiguate the candidates.
    a. For each requested attribute, if a candidate does not have a value matching the disambiguation rule, it's eliminated from consideration.

            return consumerSchema.getAttributes().contains(attribute) || producerSchema.getAttributes().contains(attribute);
        }

        @Override
        public Set<Object> disambiguate(Attribute<?> attribute, @Nullable Object requested, Set<Object> candidates) {
            DefaultMultipleCandidateResult<Object> result = null;

                module("org.test:moduleA:1.0:$expectedVariant") {
                    module("org.test:moduleB:1.0")
                }
            }
        }
    }

    def "can disambiguate variants to select #selectedVariant"() {
        given:
        withDefaultVariantToTest()
        buildFile << """
            class AttributeRule implements ComponentMetadataRule {

	AttrRnglistsBase:   ClassRngListsPtr,
	AttrLoclistsBase:   ClassLocListPtr,
}

// formToClass returns the DWARF 4 Class for the given form. If the
// DWARF version is less then 4, it will disambiguate some forms
// depending on the attribute.
func formToClass(form format, attr Attr, vers int, b *buf) Class {
	switch form {
	default:
		b.error("cannot determine class of unknown attribute form")
		return 0