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

        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

        // 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 {

        if (componentMetadata != null) {
            AttributeContainerInternal attributes = (AttributeContainerInternal) componentMetadata.getAttributes();
            boolean matching = attributesSchema.matcher().isMatching(attributes, consumerAttributes);
            if (!matching) {
                return new RejectedByAttributesVersion(id, attributesSchema.matcher().describeMatching(attributes, consumerAttributes));
            }
        }

        attributeMatcher.matches(_ as Collection, typeAttributes("classes"), _ as AttributeMatchingExplanationBuilder) >> [variant1, variant2]
        attributeMatcher.isMatching(_, _, _) >> true

        when:
        def result = variantSelectorFactory.create(dependenciesResolverFactory).select(set, typeAttributes("classes"), false, factory)
        visit(result)

        then:

            AttributeValue<?> producerValue = candidateAttributes.findEntry(attributeName);

            if (consumerValue.isPresent() && producerValue.isPresent()) {
                if (attributeMatcher.isMatching(untyped, producerValue.coerce(attribute), consumerValue.coerce(attribute))) {
                    compatible.add(new AssessedAttribute<>(attribute, Cast.uncheckedCast(consumerValue.get()), Cast.uncheckedCast(producerValue.get())));

        if (!consumerAttributes.isEmpty() && !conf.getAttributes().isEmpty()) {
            // Need to validate that the selected configuration still matches the consumer attributes
            if (!attributeMatcher.isMatching(conf.getAttributes(), consumerAttributes)) {
                throw failureHandler.incompatibleRequestedConfigurationFailure(consumerSchema, attributeMatcher, consumerAttributes, targetComponent, conf);
            }
        }

			src:        mustReader(t, bytes.NewReader([]byte("abcd")), 4, "", "", 4),
			size:       4,
			actualSize: 4,
			success:    true,
		},
		{
			desc:       "Mismatching sha256",
			src:        mustReader(t, bytes.NewReader([]byte("abcd")), 4, "", "88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589", 4),
			size:       4,
			actualSize: 4,