def test_conc_parsing():
assert conc.parse("abcde[^fg]*h{5}[a-z]+") == conc(
mult(charclass("a"), one),
mult(charclass("b"), one),
mult(charclass("c"), one),
mult(charclass("d"), one),
mult(charclass("e"), one),
mult(~charclass("fg"), star),
mult(charclass("h"), multiplier(bound(5), bound(5))),
mult(charclass("abcdefghijklmnopqrstuvwxyz"), plus),
)
assert conc.parse("[bc]*[ab]*") == conc(
mult(charclass("bc"), star),
mult(charclass("ab"), star),
)
assert conc.parse("abc...") == conc(
mult(charclass("a"), one),
mult(charclass("b"), one),
mult(charclass("c"), one),
mult(dot, one),
mult(dot, one),
mult(dot, one),
)
assert conc.parse("\\d{4}-\\d{2}-\\d{2}") == conc(
mult(charclass("0123456789"), multiplier(bound(4), bound(4))),
mult(charclass("-"), one),
mult(charclass("0123456789"), multiplier(bound(2), bound(2))),
mult(charclass("-"), one),
mult(charclass("0123456789"), multiplier(bound(2), bound(2))),
)
def test_pattern_beheading():
# "aa".behead("a") = "a"
assert pattern.parse("aa").behead(conc.parse("a")) == pattern.parse("a")
# "abc|aa".behead("a") = "a|bc"
assert pattern.parse("abc|aa").behead(conc.parse("a")) == pattern.parse("a|bc")
# "cf{1,2}|cf".behead("c") = "f{1,2}|f" (no simplification)
assert pattern.parse("cf{1,2}|cf").behead(conc.parse("c")) == pattern.parse("f{1,2}|f")
def test_conc_parsing():
assert conc.parse("abcde[^fg]*h{5}[a-z]+") == conc(
mult(charclass("a"), one),
mult(charclass("b"), one),
mult(charclass("c"), one),
mult(charclass("d"), one),
mult(charclass("e"), one),
mult(~charclass("fg"), star),
mult(charclass("h"), multiplier(bound(5), bound(5))),
mult(charclass("abcdefghijklmnopqrstuvwxyz"), plus),
)
assert conc.parse("[bc]*[ab]*") == conc(
mult(charclass("bc"), star),
mult(charclass("ab"), star),
)
assert conc.parse("abc...") == conc(
mult(charclass("a"), one),
mult(charclass("b"), one),
mult(charclass("c"), one),
mult(dot, one),
mult(dot, one),
mult(dot, one),
)
assert conc.parse("\\d{4}-\\d{2}-\\d{2}") == conc(
mult(charclass("0123456789"), multiplier(bound(4), bound(4))),
mult(charclass("-"), one),
mult(charclass("0123456789"), multiplier(bound(2), bound(2))),
mult(charclass("-"), one),
mult(charclass("0123456789"), multiplier(bound(2), bound(2))),
)
def test_remove_unnecessary_parens():
# mult contains a pattern containing a single conc containing a single mult?
# that can be reduced greatly
assert conc.parse("(a){2}b").reduce() == conc.parse("a{2}b")
assert conc.parse("(a?)+b").reduce() == conc.parse("a*b")
assert mult.parse("([ab])*").reduce() == mult.parse("[ab]*")
assert mult.parse("(c{1,2}){3,4}").reduce() == mult.parse("c{3,8}")
def test_remove_unnecessary_parens():
# mult contains a pattern containing a single conc containing a single mult?
# that can be reduced greatly
assert conc.parse("(a){2}b").reduce() == conc.parse("a{2}b")
assert conc.parse("(a?)+b").reduce() == conc.parse("a*b")
assert mult.parse("([ab])*").reduce() == mult.parse("[ab]*")
assert mult.parse("(c{1,2}){3,4}").reduce() == mult.parse("c{3,8}")
def test_mult_factor_out_qm():
# mult contains a pattern containing an empty conc? Pull the empty
# part out where it's external
assert mult.parse("(a|b*|)").reduce() == mult.parse("(a|b*)?")
assert conc.parse("(a|b*|)c").reduce() == conc.parse("(a|b*)?c")
# This happens even if emptystring is the only thing left inside the mult
assert mult.parse("()").reduce() == conc.parse("")
assert mult.parse("([$%\\^]|){1}").reduce() == mult.parse("[$%\\^]?")
def test_conc_reduction_basic():
assert conc.parse("a[]b").reduce() == charclass.parse("[]")
# conc -> conc
assert conc.parse("ab").reduce() == conc.parse("ab")
# conc -> mult
assert conc.parse("a{3,4}").reduce() == mult.parse("a{3,4}")
# conc -> charclass
assert conc.parse("a").reduce() == charclass.parse("a")
def test_new_reduce():
# The @reduce_after decorator has been removed from many methods since it
# takes unnecessary time which the user may not wish to spend.
# This alters the behaviour of several methods and also exposes a new
# opportunity for conc.reduce()
assert conc.parse("a()").reduce() == charclass.parse("a")
assert conc.parse("a()()").reduce() == charclass.parse("a")
assert conc.parse("a.b()()").reduce() == conc.parse("a.b")
def test_mult_factor_out_qm():
# mult contains a pattern containing an empty conc? Pull the empty
# part out where it's external
assert mult.parse("(a|b*|)").reduce() == mult.parse("(a|b*)?")
assert conc.parse("(a|b*|)c").reduce() == conc.parse("(a|b*)?c")
# This happens even if emptystring is the only thing left inside the mult
assert mult.parse("()").reduce() == conc.parse("")
assert mult.parse("([$%\\^]|){1}").reduce() == mult.parse("[$%\\^]?")
def test_new_reduce():
# The @reduce_after decorator has been removed from many methods since it
# takes unnecessary time which the user may not wish to spend.
# This alters the behaviour of several methods and also exposes a new
# opportunity for conc.reduce()
assert conc.parse("a()").reduce() == charclass.parse("a")
assert conc.parse("a()()").reduce() == charclass.parse("a")
assert conc.parse("a.b()()").reduce() == conc.parse("a.b")
def test_main_bug():
assert parse("a*").reduce() == mult.parse("a*")
assert parse("a|a*").reduce() == mult.parse("a*")
assert parse("a{1,2}|a{3,4}|bc").reduce() == pattern.parse("a{1,4}|bc")
assert parse("a{1,2}|bc|a{3,4}").reduce() == pattern.parse("a{1,4}|bc")
assert parse("a{1,2}|a{3,4}|a{5,6}|bc").reduce() == pattern.parse("a{1,6}|bc")
assert parse("a{1,2}|a{3}|a{5,6}").reduce() == conc.parse("a{1,2}(a?|a{4})")
assert parse("a{1,2}|a{3}|a{5,6}|bc").reduce() == pattern.parse("a{1,3}|a{5,6}|bc")
assert parse("a{1,2}|a{4}|a{5,6}").reduce() == conc.parse("a{1,2}(a{3,4})?")
assert parse("a{1,2}|a{4}|a{5,6}|bc").reduce() == pattern.parse("a{1,2}|a{4,6}|bc")
assert (parse("a") | parse("a*")).reduce() == mult.parse("a*")
def test_pattern_beheading():
assert pattern.parse("aa").behead(conc.parse("a")) == pattern.parse("a")
assert pattern.parse("abc|aa").behead(conc.parse("a")) == pattern.parse("a|bc")
assert pattern.parse("cf{1,2}|cf").behead(conc.parse("c")) == pattern.parse("f{1,2}|f")
assert pattern.parse("aa|aa").behead(conc.parse("aa")) == pattern.parse("")
assert pattern.parse("abc|aa").behead(conc.parse("a")) == pattern.parse("a|bc")
assert pattern.parse("a|bc").behead(conc.parse("")) == pattern.parse("a|bc")
assert pattern.parse("cf{1,2}|cf").behead(conc.parse("cf")) == pattern.parse("f?|")
assert pattern.parse("ZA|ZB|ZC").behead(conc.parse("Z")) == pattern.parse("A|B|C")
assert pattern.parse("Z+A|ZB|ZZC").behead(conc.parse("Z")) == pattern.parse("Z*A|B|ZC")
assert pattern.parse("a{2}b|a+c").behead(conc.parse("a")) == pattern.parse("ab|a*c")
def test_pattern_beheading():
assert pattern.parse("aa").behead(conc.parse("a")) == pattern.parse("a")
assert pattern.parse("abc|aa").behead(conc.parse("a")) == pattern.parse("a|bc")
assert pattern.parse("cf{1,2}|cf").behead(conc.parse("c")) == pattern.parse("f{1,2}|f")
assert pattern.parse("aa|aa").behead(conc.parse("aa")) == pattern.parse("")
assert pattern.parse("abc|aa").behead(conc.parse("a")) == pattern.parse("a|bc")
assert pattern.parse("a|bc").behead(conc.parse("")) == pattern.parse("a|bc")
assert pattern.parse("cf{1,2}|cf").behead(conc.parse("cf")) == pattern.parse("f?|")
assert pattern.parse("ZA|ZB|ZC").behead(conc.parse("Z")) == pattern.parse("A|B|C")
assert pattern.parse("Z+A|ZB|ZZC").behead(conc.parse("Z")) == pattern.parse("Z*A|B|ZC")
assert pattern.parse("a{2}b|a+c").behead(conc.parse("a")) == pattern.parse("ab|a*c")
def test_main_bug():
assert parse("a*").reduce() == mult.parse("a*")
assert parse("a|a*").reduce() == mult.parse("a*")
assert parse("a{1,2}|a{3,4}|bc").reduce() == pattern.parse("a{1,4}|bc")
assert parse("a{1,2}|bc|a{3,4}").reduce() == pattern.parse("a{1,4}|bc")
assert parse("a{1,2}|a{3,4}|a{5,6}|bc").reduce() == pattern.parse("a{1,6}|bc")
assert parse("a{1,2}|a{3}|a{5,6}").reduce() == conc.parse("a{1,2}(a?|a{4})")
assert parse("a{1,2}|a{3}|a{5,6}|bc").reduce() == pattern.parse("a{1,3}|a{5,6}|bc")
assert parse("a{1,2}|a{4}|a{5,6}").reduce() == conc.parse("a{1,2}(a{3,4})?")
assert parse("a{1,2}|a{4}|a{5,6}|bc").reduce() == pattern.parse("a{1,2}|a{4,6}|bc")
assert (parse("a") | parse("a*")).reduce() == mult.parse("a*")
def test_empty():
assert nothing.empty()
assert charclass().empty()
assert not dot.empty()
assert not mult.parse("a{0}").empty()
assert mult.parse("[]").empty()
assert not mult.parse("[]?").empty()
assert conc.parse("a[]").empty()
assert not conc.parse("a[]?").empty()
assert pattern().empty()
assert not pattern.parse("a{0}").empty()
assert not pattern.parse("[]?").empty()
def test_empty():
assert nothing.empty()
assert charclass().empty()
assert not dot.empty()
assert not mult.parse("a{0}").empty()
assert mult.parse("[]").empty()
assert not mult.parse("[]?").empty()
assert conc.parse("a[]").empty()
assert not conc.parse("a[]?").empty()
assert pattern().empty()
assert not pattern.parse("a{0}").empty()
assert not pattern.parse("[]?").empty()
def test_empty_mult_suppression():
assert conc.parse("[]0\d").reduce() == charclass.parse("[]")
assert conc(
mult(pattern(), one), # this mult can never actually match anything
mult(charclass("0"), one),
mult(charclass("0123456789"), one),
).reduce() == charclass.parse("[]")
def test_empty_mult_suppression():
assert conc.parse("[]0\\d").reduce() == charclass.parse("[]")
assert conc(
mult(pattern(), one), # this mult can never actually match anything
mult(charclass("0"), one),
mult(charclass("0123456789"), one),
).reduce() == charclass.parse("[]")
def test_pattern_commonconc():
assert pattern.parse("aa|aa")._commonconc() == conc.parse("aa")
assert pattern.parse("abc|aa")._commonconc() == conc.parse("a")
assert pattern.parse("a|bc")._commonconc() == conc.parse("")
assert pattern.parse("cf{1,2}|cf")._commonconc() == conc.parse("cf")
assert pattern.parse("ZA|ZB|ZC")._commonconc() == conc.parse("Z")
assert pattern.parse("Z+A|ZB|ZZC")._commonconc() == conc.parse("Z")
assert pattern.parse("a{2}b|a+c")._commonconc() == conc.parse("a")
def test_pattern_commonconc():
assert pattern.parse("aa|aa")._commonconc() == conc.parse("aa")
assert pattern.parse("abc|aa")._commonconc() == conc.parse("a")
assert pattern.parse("a|bc")._commonconc() == conc.parse("")
assert pattern.parse("cf{1,2}|cf")._commonconc() == conc.parse("cf")
assert pattern.parse("ZA|ZB|ZC")._commonconc() == conc.parse("Z")
assert pattern.parse("Z+A|ZB|ZZC")._commonconc() == conc.parse("Z")
assert pattern.parse("a{2}b|a+c")._commonconc() == conc.parse("a")
def test_pattern_reduce_basic():
# pattern -> pattern
# (ab|cd) -> (ab|cd)
assert pattern.parse("ab|cd").reduce() == pattern.parse("ab|cd")
# pattern -> conc
assert pattern.parse("a{2}b{2}").reduce() == conc.parse("a{2}b{2}")
# pattern -> mult
assert pattern.parse("a{2}").reduce() == mult.parse("a{2}")
# pattern -> charclass
assert pattern.parse("a").reduce() == charclass.parse("a")
def test_conc_generator():
gen = conc.parse("[ab][cd]").strings()
assert next(gen) == "ac"
assert next(gen) == "ad"
assert next(gen) == "bc"
assert next(gen) == "bd"
try:
next(gen)
assert False
except StopIteration:
assert True
def test_conc_generator():
gen = conc.parse("[ab][cd]").strings()
assert next(gen) == "ac"
assert next(gen) == "ad"
assert next(gen) == "bc"
assert next(gen) == "bd"
try:
next(gen)
assert False
except StopIteration:
assert True
def test_mult_intersection():
assert mult.parse("a") & mult.parse("b?") == charclass()
assert mult.parse("a") & mult.parse("b?") == nothing
assert mult.parse("a") & mult.parse("a?") == charclass.parse("a")
assert mult.parse("a{2}") & mult.parse("a{2,}") == mult.parse("a{2}")
assert mult.parse("a") & mult.parse("b") == charclass.parse("[]")
assert mult.parse("a") & mult.parse("a") == charclass.parse("a")
assert mult.parse("a*") & mult.parse("a") == charclass.parse("a")
assert mult.parse("a*") & mult.parse("b*") == conc.parse("")
assert mult.parse("a*") & mult.parse("a+") == mult.parse("a+")
assert mult.parse("a{2}") & mult.parse("a{4}") == charclass.parse("[]")
assert mult.parse("a{3,}") & mult.parse("a{3,}") == mult.parse("a{3,}")
def test_mult_intersection():
assert mult.parse("a") & mult.parse("b?") == charclass()
assert mult.parse("a") & mult.parse("b?") == nothing
assert mult.parse("a") & mult.parse("a?") == charclass.parse("a")
assert mult.parse("a{2}") & mult.parse("a{2,}") == mult.parse("a{2}")
assert mult.parse("a") & mult.parse("b") == charclass.parse("[]")
assert mult.parse("a") & mult.parse("a") == charclass.parse("a")
assert mult.parse("a*") & mult.parse("a") == charclass.parse("a")
assert mult.parse("a*") & mult.parse("b*") == conc.parse("")
assert mult.parse("a*") & mult.parse("a+") == mult.parse("a+")
assert mult.parse("a{2}") & mult.parse("a{4}") == charclass.parse("[]")
assert mult.parse("a{3,}") & mult.parse("a{3,}") == mult.parse("a{3,}")
def test_pattern_commonconc_suffix():
# pattern._commonconc(suffix=True) tests
# a | bc -> emptystring
assert pattern.parse("a|bc")._commonconc(suffix=True) == conc.parse("")
# (a|bc) - () = (a|bc)
assert pattern.parse("a|bc") - conc.parse("") == pattern.parse("a|bc")
# (aa|bca) -> a
assert pattern.parse("aa|bca")._commonconc(suffix=True) == conc.parse("a")
# (aa|bca) - a = (a|bc)
assert pattern.parse("aa|bca") - conc.parse("a") == pattern.parse("a|bc")
# xyza | abca | a -> a
assert pattern.parse("xyza|abca|a")._commonconc(suffix=True) == conc.parse("a")
# (xyza|abca|a) - a = (xyz|abc|)
assert pattern.parse("xyza|abca|a") - conc.parse("a") == pattern.parse("xyz|abc|")
# f{2,3}c, fc -> fc
assert pattern.parse("f{2,3}c|fc")._commonconc(suffix=True) == conc.parse("fc")
# (f{2,3}c|fc) - fc = (f{1,2}|)
assert pattern.parse("f{2,3}c|fc") - conc.parse("fc") == pattern.parse("f{1,2}|")
# (aa) -> aa
assert pattern.parse("aa")._commonconc(suffix=True) == conc.parse("aa")
# (aa) - aa = ()
assert pattern.parse("aa") - conc.parse("aa") == pattern.parse("")
def test_mult_intersection():
# a & b? = nothing
assert mult.parse("a") & mult.parse("b?") == charclass()
assert mult.parse("a") & mult.parse("b?") == nothing
# a & a? = nothing
assert mult.parse("a").reduce() == charclass.parse("a")
assert mult.parse("a") & mult.parse("a?") == charclass.parse("a")
# a{2} & a{2,} = a{2}
assert mult.parse("a{2}") & mult.parse("a{2,}") == mult.parse("a{2}")
# a & b -> no intersection.
assert mult.parse("a") & mult.parse("b") == charclass.parse("[]")
# a & a -> a
assert mult.parse("a") & mult.parse("a") == charclass.parse("a")
# a* & a -> a
assert mult.parse("a*") & mult.parse("a") == charclass.parse("a")
# a* & b* -> emptystring
assert mult.parse("a*") & mult.parse("b*") == conc.parse("")
# a* & a+ -> a+
assert mult.parse("a*") & mult.parse("a+") == mult.parse("a+")
# aa & aaaa -> []
assert mult.parse("a{2}") & mult.parse("a{4}") == charclass.parse("[]")
# a{3,4} & a{2,5} -> a{2,3}
assert mult.parse("a{3,4}").common(mult.parse("a{2,5}")) == mult.parse("a{2,3}")
# a{2,} & a{1,5} -> a{1,5}
assert mult.parse("a{2,}").common(mult.parse("a{1,5}")) == mult.parse("a{1,5}")
# a{3,}, a{2,} -> a{2,} (with a, epsilon left over)
assert mult.parse("a{3,}").common(mult.parse("a{2,}")) == mult.parse("a{2,}")
# a{3,}, a{3,} -> a{3,} (with inf, inf left over)
assert mult.parse("a{3,}") & mult.parse("a{3,}") == mult.parse("a{3,}")
def test_empty_pattern_suppression():
assert mult.parse("[]?").reduce() == conc.parse("")
assert mult(pattern(), qm).reduce() == conc.parse("")
def test_nested_pattern_reduction():
# a(d(ab|a*c)) -> ad(ab|a*c)
assert conc.parse("a(d(ab|a*c))").reduce() == conc.parse("ad(ab|a*c)")
def test_reduce_concatenations():
assert parse("aa").reduce() == mult.parse("a{2}")
assert parse("bb").reduce() == mult.parse("b{2}")
assert parse("b*b").reduce() == mult.parse("b+")
assert parse("aa{2,}").reduce() == mult.parse("a{3,}")
assert parse("a*a{2}").reduce() == mult.parse("a{2,}")
assert parse("aa{0,8}").reduce() == mult.parse("a{1,9}")
assert parse("b{0,8}b").reduce() == mult.parse("b{1,9}")
assert parse("aab").reduce() == conc.parse("a{2}b")
assert parse("abb").reduce() == conc.parse("ab{2}")
assert parse("abb*").reduce() == conc.parse("ab+")
assert parse("abbc").reduce() == conc.parse("ab{2}c")
assert parse("a?ab").reduce() == conc.parse("a{1,2}b")
assert parse("(ac{2}|bc+)c").reduce() == conc.parse("(ac|bc*)c{2}")
assert parse("a(a{2}b|a+c)").reduce() == conc.parse("a{2}(ab|a*c)")
assert parse("a{2,3}(a{2}b|a+c)").reduce() == conc.parse("a{3,4}(ab|a*c)")
assert parse("(ba{2}|ca+)a{2,3}").reduce() == conc.parse("(ba|ca*)a{3,4}")
assert parse("za{2,3}(a{2}b|a+c)").reduce() == conc.parse("za{3,4}(ab|a*c)")
assert parse("(ba{2}|ca+)a{2,3}z").reduce() == conc.parse("(ba|ca*)a{3,4}z")
assert parse("(a|bc)(a|bc)").reduce() == mult.parse("(a|bc){2}")
def test_conc_common():
assert conc.parse("AAZY").common(conc.parse("BBZY"), suffix=True) == conc.parse("ZY")
assert conc.parse("CZ").common(conc.parse("CZ"), suffix=True) == conc.parse("CZ")
assert conc.parse("CY").common(conc.parse("CZ"), suffix=True) == conc.parse("")
assert conc.parse("AZ").common(conc.parse("BZ"), suffix=True) == conc.parse("Z")
assert conc.parse("AZ*").common(conc.parse("BZ"), suffix=True) == conc.parse("")
assert conc.parse("A").common(conc.parse("B"), suffix=True) == conc.parse("")
def test_mult_squoosh():
# sequence squooshing of mults within a conc
assert conc.parse("[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]").reduce() == mult.parse("[0-9A-Fa-f]{3}")
assert conc.parse("[$%\\^]?[$%\\^]").reduce() == mult.parse("[$%\\^]{1,2}")
assert conc.parse("(|(|(|(|(|(|[$%\^])[$%\^])[$%\^])[$%\^])[$%\^])[$%\^])[$%\^][$%\^]").reduce() == mult.parse("[$%\^]{2,8}")
def test_common_prefix_pattern_reduction():
assert pattern.parse("a{2}b|a+c").reduce() == conc.parse("a(ab|a*c)")
def test_conc_multiplication():
assert conc.parse("ab?") * qm == mult.parse("(ab?)?")
def test_reduce_concatenations():
assert parse("aa").reduce() == mult.parse("a{2}")
assert parse("bb").reduce() == mult.parse("b{2}")
assert parse("b*b").reduce() == mult.parse("b+")
assert parse("aa{2,}").reduce() == mult.parse("a{3,}")
assert parse("a*a{2}").reduce() == mult.parse("a{2,}")
assert parse("aa{0,8}").reduce() == mult.parse("a{1,9}")
assert parse("b{0,8}b").reduce() == mult.parse("b{1,9}")
assert parse("aab").reduce() == conc.parse("a{2}b")
assert parse("abb").reduce() == conc.parse("ab{2}")
assert parse("abb*").reduce() == conc.parse("ab+")
assert parse("abbc").reduce() == conc.parse("ab{2}c")
assert parse("a?ab").reduce() == conc.parse("a{1,2}b")
assert parse("(ac{2}|bc+)c").reduce() == conc.parse("(ac|bc*)c{2}")
assert parse("a(a{2}b|a+c)").reduce() == conc.parse("a{2}(ab|a*c)")
assert parse("a{2,3}(a{2}b|a+c)").reduce() == conc.parse("a{3,4}(ab|a*c)")
assert parse("(ba{2}|ca+)a{2,3}").reduce() == conc.parse("(ba|ca*)a{3,4}")
assert parse("za{2,3}(a{2}b|a+c)").reduce() == conc.parse("za{3,4}(ab|a*c)")
assert parse("(ba{2}|ca+)a{2,3}z").reduce() == conc.parse("(ba|ca*)a{3,4}z")
assert parse("(a|bc)(a|bc)").reduce() == mult.parse("(a|bc){2}")
def test_pattern_dock():
assert pattern.parse("a|bc").dock(conc.parse("")) == pattern.parse("a|bc")
assert pattern.parse("aa|bca").dock(conc.parse("a")) == pattern.parse("a|bc")
assert pattern.parse("xyza|abca|a").dock(conc.parse("a")) == pattern.parse("xyz|abc|")
assert pattern.parse("f{2,3}c|fc").dock(conc.parse("fc")) == pattern.parse("f{1,2}|")
assert pattern.parse("aa").dock(conc.parse("aa")) == pattern.parse("")
def test_conc_dock():
assert conc.parse("AZ").dock(conc.parse("Z")) == conc.parse("A")
assert conc.parse("ABXY+Z").dock(conc.parse("XY+Z")) == conc.parse("AB")
assert conc.parse("ABXY+Z").behead(conc.parse("ABXY+")) == conc.parse("Z")
assert conc.parse("A").dock(conc.parse("")) == conc.parse("A")
try:
conc.parse("X{2}Y+Z").behead(conc.parse("XY+"))
assert False
except AssertionError:
assert False
except Exception:
pass
def test_pattern_reduce_basic():
assert pattern.parse("ab|cd").reduce() == pattern.parse("ab|cd")
assert pattern.parse("a{2}b{2}").reduce() == conc.parse("a{2}b{2}")
assert pattern.parse("a{2}").reduce() == mult.parse("a{2}")
assert pattern.parse("a").reduce() == charclass.parse("a")
def test_conc_dock():
assert conc.parse("AZ").dock(conc.parse("Z")) == conc.parse("A")
assert conc.parse("ABXY+Z").dock(conc.parse("XY+Z")) == conc.parse("AB")
assert conc.parse("ABXY+Z").behead(conc.parse("ABXY+")) == conc.parse("Z")
assert conc.parse("A").dock(conc.parse("")) == conc.parse("A")
try:
conc.parse("X{2}Y+Z").behead(conc.parse("XY+"))
assert False
except AssertionError:
assert False
except Exception:
pass
def test_concatenation():
# empty conc + empty conc
assert conc.parse("") + conc.parse("") == conc.parse("")
# charclass + charclass
# a + b = ab
assert charclass.parse("a") + charclass.parse("b") == conc.parse("ab")
# a + a = a{2}
assert (charclass.parse("a") + charclass.parse("a")).reduce() == mult.parse("a{2}")
# charclass + mult
# a + a = a{2}
assert (charclass.parse("a") + mult.parse("a")).reduce() == mult.parse("a{2}")
# a + a{2,} = a{3,}
assert (charclass.parse("a") + mult.parse("a{2,}")).reduce() == mult.parse("a{3,}")
# a + a{,8} = a{1,9}
assert (charclass.parse("a") + mult.parse("a{0,8}")).reduce() == mult.parse("a{1,9}")
# a + b{,8} = ab{,8}
assert charclass.parse("a") + mult.parse("b{0,8}") == conc.parse("ab{0,8}")
# mult + charclass
# b + b = b{2}
assert (mult.parse("b") + charclass.parse("b")).reduce() == mult.parse("b{2}")
# b* + b = b+
assert (mult.parse("b*") + charclass.parse("b")).reduce() == mult.parse("b+")
# b{,8} + b = b{1,9}
assert (mult.parse("b{0,8}") + charclass.parse("b")).reduce() == mult.parse("b{1,9}")
# b{,8} + c = b{,8}c
assert mult.parse("b{0,8}") + charclass.parse("c") == conc.parse("b{0,8}c")
# charclass + conc
# a + nothing = a
assert (charclass.parse("a") + conc.parse("")).reduce() == charclass.parse("a")
# a + bc = abc
assert charclass.parse("a") + conc.parse("bc") == conc.parse("abc")
# a + ab = a{2}b
assert (charclass.parse("a") + conc.parse("ab")).reduce() == conc.parse("a{2}b")
# conc + charclass
# nothing + a = a
assert (conc.parse("") + charclass.parse("a")).reduce() == charclass.parse("a")
# ab + c = abc
assert conc.parse("ab") + charclass.parse("c") == conc.parse("abc")
# ab + b = ab{2}
assert (conc.parse("ab") + charclass.parse("b")).reduce() == conc.parse("ab{2}")
# pattern + charclass
# (a|bd) + c = (a|bd)c
assert pattern.parse("a|bd") + charclass.parse("c") == conc.parse("(a|bd)c")
# (ac{2}|bc+) + c = (ac|bc*)c{2}
assert (pattern.parse("ac{2}|bc+") + charclass.parse("c")).reduce() == conc.parse("(ac|bc*)c{2}")
# charclass + pattern
# a + (b|cd) = a(b|cd)
assert charclass.parse("a") + pattern.parse("b|cd") == conc.parse("a(b|cd)")
# a + (a{2}b|a+c) = a{2}(ab|a*c)
assert (charclass.parse("a") + pattern.parse("(a{2}b|a+c)")).reduce() == conc.parse("a{2}(ab|a*c)")
# mult + mult
# a{3,4} + b? = a{3,4}b?
assert mult.parse("a{3,4}") + mult.parse("b?") == conc.parse("a{3,4}b?")
# a* + a{2} = a{2,}
assert (mult.parse("a*") + mult.parse("a{2}")).reduce() == mult.parse("a{2,}")
# mult + conc
# a{2} + bc = a{2}bc
assert mult.parse("a{2}") + conc.parse("bc") == conc.parse("a{2}bc")
# a? + ab = a{1,2}b
assert (mult.parse("a?") + conc.parse("ab")).reduce() == conc.parse("a{1,2}b")
# conc + mult
# ab + c* = abc*
assert conc.parse("ab") + mult.parse("c*") == conc.parse("abc*")
# ab + b* = ab+
assert (conc.parse("ab") + mult.parse("b*")).reduce() == conc.parse("ab+")
# mult + pattern
# a{2,3} + (b|cd) = a{2,3}(b|cd)
assert mult.parse("a{2,3}") + pattern.parse("b|cd") == conc.parse("a{2,3}(b|cd)")
# a{2,3} + (a{2}b|a+c) = a{3,4}(ab|a*c)
assert (mult.parse("a{2,3}") + pattern.parse("a{2}b|a+c")).reduce() == conc.parse("a{3,4}(ab|a*c)")
# pattern + mult
# (b|cd) + a{2,3} = (b|cd)a{2,3}
assert pattern.parse("b|cd") + mult.parse("a{2,3}") == conc.parse("(b|cd)a{2,3}")
# (ba{2}|ca+) + a{2,3} = (ba|ca*)a{3,4}
assert (pattern.parse("ba{2}|ca+") + mult.parse("a{2,3}")).reduce() == conc.parse("(ba|ca*)a{3,4}")
# conc + conc
# ab + cd = abcd
assert conc.parse("ab") + conc.parse("cd") == conc.parse("abcd")
# ab + bc = ab{2}c
assert (conc.parse("ab") + conc.parse("bc")).reduce() == conc.parse("ab{2}c")
# conc + pattern
# za{2,3} + (b|cd) = za{2,3}(b|cd)
assert conc.parse("za{2,3}") + pattern.parse("b|cd") == conc.parse("za{2,3}(b|cd)")
# za{2,3} + (a{2}b|a+c) = za{3,4}(ab|a*c)
assert (conc.parse("za{2,3}") + pattern.parse("a{2}b|a+c")).reduce() == conc.parse("za{3,4}(ab|a*c)")
# pattern + conc
# (b|cd) + za{2,3} = (b|cd)za{2,3}
assert pattern.parse("b|cd") + conc.parse("za{2,3}") == conc.parse("(b|cd)za{2,3}")
# (ba{2}|ca+) + a{2,3}z = (ba|ca*)a{3,4}z
assert (pattern.parse("ba{2}|ca+") + conc.parse("a{2,3}z")).reduce() == conc.parse("(ba|ca*)a{3,4}z")
# pattern + pattern
# (a|bc) + (c|de) = (a|bc)(c|de)
assert pattern.parse("a|bc") + pattern.parse("c|de") == conc.parse("(a|bc)(c|de)")
# (a|bc) + (a|bc) = (a|bc){2}
assert (pattern.parse("a|bc") + pattern.parse("a|bc")).reduce() == mult.parse("(a|bc){2}")
def test_mult_squoosh():
# sequence squooshing of mults within a conc
assert conc.parse("[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]").reduce() == mult.parse("[0-9A-Fa-f]{3}")
assert conc.parse("[$%\\^]?[$%\\^]").reduce() == mult.parse("[$%\\^]{1,2}")
assert conc.parse("(|(|(|(|(|(|[$%\\^])[$%\\^])[$%\\^])[$%\\^])[$%\\^])[$%\\^])[$%\\^][$%\\^]").reduce() == mult.parse("[$%\\^]{2,8}")
def test_concatenation():
assert charclass.parse("a") + charclass.parse("b") == conc.parse("ab")
assert charclass.parse("a") + mult.parse("b{0,8}") == conc.parse("ab{0,8}")
assert charclass.parse("a") + conc.parse("bc") == conc.parse("abc")
assert charclass.parse("a") + pattern.parse("b|cd") == conc.parse("a(b|cd)")
assert mult.parse("b{0,8}") + charclass.parse("c") == conc.parse("b{0,8}c")
assert mult.parse("a{3,4}") + mult.parse("b?") == conc.parse("a{3,4}b?")
assert mult.parse("a{2}") + conc.parse("bc") == conc.parse("a{2}bc")
assert mult.parse("a{2,3}") + pattern.parse("b|cd") == conc.parse("a{2,3}(b|cd)")
assert conc.parse("ab") + charclass.parse("c") == conc.parse("abc")
assert conc.parse("ab") + mult.parse("c*") == conc.parse("abc*")
assert conc.parse("") + conc.parse("") == conc.parse("")
assert conc.parse("ab") + conc.parse("cd") == conc.parse("abcd")
assert conc.parse("za{2,3}") + pattern.parse("b|cd") == conc.parse("za{2,3}(b|cd)")
assert pattern.parse("a|bd") + charclass.parse("c") == conc.parse("(a|bd)c")
assert pattern.parse("b|cd") + mult.parse("a{2,3}") == conc.parse("(b|cd)a{2,3}")
assert pattern.parse("b|cd") + conc.parse("za{2,3}") == conc.parse("(b|cd)za{2,3}")
assert pattern.parse("a|bc") + pattern.parse("c|de") == conc.parse("(a|bc)(c|de)")
def test_reduce_boom():
# make sure recursion problem in reduce() has gone away
assert conc.parse("([1-9]|0)").reduce() == d
def test_nested_pattern_reduction():
# a(d(ab|a*c)) -> ad(ab|a*c)
assert conc.parse("a(d(ab|a*c))").reduce() == conc.parse("ad(ab|a*c)")
def test_common_prefix_pattern_reduction():
assert pattern.parse("a{2}b|a+c").reduce() == conc.parse("a(ab|a*c)")
def test_pattern_reduce_basic():
assert pattern.parse("ab|cd").reduce() == pattern.parse("ab|cd")
assert pattern.parse("a{2}b{2}").reduce() == conc.parse("a{2}b{2}")
assert pattern.parse("a{2}").reduce() == mult.parse("a{2}")
assert pattern.parse("a").reduce() == charclass.parse("a")
def test_conc_multiplication():
assert conc.parse("ab?") * qm == mult.parse("(ab?)?")
def test_concatenation():
assert charclass.parse("a") + charclass.parse("b") == conc.parse("ab")
assert charclass.parse("a") + mult.parse("b{0,8}") == conc.parse("ab{0,8}")
assert charclass.parse("a") + conc.parse("bc") == conc.parse("abc")
assert charclass.parse("a") + pattern.parse("b|cd") == conc.parse("a(b|cd)")
assert mult.parse("b{0,8}") + charclass.parse("c") == conc.parse("b{0,8}c")
assert mult.parse("a{3,4}") + mult.parse("b?") == conc.parse("a{3,4}b?")
assert mult.parse("a{2}") + conc.parse("bc") == conc.parse("a{2}bc")
assert mult.parse("a{2,3}") + pattern.parse("b|cd") == conc.parse("a{2,3}(b|cd)")
assert conc.parse("ab") + charclass.parse("c") == conc.parse("abc")
assert conc.parse("ab") + mult.parse("c*") == conc.parse("abc*")
assert conc.parse("") + conc.parse("") == conc.parse("")
assert conc.parse("ab") + conc.parse("cd") == conc.parse("abcd")
assert conc.parse("za{2,3}") + pattern.parse("b|cd") == conc.parse("za{2,3}(b|cd)")
assert pattern.parse("a|bd") + charclass.parse("c") == conc.parse("(a|bd)c")
assert pattern.parse("b|cd") + mult.parse("a{2,3}") == conc.parse("(b|cd)a{2,3}")
assert pattern.parse("b|cd") + conc.parse("za{2,3}") == conc.parse("(b|cd)za{2,3}")
assert pattern.parse("a|bc") + pattern.parse("c|de") == conc.parse("(a|bc)(c|de)")
def test_conc_common():
assert conc.parse("AAZY").common(conc.parse("BBZY"), suffix=True) == conc.parse("ZY")
assert conc.parse("CZ").common(conc.parse("CZ"), suffix=True) == conc.parse("CZ")
assert conc.parse("CY").common(conc.parse("CZ"), suffix=True) == conc.parse("")
assert conc.parse("AZ").common(conc.parse("BZ"), suffix=True) == conc.parse("Z")
assert conc.parse("AZ*").common(conc.parse("BZ"), suffix=True) == conc.parse("")
assert conc.parse("A").common(conc.parse("B"), suffix=True) == conc.parse("")
def test_conc_reduction_basic():
assert conc.parse("a").reduce() == charclass.parse("a")
assert conc.parse("a{3,4}").reduce() == mult.parse("a{3,4}")
assert conc.parse("ab").reduce() == conc.parse("ab")
assert conc.parse("a[]b").reduce() == charclass.parse("[]")
def test_pattern_commonconc_suffix():
assert pattern.parse("a|bc")._commonconc(suffix=True) == conc.parse("")
assert pattern.parse("aa|bca")._commonconc(suffix=True) == conc.parse("a")
assert pattern.parse("xyza|abca|a")._commonconc(suffix=True) == conc.parse("a")
assert pattern.parse("f{2,3}c|fc")._commonconc(suffix=True) == conc.parse("fc")
assert pattern.parse("aa")._commonconc(suffix=True) == conc.parse("aa")
def test_reduce_boom():
# make sure recursion problem in reduce() has gone away
assert conc.parse("([1-9]|0)").reduce() == d
def test_pattern_dock():
assert pattern.parse("a|bc").dock(conc.parse("")) == pattern.parse("a|bc")
assert pattern.parse("aa|bca").dock(conc.parse("a")) == pattern.parse("a|bc")
assert pattern.parse("xyza|abca|a").dock(conc.parse("a")) == pattern.parse("xyz|abc|")
assert pattern.parse("f{2,3}c|fc").dock(conc.parse("fc")) == pattern.parse("f{1,2}|")
assert pattern.parse("aa").dock(conc.parse("aa")) == pattern.parse("")
def test_pattern_commonconc_suffix():
assert pattern.parse("a|bc")._commonconc(suffix=True) == conc.parse("")
assert pattern.parse("aa|bca")._commonconc(suffix=True) == conc.parse("a")
assert pattern.parse("xyza|abca|a")._commonconc(suffix=True) == conc.parse("a")
assert pattern.parse("f{2,3}c|fc")._commonconc(suffix=True) == conc.parse("fc")
assert pattern.parse("aa")._commonconc(suffix=True) == conc.parse("aa")
