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).
//

        schema.matcher().matches([candidate3, candidate4, candidate5, candidate6], requested, explanationBuilder) == [candidate3]
        schema.matcher().matches([candidate4, candidate5, candidate6], requested, explanationBuilder) == [candidate4]
        schema.matcher().matches([candidate5, candidate6], requested, explanationBuilder) == [candidate5]
        schema.matcher().matches([candidate6], requested, explanationBuilder) == [candidate6]
    }

        matcher.matches(["c"] as String[], 0)
        matcher.matches(["prefix", "c"] as String[], 1)
        matcher.matches(["a", "c"] as String[], 0)
        matcher.matches(["a", "c", "d"] as String[], 0)
        matcher.matches(["a", "b", "c", "d"] as String[], 0)
        matcher.matches(["a", "b", "c", "d"] as String[], 1)
    }

    def "every path is a prefix"() {

            } else if (version.getBaseVersion().equals(baseVersion)) {
                matches.put(version, candidate);
            }
        }

        if (matches.size() == 1) {
            details.select(matches.values().iterator().next());
            return;
        }