def execute_preemptive_state_forwards_backwards():
from rafcon.core.singleton import state_machine_execution_engine
import rafcon.gui.singleton as gui_singleton
menubar_ctrl = gui_singleton.main_window_controller.get_controller(
'menu_bar_controller')
call_gui_callback(
menubar_ctrl.on_open_activate, None, None,
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"backward_step_preemtive_test")))
testing_utils.wait_for_gui()
# reset the synchronization counter; although the tests run in different processes they share their memory
# as the import statements are at the top of the file and not inside the parallel called functions
state_machine_execution_engine.synchronization_lock.acquire()
state_machine_execution_engine.synchronization_counter = 0
state_machine_execution_engine.synchronization_lock.release()
call_gui_callback(menubar_ctrl.on_step_mode_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
# forward
for i in range(3):
call_gui_callback(menubar_ctrl.on_step_into_activate, None, None)
wait_for_execution_engine_sync_counter(2, logger)
for i in range(2):
call_gui_callback(menubar_ctrl.on_step_into_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
# "take turn" state reached
# backward
for i in range(1):
call_gui_callback(menubar_ctrl.on_backward_step_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
for i in range(3):
call_gui_callback(menubar_ctrl.on_backward_step_activate, None, None)
wait_for_execution_engine_sync_counter(2, logger)
call_gui_callback(menubar_ctrl.on_backward_step_activate, None, None)
while not state_machine_execution_engine.finished_or_stopped():
time.sleep(0.1)
call_gui_callback(verify_execute_preemptive_state_forwards_backwards)
call_gui_callback(menubar_ctrl.on_stop_activate, None)
def execute_library_state_forwards_backwards():
from rafcon.core.singleton import state_machine_execution_engine, state_machine_manager
import rafcon.gui.singleton as gui_singleton
menubar_ctrl = gui_singleton.main_window_controller.get_controller(
'menu_bar_controller')
call_gui_callback(
menubar_ctrl.on_open_activate, None, None,
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"backward_step_library_execution_test")))
testing_utils.wait_for_gui()
# reset the synchronization counter; although the tests run in different processes they share their memory
# as the import statements are at the top of the file and not inside the parallel called functions
state_machine_execution_engine.synchronization_lock.acquire()
state_machine_execution_engine.synchronization_counter = 0
state_machine_execution_engine.synchronization_lock.release()
call_gui_callback(menubar_ctrl.on_step_mode_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
# forward
for i in range(5):
call_gui_callback(menubar_ctrl.on_step_into_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
# backward
for i in range(4):
call_gui_callback(menubar_ctrl.on_backward_step_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
call_gui_callback(menubar_ctrl.on_backward_step_activate, None, None)
sm = state_machine_manager.get_active_state_machine()
while not state_machine_execution_engine.finished_or_stopped():
time.sleep(0.1)
for key, sd in sm.root_state.scoped_data.iteritems():
if sd.name == "beer_count":
assert sd.value == 100
call_gui_callback(menubar_ctrl.on_stop_activate, None)
def test_step_through_library(caplog):
testing_utils.initialize_environment_core()
testing_utils.rewind_and_set_libraries({
"unit_test_state_machines":
os.path.join(testing_utils.TEST_ASSETS_PATH,
"unit_test_state_machines")
})
state_machine = storage.load_state_machine_from_path(
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"stepping_test_with_library")))
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
rafcon.core.singleton.state_machine_manager.active_state_machine_id = state_machine.state_machine_id
state_machine_execution_engine.synchronization_lock.acquire()
state_machine_execution_engine.synchronization_counter = 0
state_machine_execution_engine.synchronization_lock.release()
rafcon.core.singleton.state_machine_execution_engine.step_mode()
wait_for_execution_engine_sync_counter(1, logger)
# step till library
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
# step into library and step out
rafcon.core.singleton.state_machine_execution_engine.step_into()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.step_out()
wait_for_execution_engine_sync_counter(2, logger)
# step till library
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
# step into library and step over library children
rafcon.core.singleton.state_machine_execution_engine.step_into()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
# step over last library item
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.stop()
rafcon.core.singleton.state_machine_execution_engine.join()
try:
from rafcon.core.state_elements.scope import ScopedVariable
for s in state_machine.root_state.scoped_data.itervalues():
if s.name == 'bottles' and s.data_port_type == ScopedVariable:
assert s.value == 4
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog)