apiVersion: release-notes/v2
kind: feature
area: traffic-management
releaseNotes:
- |

     *
     * @param includes Inclusions
     */
    void setIncludes(List<String> includes);

    /**
     * List of elements that should be included in check. Names can use wildcards (* and ?).
     * If left empty, all elements will be included. Defaults to [*].
     */
    @Input
    List<String> getIncludes();

    /**
     * Sets list of elements that should be excluded from check.
     *

        runTask('idea', """
apply plugin: 'idea'

idea.project.wildcards = ['1'] as Set
assert idea.project.wildcards == ['1'] as Set

idea {
    project.wildcards += '2'
    assert project.wildcards == ['1', '2'] as Set
}

idea.project {
    wildcards += '3'
    assert wildcards == ['1', '2', '3'] as Set
}

""")
    }

    @Test

    check(rule.startsWith(WILDCARD_CHAR)) {
      """Wildcard Assertion Failure: '$rule'
A wildcard rule was added with a wildcard that is not in leftmost position! We'll need to change the ${PublicSuffixDatabase::class.java.name} to handle this."""
    }
    check(rule.indexOf(WILDCARD_CHAR, 1) == -1) {
      """Wildcard Assertion Failure: '$rule'

# Test that wildcards don't look in useless directories.

# First make sure that badpkg fails the list of '...'.
! go list ./...
stderr badpkg

# Check that the list of './goodpkg...' succeeds. That implies badpkg was skipped.
go list ./goodpkg...

-- go.mod --
module m

go 1.16
-- goodpkg/x.go --
package goodpkg
-- badpkg/x.go --

// RegisterFormat registers an image format for use by [Decode].
// Name is the name of the format, like "jpeg" or "png".
// Magic is the magic prefix that identifies the format's encoding. The magic
// string can contain "?" wildcards that each match any one byte.
// [Decode] is the function that decodes the encoded image.
// [DecodeConfig] is the function that decodes just its configuration.

		},
		{
			name: "glob deployments with labels and annotations",
			config: `
include:
  - ns1,ns2/d1,d2/p1,p2,p3,p4/l1=v1,l2=v2/k2=v2`,
			want:    p1,
			wantErr: "",
		},
		{
			name: "label wildcards",
			config: `
include:
  - n*/*/*/l1=v1,l2=v2*`,
			want:    joinSlices(p1, p2, p3),
			wantErr: "",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {

	// those with a multi wildcard.
	// We skip this step if the segment is a trailing slash, because single wildcards
	// don't match trailing slashes.
	if seg != "/" {
		if n, m := n.emptyChild.matchPath(rest, append(matches, seg)); n != nil {
			return n, m
		}
	}
	// Lastly, match the pattern (there can be at most one) that has a multi

To eliminate ambiguity about which module versions are used in the build, the
arguments must satisfy the following constraints:

 - Arguments must be package paths or package patterns (with "..." wildcards).
 They must not be standard packages (like fmt), meta-patterns (std, cmd,
 all), or relative or absolute file paths.

 - All arguments must have the same version suffix. Different queries are not

 * limitations under the License.
 */

package org.gradle.api.internal.file.pattern;

/**
 * A pattern step for a fixed pattern segment that does not contain any wildcards.
 */
public class FixedPatternStep implements PatternStep {
    private final String value;
    private final boolean caseSensitive;

    public FixedPatternStep(String value, boolean caseSensitive) {