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

    /**

	"testing"
)

func TestIndex(t *testing.T) {
	// Generate every kind of pattern up to some number of segments,
	// and compare conflicts found during indexing with those found
	// by exhaustive comparison.
	patterns := generatePatterns()
	var idx routingIndex
	for i, pat := range patterns {
		got := indexConflicts(pat, &idx)
		want := trueConflicts(pat, patterns[:i])
		if !slices.Equal(got, want) {

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

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

 *
 * <p>Several methods accept a file pattern to selectively normalize files.  Patterns may include:</p>
 *
 * <ul>
 *
 * <li>'*' to match any number of characters
 *
 * <li>'?' to match any single character
 *
 * <li>'**' to match any number of directories or files
 *
 * </ul>
 *
 * <p>Either '/' or '\' may be used in a pattern to separate directories. Patterns ending with '/' or '\' will have '**'

        return this;
    }

    @Override
    public TestSpec includePattern(String pattern) {
        return includePatterns(Collections.singletonList(pattern));
    }

    @Override
    public TestSpec includePatterns(Collection<String> patterns) {
        this.patterns.addAll(patterns);
        return this;
    }

    @Override
    public List<String> getPackages() {
        return packages;

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

		paths121 []string // paths that matched the pattern in Go 1.21.
	}{
		{
			"/a", // this pattern matches a path that unescapes to "/a"
			[]string{"/a", "/%61"},
			[]string{"/a", "/%61"},
		},
		{
			"/%62", // patterns are unescaped by segment; matches paths that unescape to "/b"
			[]string{"/b", "/%62"},
			[]string{"/%2562"}, // In 1.21, patterns were not unescaped but paths were.
		},
		{

# bad patterns are reported (for more bad patterns, see TestGOVCSErrors)
env GOVCS='git'
! go get github.com/google/go-cmp
stderr '^go: github.com/google/go-cmp: malformed entry in GOVCS \(missing colon\): "git"$'

env GOVCS=github.com:hg,github.com:git
! go get github.com/google/go-cmp
stderr '^go: github.com/google/go-cmp: unreachable pattern in GOVCS: "github.com:git" after "github.com:hg"$'

// Adds the HLO to TF rewrite patterns to the specified pattern list.
void PopulateLegalizeHloToTfPatterns(RewritePatternSet* patterns,
                                     MLIRContext* context);

// Adds the HLO to TFLite rewrite patterns to the specified pattern list.
void PopulateLegalizeHloToTFLitePatterns(RewritePatternSet* patterns,
                                         MLIRContext* context);