def test_automata_without_final_states(self):
initial = Node()
final = Node()
initial.add_transition('a', final)
automata = Automata([initial, final], ['a'], initial, [])
#assert para que haya alguno, la idea es que si no tendría que tirar excepción.
self.assertTrue(automata.initial == initial)
def test_is_deterministic_automata__det(self):
initial = Node()
final = Node()
other_node = Node()
initial.add_transition('a', final)
automata = Automata([initial, final, other_node], ['a'], initial, [final])
self.assertTrue(automata.is_deterministic())
self.assertFalse(automata.has_lambda())
def test_add_transition__new_symbol(self):
tested = Node()
target = Node()
s = 'a'
self.assertFalse(s in tested.transitions)
tested.add_transition(s, target)
self.assertTrue(s in tested.transitions)
self.assertEqual([target], tested.transitions[s])
def test_add_transition__existing_symbol(self):
tested = Node()
target1 = Node()
target2 = Node()
s = 'a'
tested.add_transition(s, target1)
tested.add_transition(s, target2)
self.assertEqual(set([target1, target2]), set(tested.transitions[s]))
def test_is_deterministic_node__not_det(self):
tested = Node()
target1 = Node()
target3 = Node()
s = 'a'
tested.add_transition(s, target1)
tested.add_transition(s, target3)
self.assertFalse(tested.is_deterministic())
def test_is_deterministic_node__lambda_det(self):
tested = Node()
target1 = Node()
target2 = Node()
s = 'a'
tested.add_transition(s, target1)
tested.add_transition(LAMBDA, target2)
self.assertFalse(tested.is_deterministic())
def test_construction_automata__extra_final(self):
initial = Node()
final = Node()
initial.add_transition('a', final)
states = [initial, final]
symbols = ['a']
with self.assertRaises(FinalsNotInStatesException):
Automata(states, symbols, initial, [final, Node()])
def test_is_deterministic_node__det(self):
tested = Node()
target1 = Node()
target2 = Node()
s = 'a'
s2 = 'b'
tested.add_transition(s, target1)
tested.add_transition(s2, target2)
self.assertTrue(tested.is_deterministic())
def to_automata(self):
content_automata = self.content.to_automata()
q0 = Node()
qf = Node()
states = [q0, qf] + content_automata.states
q0.add_transition(LAMBDA, qf)
q0.add_transition(LAMBDA, content_automata.initial)
for q in content_automata.finals:
q.add_transition(LAMBDA, qf)
return Automata(states, content_automata.symbols, q0, [qf])
def test_reachable_nodes(self):
q0 = Node("q0")
q1 = Node("q1")
q2 = Node("q2")
q0.add_transition(0, q1)
q0.add_transition(1, q2)
q2.add_transition(1, q1)
self.assertEqual(set([q1, q2]), q0.reachable_nodes())
self.assertEqual(set([]), q1.reachable_nodes())
self.assertEqual(set([q1]), q2.reachable_nodes())
def test_minimize__con_nodo_trampa(self):
q0 = Node('q0')
q1 = Node('q1')
qT = Node('qT')
q0.add_transition('0', q1)
q0.add_transition('0', qT)
q0.add_transition('1', qT)
q1.add_transition('0', qT)
q1.add_transition('0', qT)
qT.add_transition('0', qT)
qT.add_transition('1', qT)
automata = Automata([q0, q1, qT], ['0', '1'], q0, [q1])
minimized = minimize(automata)
self.assertEquals(set(minimized.symbols), set(automata.symbols))
self.assertEquals(len(minimized.states), 2)
q0 = minimized.state_by_name('q0')
q1 = minimized.state_by_name('q1')
self.assertEquals(q0.transition('0'), q1)
self.assertEquals(q0.transitions.keys(), ['0'])
self.assertEquals(q1.transitions.keys(), [])
def to_automata(self):
content_automatas = [tree.to_automata() for tree in self.content]
q0 = Node()
qf = Node()
states = [q0, qf]
symbols = []
for automata in content_automatas:
states += automata.states
symbols += automata.symbols
q0.add_transition(LAMBDA, automata.initial)
for finals in automata.finals:
finals.add_transition(LAMBDA, qf)
return Automata(states, list(set(symbols)), q0, [qf])
def test_interseccion_vacia(self):
q0 = Node("q0")
q1 = Node("q1")
q0.add_transition('0', q1)
q0.add_transition('1', q0)
automata1 = Automata([q0, q1], ['0', '1'], q0, [q1])
q2 = Node("q2")
q3 = Node("q3")
q2.add_transition('1', q3)
q2.add_transition('0', q2)
automata2 = Automata([q2, q3], ['0', '1'], q2, [q3])
interseccion = afd_interseccion(automata1, automata2)
self.assertEqual(set(automata1.symbols), set(interseccion.symbols))
self.assertEqual(0, len(interseccion.states))
def test_interseccion_dos_automatas_iguales(self):
q0 = Node("q0")
q1 = Node("q1")
q0.add_transition('0', q1)
q0.add_transition('1', q1)
q1.add_transition('0', q0)
automata = Automata([q0, q1], ['0', '1'], q0, [q1])
result = afd_interseccion(automata, automata)
self.assertEqual(set(automata.symbols), set(result.symbols))
self.assertEqual(len(automata.states), len(result.states))
self.assertEqual(len(automata.finals), len(result.finals))
qI = result.initial
qII = result.finals[0]
self.assertEqual(qII, qI.transition('0'))
self.assertEqual(qII, qI.transition('1'))
self.assertEqual(qI, qII.transition('0'))
def test_no_determinismo(self):
q0_1 = Node("q0")
q1_1 = Node("q1")
q0_1.add_transition('0', q1_1)
q0_1.add_transition('1', q1_1)
q1_1.add_transition('0', q0_1)
automata1 = Automata([q0_1, q1_1], ['0', '1'], q0_1, [q1_1])
q0_2 = Node("q0")
q1_2 = Node("q1")
q0_2.add_transition('0', q1_2)
q0_2.add_transition('1', q1_2)
q1_2.add_transition('0', q0_2)
q1_2.add_transition('0', q1_2)
q1_2.add_transition('1', q1_2)
automata2 = Automata([q0_2, q1_2], ['0', '1'], q0_2, [q1_2])
with self.assertRaises(NonDeterministicAutomataError):
afd_interseccion(automata1, automata2)
def test_add_terminal_node__ejemplo_simple(self):
q0 = Node('q0')
q1 = Node('q1')
q2 = Node('q2')
q0.add_transition('a', q1)
q1.add_transition('b', q2)
q2.add_transition('a', q2)
q2.add_transition('b', q2)
symbols = ['a', 'b']
automata = Automata([q0, q1, q2], symbols, q0, [q2])
with_terminal_node = add_terminal_node(automata)
self.assertEqual(automata.symbols, with_terminal_node.symbols)
self.assertEqual(len(automata.states) + 1, len(with_terminal_node.states))
q0T = with_terminal_node.state_by_name("q0")
q1T = with_terminal_node.state_by_name("q1")
q2T = with_terminal_node.state_by_name("q2")
qT = with_terminal_node.state_by_name("qT")
self.assertEqual(symbols, q0T.transitions.keys())
self.assertEqual([q1T], q0T.transitions['a'])
self.assertEqual([qT], q0T.transitions['b'])
self.assertEqual(symbols, q1T.transitions.keys())
self.assertEqual([qT], q1T.transitions['a'])
self.assertEqual([q2T], q1T.transitions['b'])
self.assertEqual(symbols, q2T.transitions.keys())
self.assertEqual([q2T], q2T.transitions['a'])
self.assertEqual([q2T], q2T.transitions['b'])
self.assertEqual(symbols, qT.transitions.keys())
self.assertEqual([qT], qT.transitions['a'])
self.assertEqual([qT], qT.transitions['b'])
def test_accept__ejemplo_enunciado(self):
q0 = Node('q0')
q1 = Node('q1')
q2 = Node('q2')
symbols = ['a', 'b', 'c', 'd', 'e', 'f']
q0.add_transition('a', q1)
q1.add_transition('b', q2)
q1.add_transition('c', q1)
q2.add_transition('f', q2)
tested = Automata([q0, q1, q2], symbols, q0, [q1, q2])
self.assertTrue(tested.accepts("a"))
self.assertTrue(tested.accepts("ac"))
self.assertTrue(tested.accepts("accc"))
self.assertTrue(tested.accepts("ab"))
self.assertTrue(tested.accepts("acccb"))
self.assertTrue(tested.accepts("acccbf"))
self.assertTrue(tested.accepts("acccbfff"))
self.assertFalse(tested.accepts(""))
self.assertFalse(tested.accepts("b"))
self.assertFalse(tested.accepts("c"))
self.assertFalse(tested.accepts("d"))
self.assertFalse(tested.accepts("e"))
self.assertFalse(tested.accepts("f"))
self.assertFalse(tested.accepts("Z"))
self.assertFalse(tested.accepts("abb"))
self.assertFalse(tested.accepts("af"))
self.assertFalse(tested.accepts("acca"))
def test_correccion(self):
"""
agrego el test que nos dieron como ejemplo en el informe
"""
q0 = Node("q0")
q1 = Node("q1")
q0.add_transition('a', q1)
q0.add_transition('b', q1)
automata1 = Automata([q0, q1], ['a', 'b'], q0, [q1])
q2 = Node("q2")
q3 = Node("q3")
q2.add_transition('a', q3)
q2.add_transition('c', q3)
automata2 = Automata([q2, q3], ['a', 'c'], q2, [q3])
res = afd_interseccion(automata1, automata2)
self.assertEquals(len(res.states), 2)
self.assertEquals(len(res.finals), 1)
self.assertEquals(res.initial.transitions.keys(), ['a'])
self.assertEquals(res.initial.transition('a'), res.finals[0])
def test_prune_unreachable_states_simple(self):
q00 = Node("q00")
q01 = Node("q01")
q10 = Node("q10")
q11 = Node("q11")
q00.add_transition(0, q11)
q00.add_transition(1, q11)
q01.add_transition(0, q10)
q10.add_transition(0, q01)
q11.add_transition(0, q00)
automata = Automata([q00, q01, q10, q11], [0, 1], q00, [q11])
automata.prune_unreachable_states()
self.assertIn(q00, automata.states)
self.assertIn(q11, automata.states)
self.assertEqual(2, len(automata.states))
def test_construction_automata__unexpected_symbol(self):
initial = Node()
final = Node()
other_node = Node()
initial.add_transition('a', other_node)
initial.add_transition('a', final)
other_node.add_transition('z', final)
states = [initial, final, other_node]
symbols = ['a']
with self.assertRaises(UnexpectedSymbolOnStateException):
Automata(states, symbols, initial, [final])
def test_alfabetos_disjuntos(self):
q0_1 = Node("q0")
q1_1 = Node("q1")
q0_1.add_transition('0', q1_1)
q0_1.add_transition('1', q1_1)
q1_1.add_transition('0', q0_1)
automata1 = Automata([q0_1, q1_1], ['0', '1'], q0_1, [q1_1])
q0_2 = Node("q0")
q1_2 = Node("q1")
q0_2.add_transition('a', q1_2)
q0_2.add_transition('b', q1_2)
q1_2.add_transition('a', q0_2)
automata2 = Automata([q0_2, q1_2], ['a', 'b'], q0_2, [q1_2])
interseccion = afd_interseccion(automata1, automata2)
self.assertEqual(set(automata1.symbols) | set(automata2.symbols), set(interseccion.symbols))
self.assertEqual(0, len(interseccion.states))
def test_all_states_reachable_from(self):
q0 = Node('q0')
q1 = Node('q1')
q2 = Node('q2')
symbols = ['a', 'b', 'c', 'd', 'e', 'f']
q0.add_transition('a', q1)
q1.add_transition('b', q2)
q1.add_transition('c', q1)
q2.add_transition('f', q2)
tested = Automata([q0, q1, q2], symbols, q0, [q1, q2])
self.assertEqual(set([q1, q2]), tested.all_states_reachable_from(q0))
self.assertEqual(set([q1, q2]), tested.all_states_reachable_from(q1))
self.assertEqual(set([q2]), tested.all_states_reachable_from(q2))
def test_alfabetos_solapados(self):
q0_1 = Node("q0")
q1_1 = Node("q1")
q0_1.add_transition('0', q1_1)
q0_1.add_transition('1', q1_1)
q1_1.add_transition('0', q0_1)
automata1 = Automata([q0_1, q1_1], ['0', '1'], q0_1, [q1_1])
q0_2 = Node("q0")
q1_2 = Node("q1")
q0_2.add_transition('a', q1_2)
q0_2.add_transition('1', q1_2)
q1_2.add_transition('a', q0_2)
automata2 = Automata([q0_2, q1_2], ['a', '1'], q0_2, [q1_2])
interseccion = afd_interseccion(automata1, automata2)
self.assertEqual(set(automata1.symbols) | set(automata2.symbols), set(interseccion.symbols))
self.assertEqual(2, len(interseccion.states))
self.assertEqual(1, len(interseccion.finals))
q0 = interseccion.initial
q1 = interseccion.finals[0]
self.assertEqual(q1, q0.transition('1'))
with self.assertRaises(KeyError):
q0.transition('0')
with self.assertRaises(KeyError):
q0.transition('a')
with self.assertRaises(KeyError):
q1.transition('0')
with self.assertRaises(KeyError):
q1.transition('1')
with self.assertRaises(KeyError):
q1.transition('a')
def test_construction_automata__ok(self):
initial = Node()
final = Node()
other_node = Node()
initial.add_transition('a', other_node)
initial.add_transition('a', final)
other_node.add_transition(LAMBDA, final)
states = [initial, final, other_node]
symbols = ['a']
automata = Automata(states, symbols, initial, [final])
self.assertEqual(states, automata.states)
self.assertEqual(symbols, automata.symbols)
self.assertEqual(initial, automata.initial)
self.assertEqual([final], automata.finals)
self.assertFalse(automata.is_deterministic())
self.assertTrue(automata.has_lambda())
def test_minimize__example_from_hopcroft(self):
"""
basado en la figura 4.10 del libro
"""
state_c = Node(name='c')
state_d = Node(name='d')
state_e = Node(name='e')
state_c.add_transition('0', state_d)
state_c.add_transition('1', state_e)
state_d.add_transition('0', state_d)
state_d.add_transition('1', state_e)
state_e.add_transition('1', state_e)
state_e.add_transition('0', state_c)
finals = [state_c, state_d]
states = [state_c, state_d, state_e]
symbols = ['0', '1']
not_minimized = Automata(states, symbols, state_c, finals)
minimized = minimize(not_minimized)
# save_dot(minimized, open('hopcroft_410.dot', 'w'))
self.assertEquals(len(minimized.states), 2)
self.assertTrue(LAMBDA not in minimized.symbols)
self.assertEquals(minimized.symbols, not_minimized.symbols)
self.assertEquals(minimized.initial.transition('0'), minimized.initial)
other_node = minimized.initial.transition('1')
self.assertEquals(minimized.initial.transition('1').transition('0'), minimized.initial)
self.assertEquals(minimized.initial.transition('1'), other_node)
self.assertEquals(minimized.initial.transition('1').transition('1'), other_node)
def test_interseccion_010(self):
q0_e = Node("q0")
q1_e = Node("q1")
q2_e = Node("q2")
q3_e = Node("q3")
q0_e.add_transition('0', q1_e)
q1_e.add_transition('1', q2_e)
q2_e.add_transition('0', q3_e)
q3_e.add_transition('0', q3_e)
q3_e.add_transition('1', q3_e)
q0_t = Node("q0")
q1_t = Node("q1")
q2_t = Node("q2")
q3_t = Node("q3")
q0_t.add_transition('0', q1_t)
q0_t.add_transition('1', q0_t)
q1_t.add_transition('0', q1_t)
q1_t.add_transition('1', q2_t)
q2_t.add_transition('0', q3_t)
q2_t.add_transition('1', q0_t)
q3_t.add_transition('0', q0_t)
q3_t.add_transition('1', q0_t)
automata_empieza_010 = Automata([q0_e, q1_e, q2_e, q3_e], ['0', '1'], q0_e, [q3_e])
automata_termina_010 = Automata([q0_t, q1_t, q2_t, q3_t], ['0', '1'], q0_t, [q3_t])
automata_empieza_termina_010 = afd_interseccion(automata_empieza_010, automata_termina_010)
self.assertEqual(set(automata_empieza_010.symbols), set(automata_empieza_termina_010.symbols))
self.assertEqual(7, len(automata_empieza_termina_010.states))
self.assertEqual(1, len(automata_empieza_termina_010.finals))
# Voy a usar este método porque el minimzar le pone los nombres de cualquier manera.
q0 = automata_empieza_termina_010.initial
with self.assertRaises(KeyError):
q0.transition('1')
q1 = q0.transition('0')
with self.assertRaises(KeyError):
q1.transition('0')
q2 = q1.transition('1')
with self.assertRaises(KeyError):
q2.transition('1')
q3 = q2.transition('0')
self.assertIn(q3, automata_empieza_termina_010.finals)
q4 = q3.transition('0')
self.assertEqual(q4, q3.transition('1'))
self.assertEqual(q4, q4.transition('1'))
q5 = q4.transition('0')
self.assertEqual(q5, q5.transition('0'))
q6 = q5.transition('1')
self.assertEqual(q3, q6.transition('0'))
self.assertEqual(q4, q6.transition('1'))
def test_wikipedia_example_minimization(self):
state_a = Node(name='a')
state_b = Node(name='b')
state_c = Node(name='c')
state_d = Node(name='d')
state_e = Node(name='e')
state_f = Node(name='f')
state_a.add_transition('0', state_b)
state_a.add_transition('1', state_c)
state_b.add_transition('0', state_a)
state_b.add_transition('1', state_d)
state_c.add_transition('0', state_e)
state_c.add_transition('1', state_f)
state_d.add_transition('0', state_e)
state_d.add_transition('1', state_f)
state_e.add_transition('0', state_e)
state_e.add_transition('1', state_f)
state_f.add_transition('0', state_f)
state_f.add_transition('1', state_f)
automata = Automata([state_a, state_b, state_c, state_d, state_e, state_f], ['0', '1'], state_a, [state_c, state_d, state_e])
minimized = minimize(automata)
self.assertEqual(automata.symbols, minimized.symbols)
self.assertEqual(2, len(minimized.states))
q0 = minimized.state_by_name("q0")
q1 = minimized.state_by_name("q1")
self.assertEqual(q0, minimized.initial)
self.assertEqual([q1], minimized.finals)
self.assertEqual(q0, q0.transition('0'))
self.assertEqual(q1, q0.transition('1'))
self.assertEqual(q1, q1.transition('0'))
def test_minimize__ejemplo_clase(self):
q0 = Node('q0')
q1 = Node('q1')
q2 = Node('q2')
q3 = Node('q3')
q4 = Node('q4')
q5 = Node('q5')
q0.add_transition('a', q1)
q0.add_transition('b', q0)
q1.add_transition('a', q2)
q1.add_transition('b', q0)
q2.add_transition('a', q3)
q2.add_transition('b', q0)
q3.add_transition('a', q3)
q3.add_transition('b', q4)
q4.add_transition('a', q5)
q4.add_transition('b', q4)
q5.add_transition('a', q3)
q5.add_transition('b', q4)
symbols = ['a', 'b']
automata = Automata([q0, q1, q2, q3, q4, q5], symbols, q0, [q3, q4, q5])
minimized = minimize(automata)
self.assertEqual(automata.symbols, minimized.symbols)
self.assertEqual(4, len(minimized.states))
# Assert implícito de que estas líneas no tiran excepciones
q0 = minimized.state_by_name("q0")
q1 = minimized.state_by_name("q1")
q2 = minimized.state_by_name("q2")
q3 = minimized.state_by_name("q3")
self.assertEqual(q0, minimized.initial)
self.assertEqual([q3], minimized.finals)
self.assertEqual(symbols, q0.transitions.keys())
self.assertEqual([q1], q0.transitions['a'])
self.assertEqual([q0], q0.transitions['b'])
self.assertEqual(symbols, q1.transitions.keys())
self.assertEqual([q2], q1.transitions['a'])
self.assertEqual([q0], q1.transitions['b'])
self.assertEqual(symbols, q2.transitions.keys())
self.assertEqual([q3], q2.transitions['a'])
self.assertEqual([q0], q2.transitions['b'])
self.assertEqual(symbols, q3.transitions.keys())
self.assertEqual([q3], q3.transitions['a'])
self.assertEqual([q3], q3.transitions['b'])
def to_automata(self):
q0 = Node()
q1 = Node()
q0.add_transition(self.content, q1)
return Automata([q0, q1], [self.content], q0, [q1])
