* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.internal.attributes;

import org.gradle.api.Action;

public interface DisambiguationRule<T> extends Action<MultipleCandidatesResult<T>> {
    boolean doesSomething();

            disambiguationRules.add(DisambiguationRule)
        }
        schema.attribute(middle).with {
            compatibilityRules.add(CompatibilityRule)
            disambiguationRules.add(DisambiguationRule)
        }
        schema.attribute(lowest).with {
            compatibilityRules.add(CompatibilityRule)
            disambiguationRules.add(DisambiguationRule)
        }
        schema.attribute(additional).with {

    private final DoNothingDisambiguationRule disambiguationRule = new DoNothingDisambiguationRule();

    protected EmptySchema() {
    }

    @Override
    public CompatibilityRule<Object> compatibilityRules(Attribute<?> attribute) {
        return compatibilityRule;
    }

    @Override
    public DisambiguationRule<Object> disambiguationRules(Attribute<?> attribute) {

import com.google.common.collect.Sets;
import org.gradle.api.attributes.Attribute;
import org.gradle.api.attributes.LibraryElements;
import org.gradle.api.attributes.Usage;
import org.gradle.api.internal.attributes.DisambiguationRule;
import org.gradle.api.internal.attributes.EmptySchema;
import org.gradle.api.internal.attributes.MultipleCandidatesResult;
import org.gradle.api.internal.model.NamedObjectInstantiator;
import org.gradle.internal.Cast;

import org.gradle.api.internal.attributes.DisambiguationRule
import org.gradle.api.internal.attributes.MultipleCandidatesResult
import org.gradle.util.SnapshotTestUtil
import org.gradle.util.TestUtil
import spock.lang.Specification
import spock.lang.Unroll

class TargetJvmVersionRulesTest extends Specification {
    private CompatibilityRule<Object> compatibilityRules
    private DisambiguationRule<Object> disambiguationRules

     */
    AttributeMatcher matcher();

    CompatibilityRule<Object> compatibilityRules(Attribute<?> attribute);

    DisambiguationRule<Object> disambiguationRules(Attribute<?> attribute);

    @Nullable
    Attribute<?> getAttributeByName(String name);

    /**

            return Cast.uncheckedCast(matchingStrategy.getCompatibilityRules());
        }
        return EmptySchema.INSTANCE.compatibilityRules(attribute);
    }

    @Override
    public DisambiguationRule<Object> disambiguationRules(Attribute<?> attribute) {
        AttributeMatchingStrategy<?> matchingStrategy = strategies.get(attribute);
        if (matchingStrategy != null) {

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Set;

public class DefaultDisambiguationRuleChain<T> implements DisambiguationRuleChain<T>, DisambiguationRule<T> {
    private final List<Action<? super MultipleCandidatesDetails<T>>> rules = new ArrayList<>();
    private final Instantiator instantiator;
    private final IsolatableFactory isolatableFactory;

     * {@link org.gradle.api.internal.attributes.DisambiguationRule DisambiguationRule}s defined.
     */
    private final class ConfigurationRuleScanner {
        private final AttributesSchema attributesSchema;

        public ConfigurationRuleScanner(Project project) {