def test_addbug():
# Odd bug with fsm.__add__(), exposed by "[bc]*c"
int5A = FSM(
alphabet = {"a", "b", "c", anything_else},
states = {0, 1},
initial = 1,
finals = {1},
map = {
0: {anything_else: 0, "a": 0, "b": 0, "c": 0},
1: {anything_else: 0, "a": 0, "b": 1, "c": 1},
}
)
assert int5A.accepts("")
int5B = FSM(
alphabet = {"a", "b", "c", anything_else},
states = {0, 1, 2},
initial = 1,
finals = {0},
map = {
0: {anything_else: 2, "a": 2, "b": 2, "c": 2},
1: {anything_else: 2, "a": 2, "b": 2, "c": 0},
2: {anything_else: 2, "a": 2, "b": 2, "c": 2},
}
)
assert int5B.accepts("c")
int5C = int5A + int5B
assert int5C.accepts("c")
def test_dead_default():
'''
You may now omit a transition, or even an entire state, from the map. This
affects every usage of `fsm.map`.
'''
blockquote = FSM(
alphabet = {"/", "*", anything_else},
states = {0, 1, 2, 3, 4, 5},
initial = 0,
finals = {4},
map = {
0 : {"/" : 1},
1 : {"*" : 2},
2 : {"/" : 2, anything_else : 2, "*" : 3},
3 : {"/" : 4, anything_else : 2, "*" : 3},
}
)
assert blockquote.accepts(["/", "*", "whatever", "*", "/"])
assert not blockquote.accepts(["*", "*", "whatever", "*", "/"])
str(blockquote) # test stringification
blockquote | blockquote
blockquote & blockquote
blockquote ^ blockquote
reversed(blockquote)
assert not blockquote.everythingbut().accepts(["/", "*", "whatever", "*", "/"])
assert blockquote.everythingbut().accepts(["*"]) # deliberately seek oblivion
assert blockquote.islive(3)
assert blockquote.islive(4)
assert not blockquote.islive(5)
gen = blockquote.strings()
assert next(gen) == ["/", "*", "*", "/"]
def test_bug_36():
etc1 = FSM(
alphabet = {anything_else},
states = {0},
initial = 0,
finals = {0},
map = {
0: {
anything_else: 0
}
}
)
etc2 = FSM(
alphabet = {'s', anything_else},
states = {0, 1},
initial = 0,
finals = {1},
map = {
0: {
's': 1
},
1: {
's': 1,
anything_else: 1
}
}
)
both = etc1 & etc2
assert etc1.accepts(["s"])
assert etc2.accepts(["s"])
assert both.alphabet == {anything_else, "s"}
assert both.accepts(["s"])
def test_star_advanced():
# This is (a*ba)*. Naively connecting the final states to the initial state
# gives the incorrect result here.
starred = FSM(
alphabet = {"a", "b"},
states = {0, 1, 2, "oblivion"},
initial = 0,
finals = {2},
map = {
0 : {"a" : 0 , "b" : 1 },
1 : {"a" : 2 , "b" : "oblivion"},
2 : {"a" : "oblivion", "b" : "oblivion"},
"oblivion" : {"a" : "oblivion", "b" : "oblivion"},
}
).star()
assert starred.alphabet == frozenset(["a", "b"])
assert starred.accepts("")
assert not starred.accepts("a")
assert not starred.accepts("b")
assert not starred.accepts("aa")
assert starred.accepts("ba")
assert starred.accepts("aba")
assert starred.accepts("aaba")
assert not starred.accepts("aabb")
assert starred.accepts("abababa")
def test_anything_else_acceptance():
a = FSM(
alphabet = {"a", "b", "c", anything_else},
states = {1},
initial = 1,
finals = {1},
map = {
1 : {"a" : 1, "b" : 1, "c" : 1, anything_else : 1}
},
)
assert a.accepts("d")
def test_bug_28():
# This is (ab*)* and it caused some defects.
abstar = FSM(
alphabet = {'a', 'b'},
states = {0, 1},
initial = 0,
finals = {1},
map = {
0: {'a': 1},
1: {'b': 1}
}
)
assert abstar.accepts("a")
assert not abstar.accepts("b")
assert abstar.accepts("ab")
assert abstar.accepts("abb")
abstarstar = abstar.star()
assert abstarstar.accepts("a")
assert not abstarstar.accepts("b")
assert abstarstar.accepts("ab")
assert not abstar.star().accepts("bb")
def test_reverse_brzozowski():
# This is (a|b)*a(a|b)
brzozowski = FSM(
alphabet = {"a", "b"},
states = {"A", "B", "C", "D", "E"},
initial = "A",
finals = {"C", "E"},
map = {
"A" : {"a" : "B", "b" : "D"},
"B" : {"a" : "C", "b" : "E"},
"C" : {"a" : "C", "b" : "E"},
"D" : {"a" : "B", "b" : "D"},
"E" : {"a" : "B", "b" : "D"},
},
)
assert brzozowski.accepts("aa")
assert brzozowski.accepts("ab")
assert brzozowski.accepts("aab")
assert brzozowski.accepts("bab")
assert brzozowski.accepts("abbbbbbbab")
assert not brzozowski.accepts("")
assert not brzozowski.accepts("a")
assert not brzozowski.accepts("b")
assert not brzozowski.accepts("ba")
assert not brzozowski.accepts("bb")
assert not brzozowski.accepts("bbbbbbbbbbbb")
# So this is (a|b)a(a|b)*
b2 = reversed(brzozowski)
assert b2.accepts("aa")
assert b2.accepts("ba")
assert b2.accepts("baa")
assert b2.accepts("bab")
assert b2.accepts("babbbbbbba")
assert not b2.accepts("")
assert not b2.accepts("a")
assert not b2.accepts("b")
assert not b2.accepts("ab")
assert not b2.accepts("bb")
assert not b2.accepts("bbbbbbbbbbbb")
# Test string generator functionality.
gen = b2.strings()
assert next(gen) == ["a", "a"]
assert next(gen) == ["b", "a"]
assert next(gen) == ["a", "a", "a"]
assert next(gen) == ["a", "a", "b"]
assert next(gen) == ["b", "a", "a"]
assert next(gen) == ["b", "a", "b"]
assert next(gen) == ["a", "a", "a", "a"]
def test_binary_3():
# Binary numbers divisible by 3.
# Disallows the empty string
# Allows "0" on its own, but not leading zeroes.
div3 = FSM(
alphabet = {"0", "1"},
states = {"initial", "zero", 0, 1, 2, None},
initial = "initial",
finals = {"zero", 0},
map = {
"initial" : {"0" : "zero", "1" : 1 },
"zero" : {"0" : None , "1" : None},
0 : {"0" : 0 , "1" : 1 },
1 : {"0" : 2 , "1" : 0 },
2 : {"0" : 1 , "1" : 2 },
None : {"0" : None , "1" : None},
},
)
assert not div3.accepts("")
assert div3.accepts("0")
assert not div3.accepts("1")
assert not div3.accepts("00")
assert not div3.accepts("01")
assert not div3.accepts("10")
assert div3.accepts("11")
assert not div3.accepts("000")
assert not div3.accepts("001")
assert not div3.accepts("010")
assert not div3.accepts("011")
assert not div3.accepts("100")
assert not div3.accepts("101")
assert div3.accepts("110")
assert not div3.accepts("111")
assert not div3.accepts("0000")
assert not div3.accepts("0001")
assert not div3.accepts("0010")
assert not div3.accepts("0011")
assert not div3.accepts("0100")
assert not div3.accepts("0101")
assert not div3.accepts("0110")
assert not div3.accepts("0111")
assert not div3.accepts("1000")
assert div3.accepts("1001")
