return false
	}
	if pattern.Version != AnyVersion && pattern.Version != resource.Version {
		return false
	}
	if pattern.Resource != AnyResource && pattern.Resource != resource.Resource {
		return false
	}

	return true
}

func kindMatches(pattern schema.GroupVersionKind, kind schema.GroupVersionKind) bool {
	if pattern.Group != AnyGroup && pattern.Group != kind.Group {

	t.init()
	return parseFS(t, fsys, patterns)
}

func parseFS(t *Template, fsys fs.FS, patterns []string) (*Template, error) {
	var filenames []string
	for _, pattern := range patterns {
		list, err := fs.Glob(fsys, pattern)
		if err != nil {
			return nil, err
		}
		if len(list) == 0 {

        builder.setLayoutType("Pattern");
        builder.setM2Compatible(m2compatible);

        for (String pattern : artifactPatterns) {
            builder.addArtifactPattern(pattern);
            builder.addArtifactResource(baseUri, pattern);
        }

        for (String pattern : ivyPatterns) {
            builder.addIvyPattern(pattern);
        }

  // 3) Op specific patterns over patterns with MatchAnyOpTypeTag.
  // 4) Order of patterns in `RewritePatternSet`.

  // Add TF->HLO legalization patterns.
  PopulateLegalizeTfPatterns(context, &legalize_lower_patterns);

  // Add TF->TF lowering patterns.
  TF::PopulateTFLoweringBeforeHLOPatterns(context, &legalize_lower_patterns);

  if (tf2xla_fallback_device_type && prefer_tf2xla) {

     *
     * Patterns added in this way will be in addition to any layout-based patterns added via {@link #setUrl(Object)}.
     *
     * @param pattern The artifact pattern.
     */
    void artifactPattern(String pattern);

    /**
     * Adds an independent pattern that will be used to locate ivy files in this repository.
     *

    /**
     * Adds an Ivy artifact pattern to define where artifacts are located in this repository.
     * @param pattern The ivy pattern
     */
    void artifact(String pattern);

    /**
     * Adds an Ivy pattern to define where ivy files are located in this repository.
     * @param pattern The ivy pattern
     */
    void ivy(String pattern);

    /**

# See golang.org/issue/34653.

# A single pattern for a package ending in '.go'.
go list ./foo.go
stdout '^test/foo.go$'

# Multiple patterns for packages including one ending in '.go'.
go list ./bar ./foo.go
stdout '^test/bar$'
stdout '^test/foo.go$'

# A single pattern for a Go file.
go list ./a.go
stdout '^command-line-arguments$'

# A single typo-ed pattern for a Go file. This should

stderr '^pattern example.com/...: '

! go list example.com/noread/...
! stdout '^example.com/noread$'
! stderr 'matched no packages'
stderr '^pattern example.com/noread/...: '


[short] stop

# Check global patterns, which should still
# fail due to errors in the local module.

! go list all
! stdout '^example.com/noread$'
! stderr 'matched no packages'
stderr '^pattern all: '

! go list ...

import org.gradle.util.internal.WrapUtil

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

    protected File srcDir
    protected File destDir
    protected File depCacheDir

    private ScalaCompile scalaCompile

	return pattern
}

// Rules - event rules
type Rules map[string]TargetIDSet

// Add - adds pattern and target ID.
func (rules Rules) Add(pattern string, targetID TargetID) {
	rules[pattern] = NewTargetIDSet(targetID).Union(rules[pattern])
}

// MatchSimple - returns true one of the matching object name in rules.
func (rules Rules) MatchSimple(objectName string) bool {
	for pattern := range rules {