default:
			return nil, fmt.Errorf("%q is not a valid label selector operator", expr.Operator)
		}
		r, err := labels.NewRequirement(expr.Key, op, append([]string(nil), expr.Values...))
		if err != nil {
			return nil, err
		}
		requirements = append(requirements, *r)
	}
	selector := labels.NewSelector()
	selector = selector.Add(requirements...)
	return selector, nil
}

        if (participatingModules.add(state)) {
            resolveOptimizations.declareVirtualPlatformInUse();
            ComponentState selected = platformModule.getSelected();
            if (selected != null) {
                // There is a possibility that a platform version was selected before a new member
                // of the platform was discovered. In this case, we need to restart the selection,

    /**
     * Indicates if a version selector can be used to short-circuit selection, whenever a different
     * version has been selected previously. Typically, an exact version selector can short-circuit,
     * in the sense that it will always return a correct answer whenever exposed to a version. But a
     * "latest" selector will give a different answer whether is called first, or starting with a

    @Override
    public String getName() {
        ComponentSelector requested = getRequested();
        ComponentIdentifier selected = getActual();

        if(exactMatch(requested, selected)) {
            return getSimpleName();
        }

        if(requested instanceof ModuleComponentSelector && selected instanceof ModuleComponentIdentifier) {

        def spec = new ArtifactSelectionSpec(ImmutableAttributes.EMPTY, { false }, selectFromAll, false, ResolutionStrategy.SortOrder.DEFAULT)
        def selected = artifactSet.select(selector, spec)

        then:
        0 * selector.select(_, _, _, _)
        selected == ResolvedArtifactSet.EMPTY

        where:
        selectFromAll << [true, false]
    }

        def differentFrom = factory.createResolvedDependency(selector('requested'), newModule('xxx'), selectedModule, variant, false)
        def differentSelected = factory.createResolvedDependency(selector('requested'), fromModule, newModule('xxx'), variant, false)
        def differentConstraint = factory.createResolvedDependency(selector('requested'), fromModule, selectedModule, variant, true)

    });

    [].slice
      .call(
        document.querySelectorAll(".multi-language-selector .language-option")
      )
      .forEach(function (optionEl) {
        if (optionEl.getAttribute("data-lang") === languageId) {
          optionEl.classList.add("selected");
        } else {
          optionEl.classList.remove("selected");
        }
      });

    [].slice

        for (ClassSelector selector : delegate.getSelectorsByType(ClassSelector.class)) {
            if (ToolingApiSpecification.class.isAssignableFrom(selector.getJavaClass())) {
                ClassLoader classLoader = toolingApiClassLoaderForTest(selector.getJavaClass());
                try {
                    addSelector(DiscoverySelectors.selectClass(classLoader.loadClass(selector.getClassName())));

        given:
        def selector = Mock(ResolvableSelectorState)
        selectors.add(selector, false)

        when:
        def result = selectors.remove(selector)

        then:
        result
        verifyEmpty(selectors)
    }

    def 'can ad a selector marked as deferring'() {
        given:
        def selector = Mock(ResolvableSelectorState)

        when:
        selectors.add(selector, true)

        given:
        def selected = revision('a', '1.2')
        def evicted = revision('a', '1.1')
        def b = revision('b')
        def c = revision('c')
        def d = revision('d')
        def e = revision('e')
        traverses root, selected
        traverses selected, c
        traverses root, b