def test_edge_traversal_order(self): machine = StateMachine(states=[ State(START_STATE, Edge('', 'a')), State('a', [Edge('a', 'a'), Edge('', FINAL_STATE)]), State(FINAL_STATE) ]) start_record = gen_test_state_record(START_STATE, 0, 0) a_record = gen_test_state_record('a', 0, 0) end_record = gen_test_state_record(FINAL_STATE, 0, 0) state_records = [start_record, a_record] result = (True, state_records, 0) self.assertEqual(machine.accepts_partial('aab'), result) start_record = gen_test_state_record(START_STATE, 0, 0) a_record = gen_test_state_record('a', 0, 1) a_record_2 = gen_test_state_record('a', 1, 1) state_records = [start_record, a_record, a_record_2] result = (True, state_records, 1) self.assertEqual(machine.accepts_partial('aab'), result) start_record = gen_test_state_record(START_STATE, 0, 0) a_record = gen_test_state_record('a', 0, 1) a_record_2 = gen_test_state_record('a', 1, 2) a_record_3 = gen_test_state_record('a', 2, 2) state_records = [start_record, a_record, a_record_2, a_record_3] result = (True, state_records, 2) self.assertEqual(machine.accepts_partial('aab'), result) self.assertEqual(machine.accepts_partial('aab'), (False, None, -1))
def test_states_manager_add_state_method(): """Testing the StatesManager add_state method """ # Setup state1 = State(name="state1", routine_function=fun_routine, decision_function=fun_decision, entry_function=fun_entry, exit_function=fun_exit, is_async=False) state2 = State(name="state2", routine_function=fun_routine, decision_function=fun_decision, entry_function=fun_entry, exit_function=fun_exit, is_async=False) state3 = State(name="state3", routine_function=fun_routine, decision_function=fun_decision, entry_function=fun_entry, exit_function=fun_exit, next_states=[state1], is_async=False) state_manager = StatesManager() # Execute state_manager.add_state(state1, state2, state3) # Verify assert len(state_manager.states) == 3
class TicketState: arrived = State(initial=True) waiting = State() running = State() stopped = State() wait = Event(from_states=(arrived, running, stopped), to_state=waiting) run = Event(from_states=waiting, to_state=running) stop = Event(from_states=(running, waiting, arrived), to_state=stopped) def __init__(self, name): self.name = name @after('wait') def wait_info(self): print(f'{self.name} WAITINGUJE') @after('run') def run_info(self): print(f'{self.name} RUNNINGUJE') @after('terminate') def block_info(self): print(f'{self.name} TERMINATORUJE')
class Person(mongoengine.Document): name = mongoengine.StringField(default='Billy') sleeping = State(initial=True) running = State() cleaning = State() run = Event(from_states=sleeping, to_state=running) cleanup = Event(from_states=running, to_state=cleaning) sleep = Event(from_states=(running, cleaning), to_state=sleeping) @before('sleep') def do_one_thing(self): print("{} is sleepy".format(self.name)) @before('sleep') def do_another_thing(self): print("{} is REALLY sleepy".format(self.name)) @after('sleep') def snore(self): print("Zzzzzzzzzzzz") @after('sleep') def snore(self): print("Zzzzzzzzzzzzzzzzzzzzzz")
def test_continuation_works(self): machine = StateMachine(states=[ State(START_STATE, Edge('a', FINAL_STATE)), State(FINAL_STATE, Edge('', START_STATE)) ]) start_record = gen_test_state_record(START_STATE, 0, 1) state_records = [start_record] result = (True, state_records, 1) self.assertEqual(machine.accepts_partial('aaa'), result) end_record = gen_test_state_record(FINAL_STATE, 1, 1) start_record = gen_test_state_record(START_STATE, 0, 1) start_record2 = gen_test_state_record(START_STATE, 1, 2) state_records = [start_record, end_record, start_record2] result = (True, state_records, 2) self.assertEqual(machine.accepts_partial('aaa'), result) start_record = gen_test_state_record(START_STATE, 0, 1) end_record = gen_test_state_record(FINAL_STATE, 1, 1) start_record2 = gen_test_state_record(START_STATE, 1, 2) end_record2 = gen_test_state_record(FINAL_STATE, 2, 2) start_record3 = gen_test_state_record(START_STATE, 2, 3) state_records = [ start_record, end_record, start_record2, end_record2, start_record3 ] result = (True, state_records, 3) self.assertEqual(machine.accepts_partial('aaa'), result) self.assertEqual(machine.accepts_partial('aaa'), (False, None, -1))
def test_continuation_with_internal_repetition(self): machine = StateMachine(states=[ State(START_STATE, Edge('', 'a')), State('a', [Edge('a', 'a'), Edge('', FINAL_STATE)]), State(FINAL_STATE) ]) start_record = gen_test_state_record(START_STATE, 0, 0) a_record = gen_test_state_record('a', 0, 0) state_records = [start_record, a_record] result = (True, state_records, 0) self.assertEqual(machine.accepts_partial('aab'), result) start_record = gen_test_state_record(START_STATE, 0, 0) a_record = gen_test_state_record('a', 0, 1) a_record_2 = gen_test_state_record('a', 1, 1) state_records = [start_record, a_record, a_record_2] result = (True, state_records, 1) self.assertEqual(machine.accepts_partial('aab'), result) start_record = gen_test_state_record(START_STATE, 0, 0) a_record = gen_test_state_record('a', 0, 1) a_record_2 = gen_test_state_record('a', 1, 2) a_record_3 = gen_test_state_record('a', 2, 2) state_records = [start_record, a_record, a_record_2, a_record_3] result = (True, state_records, 2) self.assertEqual(machine.accepts_partial('aab'), result) self.assertEqual(machine.accepts_partial('aab'), (False, None, -1))
class Person: name = "Jim" sleeping = State(initial=True) running = State() cleaning = State() run = Event(from_states=sleeping, to_state=running) cleanup = Event(from_states=running, to_state=cleaning) sleep = Event(from_states=(running, cleaning), to_state=sleeping) @before("sleep") def sleep_before(self): print("After the busy day start. {} is going to sleep.".format( self.name)) @after("sleep") def sleep_after(self): print("After finish the whole day. {} sleep well".format(self.name)) @before('run') def run_before(self): print('exec before_run') @after('run') def run_after(self): print('exec after_run') @before("cleanup") def cleanup_before(self): print("exec before_cleanup") @after("cleanup") def cleanup_after(self): print("exec after_cleanup")
class Puppy(Base): __tablename__ = 'puppies' id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True) name = sqlalchemy.Column(sqlalchemy.String) sleeping = State(initial=True) running = State() cleaning = State() run = Event(from_states=sleeping, to_state=running) cleanup = Event(from_states=running, to_state=cleaning) sleep = Event(from_states=(running, cleaning), to_state=sleeping) @before('sleep') def do_one_thing(self): print("{} is sleepy".format(self.name)) @before('sleep') def do_another_thing(self): print("{} is REALLY sleepy".format(self.name)) @after('sleep') def snore(self): print("Zzzzzzzzzzzz") @after('sleep') def snore(self): print("Zzzzzzzzzzzzzzzzzzzzzz")
class Robot(): name = 'R2-D2' sleeping = State(initial=True) running = State() cleaning = State() run = Event(from_states=sleeping, to_state=running) cleanup = Event(from_states=running, to_state=cleaning) sleep = Event(from_states=(running, cleaning), to_state=sleeping) @before('sleep') def do_one_thing(self): print("{} is sleepy".format(self.name)) @before('sleep') def do_another_thing(self): print("{} is REALLY sleepy".format(self.name)) @after('sleep') def snore(self): print("Zzzzzzzzzzzz") @after('sleep') def snore(self): print("Zzzzzzzzzzzzzzzzzzzzzz")
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_accepts_repeated_symbols(self): machine = StateMachine(states=[ State(START_STATE, Edge('a', FINAL_STATE)), State(FINAL_STATE, Edge('', START_STATE)) ]) self.assertTrue(machine.accepts('a')[0]) machine.reset() self.assertTrue(machine.accepts('aa')[0]) machine.reset() self.assertTrue(machine.accepts('aaa')[0])
class Robot(): name = 'R2-D2' sleeping = State(initial=True) running = State() cleaning = State() run = Event(from_states=sleeping, to_state=running) cleanup = Event(from_states=running, to_state=cleaning) sleep = Event(from_states=(running, cleaning), to_state=sleeping)
class Person(mongoengine.Document): name = mongoengine.StringField(default='Billy') sleeping = State(initial=True) running = State() cleaning = State() run = Event(from_states=sleeping, to_state=running) cleanup = Event(from_states=running, to_state=cleaning) sleep = Event(from_states=(running, cleaning), to_state=sleeping)
def test_accepts_both_optional_paths(self): machine = StateMachine(states=[ State(START_STATE, [Edge('a', 'b'), Edge('a', 'c')]), State('b', Edge('b', FINAL_STATE)), State('c', Edge('c', FINAL_STATE)), State(FINAL_STATE) ]) self.assertTrue(machine.accepts('ab')[0]) machine.reset() self.assertTrue(machine.accepts('ac')[0])
class Dog(object): sleeping = State(initial=True) running = State() run = Event(from_states=sleeping, to_state=running) sleep = Event(from_states=(running,), to_state=sleeping) @before('run') def on_run(self): things_done.append("Dog.ran")
class Penguin(Base): __tablename__ = 'penguins' id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True) name = sqlalchemy.Column(sqlalchemy.String) sleeping = State(initial=True) running = State() cleaning = State() run = Event(from_states=sleeping, to_state=running) cleanup = Event(from_states=running, to_state=cleaning) sleep = Event(from_states=(running, cleaning), to_state=sleeping)
def test_accepts_repeated_digit(self): machine = StateMachine(states=[ State(START_STATE, Edge('DIGIT', FINAL_STATE, True)), State(FINAL_STATE, Edge('', START_STATE)) ]) self.assertTrue(machine.accepts('1')[0]) machine.reset() self.assertTrue(machine.accepts('12')[0]) machine.reset() self.assertTrue(machine.accepts('123')[0]) machine.reset() self.assertFalse(machine.accepts('1a3')[0])
def test_accepts_repeated_alpha(self): machine = StateMachine(states=[ State(START_STATE, Edge('ALPHA', FINAL_STATE, True)), State(FINAL_STATE, Edge('', START_STATE)) ]) self.assertTrue(machine.accepts('a')[0]) machine.reset() self.assertTrue(machine.accepts('ab')[0]) machine.reset() self.assertTrue(machine.accepts('abc')[0]) machine.reset() self.assertFalse(machine.accepts('a2c')[0])
def test_accepts_optional_symbols(self): machine = StateMachine(states=[ State(START_STATE, [Edge('a', FINAL_STATE), Edge('a', 'b')]), State('b', Edge('b', FINAL_STATE)), State(FINAL_STATE) ]) self.assertTrue(machine.accepts('a')[0]) machine.reset() self.assertTrue(machine.accepts('ab')[0]) machine.reset() self.assertFalse(machine.accepts('b')[0])
class Person(object): sleeping = State(initial=True) running = State() cleaning = State() run = Event(from_states=sleeping, to_state=running) cleanup = Event(from_states=running, to_state=cleaning) sleep = Event(from_states=(running, cleaning), to_state=sleeping) @before('run') def on_run(self): things_done.append("Person.ran")
def test_trivial_case(self): rulename = 'rulename' elements = 'abc' edge = Edge('abc', 'abc') final_edge = Edge('', FINAL_STATE) state = State('abc', final_edge, is_automata=True) start_state = State(START_STATE, edge) final_state = State(FINAL_STATE) states = [start_state, state, final_state] expected = StateMachine(rulename, states) actual = choices_parser.parse_elements(rulename, elements) assert_state_machines_equal(actual, expected)
def test_accepts_single_digit(self): machine = StateMachine(states=[ State(START_STATE, Edge('DIGIT', FINAL_STATE, True)), State(FINAL_STATE) ]) self.assertTrue(machine.accepts('1')[0]) machine.reset() self.assertTrue(machine.accepts('2')[0]) machine.reset() self.assertTrue(machine.accepts('3')[0]) machine.reset() self.assertFalse(machine.accepts('A')[0]) machine.reset() self.assertFalse(machine.accepts('a')[0])
def test_accepts_single_alpha(self): machine = StateMachine(states=[ State(START_STATE, Edge('ALPHA', FINAL_STATE, True)), State(FINAL_STATE) ]) self.assertTrue(machine.accepts('a')[0]) machine.reset() self.assertTrue(machine.accepts('A')[0]) machine.reset() self.assertTrue(machine.accepts('z')[0]) machine.reset() self.assertTrue(machine.accepts('Z')[0]) machine.reset() self.assertFalse(machine.accepts('0')[0])
class Runner(mongoengine.Document): name = mongoengine.StringField(default='Billy') sleeping = State(initial=True) running = State() cleaning = State() run = Event(from_states=sleeping, to_state=running) cleanup = Event(from_states=running, to_state=cleaning) sleep = Event(from_states=(running, cleaning), to_state=sleeping) @before('run') def check_sneakers(self): return False
def test_accepts_N_star_repeated_symbols(self): machine = StateMachine(states=[ State(START_STATE, Edge('a', 'a1')), State('a1', Edge('a', 'a2')), State('a2', [Edge('a', FINAL_STATE), Edge('a', 'a2')]), State(FINAL_STATE), ]) self.assertFalse(machine.accepts('a')[0]) machine.reset() self.assertFalse(machine.accepts('aa')[0]) machine.reset() self.assertTrue(machine.accepts('aaa')[0]) machine.reset() self.assertTrue(machine.accepts('aaaa')[0])
def test_identical_parenthetized_token_case(self): rulename = 'rulename' elements = 'abc (abc)' edge = Edge('abc', 'abc') edge2 = Edge('abc', 'abc_#2') final_edge = Edge('', FINAL_STATE) state = State('abc', edge2, is_automata=True) state2 = State('abc_#2', final_edge, is_automata=True) start_state = State(START_STATE, edge) final_state = State(FINAL_STATE) states = [start_state, state, state2, final_state] expected = StateMachine(rulename, states) actual = choices_parser.parse_elements(rulename, elements) assert_state_machines_equal(actual, expected)
def test_two_alternative_tokens_case(self): rulename = 'rulename' elements = 'abc / "def"' edge = Edge('abc', 'abc') edge2 = Edge('def', 'def') final_edge = Edge('', FINAL_STATE) state = State('abc', final_edge, is_automata=True) state2 = State('def', final_edge) start_state = State(START_STATE, [edge, edge2]) final_state = State(FINAL_STATE) states = [start_state, state, state2, final_state] expected = StateMachine(rulename, states) actual = choices_parser.parse_elements(rulename, elements) assert_state_machines_equal(actual, expected)
class Process: created = State(initial=True) waiting = State() running = State() terminated = State() blocked = State() swapped_out_waiting = State() swapped_out_blocked = State() wait = Event( from_states=(created, running, blocked, swapped_out_waiting), to_state=waiting ) run = Event( from_states=waiting, to_state=running ) terminate = Event( from_states=running, to_state=terminated ) block = Event( from_states=(running, swapped_out_blocked), to_state=blocked ) swap_wait = Event( from_states=waiting, to_state=swapped_out_waiting ) swap_block = Event( from_states=blocked, to_state=swapped_out_blocked ) def __init__(self, name): self.name = name @after('wait') def wait_info(self): print '{} entered waiting mode'.format(self.name) @after('run') def run_info(self): print '{} entered running mode'.format(self.name) @before('terminate') def terminate_info(self): print '{} terminated'.format(self.name) @after('block') def block_info(self): print '{} is blocked'.format(self.name) @after('swap_wait') def swap_wait_info(self): print '{} is swapped out and waiting'.format(self.name) @after('swap_block') def swap_block_info(self): print '{} is swapped out and blocked'.format(self.name)
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_parenthized_alternative_repeated_alternative_tokens_case(self): rulename = 'rulename' elements = 'abc / 2*("def" / "ghi")' edge = Edge('abc', 'abc') edge2 = Edge('def', 'def') edge3 = Edge('ghi', 'ghi') edge2_2 = Edge('def', 'def_2') edge3_2 = Edge('ghi', 'ghi_2') edge2_2 = Edge('def', 'def_2') edge2_e = Edge('def', 'def_2') edge3_2 = Edge('ghi', 'ghi_2') final_edge = Edge('', FINAL_STATE) state = State('abc', final_edge, is_automata=True) state2 = State('def', [edge2_2, edge3_2]) state3 = State('ghi', [edge2_2, edge3_2]) state2_2 = State('def_2', [edge2_2, edge3_2, final_edge]) state3_2 = State('ghi_2', [edge2_2, edge3_2, final_edge]) start_state = State(START_STATE, [edge, edge2, edge3]) final_state = State(FINAL_STATE) states = [ start_state, state, state2, state3, state2_2, state3_2, final_state ] expected = StateMachine(rulename, states) actual = choices_parser.parse_elements(rulename, elements) assert_state_machines_equal(actual, expected)