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:

*/

// Package leaderelection implements leader election of a set of endpoints.
// It uses an annotation in the endpoints object to store the record of the
// election state. This implementation does not guarantee that only one
// client is acting as a leader (a.k.a. fencing).
//
// A client only acts on timestamps captured locally to infer the state of the
// leader election. The client does not consider timestamps in the leader

		o.ApplyDeprecated()
		o.ApplyLeaderElectionTo(o.ComponentConfig)
		c.ComponentConfig = *o.ComponentConfig
	} else {
		cfg, err := LoadConfigFromFile(logger, o.ConfigFile)
		if err != nil {
			return err
		}
		// If the --config arg is specified, honor the leader election CLI args only.
		o.ApplyLeaderElectionTo(cfg)

            }
        }

        where:
        target << ['maven', 'maven-gradle', 'ivy-gradle']
    }

    def "explicit configuration selection in ivy modules is supported if targeting a ivy module"() {
        given:
        // use a different name if selection is supported to not follow the default expectations defined in leaksRuntime()
        String targetRepoName = "ivy-select"

        ComponentSelectionInternal selection = new DefaultComponentSelection(candidateIdentifier, metadataProvider);
        rulesProcessor.apply(selection, rules, metadataProvider);
        if (selection.isRejected()) {
            return new RejectedByRuleVersion(candidateIdentifier, selection.getRejectionReason());
        }
        return null;
    }

Examples of variants each Java components typically offers are _api_ and _runtime_ variants.
Others examples are JDK8 and JDK11 variants.
For more information, see the section on <<variant_model.adoc#understanding-variant-selection,variant selection>>.

[[sub:terminology_attribute]]
== Variant Attribute

Attributes are used to identify and select <<#sub:terminology_variant,variants>>.

type EgressSelectorConfiguration struct {
	metav1.TypeMeta

	// EgressSelections contains a list of egress selection client configurations
	EgressSelections []EgressSelection
}

// EgressSelection provides the configuration for a single egress selection client.
type EgressSelection struct {
	// Name is the name of the egress selection.
	// Currently supported values are "controlplane", "etcd" and "cluster"
	Name string

 * dependencies are executed. For this reason, we delay artifact selection until after this artifact
 * set is restored from the configuration cache. This differs from normal artifact variant selection
 * where we can perform selection before serialization.</p>
 *
 * <p>The tricky part that due to the artifactType registry, artifact variant selection depends on the

        then:
        failure.assertHasCause("Could not resolve org:transitive:1.+: Resolution strategy disallows usage of dynamic versions")
    }

    def "fails if a transitive dynamic selector participates in selection"() {
        buildFile << """
            dependencies {
                conf 'org:test:1.0'
                conf 'org:testB:1.0'
            }
        """

        repository {

   SELECTED_BY_RULE : fix comes from component selection rule
   CONSTRAINT : ${useReason?'This reason comes from a constraint':'constraint'}
""")
        where:
        useReason << [true, false]
    }

    @ToBeFixedForConfigurationCache(because = "task exercises the resolution result API")
    def "direct dependency reasons are not mis-showing up as a separate REQUESTED and do not overwrite selection by rule"() {
        given: