}

    def "matches name case insensitive"() {
        def step = new HasPrefixPatternStep(".abc", false)

        expect:
        step.matches(".abc")
        step.matches(".ABC")
        step.matches(".Abc")
        step.matches(".aBCD")
        !step.matches(".A")
        !step.matches(".Ab")
        !step.matches(".BCD")
        !step.matches("ABC")
        !step.matches("")
        !step.matches("something else")
    }

        Matcher matcher = boundaryPattern.matcher(name);
        int pos = 0;
        StringBuilder builder = new StringBuilder();
        while (matcher.find()) {
            String prefix = name.substring(pos, matcher.start());
            if (prefix.length() > 0) {
                builder.append(Pattern.quote(prefix));
            }
            builder.append(Pattern.quote(matcher.group()));

import spock.lang.Specification

class FixedPatternStepTest extends Specification {
    def "matches name case sensitive"() {
        def step = new FixedPatternStep("name", true)

        expect:
        step.matches("name")
        !step.matches("Name")
        !step.matches("")
        !step.matches("something else")
    }

    def "matches name case insensitive"() {
        def step = new FixedPatternStep("name", false)

        Matcher matcher = boundaryPattern.matcher(name);
        int pos = 0;
        StringBuilder builder = new StringBuilder();
        while (matcher.find()) {
            String prefix = name.substring(pos, matcher.start());
            if (prefix.length() > 0) {
                builder.append(Pattern.quote(prefix));
            }
            builder.append(Pattern.quote(matcher.group()));

    - namespaces:
      - exact: only-l4-ns
      principals:
      - exact: only-l4-principals
- rules:
  - matches:
    - {}
  - matches:
    - {}
- rules:
  - matches:
    - namespaces:
      - exact: when-l4-l7-ns
  - matches:
    - {}
- rules:
  - matches:
    - namespaces:
      - exact: when-l4-ns
  - matches:
    - notSourceIps:
      - address: FBQUFA==
        length: 32

        step2.matches("abac")
        !step2.matches("ac")
        !step2.matches("ABC")
        !step2.matches("other")

        and:
        def step3 = PatternStepFactory.getStep("?bc", true);
        step3 instanceof RegExpPatternStep
        step3.matches("abc")
        step3.matches("Abc")
        !step3.matches("bc")
        !step3.matches("ABC")
        !step3.matches("other")

        and:

        RegExpPatternStep step = new RegExpPatternStep("a?c", true);
        assertTrue(step.matches("abc"));
        assertTrue(step.matches("a$c"));
        assertTrue(step.matches("a?c"));

        assertFalse(step.matches("ac"));
        assertFalse(step.matches("abcd"));
        assertFalse(step.matches("abd"));
        assertFalse(step.matches("a"));
    }

    @Test public void testMultiCharWildcard() {

    def "matches name case insensitive"() {
        def step = new HasSuffixPatternStep(".java", false)

        expect:
        step.matches("thing.java")
        step.matches(".java")
        step.matches("thing.JAVA")
        step.matches("thing.Java")
        !step.matches("thing.jav")
        !step.matches("thing.c")
        !step.matches("")
        !step.matches("something else")
    }

//
//  - Op(string): matches the op exactly.
//
//  - AssignedDevice(string): matches the assigned device exactly.
//
//  - Inputs(<ordered list>): matches the list of non-control inputs to the node
//    exactly (i.e. does not match a suffix or a prefix) where each element
//    matches an output of a node (see Out(idx, node) below).
//

// must agree in advance what dictionary to use.
func Example_dictionary() {
	// The dictionary is a string of bytes. When compressing some input data,
	// the compressor will attempt to substitute substrings with matches found
	// in the dictionary. As such, the dictionary should only contain substrings
	// that are expected to be found in the actual data stream.