1 * attributeMatcher.isMatching(sourceVariant.getAttributes(), fromSource) >> true
        1 * attributeMatcher.isMatching(sourceVariant.getAttributes(), fromOther) >> false
        // other variant matches fromOther, but not fromSource
        1 * attributeMatcher.isMatching(otherVariant.getAttributes(), fromSource) >> false
        1 * attributeMatcher.isMatching(otherVariant.getAttributes(), fromOther) >> true

    /**
     * Determines whether the given candidate is compatible with the requested criteria.
     */
    boolean isMatching(AttributeContainerInternal candidate, AttributeContainerInternal requested);

    <T> boolean isMatching(Attribute<T> attribute, T candidate, T requested);

    /**

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

        matcher.isMatching(candidate1, requested)
        !matcher.isMatching(candidate2, requested)
        !matcher.isMatching(candidate3, requested)
        matcher.isMatching(candidate4, requested)
    }

    def "selects candidate with additional attributes and whose values match"() {
        given:

                        ImmutableAttributes sourceAttrs = sources.get(i);
                        if (matcher.isMatching(sourceAttrs, candidate.getFrom())) {
                            ImmutableAttributes rootAttrs = attributesFactory.concat(sourceAttrs, candidate.getTo());
                            if (matcher.isMatching(rootAttrs, state.requested)) {

        expect:
        !schema.matcher().selectionSchema.matchValue(attribute, "a", "b")
        schema.matcher().selectionSchema.matchValue(attribute, "a", "a")

        !schema.matcher().isMatching(attribute, "a", "b")
        schema.matcher().isMatching(attribute, "a", "a")
    }

    static class DoNothingRule implements AttributeCompatibilityRule<String> {
        static int count

        @Override

        for (String targetGradleVersion : targetGradleVersions) {
            if (isMatching(targetGradleVersion, previousVersion.version.version)) {
                return true
            }
        }
        return false
    }

    private static boolean isMatching(String targetGradleVersion, String candidate) {
        if (targetGradleVersion.endsWith('+')) {

        this.schema = schema;
    }

    @Override
    public AttributeSelectionSchema getSelectionSchema() {
        return schema;
    }

    @Override
    public boolean isMatching(AttributeContainerInternal candidate, AttributeContainerInternal requested) {
        if (requested.isEmpty() || candidate.isEmpty()) {
            return true;
        }

        // while y may not be compatible with x. We accept compatibility in either direction as sufficient for this method.
        return !matcher.isMatching(firstCandidate.getAttributes(), secondCandidate.getAttributes()) &&
            !matcher.isMatching(secondCandidate.getAttributes(), firstCandidate.getAttributes());
    }

    private static class TraceDiscardedVariants implements AttributeMatchingExplanationBuilder {

        def producer = versionAttribute('7.0')

        then:
        accepts == (schema.matcher().matches([producer], consumer, ep) == [producer])
        accepts == schema.matcher().isMatching(producer, consumer)

        where:
        currentGradleVersion       | acceptsOrRejects
        '7.0'                      | 'accepts'
        '7.0-20210211230048+0000'  | 'accepts'

        1 * variantSet.getOverriddenAttributes() >> ImmutableAttributes.EMPTY
        2 * attributeMatcher.matches(_, _, _) >> [variant, otherVariant]
        2 * attributeMatcher.isMatching(_, _, _) >> true
        0 * consumerProvidedVariantFinder._
    }

    def 'does not perform schema disambiguation against a single transform result'() {
        given: