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

        when:
        rule.execute(candidates)

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

        where:
        consumerValue      | candidateValues                                 | choosesRuntime

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

            dependencies.attributesSchema {
                attribute(flavor) {

                    bestMatchVersion = producer;
                    bestMatchAttribute = candidate;
                }
            }
            if (bestMatchAttribute != null) {
                details.closestMatch(bestMatchAttribute);
            }
        }
    }

        MultipleCandidatesResult details = Mock()

        when:
        disambiguationRules.execute(details)

        then:
        1 * details.getCandidateValues() >> candidates
        1 * details.closestMatch(expected)
        1 * details.hasResult()
        0 * details._

        where:
        consumer | candidates | expected
        6        | [6]        | 6
        7        | [6, 7]     | 7

        then:
        1 * details.getConsumerValue() >> bundling(consumer)
        1 * details.getCandidateValues() >> candidates.collect { bundling(it) }
        1 * details.closestMatch({ assert it.name == expected })

        where:
        consumer | candidates                     | expected
        null     | [EXTERNAL, EMBEDDED, SHADOWED] | EXTERNAL

            void execute(MultipleCandidatesDetails details) {
                if (details.consumerValue == null) {
                    details.closestMatch("compatible")
                } else if (details.consumerValue == "requested") {
                    details.closestMatch("best")
                }
            }
        }
        schema.attribute(usage)
        schema.accept(usage, "requested", "compatible")

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

dependencies.attributesSchema {
    attribute(buildType) {
        compatibilityRules.add(BuildTypeCompatibilityRule)
    }
    attribute(flavor) {

class OneRule implements AttributeDisambiguationRule<String> {
    void execute(MultipleCandidatesDetails<String> details) {
        details.closestMatch('one')
    }
}
class TwoRule implements AttributeDisambiguationRule<String> {
    void execute(MultipleCandidatesDetails<String> details) {
        details.closestMatch('two')
    }
}

allprojects {
    configurations.compile.attributes.attribute(usage, 'compile')
}

    void execute(MultipleCandidatesDetails<String> details) {
        details.closestMatch('free')
    }
}
class SelectPaidRule implements AttributeDisambiguationRule<String> {
    void execute(MultipleCandidatesDetails<String> details) {
        details.closestMatch('paid')
    }
}

def flavor = Attribute.of('flavor', String)

dependencies {
    compile project(':a')

        public void execute(MultipleCandidatesDetails<Usage> details) {
            if (details.getConsumerValue() == null) {
                if (details.getCandidateValues().equals(expectedUsages)) {
                    details.closestMatch(javaRuntime);
                }
            }
        }
    }