IsWaypoint: true,
		Service:    "sample-svc",
	}
	tests := []struct {
		name                   string
		selection              WorkloadPolicyMatcher
		policy                 TargetablePolicy
		enableSelectorPolicies bool

		expected bool
	}{
		{
			name:      "non-gateway API workload and a targetRef",
			selection: regularApp,
			policy: &mockPolicyTargetGetter{
				targetRef: sampleTargetRef,
			},

            } else {
                Path projectPrefix = selection.getOriginalPath().getParent();
                ProjectState project = defaultBuild.getProjects().getProject(projectPrefix);
                return getSelectorForBuild(defaultBuild).getSelection(selection, project, selection.getOriginalPath().getName(), false);
            }

[[sec:resolving-variant-aware-errors]]
=== Variant Selection Errors

Sometimes a selection error happens at the <<variant_model.adoc#understanding-variant-selection,variant selection level>>.
Have a look at the <<variant_model.adoc#sec:variant-select-errors,dedicated section>> to understand these errors and how to resolve them.

	for k, v := range ps.MatchLabels {
		r, err := labels.NewRequirement(k, selection.Equals, []string{v})
		if err != nil {
			return nil, err
		}
		requirements = append(requirements, *r)
	}
	for _, expr := range ps.MatchExpressions {
		var op selection.Operator
		switch metav1.LabelSelectorOperator(expr.Operator) {
		case metav1.LabelSelectorOpIn:
			op = selection.In
		case metav1.LabelSelectorOpNotIn:
			op = selection.NotIn

        // Remove any outgoing edges for the current selection
        selected.removeOutgoingEdges();

        this.selected = newSelection;
        this.replaced = false;

        doRestart(newSelection);
        changingSelection = false;
    }

    /**
     * Clears the current selection for the module, to prepare for conflict resolution.
     * - For the current selection, disconnect and remove any outgoing dependencies.

import java.util.Optional;
import java.util.Set;

/**
 * Provides a central location for handling failures encountered during
 * each stage of the variant selection process during dependency resolution.
 *
 * All variant selection failures encountered during selection by the {@link GraphVariantSelector} or
 * {@link AttributeMatchingArtifactVariantSelector}
 * should be routed through this class.
 *

            }

            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:

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

	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:

    /**
     * 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.