}
        for (T candidateValue : candidateValues) {
            if (candidateValue == null)  {
                throw new IllegalArgumentException("candidateValues cannot contain null elements");
            }
        }

        this.candidateValues = candidateValues;
        this.consumerValue = consumerValue;
    }

    @Override

    static class SelectionRule implements AttributeDisambiguationRule<String> {
        @Override
        void execute(MultipleCandidatesDetails<String> details) {
            assert details.candidateValues == ["value1", "value2"] as Set
            details.closestMatch("value1")
        }
    }
    static class SelectionRuleWithParams implements AttributeDisambiguationRule<String> {
        String p1

        this.pickFirst = pickFirst;
    }

    @Override
    public void execute(MultipleCandidatesDetails<T> details) {
        Set<T> candidateValues = details.getCandidateValues();
        T min = null;
        T max = null;
        for (T value : candidateValues) {
            if (min == null || comparator.compare(value, min) < 0) {
                min = value;
            }

        candidates.getConsumerValue() >> consumerValue
        candidates.getCandidateValues() >> candidateValues.collect { usage(it) }

        when:
        rule.execute(candidates)

        then:
        count * candidates.closestMatch({ it.name == Usage.JAVA_RUNTIME })

        where:
        consumerValue      | candidateValues                                 | choosesRuntime

            if (consumerValue == null) {
                Set<Category> candidateValues = details.getCandidateValues();
                if (candidateValues.contains(library)) {
                    // default to library
                    details.closestMatch(library);
                } else if (candidateValues.contains(platform)) {

        void execute(MultipleCandidatesDetails<String> details) {
            if (details.consumerValue == null) {
                if (details.candidateValues.contains("best")) {
                    details.closestMatch("best")
                }
            } else {
                if (details.candidateValues.contains("best")) {
                    details.closestMatch("best")
                } else {

            AttributeValue<?> requestedValue = requestedAttributes.findEntry(attribute);
            AttributeValue<?> candidateValue = candidateAttributes.findEntry(attribute.getName());
            if (candidateValue.isPresent()) {
                Object coercedValue = candidateValue.coerce(attribute);
                boolean match = schema.matchValue(attribute, requestedValue.get(), coercedValue);
                if (!match) {

    @Override
    public <T extends HasAttributes> void candidateAttributeDoesNotMatch(T candidate, Attribute<?> attribute, Object requestedValue, AttributeValue<?> candidateValue) {
        LOGGER.debug("Candidate {} attribute {} value {} doesn't requested value {}", candidate, attribute, candidateValue, requestedValue);
    }

    @Override

    }

    default <T extends HasAttributes> void candidateAttributeDoesNotMatch(T candidate, Attribute<?> attribute, Object requestedValue, AttributeValue<?> candidateValue) {

    }

    default <T extends HasAttributes> void candidateAttributeMissing(T candidate, Attribute<?> attribute, Object requestedValue) {

    }