return MatchResult.EXACT_MATCH;
        }
        for (Capability capability : capabilitiesSet) {
            capability = unwrap(capability);
            if (group.equals(capability.getGroup()) && name.equals(capability.getName())) {
                boolean exactMatch = capabilitiesSet.size() == 1;
                return exactMatch ? MatchResult.EXACT_MATCH : MatchResult.MATCHES_ALL;
            }
        }

                                       const std::vector<std::string>& filter,
                                       bool exact_match) {
  if (filter.empty()) return true;
  for (const std::string& filter_str : filter) {
    if (str == filter_str) return true;
    if (!exact_match && str.find(filter_str) != std::string::npos) return true;
  }
  return false;
}

  // Returns `true` iff any of the strings in `filter` matches `str`, either
  // exactly or as a substring, depending on `exact_match`.
  static bool MatchesFilter(const std::string& str,
                            const std::vector<std::string>& filter,
                            bool exact_match);

  // Only log pass invocations whose pass name exactly matches any string in
  // `pass_filter_` (or when `pass_filter_` is empty).

                       "or_rules": {
                        "rules": [
                         {
                          "header": {
                           "name": ":method",
                           "exact_match": "GET"
                          }
                         }
                        ]
                       }
                      },
                      {
                       "or_rules": {

    // will look like: [foo, bar, com], [bar, com], [com]. The longest matching rule wins.
    var exactMatch: String? = null
    for (i in domainLabelsUtf8Bytes.indices) {
      val rule = publicSuffixListBytes.binarySearch(domainLabelsUtf8Bytes, i)
      if (rule != null) {
        exactMatch = rule
        break
      }
    }

	assert.Equal(t, 1, precisePrefixCount)
	http.Get(s.URL + "/publicPrefix/but-more-precise/more-stuff")
	assert.Equal(t, 2, precisePrefixCount)

	http.Get(s.URL + "/publicPrefix/exactmatch")
	assert.Equal(t, 1, exactMatchCount)
	http.Get(s.URL + "/publicPrefix/exactmatch/")
	assert.Equal(t, 4, publicPrefixCount)
	http.Get(s.URL + "/otherPublic/exactmatchslash")
	assert.Equal(t, 3, fallThroughCount)

        return getActual();
    }

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

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

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

            }
        }
        return new LinkedHashSet<>(children.values());
    }

    @Override
    public String getDescription() {
        if (dependencyResult != null) {
            if (!exactMatch(dependencyResult.getRequested(), dependencyResult.getSelected().getId())) {
                return "(requested " + dependencyResult.getRequested() + ")";
            }
        }
        return null;
    }

              - actions:
                  - remote_address: {}
              - actions:
                  - header_value_match:
                      descriptor_value: "productpage"
                      expect_match: true
                      headers:
                        - name: :path
                          string_match:
                            prefix: /productpage
                            ignore_case: true

        return Collections.emptySet();
    }

    @Override
    public List<Section> getExtraDetails() {
        return Collections.emptyList();
    }

    protected boolean exactMatch(ComponentSelector requested, ComponentIdentifier selected) {
        if (requested instanceof ModuleComponentSelector) {
            VersionConstraint versionConstraint = ((ModuleComponentSelector) requested).getVersionConstraint();