// NominalConcurrencyLimit (NominalCL) of this level.
	// This is the number of execution seats nominally reserved for this priority level.
	// This DOES NOT limit the dispatching from this priority level
	// but affects the other priority levels through the borrowing mechanism.
	// The server's concurrency limit (ServerCL) is divided among all the
	// priority levels in proportion to their NCS values:

        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

		return nil
	}

	// Report differences in environment variables.
	var missing []string
	var mismatching []string
	for k, v := range s1.MinioEnv {
		ev, ok := s2.MinioEnv[k]
		if !ok {
			missing = append(missing, k)
		} else if v != ev {
			mismatching = append(mismatching, k)
		}
	}
	var extra []string
	for k := range s2.MinioEnv {
		_, ok := s1.MinioEnv[k]
		if !ok {

-...

        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:

        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

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

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

    /**

        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;
        }