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

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

    @Override

            Set<Bundling> candidateValues = details.getCandidateValues();
            if (candidateValues.contains(consumerValue)) {
                details.closestMatch(consumerValue);
                return;
            }
            if (consumerValue == null) {
                Bundling embedded = null;
                for (Bundling candidateValue : candidateValues) {

        Set<Object> candidateValues = getCandidateValues(compatible, c -> getCandidateValue(c, a));
        if (candidateValues.size() <= 1) {
            return;
        }

        Set<Object> matches = schema.disambiguate(requestedAttributes.get(a), requestedAttributeValues[a], candidateValues);
        if (matches != null && matches.size() < candidateValues.size()) {

    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<Flavor> details) {
                    assert details.candidateValues*.name as Set == ['ONE', 'TWO'] as Set
                    details.candidateValues.each { producerValue ->
                        if (producerValue.name == 'TWO') {
                            details.closestMatch(producerValue)
                        }

        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 {

            }

            class CategorySelectionRule implements AttributeDisambiguationRule<String> {
                void execute(MultipleCandidatesDetails<String> details) {
                    if (details.candidateValues.contains('chocolate')) {
                        details.closestMatch('chocolate')
                    }
                }
            }

            dependencies.attributesSchema {