Pattern.MULTILINE + Pattern.DOTALL);

        Matcher matcher = pattern.matcher(daemonLog.text);
        assert matcher.matches(): "Unable to find daemon address in the daemon log. Daemon: $context"

        try {
            return Integer.parseInt(matcher.group(1))
        } catch (NumberFormatException e) {

		return match.NotRegularPod.GetMatches(instances)
	}
}

// FilterMatch returns a filter that simply applies the given matcher.
func FilterMatch(matcher match.Matcher) Filter {
	return func(instances echo.Instances) echo.Instances {
		return matcher.GetMatches(instances)
	}
}

// SameNetwork filters out destinations that are on a different network from the source.

    static Set<File> parse(Reader output) {
        BufferedReader reader = new BufferedReader(output);
        return reader.lines().flatMap(line -> {
            Matcher matcher = INSTALLATION_PATTERN.matcher(line);
            if (matcher.matches()) {
                String javaHome = matcher.group(1);
                return Stream.of(javaHome);
            }
            return Stream.empty();
        }).map(File::new).collect(Collectors.toSet());

     */
    ExecutionFailure assertThatDescription(Matcher<? super String> matcher);

    /**
     * Asserts that there all failures match the given description (ie the bit after '* What went wrong').
     *
     * <p>Error messages are normalized to use new-line char as line separator.
     */
    ExecutionFailure assertThatAllDescriptions(Matcher<? super String> matcher);

    /**

		ForwardNotMatchingPreflights: wrapperspb.Bool(false),
		AllowOriginStringMatch: []*matcher.StringMatcher{
			{MatchPattern: &matcher.StringMatcher_Exact{Exact: "exact"}},
			{MatchPattern: &matcher.StringMatcher_Prefix{Prefix: "prefix"}},
			{
				MatchPattern: &matcher.StringMatcher_SafeRegex{
					SafeRegex: &matcher.RegexMatcher{
						Regex: "regex",
					},
				},
			},
		},

                        }
                    } as Collection<Matcher<Iterable<? super File>>>
                } as Collection<Matcher<Iterable<? super File>>>

            def resourceDirs =
                sourceRoots.sourceSets.collect { sourceSet ->
                    hasLanguageDir(sourceRoots.projectDir, sourceSet, "resources")
                } as Collection<Matcher<Iterable<? super File>>>

            languageDirs + resourceDirs

    }

    private static class ClassMethodNameFilter implements PostDiscoveryFilter {
        private final TestSelectionMatcher matcher;

        private ClassMethodNameFilter(TestSelectionMatcher matcher) {
            this.matcher = matcher;
        }

        @Override
        public FilterResult apply(TestDescriptor descriptor) {
            if (classMatch(descriptor)) {

            Matcher matcher = text =~ /(mavenCentral\(\))/
            boolean matched = false
            matcher.find() // skip first match in pluginManagement {}
            if (matcher.find()) {
                matched = true // matched dependencyResolutionManagement {}
                def result = matcher.toMatchResult()
                text.replace(

)

// 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

            java.util.regex.Matcher matcher = LOCATION_PATTERN.matcher(failureMessage);
            if (matcher.find()) {
                fileNames.add(matcher.group(1));
                lineNumbers.add(matcher.group(3));
                failures.add(new FailureDetails(failure, failureMessage.substring(matcher.end()).trim(), causes));
            } else {