def execute_command_synchronized_on_state(state_machine,
state_id,
command,
counter=1,
join=True):
old_run_id = state_machine.get_state_by_path(state_id).run_id
old_execution_counter = state_machine.get_state_by_path(
state_id)._execution_counter
getattr(rafcon.core.singleton.state_machine_execution_engine, command)()
# let the state start properly
while old_run_id == state_machine.get_state_by_path(state_id).run_id:
time.sleep(0.005)
while old_execution_counter == state_machine.get_state_by_path(
state_id)._execution_counter:
time.sleep(0.005)
if join:
try:
state_machine.get_state_by_path(state_id).join()
except RuntimeError:
# if the state is already executed then join() returns with an RuntimeError
pass
# let the hierarchy properly chose the next state
wait_for_execution_engine_sync_counter(counter, logger)
def test_run_this_state(caplog):
# run_selected
# Initialize testing environment
testing_utils.initialize_environment_core()
# Load State Machine
sm = storage.load_state_machine_from_path(
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines", "test_run_this_state")))
rafcon.core.singleton.state_machine_manager.add_state_machine(sm)
# Run selected state machine
rafcon.core.singleton.global_variable_manager.set_variable("test_value", 1)
state_machine_execution_engine.run_selected_state("BTWFZQ/EPQSTG",
sm.state_machine_id)
wait_for_execution_engine_sync_counter(1, logger)
state_machine_execution_engine.stop()
rafcon.core.singleton.state_machine_execution_engine.join()
# assert variable state
try:
assert rafcon.core.singleton.global_variable_manager.get_variable(
"test_value") == 2
# Shutdown testing environment
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_backward_stepping_library_state(gui):
gui(initialize_global_variables)
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.menu_bar_controller
sm = gui(
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
with state_machine_execution_engine._status.execution_condition_variable:
state_machine_execution_engine.synchronization_counter = 0
gui(menubar_ctrl.on_step_mode_activate, None, None)
current_state_machine_id = gui_singleton.state_machine_manager.active_state_machine_id
state_machines_editor_tab_status_check(current_state_machine_id, active=True) # execution start is synchronous
wait_for_execution_engine_sync_counter(1, logger)
# forward
for i in range(5):
gui(menubar_ctrl.on_step_into_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
# backward
for i in range(4):
gui(menubar_ctrl.on_backward_step_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
gui(menubar_ctrl.on_backward_step_activate, None, None)
while not state_machine_execution_engine.finished_or_stopped():
time.sleep(0.1)
for key, sd in sm.root_state.scoped_data.items():
if sd.name == "beer_count":
assert sd.value == 100
# stop or finished are asynchronous but the call_gui_callback makes the check synchronous
gui(state_machines_editor_tab_status_check, current_state_machine_id, False)
def test_backward_stepping_preemptive_state(gui):
gui(initialize_global_variables)
from rafcon.core.singleton import state_machine_execution_engine
menubar_ctrl = gui.singletons.main_window_controller.menu_bar_controller
state_machine = gui(
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
with state_machine_execution_engine._status.execution_condition_variable:
state_machine_execution_engine.synchronization_counter = 0
gui(menubar_ctrl.on_step_mode_activate, None, None)
current_state_machine_id = gui.singletons.state_machine_manager.active_state_machine_id
state_machines_editor_tab_status_check(current_state_machine_id, active=True) # execution start is synchronous
wait_for_execution_engine_sync_counter(1, logger)
for i in range(3):
gui(menubar_ctrl.on_step_into_activate, None, None)
wait_for_execution_engine_sync_counter(2, logger)
gui(menubar_ctrl.on_step_into_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
# preemptive concurrency state must be finished before the next step
while not state_machine.get_state_by_path("AOURYA/LXEMOO").final_outcome:
time.sleep(0.010)
gui(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):
gui(menubar_ctrl.on_backward_step_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
for i in range(3):
gui(menubar_ctrl.on_backward_step_activate, None, None)
wait_for_execution_engine_sync_counter(2, logger)
state_machines_editor_tab_status_check(current_state_machine_id, active=True)
gui(menubar_ctrl.on_backward_step_activate, None, None)
while not state_machine_execution_engine.finished_or_stopped():
time.sleep(0.1)
# stop or finished are asynchronous but the call_gui_callback makes the check synchronous
gui(state_machines_editor_tab_status_check, current_state_machine_id, False)
gui(verify_execute_preemptive_state_forwards_backwards)
def test_backward_stepping_barrier_state(gui):
gui(initialize_global_variables)
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')
sm = gui(
menubar_ctrl.on_open_activate, None, None,
testing_utils.get_test_sm_path(os.path.join("unit_test_state_machines", "backward_step_barrier_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
with state_machine_execution_engine._status.execution_condition_variable:
state_machine_execution_engine.synchronization_counter = 0
gui(menubar_ctrl.on_step_mode_activate, sm.state_machine_id, None)
wait_for_execution_engine_sync_counter(1, logger)
for i in range(2):
gui(menubar_ctrl.on_step_into_activate, None, None)
wait_for_execution_engine_sync_counter(3, logger)
gui(menubar_ctrl.on_step_over_activate, None, None)
wait_for_execution_engine_sync_counter(3, logger)
gui(menubar_ctrl.on_step_out_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
for i in range(3):
gui(menubar_ctrl.on_step_into_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
# backward
for i in range(3):
gui(menubar_ctrl.on_backward_step_activate, None, None)
wait_for_execution_engine_sync_counter(1, logger)
print("cp1")
for i in range(4):
gui(menubar_ctrl.on_backward_step_activate, None, None)
wait_for_execution_engine_sync_counter(3, logger)
print("cp2")
gui(menubar_ctrl.on_backward_step_activate, None, None)
print("cp3")
while not state_machine_execution_engine.finished_or_stopped():
time.sleep(0.1)
print("cp4")
testing_utils.wait_for_gui()
print("cp5")
for key, sd in sm.root_state.scoped_data.items():
if sd.name == "beer_number":
assert sd.value == 100
elif sd.name == "wine_number":
assert sd.value == 40
elif sd.name == "whiskey_number":
assert sd.value == 20
gui.expected_warnings = 3
gui(menubar_ctrl.on_stop_activate, None)
def test_step_into_over_out_no_library(caplog):
testing_utils.initialize_environment_core()
state_machine = storage.load_state_machine_from_path(
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines", "stepping_test")))
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
with state_machine_execution_engine._status.execution_condition_variable:
state_machine_execution_engine.synchronization_counter = 0
rafcon.core.singleton.state_machine_execution_engine.step_mode(
state_machine.state_machine_id)
wait_for_execution_engine_sync_counter(1, logger)
# sm structure
# GLSUJY
# GLSUJY/PXTKIH
# GLSUJY/NDIVLD
# GLSUJY/SFZGMH
# GLSUJY/SMCOIB
# GLSUJY/SMCOIB/YSBJGK
# GLSUJY/SMCOIB/OUWQUJ
# GLSUJY/SMCOIB/UGGFFI
execute_command_synchronized_on_state(state_machine, "GLSUJY/PXTKIH",
"step_over", 1)
execute_command_synchronized_on_state(state_machine, "GLSUJY/NDIVLD",
"step_over", 1)
execute_command_synchronized_on_state(state_machine, "GLSUJY/SFZGMH",
"step_over", 1)
execute_command_synchronized_on_state(state_machine, "GLSUJY/SMCOIB",
"step_over", 1)
execute_command_synchronized_on_state(state_machine, "GLSUJY/PXTKIH",
"step_into")
execute_command_synchronized_on_state(state_machine, "GLSUJY/NDIVLD",
"step_into")
execute_command_synchronized_on_state(state_machine, "GLSUJY/SFZGMH",
"step_into")
execute_command_synchronized_on_state(state_machine,
"GLSUJY/SMCOIB",
"step_into",
join=False)
execute_command_synchronized_on_state(state_machine,
"GLSUJY/SMCOIB/YSBJGK", "step_into")
rafcon.core.singleton.state_machine_execution_engine.step_out()
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:
assert rafcon.core.singleton.global_variable_manager.get_variable(
"bottles") == 95
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog)
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)
with state_machine_execution_engine._status.execution_condition_variable:
state_machine_execution_engine.synchronization_counter = 0
rafcon.core.singleton.state_machine_execution_engine.step_mode(
state_machine.state_machine_id)
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(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 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.values():
if s.name == 'bottles' and s.data_port_type == ScopedVariable:
assert s.value == 4
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog)