when:
        def selector = matcher.parseSelector(version)

        then:
        selector instanceof ExactVersionSelector
        selector.selector == '1.0'

        where:
        version << ["[1.0]", "[1.0, 1.0]"]
    }

    def "computes rejection selector for strict dependency version #selector"() {
        given:

    private void doAddWhenListHasOneElement(T selector) {
        T first = selectors.get(0);
        int c = selectorComparator.compare(first, selector);
        if (c <= 0) {
            selectors.add(selector);
        } else {
            selectors.add(0, selector);
        }
    }

    public boolean remove(T selector) {
        return selectors.remove(selector);
    }

        dependenciesMetadata[0].selector.group == "org.gradle.test"
        dependenciesMetadata[0].selector.module == "module2"
        dependenciesMetadata[0].selector.version == "1.0"

        dependenciesMetadata[1].selector.group == "org.gradle.test"
        dependenciesMetadata[1].selector.module == "module1"
        dependenciesMetadata[1].selector.version == "2.0"
    }

    private final ComponentSelector selector;

    public ModuleVersionResolveException(ComponentSelector selector, Factory<String> message, Throwable cause) {
        super(message, cause);
        this.selector = selector;
    }

    public ModuleVersionResolveException(ComponentSelector selector, Factory<String> message) {
        super(message);
        this.selector = selector;
    }

     * Mark a project as required and activated.
     * @param selector The selector of the project.
     */
    public void activateRequiredProject(String selector) {
        this.activations.add(new ProjectActivationSettings(selector, ActivationSettings.ACTIVATION_REQUIRED));
    }

    /**
     * Mark a project as optional and activated.
     * @param selector The selector of the project.
     */

        selector != diffVersion
    }

    def "knows if matches the id"() {
        def selector = newSelector(UTIL, "1.0")
        def matching = newId(UTIL, "1.0")

        def differentGroup = newId("xorg", "util", "1.0")
        def differentName = newId("org", "xutil", "1.0")
        def differentVersion = newId("org", "xutil", "x1.0")

        expect:
        selector.matchesStrictly(matching)

)

var GlobalTime = time.Now()

// ServiceEntry with a selector
var selector = &config.Config{
	Meta: config.Meta{
		GroupVersionKind:  gvk.ServiceEntry,
		Name:              "selector",
		Namespace:         "selector",
		CreationTimestamp: GlobalTime,
	},
	Spec: &networking.ServiceEntry{
		Hosts: []string{"selector.com"},
		Ports: []*networking.ServicePort{

		default:
			return selector, fmt.Errorf("%q is not a valid selector operator", expr.Operator)
		}
	}
	return selector, nil
}

// ParseToLabelSelector parses a string representing a selector into a LabelSelector object.
// Note: This function should be kept in sync with the parser in pkg/labels/selector.go
func ParseToLabelSelector(selector string) (*LabelSelector, error) {

		policy := admissionregistrationv1beta1.Equivalent
		obj.MatchPolicy = &policy
	}
	if obj.NamespaceSelector == nil {
		selector := metav1.LabelSelector{}
		obj.NamespaceSelector = &selector
	}
	if obj.ObjectSelector == nil {
		selector := metav1.LabelSelector{}
		obj.ObjectSelector = &selector
	}
}

// SetDefaults_ValidatingWebhook sets defaults for webhook validating

    public boolean requiresMetadata() {
        for (VersionSelector selector : selectors) {
            if (selector.requiresMetadata()) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean matchesUniqueVersion() {
        for (VersionSelector selector : selectors) {
            if (!selector.matchesUniqueVersion()) {
                return false;
            }