}

        @Override
        public void execute(MultipleCandidatesDetails<Usage> details) {
            Set<Usage> candidateValues = details.getCandidateValues();
            Usage consumerValue = details.getConsumerValue();
            if (consumerValue == null) {
                if (candidateValues.contains(javaRuntimeJars)) {
                    // Use the Jars when nothing has been requested

     * Never equal to the {@link #getProducerValue()}.
     *
     * @return the value from the consumer
     */
    @Nullable
    T getConsumerValue();

    /**
     * The value of the attribute as found on the producer side.
     * <p>
     * Never equal to the {@link #getConsumerValue()}.
     *
     * @return the value from the producer
     */
    @Nullable
    T getProducerValue();

    /**

            // we compare to the base version of the consumer, because pre-release versions should already match variants targeting the final release
            GradlePluginApiVersion consumer = details.getConsumerValue();
            GradlePluginApiVersion producer = details.getProducerValue();
            if (consumer == null || producer == null) {
                details.compatible();

        def details = Mock(CompatibilityCheckDetails)
        when:
        rules.execute(details)

        then:
        1 * details.getConsumerValue() >> usage(consumer)
        1 * details.getProducerValue() >> usage(producer)
        if (producer == consumer) {
            // implementations are NOT required to say "compatible" because

    /**
     * Returns the value of the attribute specified by the consumer.
     *
     * @return The value or {@code null} if the consumer did not specify a value.
     * @since 4.1
     */
    @Nullable
    T getConsumerValue();

    /**
     * A set of candidate values.
     *
     * @return the set of candidates
     */
    Set<T> getCandidateValues();

    /**

        this.comparator = comparator;
        this.reverse = reverse;
    }

    @Override
    public void execute(CompatibilityCheckDetails<T> details) {
        T consumerValue = details.getConsumerValue();
        T producerValue = details.getProducerValue();
        int cmp = comparator.compare(consumerValue, producerValue);
        if (reverse) {
            cmp = -cmp;
        }
        if (cmp >= 0) {

        @Override
        public boolean doesSomething() {
            return true;
        }

        @Override
        public void execute(MultipleCandidatesResult<Usage> details) {
            if (details.getConsumerValue() == null) {
                Set<Usage> candidates = details.getCandidateValues();
                if (candidates.contains(runtimeUsage)) {
                    details.closestMatch(runtimeUsage);
                }

    public boolean isCompatible() {
        assert done;
        return compatible;
    }

    @Override
    public boolean hasResult() {
        return done;
    }

    @Override
    public T getConsumerValue() {
        return consumerValue;
    }

    @Override
    public T getProducerValue() {
        return producerValue;
    }

    @Override
    public void compatible() {
        done = true;

        given:
        def rule = schema.disambiguationRules(Usage.USAGE_ATTRIBUTE)
        MultipleCandidatesResult<Usage> candidates = Mock(MultipleCandidatesResult)
        candidates.getConsumerValue() >> consumerValue
        candidates.getCandidateValues() >> candidateValues.collect { usage(it) }

        when:
        rule.execute(candidates)

        then:

        if (singleMatch != null) {
            return Collections.singleton(singleMatch);
        }
        return multipleMatches;
    }

    @Nullable
    @Override
    public T getConsumerValue() {
        return consumerValue;
    }

    @Override
    public Set<T> getCandidateValues() {
        return candidateValues;
    }

    @Override
    public void closestMatch(T candidate) {