}

    TestClassExecutionResult assertStdout(Matcher<? super String> matcher) {
        def stdout = testClassNode.'system-out'[0].text();
        assertThat(stdout, matcher)
        this
    }

    TestClassExecutionResult assertStderr(Matcher<? super String> matcher) {
        def stderr = testClassNode.'system-err'[0].text();
        assertThat(stderr, matcher)
        this
    }

        def matcher = headerPattern.matcher(summary.first)
        assert matcher.matches()
        def totalProblems = matcher.group(1).toInteger()
        def expectedUniqueProblems = matcher.group(5)?.toInteger() ?: totalProblems
        summary = summary.drop(1)

        def problems = []
        for (int i = 0; i < expectedUniqueProblems; i++) {
            matcher = problemPattern.matcher(summary.first)

        def attribute = Attribute.of(String)
        schema.attribute(attribute)

        expect:
        !schema.matcher().selectionSchema.matchValue(attribute, "a", "b")
        schema.matcher().selectionSchema.matchValue(attribute, "a", "a")

        !schema.matcher().isMatching(attribute, "a", "b")
        schema.matcher().isMatching(attribute, "a", "a")
    }

    static class DoNothingRule implements AttributeCompatibilityRule<String> {

import spock.lang.Specification

class TestSelectionMatcherTest extends Specification {

    def "knows if test matches class"() {
        expect:
        matcher(input, [], []).matchesTest(className, methodName) == match
        matcher([], [], input).matchesTest(className, methodName) == match

        where:
        input                    | className                 | methodName            | match

        copyAction instanceof MatchingCopyAction
        PatternMatcher matcher = copyAction.matcher

        ['/root/folder/abc', '/root/abc'].each {
            assertMatches matcher, it
        }

        ['/notRoot/abc', '/not/root/abc', 'root/bbc', 'notRoot/bbc'].each {
            assertMatches matcher.negate(), it
        }
    }

      DCHECK(!matcher->op);
      matcher->op = prop.op();
    }

    if (prop.constant_value()) {
      DCHECK(!matcher->constant_value);
      matcher->constant_value = prop.constant_value();
    }

    if (prop.assigned_device()) {
      DCHECK(!matcher->assigned_device);
      matcher->assigned_device = prop.assigned_device();
    }

    if (prop.inputs()) {
      DCHECK(!matcher->input_matchers);

            testClassResults*.assertStderr(matcher)
            this
        }

        TestClassExecutionResult assertTestCaseStderr(String testCaseName, Matcher<? super String> matcher) {
            testClassResults*.assertTestCaseStderr(removeParentheses(testCaseName), matcher)
            this
        }

        ResolutionCandidateAssessor resolutionCandidateAssessor = new ResolutionCandidateAssessor(requestedAttributes, matcher);

            Node matcherNode = parent.appendNode("matcher");
             matcherNode.appendNode("id", matcher.getId());
            // A matcher may have either arguments or children, but not both
            if (!isNullOrEmpty(matcher.getArguments())) {
                matcherNode.appendNode("arguments", matcher.getArguments());

)

// New creates and returns a new Matcher implementing the given pattern.
// The pattern syntax is defined in the package doc comment.
//
// In addition to the pattern syntax syntax, New("") returns nil, nil.
// The nil *Matcher is valid for use: it returns true from ShouldEnable
// and false from ShouldPrint for all changes. Callers can avoid calling
// [Hash], [Matcher.ShouldEnable], and [Matcher.ShouldPrint] entirely