private final Set<String> includes;
    private final Set<String> excludes;
    private final boolean caseSensitive;

    public PatternSetAntBuilderDelegate(Set<String> includes, Set<String> excludes, boolean caseSensitive) {
        this.includes = includes;
        this.excludes = excludes;
        this.caseSensitive = caseSensitive;
    }

    private static Object logical(Object node, String op, final Action<Object> withNode) {

 */
public class HasSuffixPatternStep implements PatternStep {
    private final String suffix;
    private final boolean caseSensitive;
    private final int suffixLength;
    private final int prefixLength;

    public HasSuffixPatternStep(String suffix, boolean caseSensitive) {
        this(suffix, caseSensitive, 0);
    }

    // Used by HasPrefixAndSuffixPatternStep to ensure the suffix isn't matching any part of the prefix.

        this.excludes = null;
        return exclude(excludes);
    }


    public boolean isCaseSensitive() {
        return caseSensitive;
    }

    public void setCaseSensitive(boolean caseSensitive) {
        this.caseSensitive = caseSensitive;
    }

    /*
    This can't be called just include, because it has the same erasure as include(Iterable<String>).
     */

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.snapshot


import static org.gradle.internal.snapshot.CaseSensitivity.CASE_SENSITIVE

class UnknownFileSystemNodeTest extends AbstractIncompleteFileSystemNodeTest<UnknownFileSystemNode> {

    @Override
    protected UnknownFileSystemNode createInitialRootNode(ChildMap<FileSystemNode> children) {

public class HasPrefixPatternStep implements PatternStep {
    private final String prefix;
    private final boolean caseSensitive;
    private final int prefixLength;

    public HasPrefixPatternStep(String prefix, boolean caseSensitive) {
        this.prefix = prefix;
        prefixLength = prefix.length();
        this.caseSensitive = caseSensitive;
    }

    @Override
    public String toString() {
        return "{prefix: " + prefix + "}";

        then:
        childResolver.caseSensitive
        childResolver.patternSet.caseSensitive

        when:
        parentSpec.caseSensitive = false

        then:
        !childResolver.caseSensitive
        !childResolver.patternSet.caseSensitive

        when:
        child.caseSensitive = true

        then:
        childResolver.caseSensitive
        childResolver.patternSet.caseSensitive

        expect:
        initialRoot.store(childAbsolutePath("some/child"), CASE_SENSITIVE, snapshot, changeListener) == initialRoot
        removedSnapshots.empty
        addedSnapshots.empty
    }

    def "invalidate removes the node"() {
        expect:
        initialRoot.invalidate(childAbsolutePath("some/child"), CASE_SENSITIVE, changeListener) == Optional.empty()
        removedSnapshots == [initialRoot]

                  "*"
                ],
                "routes": [
                  {
                    "match": {
                      "path": "/productpage",
                      "case_sensitive": true
                    },
                    "route": {
                      "cluster": "outbound|9080||productpage.default.svc.cluster.local",
                      "timeout": "0s",

            Pattern.compile("^user-agent:\\s*([^\\t\\n\\x0B\\f\\r]+)\\s*$", Pattern.CASE_INSENSITIVE);

    protected static final Pattern DISALLOW_RECORD = Pattern.compile("^disallow:\\s*([^\\s]*)\\s*$", Pattern.CASE_INSENSITIVE);

    protected static final Pattern ALLOW_RECORD = Pattern.compile("^allow:\\s*([^\\s]*)\\s*$", Pattern.CASE_INSENSITIVE);

    private final HasSuffixPatternStep suffixMatch;

    public HasPrefixAndSuffixPatternStep(String prefix, String suffix, boolean caseSensitive) {
        prefixMatch = new HasPrefixPatternStep(prefix, caseSensitive);
        suffixMatch = new HasSuffixPatternStep(suffix, caseSensitive, prefix.length());
    }

    @Override
    public String toString() {
        return "{prefix: " + prefixMatch + " suffix: " + suffixMatch + "}";