</tr>
            <tr>
                <td>wildcards</td>
                <td><literal>['!?*.java', '!?*.groovy']</literal></td>
                <td/>
            </tr>
            <tr>
                <td>ipr</td>
                <td/>
                <td/>

It also allows the use of wildcards to specify the resources that should be encrypted.
Use '*.<group>' to encrypt all resources within a group or '*.*' to encrypt all resources.
'*.' can be used to encrypt all resource in the core group.  '*.*' will encrypt all
resources, even custom resources that are added after API server start.
Use of wildcards that overlap within the same resource list or across multiple

# This test covers a crazy edge-case involving wildcards and multiple passes of
# patch-upgrades, but if we get it right we probably get many other edge-cases
# right too.

go list -m all
stdout '^example.net/a v0.1.0 '
! stdout '^example.net/b '


# Requesting pattern example.../b by itself fails: there is no such module
# already in the build list, and the wildcard in the first element prevents us

            }
        }
        if (endLiteral == source.length()) {
            if (endPrefixWildcard == 0) {
                // No wildcards: matches #5 above
                return new FixedPatternStep(source, caseSensitive);
            }
            // One or more '*' followed by one or more non-wildcard: matches #2 above
            return new HasSuffixPatternStep(source.substring(endPrefixWildcard), caseSensitive);
        }

apply plugin: 'java'
apply plugin: 'idea'

idea {
    module {
        iml {
            whenMerged { it.jdkName = '1.44' }
        }
    }

    project {
        ipr {
            whenMerged { it.wildcards += '!?*.ruby' }
        }
    }
}
'''
        //then
        def iml = getFile([:], 'root.iml').text
        assert iml.contains('1.44')

        def ipr = getFile([:], 'root.ipr').text

        String id = artifact.getGroupId() + ":" + artifact.getArtifactId();

        boolean matched = false;
        for (Iterator<String> i = patterns.iterator(); i.hasNext() & !matched; ) {
            // TODO what about wildcards? Just specifying groups? versions?
            if (id.equals(i.next())) {
                matched = true;
            }
        }
        return matched;
    }

    public List<String> getPatterns() {

 * default, no recursion is done for type arguments or type bounds. But subclasses can opt to do
 * recursion by calling {@link #visit} for any {@code Type} while visitation is in progress. For
 * example, this can be used to reject wildcards or type variables contained in a type as in:
 *
 * <pre>{@code
 * new TypeVisitor() {
 *   protected void visitParameterizedType(ParameterizedType t) {
 *     visit(t.getOwnerType());

    @Test
    fun `recognizes segments that are partially wildcarded`() {
        val instance = createFromPaths(listOf("foo*/*bar*/*baz/*.xml"))
        assertTrue(instance.isFileSystemCheckIgnoredFor(File("foo/bar/baz/.xml")))
        assertTrue(instance.isFileSystemCheckIgnoredFor(File("foo1/2bar3/4baz/abc.xml")))
    }

    @Test
    fun `recognizes double-asterisk wildcards across path segments`() {

	errWildcardObjectLookup       = errors.New("Object wildcard used on non-object value")
	errWildcardArrayLookup        = errors.New("Array wildcard used on non-array value")
	errWildcardObjectUsageInvalid = errors.New("Invalid usage of object wildcard")
)

// jsonpathEval evaluates a JSON path and returns the value at the path.
// If the value should be considered flat (from wildcards) any array returned should be considered individual values.

	segments map[routingIndexKey][]*pattern
	// All patterns that end in a multi wildcard (including trailing slash).
	// We do not try to be clever about indexing multi patterns, because there
	// are unlikely to be many of them.
	multis []*pattern
}

type routingIndexKey struct {
	pos int    // 0-based segment position
	s   string // literal, or empty for wildcard
}

func (idx *routingIndex) addPattern(pat *pattern) {