ideal • runtime • patterns • test_procedure

private boolean test predicate(character c) pure

return c == 'a' || c == 'b' || c == 'c'

private string as string(readonly list[character] char list)

return char list • frozen copy() !> string

matcher[character, string] make matcher()

return procedure matcher[character, string] • new(repeat element[character] • new(test predicate, false), as string)

test case test match()

the matcher : make matcher()

assert the matcher("a")

assert the matcher("ab")

assert the matcher("abca")

assert !the matcher("")

assert !the matcher("abcda")

assert !the matcher("y")

assert !the matcher("xab")

assert the matcher • parse("a") == "a"

assert the matcher • parse("ab") == "ab"

assert the matcher • parse("abca") == "abca"

test case test viable prefix()

the pattern : make matcher()

assert the pattern • is viable prefix("")

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

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

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

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

test case test match prefix()

the pattern : make matcher()

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

assert the pattern • match prefix("a") == 1

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

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

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

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

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

test case test find first()

the pattern : make matcher()

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

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

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

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

assert match is_not null

assert match • begin == 0

assert match • end == 1

match2 : the pattern • find first("-abc-", 0)

assert match2 is_not null

assert match2 • begin == 1

assert match2 • end == 4

match3 : the pattern • find first("ayzzybacy", 2)

assert match3 is_not null

assert match3 • begin == 5

assert match3 • end == 8

test case test split()

the pattern : make matcher()

split0 : the pattern • split("foo")

assert split0 • size == 1

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

split1 : the pattern • split("fooabcxyzc")

assert split1 • size == 3

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

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

assert equals(split1[2], "")

split2 : the pattern • split("ab1bc2ca3")

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