0 * _
    }

    def 'overlapping patterns filter out parts matching more than one pattern'() {
        def resource1 = Mock(ExternalResource)

        when:
        def pattern1 = pattern("/[organisation]/[module]/[revision]/ivy-[revision].xml")
        def pattern2 = pattern("/[organisation]/[module]/ivy-[revision].xml")
        lister.listVersions(module, artifact, [pattern1, pattern2], result)
        def versions = result.versions

    }

    def "builds union of versions"() {
        LocallyAvailableExternalResource resource1 = Mock()
        LocallyAvailableExternalResource resource2 = Mock()
        def pattern1 = pattern("prefix1/" + MavenPattern.M2_PATTERN)
        def pattern2 = pattern("prefix2/" + MavenPattern.M2_PATTERN)
        def location1 = new ExternalResourceName('prefix1/org/acme/testproject/maven-metadata.xml')

            logger.debug("pattern1: {}, pattern2: {}", pattern1Str, pattern2Str);
        }
        if (pattern1Str != null) {
            pattern1 = Pattern.compile(pattern1Str);
            pattern2 = Pattern.compile(pattern2Str);
        }
    }

    @Override
    public TokenStream create(final TokenStream tokenStream) {
        return new PatternConcatenationFilter(tokenStream, pattern1, pattern2);
    }

     * <p>
     * The patterns follow the rules of
     * <a href="https://docs.gradle.org/current/userguide/java_testing.html#test_filtering">test filtering</a>.
     *
     * @param pattern the pattern to select tests.
     * @return this
     */
    TestSpec includePattern(String pattern);

    /**

// patterns that we might need to.
func (idx *routingIndex) possiblyConflictingPatterns(pat *pattern, f func(*pattern) error) (err error) {
	// Terminology:
	//   dollar pattern: one ending in "{$}"
	//   multi pattern: one ending in a trailing slash or "{x...}" wildcard
	//   ordinary pattern: neither of the above

	// apply f to all the pats, stopping on error.
	apply := func(pats []*pattern) error {
		if err != nil {

 */
public interface PatternFilterable {

    /**
     * Returns the set of include patterns.
     *
     * @return The include patterns. Returns an empty set when there are no include patterns.
     */
    Set<String> getIncludes();

    /**
     * Returns the set of exclude patterns.
     *
     * @return The exclude patterns. Returns an empty set when there are no exclude patterns.
     */

package org.gradle.api.tasks.util

import spock.lang.Specification

abstract class AbstractTestForPatternSet extends Specification {
    static final String TEST_PATTERN_1 = 'pattern1'
    static final String TEST_PATTERN_2 = 'pattern2'
    static final String TEST_PATTERN_3 = 'pattern3'

    abstract PatternFilterable getPatternSet()

    def testDefaultValues() {
        expect:
        patternSet.includes.empty

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