String patterns = System.getProperty("package.cycle.exclude.patterns");
        return Arrays.stream(patterns.split(","))
            .map(String::trim);
    }

    private static Set<String> ignoredPackagesForCycles() {
        return excludePatterns()
            .filter(pattern -> !isClassNamePattern(pattern))
            .map(pattern -> pattern.replace("/**", ".."))

		return MatchSimplePattern(pattern)(name)
	})
}

var treeCanMatchPatternTests = `
	pattern ...
	match foo

	pattern net
	match net
	not net/http

	pattern net/http
	match net net/http

	pattern net...
	match net netchan net/http
	not not/http not/net/http

	pattern net/...
	match net net/http

}

func MatchesGlobs(matchString string, patterns []string) bool {
	if len(patterns) == 0 {
		return true
	}
	if len(patterns) == 1 {
		p := strings.TrimSpace(patterns[0])
		if p == "" || p == "*" {
			return true
		}
	}

	for _, p := range patterns {
		if MatchesGlob(matchString, p) {
			return true
		}
	}
	return false
}

func MatchesGlob(matchString, pattern string) bool {

preceded by a package pattern and an equal sign, which restricts
the use of that argument list to the building of packages matching
that pattern (see 'go help packages' for a description of package
patterns). Without a pattern, the argument list applies only to the
packages named on the command line. The flags may be repeated
with different patterns in order to specify different arguments for

import static org.gradle.util.internal.WrapUtil.toSet

class TestTest extends AbstractConventionTaskTest {
    static final String TEST_PATTERN_1 = "pattern1"
    static final String TEST_PATTERN_2 = "pattern2"
    static final String TEST_PATTERN_3 = "pattern3"

    private File classesDir
    private File resultsDir
    private File binResultsDir
    private File reportDir

		idx.addPattern(pat)
	}
}

func trueConflicts(pat *pattern, pats []*pattern) []string {
	var s []string
	for _, p := range pats {
		if pat.conflictsWith(p) {
			s = append(s, p.String())
		}
	}
	slices.Sort(s)
	return s
}

func indexConflicts(pat *pattern, idx *routingIndex) []string {
	var s []string
	idx.possiblyConflictingPatterns(pat, func(p *pattern) error {
		if pat.conflictsWith(p) {

        if (pattern.endsWith("/") || pattern.endsWith("\\")) {
            pattern = pattern + "**";
        }
        List<String> parts = PATH_SPLITTER.splitToList(pattern);
        return compile(parts, 0, caseSensitive);
    }

    private static PathMatcher compile(List<String> parts, int startIndex, boolean caseSensitive) {
        if (startIndex >= parts.size()) {
            return END_OF_PATH_MATCHER;
        }

     * Test name patterns can be appended via {@link #excludeTestsMatching(String)} or set via
     * {@link #setExcludePatterns(String...)}.
     *
     * @return included test name patterns
     * @since 5.0
     */
    @Input
    Set<String> getExcludePatterns();

    /**

        for (String requiredSection : getReadmePatterns().get()) {
            Pattern pattern = Pattern.compile(requiredSection, Pattern.MULTILINE);
            if (!pattern.matcher(readmeContents).find()) {
                throw new RuntimeException("README should contain section: " + pattern.pattern());
            }
        }
    }

  RewritePatternSet patterns(&ctx);
  patterns.add<StableHloQuantization, StableHloQuantizationReverse>(&ctx);

  PopulateCommonQuantizationPatterns(ctx, patterns,
                                     enable_per_channel_quantized_weight_);

  // Quantize all quantizable ops, including ops that are not compute-heavy.
  PopulateAllQuantizablePatterns(ctx, patterns);