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)
