ideal • runtime • patterns • test_sequence

private boolean match a(character c) pure

return c == 'a' || c == 'A'

private boolean match b(character c) pure

return c == 'b' || c == 'B'

private boolean match c(character c) pure

return c == 'c' || c == 'C'

sequence pattern[character] make pattern()

pattern[character] match one or more a : repeat element[character] • new(match a, false)

pattern[character] match zero or more b : repeat element[character] • new(match b, true)

pattern[character] match one or more c : repeat element[character] • new(match c, false)

list[pattern[character]] patterns list : base list[pattern[character]] • new(match one or more a, match zero or more b, match one or more c)

return sequence pattern[character] • new(patterns list)

sequence pattern[character] make pattern2()

pattern[character] match one or more a : repeat element[character] • new(match a, false)

pattern[character] match one or more b : repeat element[character] • new(match b, false)

pattern[character] match one or more c : repeat element[character] • new(match c, false)

list[pattern[character]] patterns list : base list[pattern[character]] • new(match one or more a, match one or more b, match one or more c)

return sequence pattern[character] • new(patterns list)

test case test match()

the pattern : make pattern()

assert the pattern("abc")

assert the pattern("AC")

assert the pattern("AaaCcc")

assert the pattern("AaaBBBCcc")

assert !the pattern("bac")

assert !the pattern("aabb")

assert !the pattern("aaca")

test case test viable prefix()

the pattern : make pattern()

assert the pattern • is viable prefix("")

assert the pattern • is viable prefix("a")

assert the pattern • is viable prefix("aAa")

assert the pattern • is viable prefix("aabb")

assert the pattern • is viable prefix("aacc")

assert the pattern • is viable prefix("aaBcc")

assert !the pattern • is viable prefix("x")

assert !the pattern • is viable prefix("xyz")

assert !the pattern • is viable prefix("bbb")

assert !the pattern • is viable prefix("bcc")

assert !the pattern • is viable prefix("Ccc")

the pattern2 : make pattern2()

assert the pattern2 • is viable prefix("")

assert the pattern2 • is viable prefix("a")

assert the pattern2 • is viable prefix("aAa")

assert the pattern2 • is viable prefix("aabb")

assert the pattern2 • is viable prefix("aaBcc")

assert !the pattern2 • is viable prefix("x")

assert !the pattern2 • is viable prefix("xyz")

assert !the pattern2 • is viable prefix("bbb")

assert !the pattern2 • is viable prefix("bcc")

assert !the pattern2 • is viable prefix("Ccc")

test case test match prefix()

the pattern : make pattern()

assert the pattern • match prefix("") is null

assert the pattern • match prefix("a") is null

assert the pattern • match prefix("x") is null

assert the pattern • match prefix("xabc") is null

assert the pattern • match prefix("abc") == 3

assert the pattern • match prefix("abcdef") == 3

assert the pattern • match prefix("aAbBcCdef") == 6

assert the pattern • match prefix("aAbCdef") == 4

assert the pattern • match prefix("aaabbbcccddd") == 9

test case test find first()

the pattern : make pattern()

assert the pattern • find first("", 0) is null

assert the pattern • find first("foo", 0) is null

assert the pattern • find first("abcfoo", 3) is null

match : the pattern • find first("xxaabbcczz", 0)

assert match is_not null

assert match • begin == 2

assert match • end == 8

match2 : the pattern • find first("aaabbbAAACCCBBB", 1)

assert match2 is_not null

assert match2 • begin == 6

assert match2 • end == 12

match3 : the pattern • find first("fooACxyzABC", 0)

assert match3 is_not null

assert match3 • begin == 3

assert match3 • end == 5

test case test find first more()

pattern[character] match zero or more b : repeat element[character] • new(match b, true)

pattern[character] match one or more c : repeat element[character] • new(match c, false)

pattern[character] beta : sequence pattern[character] • new([match zero or more b, match one or more c])

match : beta • find first("aaabbbAAACCCBBB", 9)

assert match is_not null

assert match • begin == 9

assert match • end == 12

test case test split()

the pattern : make pattern()

split0 : the pattern • split("foo")

assert split0 • size == 1

assert equals(split0[0], "foo")

split1 : the pattern • split("fooACxyzABC")

assert split1 • size == 3

assert equals(split1[0], "foo")

assert equals(split1[1], "xyz")

assert equals(split1[2], "")

split2 : the pattern • split("aaabc1ac2ABC3")

assert split2 • size == 4

assert equals(split2[0], "")

assert equals(split2[1], "1")

assert equals(split2[2], "2")

assert equals(split2[3], "3")

boolean equals(immutable list[character] s0, string s1)

return (s0 !> string) == s1