CoreMatchers { public void CoreMatchers(); public static Matcher allOf(Iterable); public static transient Matcher allOf(Matcher[]); public static Matcher allOf(Matcher, Matcher); public static Matcher allOf(Matcher, Matcher, Matcher); public static Matcher allOf(Matcher, Matcher, Matcher, Matcher); public static Matcher allOf(Matcher, Matcher, Matcher, Matcher, Matcher); public static Matcher allOf(Matcher, Matcher, Matcher, Matcher, Matcher, Matcher); public static core.AnyOf anyOf(Iterable); public static...

        assertThat(matcher, matchesDir("a", "b"));
        assertThat(matcher, matchesDir("c", "a", "b"));
        assertThat(matcher, matchesDir("a", "b", "c"));
        assertThat(matcher, matchesDir("c", "a", "b", "d"));
        assertThat(matcher, matchesDir("a", "b", "a", "b"));
        assertThat(matcher, matchesDir("a"));
        assertThat(matcher, matchesDir("c"));
        assertThat(matcher, matchesDir("c", "a"));

org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second) { return org.hamcrest.core.AllOf.<T>allOf(first, second); } /** * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers. * <p/> * For example: * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre> */ public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second,...

        java.util.regex.Matcher matcher = FAILURE_PATTERN.matcher(failureText);
        if (matcher.lookingAt()) {
            summary = matcher.group(1);
        } else {
            summary = "";
        }

        matcher = LOCATION_PATTERN.matcher(failureText);
        while (matcher.find()) {
            fileNames.add(matcher.group(1).trim());
            lineNumbers.add(matcher.group(3));

		<filter>
			<id>1</id>
			<type>9</type>
			<name/>
			<matcher>
				<id>org.eclipse.some.custom.matcher</id>
				<arguments>foobar</arguments>
			</matcher>
		</filter>
		<filter>
			<id>2</id>
			<type>30</type>
			<name/>
			<matcher>
				<id>org.eclipse.some.custom.matcher</id>
				<arguments>barfoo</arguments>
			</matcher>
		</filter>
	</filteredResources>
</projectDescription>
'''

        this.stage = parseStage(matcher);
        this.snapshot = parseSnapshot(matcher);
    }

    private Long parseSnapshot(Matcher matcher) {
        if ("snapshot".equals(matcher.group(5)) || isCommitVersion(matcher)) {
            return 0L;
        } else if (matcher.group(8) == null) {
            return null;
        } else if ("SNAPSHOT".equals(matcher.group(8))) {
            return 0L;
        } else {

        expect:
        matcher.matches([candidate1, candidate2], requested, explanationBuilder) == [candidate1, candidate2]

        matcher.matches([candidate1], requested, explanationBuilder) == [candidate1]
        matcher.isMatching(candidate1, requested)

        matcher.matches([candidate2], requested, explanationBuilder) == [candidate2]
        matcher.isMatching(candidate2, requested)
    }

        TestClassExecutionResult assertStdout(Matcher<? super String> matcher) {
            return assertOutput('Standard output', matcher)
        }

        TestClassExecutionResult assertTestCaseStdout(String testCaseName, Matcher<? super String> matcher) {
            throw new UnsupportedOperationException()
        }

        TestClassExecutionResult assertStderr(Matcher<? super String> matcher) {

	}

	// If value is of format [v], create a list matcher.
	// Else, if value is of format v, create a string matcher.
	if strings.HasPrefix(value, "[") && strings.HasSuffix(value, "]") {
		m := matcher.MetadataListMatcher(parts[0], parts[1:], matcher.StringMatcher(strings.Trim(value, "[]")), false)
		return permissionMetadata(m), nil
	}
	m := matcher.MetadataStringMatcher(parts[0], parts[1], matcher.StringMatcher(value))
	return permissionMetadata(m), nil

        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);