if a.hpaSelectors.SelectorExists(hpaKey) {
		// Update HPA selector only if the HPA was registered in enqueueHPA.
		a.hpaSelectors.PutSelector(hpaKey, parsedSelector)
	}
	a.hpaSelectorsMux.Unlock()

	pods, err := a.podLister.Pods(hpa.Namespace).List(parsedSelector)
	if err != nil {
		return nil, err
	}

	selectingHpas := a.hpasControllingPodsUnderSelector(pods)
	if len(selectingHpas) > 1 {

		selector := action.(core.ListAction).GetListRestrictions().Labels
		parsedSelector := strings.Split(selector.String(), "=")
		if len(parsedSelector) > 1 {
			labelSet[parsedSelector[0]] = parsedSelector[1]
			podNamePrefix = parsedSelector[1]
		}

		podMetric := metricsapi.PodMetrics{
			ObjectMeta: metav1.ObjectMeta{

    }

    def "creates sub version selector"() {
        expect:
        matcher.parseSelector(selector) instanceof SubVersionSelector

        where:
        selector << [
            "1+",
            "1.2.3+"
        ]
    }

    def "creates latest version selector"() {
        expect:
        matcher.parseSelector(selector) instanceof LatestVersionSelector

        where:
        selector << [

        def selectedComponentResult = Mock(ComponentSelectionContext)

        when:
        chooser.selectNewestMatchingComponent([c, d, a, b], selectedComponentResult, versionSelectorScheme.parseSelector("1.+"), versionSelectorScheme.parseSelector("1.3"), consumerAttributes)

        then:
        _ * componentSelectionRules.rules >> []
        1 * selectedComponentResult.getContentFilter() >> null

        isStrict = !strictVersion.isEmpty();
        String version = isStrict ? strictVersion : requiredVersion;
        this.requiredVersionSelector = scheme.parseSelector(version);
        this.preferredVersionSelector = preferredVersion.isEmpty() ? null : scheme.parseSelector(preferredVersion);

        if (isStrict) {
            VersionSelector rejectionForStrict = getRejectionForStrict(version, scheme);

    def mapper = new MavenVersionSelectorScheme(defaultMatcher)

    def "translates to maven syntax"() {
        given:
        def selector = defaultMatcher.parseSelector(input)

        expect:
        mapper.renderSelector(selector) == output

        where:
        input                | output
        "]2,3]"              | "(2,3]"
        "[2,3["              | "[2,3)"

        this.delegate = delegate;
    }

    @Override
    public VersionSelector parseSelector(String selectorString) {
        VersionSelector versionSelector = cachedSelectors.get(selectorString);
        if (versionSelector == null) {
            versionSelector = delegate.parseSelector(selectorString);
            cachedSelectors.put(selectorString, versionSelector);
        }
        return versionSelector;

    }

    @Override
    public VersionSelector parseSelector(String selectorString) {
        if (selectorString.equals(RELEASE)) {
            return new LatestVersionSelector(LATEST_RELEASE);
        } else if (selectorString.equals(LATEST)) {
            return new LatestVersionSelector(LATEST_INTEGRATION);
        } else {
            return defaultVersionSelectorScheme.parseSelector(selectorString);
        }
    }

    @Override

    }

    @Override
    public String map(String version) {
        return mavenVersionSelectorScheme.renderSelector(defaultVersionSelectorScheme.parseSelector(version));
    }

        selectors.each {
            members.add(selectorOf(it))
        }
    }

    private VersionSelector selectorOf(String selectorString) {
        versionSelectorScheme.parseSelector(selectorString)
    }

    private Version versionOf(String candidate) {
        parser.transform(candidate)
    }

    private ComponentMetadata metadataFor(String candidate) {