* limitations under the License.
 */

package org.gradle.api.internal.attributes;

import org.gradle.api.attributes.CompatibilityCheckDetails;

public interface CompatibilityCheckResult<T> extends CompatibilityCheckDetails<T> {
    boolean hasResult();
    boolean isCompatible();

            assert details.producerValue == "value2"
            details.compatible()
        }
    }

    def "creates instance of rule implementation and delegates to it"() {
        def details = Mock(CompatibilityCheckResult)

        given:
        ruleChain.add(CompatibilityRule)

        when:
        ruleChain.execute(details)

        then:
        1 * details.consumerValue >> "value1"

 * limitations under the License.
 */

package org.gradle.internal.component.model;

import org.gradle.api.internal.attributes.CompatibilityCheckResult;

import javax.annotation.Nullable;
import java.util.Objects;

public class DefaultCompatibilityCheckResult<T> implements CompatibilityCheckResult<T> {
    private final T consumerValue;
    private final T producerValue;
    private boolean compatible;
    private boolean done;

    }

    @Unroll("compatibility consumer=#consumer producer=#producer compatible=#compatible")
    def "check compatibility rules"() {
        CompatibilityCheckResult details = Mock(CompatibilityCheckResult)

        when:
        compatibilityRules.execute(details)

        then:
        1 * details.getConsumerValue() >> consumer
        1 * details.getProducerValue() >> producer

 * limitations under the License.
 */
package org.gradle.api.internal.attributes;

import org.gradle.api.Action;

public interface CompatibilityRule<T> extends Action<CompatibilityCheckResult<T>> {
    boolean doesSomething();

        rules.add(new InstantiatingAction<>(DefaultConfigurableRules.of(DefaultConfigurableRule.of(rule)),
            instantiator, new ExceptionHandler<>(rule)));
    }

    @Override
    public void execute(CompatibilityCheckResult<T> result) {
        for (Action<? super CompatibilityCheckDetails<T>> rule : rules) {
            rule.execute(result);
            if (result.hasResult()) {
                return;
            }
        }

        return Collections.emptyList();
    }

    private static class DoNothingCompatibilityRule implements CompatibilityRule<Object> {
        @Override
        public void execute(CompatibilityCheckResult<Object> result) {
        }

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

        public boolean matchValue(Attribute<?> attribute, Object requested, Object candidate) {
            if (requested.equals(candidate)) {
                return true;
            }

            CompatibilityCheckResult<Object> result = null;

            CompatibilityRule<Object> rules = consumerSchema.compatibilityRules(attribute);
            if (rules.doesSomething()) {