def test_trivial_case(self):
grammar = 'rulename = abc "def"\nabc = "abc"'
rulename = 'rulename'
edge = Edge('abc', 'abc')
edge2 = Edge('def', 'def')
final_edge = Edge('', FINAL_STATE)
state = State('abc', edge2, is_automata=True)
state2 = State('def', final_edge)
start_state = State(START_STATE, edge)
final_state = State(FINAL_STATE)
states = [start_state, state, state2, final_state]
expected = StateMachine(rulename, states)
rulename = 'abc'
sub_edge = Edge('abc', 'abc')
sub_final_edge = Edge('', FINAL_STATE)
sub_state = State('abc', sub_final_edge)
sub_start_state = State(START_STATE, sub_edge)
sub_final_state = State(FINAL_STATE)
states = [sub_start_state, sub_state, sub_final_state]
submachine = StateMachine(rulename, states)
expected.register_automata(submachine)
actual = choices_parser.parse_from_string(grammar)
logger.debug(f'Actual: {actual}')
logger.debug(f'Expected: {expected}')
assert_state_machines_equal(actual, expected)
def test_sub_machines(self):
machine = StateMachine(id_='a',
states=[
State(START_STATE, Edge('', 'b')),
State('b',
Edge('a', FINAL_STATE),
is_automata=True),
State(FINAL_STATE, Edge('', START_STATE))
])
submachine_b = StateMachine(id_='b',
states=[
State(START_STATE,
Edge('b', FINAL_STATE)),
State(FINAL_STATE,
Edge('', START_STATE))
])
machine.register_automata(submachine_b)
start_record = StateRecord('a', START_STATE, 0, 0)
nested_start_record = StateRecord('b', START_STATE, 0, 1)
submachine_record = StateRecord('a', 'b_internal', 0, 1,
[nested_start_record])
b_record = StateRecord('a', 'b', 1, 2)
state_records = [start_record, submachine_record, b_record]
result = (True, state_records, 2)
self.assertEqual(machine.accepts_partial('ba'), result)
def test_double_nested_sub_machines(self):
machine = StateMachine(id_='c',
states=[
State(START_STATE, Edge('', 'b')),
State('b',
Edge('c', FINAL_STATE),
is_automata=True),
State(FINAL_STATE)
])
submachine_b = StateMachine(id_='b',
states=[
State(START_STATE, Edge('', 'a')),
State('a',
Edge('b', FINAL_STATE),
is_automata=True),
State(FINAL_STATE)
])
submachine_a = StateMachine(id_='a',
states=[
State(START_STATE,
Edge('a', FINAL_STATE)),
State(FINAL_STATE)
])
submachine_b.register_automata(submachine_a)
machine.register_automata(submachine_b)
start_record = StateRecord('c', START_STATE, 0, 0)
b_start_record = StateRecord('b', START_STATE, 0, 0)
a_record = StateRecord('a', START_STATE, 0, 1)
b_machine_record = StateRecord('b', 'a_internal', 0, 1, [a_record])
b_record = StateRecord('b', 'a', 1, 2)
c_machine_record = StateRecord(
'c', 'b_internal', 0, 2,
[b_start_record, b_machine_record, b_record])
c_record = StateRecord('c', 'b', 2, 3)
state_records = [start_record, c_machine_record, c_record]
result = (True, state_records, 3)
self.assertEqual(machine.accepts_partial('abc'), result)
