def test_error_det(self):
A = ssfsm.Machine(0)
A[0]['ab'] = A[1]
A[1]['a'] = A[0]
B = ssfsm.Machine(0)
B[0]['ab'] = B[1]
B[1]['ab'] = B[0]
with self.assertRaises(ValueError):
A & B
def setUp(self):
m = ssfsm.Machine()
m.One['ab'] = m.Two
m.Two['a'] = m.One
m.Two['b'] = m.Two
m().alphabet = 'abc'
self.m1 = m
m = ssfsm.Machine()
m.One['ab'] = m.Two
m.Two['a'] = m.One
m.Two['b'] = m.Two
m().alphabet = 'abc'
self.m2 = m
def test_concatenation(self):
import re
B = ssfsm.Machine(0) # B has aa
B[0]['a'] = B[1]
B[0]['b'] = B[0]
B[1]['a'] = B[2]
B[1]['b'] = B[0]
B[2] = True
B[2]['ab'] = B[2]
cat = B + B
self.assertTrue(len(cat) <= len(B) + 2**len(B))
fitting_regex = r"^.*(aa)+.*(aa).*$"
for word in all_words(B().alphabet, 10):
with cat as cat_copy:
cat_copy(word)
self.assertEqual(bool(cat_copy),
bool(re.match(fitting_regex, ''.join(word))))
from itertools import islice
cat_neg = ~cat
for word in islice(cat().language, 10000):
self.assertIsNot(None, re.match(fitting_regex, ''.join(word)))
for word in islice(cat_neg().language, 10000):
self.assertIs(None, re.match(fitting_regex, ''.join(word)))
def setUp(self):
m = ssfsm.Machine()
m.One['ab'] = m.Two
m.Two['a'] = m.One
m.Two['b'] = m.Two
m().reset(m.One)
self.m = m
def test_multi_alph(self):
A = ssfsm.Machine(0) # A is empty or ends with b
A[0] = True
A[0][('bb', )] = A[0]
A[0][('aa', )] = A[1]
A[1][('aa', )] = A[1]
A[1][('bb', )] = A[0]
B = ssfsm.Machine(0) # B has aa
B[0][('aa', )] = B[1]
B[0][('bb', )] = B[0]
B[1][('aa', )] = B[2]
B[1][('bb', )] = B[0]
B[2] = True
B[2][('aa', 'bb')] = B[2]
self.assertEqual((A & B)().alphabet, A().alphabet)
def setUp(self):
m = ssfsm.Machine()
m.One['a'] = m.Two
m.Two['a'] = m.One
m.One['b'] = m.Three
m().polyfill(m.Three)
m().reset(m.One)
self.m = m
def test_with_multi_alphabet(self):
m = ssfsm.Machine()
m.One[('aa','bb')] = m.Two
m.Two[('aa',)] = m.One
m.Two[('bb',)] = m.Two
m().reset(m.One)
with m as m_:
self.assertEqual(m().alphabet, m_().alphabet)
def setUp(self):
A = ssfsm.Machine(0) # A is empty or ends with b
A[0] = True
A[0]['b'] = A[0]
A[0]['a'] = A[1]
A[1]['a'] = A[1]
A[1]['b'] = A[0]
self.A = A
B = ssfsm.Machine(0) # B has aa
B[0]['a'] = B[1]
B[0]['b'] = B[0]
B[1]['a'] = B[2]
B[1]['b'] = B[0]
B[2] = True
B[2]['ab'] = B[2]
self.B = B
def test_language_empty(self):
A = ssfsm.Machine(0)
A[0]['ab'] = A[1]
A[1]['ab'] = A[0]
self.assertFalse(next(A().language, False))
self.assertIs(None, A().get_pumping_lemma())
self.assertTrue(A().finite_language)
self.assertFalse(A().infinite_language)
def test_language_empty_word(self):
A = ssfsm.Machine(0)
A[0]['ab'] = A[1]
A[1]['ab'] = A[1]
A[0] = True
language = frozenset(A().language)
language_expected = {()}
self.assertEqual(language, language_expected)
self.assertIs(None, A().get_pumping_lemma())
self.assertTrue(A().finite_language)
self.assertFalse(A().infinite_language)
def setUp(self):
B = ssfsm.Machine(0) # B has aa
B[0]['a'] = B[1]
B[0]['b'] = B[0]
B[1]['a'] = B[2]
B[1]['b'] = B[0]
B[2] = True
B[2]['ab'] = B[2]
B[3]
self.m = B
def test_bug_state_not_retained(self):
A = ssfsm.Machine(0) # A ends with b
A[0]['b'] = A[1]
A[0]['a'] = A[0]
A[1]['b'] = A[1]
A[1]['a'] = A[0]
A[1] = True
A = A+A
A('b')
with A as A_:
self.assertEqual(A().state.name, A_().state.name)
def test_reset(self):
m = self.m
self.assertIs(m().state, m.One)
m('a')
self.assertIs(m().state, m.Two)
m().reset()
self.assertIs(m().state, m.One)
m().reset(m.Two)
self.assertIs(m().state, m.Two)
m('a')
self.assertIs(m().state, m.One)
with self.assertRaises(ValueError):
m().reset(ssfsm.Machine().s)
def test_error_alph(self):
A = ssfsm.Machine(0)
A[0]['ab'] = A[1]
A[1]['ab'] = A[0]
B = ssfsm.Machine(0)
B[0]['abc'] = B[1]
B[1]['abc'] = B[0]
with self.assertRaises(ValueError):
A & B
with self.assertRaises(ValueError):
A | B
with self.assertRaises(ValueError):
A ^ B
with self.assertRaises(ValueError):
A - B
with self.assertRaises(ValueError):
A + B
def test_controller_initial_state_settable(self):
m = self.m
m().reset(m.One)
m.Two
self.assertIs(m.One, m().initial_state)
m().initial_state = m.Two
self.assertIs(m.Two, m().initial_state)
with self.assertRaises(TypeError):
m().initial_state = False
m2 = ssfsm.Machine()
m2.Foo
with self.assertRaises(ValueError):
m().initial_state = m2.Foo
def test_minimization(self):
from itertools import takewhile
try:
from itertools import izip
_zip = izip
except:
_zip = zip
B = ssfsm.Machine(0) # B has aa
B[0]['a'] = B[1]
B[0]['b'] = B[0]
B[1]['a'] = B[2]
B[1]['b'] = B[0]
B[2] = True
B[2]['ab'] = B[2]
C = B + B + B + B
C_ = C().get_minimized()
self.assertTrue(len(C_) <= len(C))
self.assertTrue(C_().minimized)
self.assertEqual(C().alphabet, C_().alphabet)
# languages are equal
for w1, w2 in takewhile(lambda x: len(x[0]) < 16,
_zip(C().language,
C_().language)):
self.assertEqual(w1, w2)
# state is retained
for word in all_words(B().alphabet, 12):
C().reset()
C(word)
C_ = C().get_minimized()
n1, n2 = C().state.name, C_().state.name
self.assertTrue(
(n1 == n2) or (n1 in n2),
"Unequivalent states for {}, {} <-> {}".format(word, n1, n2))
self.assertIs(bool(C), bool(C_))
def test_deterministic(self):
m = self.m
m().reset(m.One)
print(m().states_names)
m.One['ab'] = m.Two
self.assertFalse(m().deterministic)
m.Two['a'] = m.One
self.assertFalse(m().deterministic)
m.Two['b'] = m.Two
self.assertTrue(m().deterministic)
m.One['c'] = m.One
self.assertFalse(m().deterministic)
m = ssfsm.Machine()
m.One['ab'] = m.Two
self.assertFalse(m().deterministic)
m.Two['a'] = m.One
self.assertFalse(m().deterministic)
m.Two['b'] = m.Two
self.assertFalse(m().deterministic)
m().reset(m.One)
self.assertTrue(m().deterministic)
def test_constructor_module(self):
ssfsm.Machine()
def setUp(self):
self.m = ssfsm.Machine()
def test_combine(self):
A = ssfsm.Machine(0) # A is empty or ends with b
A[0] = True
A[0]['b'] = A[0]
A[0]['a'] = A[1]
A[1]['a'] = A[1]
A[1]['b'] = A[0]
def fn_A(w):
w = ''.join(w)
return (w == '') or (w[-1] == 'b')
B = ssfsm.Machine(0) # B has aa
B[0]['a'] = B[1]
B[0]['b'] = B[0]
B[1]['a'] = B[2]
B[1]['b'] = B[0]
B[2] = True
B[2]['ab'] = B[2]
def fn_B(w):
w = ''.join(w)
return 'aa' in w
union = A | B
intersection = A & B
difference = A - B
difference2 = B - A
sym_diff = A ^ B
from itertools import product
for word in all_words(A().alphabet, 10):
print(word)
with A as copy_A, B as copy_B, union as copy_union:
copy_A(word)
copy_B(word)
copy_union(word)
cond = bool(copy_A) or bool(copy_B)
cond2 = bool(copy_A | copy_B)
cond3 = bool(copy_union)
self.assertEqual(cond, cond2)
self.assertEqual(cond, cond3)
self.assertEqual(cond, fn_A(word) or fn_B(word))
with A as copy_A, B as copy_B, intersection as copy_intersection:
copy_A(word)
copy_B(word)
copy_intersection(word)
cond = (bool(copy_A) and bool(copy_B))
cond2 = bool(copy_A & copy_B)
cond3 = bool(copy_intersection)
self.assertEqual(cond, cond2)
self.assertEqual(cond, cond3)
self.assertEqual(cond, fn_A(word) and fn_B(word))
with A as copy_A, B as copy_B, difference as copy_difference:
copy_A(word)
copy_B(word)
copy_difference(word)
cond = bool(copy_A) and not bool(copy_B)
cond2 = bool(copy_A - copy_B)
cond3 = bool(copy_difference)
self.assertEqual(cond, cond2)
self.assertEqual(cond, cond3)
self.assertEqual(cond, fn_A(word) and not fn_B(word))
with A as copy_A, B as copy_B, difference2 as copy_difference2:
copy_A(word)
copy_B(word)
copy_difference2(word)
cond = bool(copy_B) and not bool(copy_A)
cond2 = bool(copy_B - copy_A)
cond3 = bool(copy_difference2)
self.assertEqual(cond, cond2)
self.assertEqual(cond, cond3)
self.assertEqual(cond, fn_B(word) and not fn_A(word))
with A as copy_A, B as copy_B, sym_diff as copy_sym_diff:
copy_A(word)
copy_B(word)
copy_sym_diff(word)
cond = bool(copy_A) ^ bool(copy_B)
cond2 = bool(copy_A ^ copy_B)
cond3 = bool(copy_sym_diff)
self.assertEqual(cond, cond2)
self.assertEqual(cond, cond3)
self.assertEqual(cond, (fn_A(word) or fn_B(word))
and not (fn_A(word) and fn_B(word)))
max_len = len(A) * len(B)
self.assertTrue(len(union) <= max_len)
self.assertTrue(len(intersection) <= max_len)
self.assertTrue(len(difference) <= max_len)
self.assertTrue(len(difference2) <= max_len)
self.assertTrue(len(sym_diff) <= max_len)
def test_states_in_different_machines(self):
m1 = ssfsm.Machine()
m2 = ssfsm.Machine()
with self.assertRaises(ValueError):
m1.One['a'] = m2.Two
