def test_is_not_absorbing(self):
node = Node('node')
true_label = Label({})
node.add_transition(true_label, [('dst1', True)])
assert not is_absorbing(node)
def test_is_not_absorbing(self):
node = Node('node')
true_label = Label({})
node.add_transition(true_label, [('dst1', True)])
assert not is_absorbing(node)
def test_complement_node_with_live_ends(self):
node = Node('node')
node.add_transition(Label({'a': True}), {(node, False)})
complement_node(node, ['a'])
assert node.transitions[Label({'a': True})] == [{(node, False)}]
assert node.transitions[Label({'a': False})] == [{(LIVE_END, False)}]
def test_is_absorbing(self):
node = Node('node')
true_label = Label({})
node.add_transition(true_label, [(node, True)])
node.add_transition(Label({'r':True}), [(node, True)])
assert is_absorbing(node)
def test_complement_node_with_live_ends(self):
node = Node('node')
node.add_transition(Label({'a': True}), {(node, False)})
complement_node(node, ['a'])
assert node.transitions[Label({'a': True})] == [{(node, False)}]
assert node.transitions[Label({'a': False})] == [{(LIVE_END, False)}]
def _conform2acw(initial_nodes, rejecting_nodes, nodes, vars):
""" Modify 'incorrect' transitions:
label->[set1,set2] modified to label->[set3], where set3=set1+set2
"""
new_name_to_node = {}
for n in nodes:
new_node = get_add(new_name_to_node, n.name, Node(n.name))
lbl_to_flagged_nodes = {}
lbl_dst_set_pairs = [(lbl, _flatten(list_of_sets))
for lbl, list_of_sets in n.transitions.items()]
for pattern_lbl, old_dst_nodes in lbl_dst_set_pairs:
new_dst_nodes = _get_create_new_nodes(new_name_to_node,
old_dst_nodes)
lbl_nodes = get_add(lbl_to_flagged_nodes, pattern_lbl, set())
lbl_nodes.update(
new_dst_nodes
) # TODO: determenize, make labels do not intersect
for lbl, flagged_dst_nodes in lbl_to_flagged_nodes.items():
new_node.add_transition(lbl, flagged_dst_nodes)
new_init_nodes = [new_name_to_node[n.name] for n in initial_nodes]
new_rejecting_nodes = [new_name_to_node[n.name] for n in rejecting_nodes]
return new_init_nodes, new_rejecting_nodes, list(new_name_to_node.values())
def test_get_next_states(self):
state = Node('init')
r = Node('r')
rg = Node('rg')
nr_g = Node('!rg')
_ = False
edge_to_r = {(r, _)}
edge_to_rg = {(rg, _)}
edge_to_not_r_g = {(nr_g, _)}
state.add_transition({'r':True}, edge_to_r)
state.add_transition({'r':True, 'g':True}, edge_to_rg)
state.add_transition({'r':False, 'g':True}, edge_to_not_r_g)
next_states = get_next_states(state, Label({'r':False, 'g':False}))
assert len(next_states) == 0
next_states = get_next_states(state, Label({'r':False, 'g':True}))
assert len(next_states) == 1
self._are_equal_sequences({nr_g}, next_states)
next_states = get_next_states(state, Label({'r':True, 'g':True}))
assert len(next_states) == 2
self._are_equal_sequences({r, rg}, next_states)
def test_get_next_states(self):
state = Node('init')
_ = False
dst_set_r = {(Node('r'),_)}
dst_set_rg = {(Node('rg'),_)}
dst_set_not_r_g = {(Node('!rg'),_)}
state.add_transition({'r':True}, dst_set_r)
state.add_transition({'r':True, 'g':True}, dst_set_rg)
state.add_transition({'r':False, 'g':True}, dst_set_not_r_g)
list_of_state_sets = get_next_states(state,
{'r':False, 'g':False})
assert len(list_of_state_sets) == 0
list_of_state_sets = get_next_states(state,
{'r':False, 'g':True})
assert len(list_of_state_sets) == 1
assert set([x[0] for x in dst_set_not_r_g]) in list_of_state_sets, \
str(list_of_state_sets)
list_of_state_sets = get_next_states(state,
{'r':True, 'g':True})
assert len(list_of_state_sets) == 2
assert set([x[0] for x in dst_set_rg]) in list_of_state_sets
assert set([x[0] for x in dst_set_r]) in list_of_state_sets
def _get_create(node_tok, name_to_node, initial_nodes, rejecting_nodes):
node = name_to_node[node_tok] = name_to_node.get(node_tok, Node(node_tok))
if 'init' in node_tok:
initial_nodes.add(node)
if 'accept' in node_tok:
rejecting_nodes.add(node)
return node
def _create_automaton(self, node_names, init_node_name, transitions_dict):
name_to_node = {}
for name in node_names:
name_to_node[name] = Node(name)
for trans_desc, is_rejecting in transitions_dict.items():
src_node, dst_node = list(map(lambda name: name_to_node[name], trans_desc.split('->')))
src_node.add_transition(Label({}), {(dst_node,is_rejecting)})
return Automaton([{name_to_node[init_node_name]}], set(), set(name_to_node.values()))
def test_is_absorbing(self):
node = Node('node')
true_label = Label({})
node.add_transition(true_label, [(node, True)])
node.add_transition(Label({'r': True}), [(node, True)])
assert is_absorbing(node)
def test_complement_node_with_live_ends3(self):
node = Node('node')
node.add_transition(Label({}), {(node, False)})
complement_node(node, ['a'])
assert node.transitions[Label({})] == [{(node, False)}]
def test_dead_end(self):
node = Node('node')
node.add_transition(Label({}), {(node, True)})
assert is_dead_end(node)
def test_get_next_states(self):
state = Node('init')
_ = False
dst_set_r = {(Node('r'), _)}
dst_set_rg = {(Node('rg'), _)}
dst_set_not_r_g = {(Node('!rg'), _)}
state.add_transition({'r': True}, dst_set_r)
state.add_transition({'r': True, 'g': True}, dst_set_rg)
state.add_transition({'r': False, 'g': True}, dst_set_not_r_g)
list_of_state_sets = get_next_states(state, {'r': False, 'g': False})
assert len(list_of_state_sets) == 0
list_of_state_sets = get_next_states(state, {'r': False, 'g': True})
assert len(list_of_state_sets) == 1
assert set([x[0] for x in dst_set_not_r_g]) in list_of_state_sets, \
str(list_of_state_sets)
list_of_state_sets = get_next_states(state, {'r': True, 'g': True})
assert len(list_of_state_sets) == 2
assert set([x[0] for x in dst_set_rg]) in list_of_state_sets
assert set([x[0] for x in dst_set_r]) in list_of_state_sets
def test_dead_end(self):
node = Node('node')
node.add_transition(Label({}), {(node, True)})
assert is_dead_end(node)
def test_complement_node_with_live_ends2(self):
node = Node('node')
complement_node(node, ['a'])
assert node.transitions[Label({})] == [{(LIVE_END, False)}]
def _get_create_new_nodes(new_name_to_node, flagged_nodes_set):
new_nodes = [(get_add(new_name_to_node, fn[0].name,
Node(fn[0].name)), fn[1])
for fn in flagged_nodes_set]
return new_nodes
def test_complement_node_with_live_ends3(self):
node = Node('node')
node.add_transition(Label({}), {(node, False)})
complement_node(node, ['a'])
assert node.transitions[Label({})] == [{(node, False)}]
