}

            configurations.compileClasspath.resolutionStrategy.componentSelection.all { ComponentSelection selection ->
               if (selection.candidate.module == 'bar' && selection.candidate.version in ['1.2', '1.1']) {
                   selection.reject("version \${selection.candidate.version} is bad")
               }
            }
        """

        when:

            this.target = target;
        }

        @Override
        public boolean isSatisfiedBy(ComponentSelection selection) {
            return selection.getCandidate().getGroup().equals(target.getGroup()) && selection.getCandidate().getModule().equals(target.getName());
        }
    }

        new DefaultDependencySubstitution(DependencyManagementTestUtil.componentSelectionDescriptorFactory(), componentSelector, artifacts)
    }

    def "can override target and selection reason for project"() {
        when:
        details.useTarget("org:foo:2.0", FORCED)
        details.useTarget("org:foo:3.0", SELECTED_BY_RULE)

        then:
        details.requested == componentSelector

        then:
        _ * componentSelectionRules.rules >> rules({ ComponentSelection selection ->
            if (selection.candidate.version != '1.3') {
                selection.reject("rejected")
            }
        })
        1 * selectedComponentResult.getContentFilter() >> null
        1 * selectedComponentResult.notMatched(c.id, _)

        when:
        details.useVersion('5.0')

        then:
        details.target.toString() == 'com:bar:5.0'
    }

    def "can provide a custom selection reason with useTarget"() {
        def details = newDependencyResolveDetails("org", "foo", "1.0")

        when:
        details.because("forcefully upgrade dependency")
        details.useTarget("org:bar:2.0")

	selector := labels.NewSelector()
	var op selection.Operator
	switch ssr.Operator {
	case v1.ScopeSelectorOpIn:
		op = selection.In
	case v1.ScopeSelectorOpNotIn:
		op = selection.NotIn
	case v1.ScopeSelectorOpExists:
		op = selection.Exists
	case v1.ScopeSelectorOpDoesNotExist:
		op = selection.DoesNotExist
	default:

//
// The order of the result is as for types.MethodSet(T).
func IntuitiveMethodSet(T types.Type, msets *MethodSetCache) []*types.Selection {
	isPointerToConcrete := func(T types.Type) bool {
		ptr, ok := aliases.Unalias(T).(*types.Pointer)
		return ok && !types.IsInterface(ptr.Elem())
	}

	var result []*types.Selection
	mset := msets.MethodSet(T)
	if types.IsInterface(T) || isPointerToConcrete(T) {
		for i, n := 0, mset.Len(); i < n; i++ {

    /**
     * Returns the set of variants of this component to use for variant aware resolution of the dependency graph nodes.
     * May be empty, in which case selection falls back to an ecosystem-specific selection strategy.
     */
    List<? extends VariantGraphResolveMetadata> getVariantsForGraphTraversal();

    /**
     * Returns the names of all legacy configurations for this component.

import org.gradle.execution.TaskSelectionException;
import org.gradle.execution.selection.BuildTaskSelector;

import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * A configuration-friendly view of a task selection.
 */
class TaskDetailsModel {
    private final String taskPath;
    private final List<TaskDetails> tasks;

rootProject.name = "component-selection-rules"...