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