// Matches the first output of a node that matches `node`.
inline ::testing::Matcher<impl::OutEdge> Out(
    ::testing::Matcher<const Node*> node) {
  return Out(0, node);
}

// Matches a node with control dependences `control_deps`.
//
// `control_deps` are unordered and will match the control deps of a node in any
// order.
template <typename... Ts>

            }
        };
    }

    @Factory
    public static Matcher<Throwable> hasMessage(final Matcher<String> matcher) {
        return new BaseMatcher<Throwable>() {
            @Override
            public boolean matches(Object o) {
                Throwable t = (Throwable) o;
                return matcher.matches(t.getMessage());
            }

            @Override

        this.comparator = comparator;

        Matcher matcher;
        matcher = FINITE_RANGE.matcher(selector);
        if (matcher.matches()) {
            lowerBound = matcher.group(1);
            lowerInclusive = selector.startsWith(OPEN_INC);
            upperBound = matcher.group(2);
            upperInclusive = selector.endsWith(CLOSE_INC);
        } else {
            matcher = LOWER_INFINITE_RANGE.matcher(selector);

    }

    private List<String> filterMatchedValues(List<String> all, final Pattern p) {
        List<String> ret = new ArrayList<>(all.size());
        for (String path : all) {
            Matcher m = p.matcher(path);
            if (m.matches()) {
                String value = m.group(1);
                ret.add(value);
            }
        }
        return ret;
    }

            return matches.get(0).getArtifacts();
        } else if (matches.size() > 1) {
            // Request is ambiguous. Rerun matching again, except capture an explanation this time for reporting.
            TraceDiscardedVariants newExpBuilder = new TraceDiscardedVariants();
            matches = matcher.matches(variants, componentRequested, newExpBuilder);

                    <matcher>
                        <id>org.eclipse.ui.ide.multiFilter</id>
                        <arguments>1.0-name-matches-false-false-node_modules</arguments>
                    </matcher>
                    <matcher>
                        <id>org.eclipse.ui.ide.multiFilter</id>
                        <arguments>1.0-name-matches-false-false-target</arguments>
                    </matcher>
                </arguments>

	GetMatchResources() v1.MatchResources
}

// Matcher decides if a request matches against matchCriteria
type Matcher struct {
	namespaceMatcher *namespace.Matcher
	objectMatcher    *object.Matcher
}

func (m *Matcher) GetNamespace(name string) (*corev1.Namespace, error) {
	return m.namespaceMatcher.GetNamespace(name)
}

// NewMatcher initialize the matcher with dependencies requires
func NewMatcher(

        if (!attributeBasedMappings.isEmpty()) {
            AttributeMatcher matcher = schema.matcher();
            Set<ImmutableAttributes> candidates = attributeBasedMappings.keySet();
            List<ImmutableAttributes> matches = matcher.matches(candidates, variantAttributes, AttributeMatchingExplanationBuilder.NO_OP);
            if (matches.size() == 1) {

				inner := NewDestinationIP()
				inner.OnNoMatch = ToMatcher(leaf.Matcher)

				root := NewDestinationPort()
				root.OnNoMatch = ToMatcher(inner.Matcher)
				return root
			},
			want: func() *matcher.Matcher {
				// src port
				// 15001: chain
				want := NewSourceIP()
				want.Map["1.2.3.4"] = ToChain("chain")
				return want.Matcher
			},
		},
		{
			name: "empty map at depths = 1 and 2",

	cases := []struct {
		name      string
		input     []string
		matches   []string
		nomatches []string
	}{
		{
			name:      "empty",
			input:     []string{},
			matches:   []string{},
			nomatches: []string{"", "foo", "foo/bar", ".*"},
		},
		{
			name:      "single",
			input:     []string{"Foo"},
			matches:   []string{"TestFoo", "TestMyFooBar", "TestFoo/TestBar"},