pattern <<= 8
				pattern |= uintptr(*src)
				src = subtract1(src)
				npattern += 8
			}

			// We started with the whole bit output buffer,
			// and then we loaded bits from whole bytes.
			// Either way, we might now have too many instead of too few.
			// Discard the extra.
			if npattern > n {
				pattern >>= npattern - n
				npattern = n
			}

// than the other.
//
//	Precedence is defined by two rules:
//	1. Patterns with a host win over patterns without a host.
//	2. Patterns whose method and path is more specific win. One pattern is more
//	   specific than another if the second matches all the (method, path) pairs
//	   of the first and more.
//
// If rule 1 doesn't apply, then two patterns conflict if their relationship

        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 {

        return Pattern.compile(acceptNamePattern);
    }

    private Pattern toControlRegexPattern(String pattern) {
        pattern = pattern.replaceAll("\\.", "\\\\.");

        // Creates a control regexp pattern where extra revision tokens _must_ have the same value as the original one
        String acceptNamePattern = pattern.replaceFirst("\\[revision]", "(.+)")
            .replaceAll("\\[revision]", "\1");

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