def test_hierarchy_save_load_test(caplog): storage_path = testing_utils.get_unique_temp_path() hierarchy_state = create_hierarchy_state() sm = StateMachine(hierarchy_state) storage.save_state_machine_to_path(sm, storage_path) sm_loaded = storage.load_state_machine_from_path(storage_path) state_machine = StateMachine(sm_loaded.root_state) testing_utils.test_multithreading_lock.acquire() 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 rafcon.core.singleton.state_machine_execution_engine.start() rafcon.core.singleton.state_machine_execution_engine.join() rafcon.core.singleton.state_machine_manager.remove_state_machine( state_machine.state_machine_id) try: assert state_machine.root_state.output_data["output1"] == 52.0 # 2 type error -> one child output port data type error and root state scoped data type error testing_utils.assert_logger_warnings_and_errors(caplog, expected_errors=2) finally: testing_utils.test_multithreading_lock.release()
def test_lock_state_machine(caplog): state_machine = StateMachine() @lock_state_machine def custom_function(object, number): raise AttributeError("Test error") State.custom_method = custom_function state1 = ExecutionState("s1") state_machine.root_state = state1 try: state1.custom_method(5) except Exception as e: import traceback print("Could not stop state machine: {0} {1}".format( e, traceback.format_exc())) assert global_lock_counter == 0 state1.add_outcome("outcome1", 3) assert len(state1.outcomes) == 4 assert_logger_warnings_and_errors(caplog)
def test_concurrency_barrier_save_load(caplog): concurrency_barrier_state = create_concurrency_barrier_state() state_machine = StateMachine(concurrency_barrier_state) test_path = testing_utils.get_unique_temp_path() storage.save_state_machine_to_path(state_machine, test_path) sm_loaded = storage.load_state_machine_from_path(test_path) root_state = sm_loaded.root_state input_data = {"input_data_port1": 0.1, "input_data_port2": 0.1} output_data = {"output_data_port1": None} root_state.input_data = input_data root_state.output_data = output_data state_machine = StateMachine(root_state) testing_utils.test_multithreading_lock.acquire() rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine) rafcon.core.singleton.state_machine_execution_engine.start(state_machine.state_machine_id) rafcon.core.singleton.state_machine_execution_engine.join() try: assert rafcon.core.singleton.global_variable_manager.get_variable("var_x") == 10 assert rafcon.core.singleton.global_variable_manager.get_variable("var_y") == 20 assert root_state.final_outcome.outcome_id == 4 with pytest.raises(ValueError): concurrency_barrier_state.remove(UNIQUE_DECIDER_STATE_ID) with pytest.raises(AttributeError): concurrency_barrier_state.remove_state(UNIQUE_DECIDER_STATE_ID) rafcon.core.singleton.state_machine_manager.remove_state_machine(state_machine.state_machine_id) finally: testing_utils.shutdown_environment_only_core(caplog=caplog, expected_warnings=0, expected_errors=1)
def test_state_machine_manager(caplog): state_machine = StateMachine() state1 = ExecutionState("s1") state_machine.root_state = state1 manager = StateMachineManager.instance([state_machine]) sm_id = manager.get_sm_id_for_root_state_id('FakeId') assert (sm_id is None) assert_logger_warnings_and_errors(caplog)
def test_save_libraries(caplog): s = storage state1 = ExecutionState("library_execution_state1", path=testing_utils.TEST_SCRIPT_PATH, filename="library_execution_state1.py") input_state1 = state1.add_input_data_port("data_input_port1", "float") output_state1 = state1.add_output_data_port("data_output_port1", "float") state2 = ExecutionState("library_execution_state2", path=testing_utils.TEST_SCRIPT_PATH, filename="library_execution_state2.py") input_state2 = state2.add_input_data_port("data_input_port1", "float") output_state2 = state2.add_output_data_port("data_output_port1", "float") state3 = HierarchyState("library_hierarchy_state1") state3.add_state(state1) state3.add_state(state2) state3.set_start_state(state1.state_id) state3.add_transition(state1.state_id, 0, state2.state_id, None) state3.add_transition(state2.state_id, 0, state3.state_id, 0) input_state3 = state3.add_input_data_port("data_input_port1", "float", 1.0) output_state3 = state3.add_output_data_port("data_output_port1", "float", 2.0) state3.add_data_flow(state3.state_id, input_state3, state1.state_id, input_state1) state3.add_data_flow(state1.state_id, output_state1, state2.state_id, input_state2) state3.add_data_flow(state2.state_id, output_state2, state3.state_id, output_state3) # save hierarchy state as state machine s.save_state_machine_to_path(StateMachine(state3), join(TEST_LIBRARY_PATH, "hierarchy_library")) # save execution state as state machine s.save_state_machine_to_path(StateMachine(state1), join(TEST_LIBRARY_PATH, "execution_library")) # save hierarchy state as nested state machines state3.name = "library_nested1" s.save_state_machine_to_path(StateMachine(state3), join(TEST_LIBRARY_PATH, "library_container", "library_nested1"), delete_old_state_machine=True) state3.name = "library_nested2" s.save_state_machine_to_path(StateMachine(state3), join(TEST_LIBRARY_PATH, "library_container", "library_nested2"), delete_old_state_machine=True) testing_utils.assert_logger_warnings_and_errors(caplog)
def create_state_machine(): state1 = ExecutionState("scoped_data_test_state", path=testing_utils.TEST_SCRIPT_PATH, filename="scoped_variable_test_state.py") state1.add_outcome("loop", 1) input1_state1 = state1.add_input_data_port("input_data_port1", "float") input2_state1 = state1.add_input_data_port("input_data_port2", "float") output_state1 = state1.add_output_data_port("output_data_port1", "float") state2 = HierarchyState("scoped_data_hierarchy_state") state2.add_state(state1) state2.set_start_state(state1.state_id) state2.add_transition(state1.state_id, 0, state2.state_id, 0) state2.add_transition(state1.state_id, 1, state1.state_id, None) input_state2 = state2.add_input_data_port("input_data_port1", "float", 10.0) output_state2 = state2.add_output_data_port("output_data_port1", "float") scoped_variable_state2 = state2.add_scoped_variable( "scoped_variable1", "float", 12.0) state2.add_data_flow( state2.state_id, state2.get_scoped_variable_from_name("scoped_variable1"), state1.state_id, input1_state1) state2.add_data_flow(state2.state_id, input_state2, state1.state_id, input2_state1) state2.add_data_flow(state1.state_id, output_state1, state2.state_id, output_state2) state2.add_data_flow(state1.state_id, output_state1, state2.state_id, scoped_variable_state2) return StateMachine(state2)
def create_preemption_state_machine(): state1 = ExecutionState("FirstState", path=testing_utils.TEST_SCRIPT_PATH, filename="concurrence_preemption1.py") state1.add_outcome("FirstOutcome", 3) input_state1 = state1.add_input_data_port("input_data_port1", "float") state2 = ExecutionState("SecondState", path=testing_utils.TEST_SCRIPT_PATH, filename="concurrence_preemption2.py") state2.add_outcome("FirstOutcome", 3) input_state2 = state2.add_input_data_port("input_data_port1", "float") state3 = PreemptiveConcurrencyState("FirstConcurrencyState") state3.add_state(state1) state3.add_state(state2) state3.add_outcome("State1 preempted", 3) input_state3 = state3.add_input_data_port("input_data_port1", "float", 0.1) input2_state3 = state3.add_input_data_port("input_data_port2", "float", 0.1) state3.add_data_flow(state3.state_id, input_state3, state1.state_id, input_state1) state3.add_data_flow(state3.state_id, input2_state3, state2.state_id, input_state2) state3.add_transition(state1.state_id, 3, state3.state_id, 3) return StateMachine(state3)
def create_state_machine(): state1 = ExecutionState("MyFirstState", state_id="FirstLevel2", path=testing_utils.TEST_SCRIPT_PATH, filename="default_data_port_test_state.py") state1.add_outcome("first_outcome", 3) input_state1 = state1.add_input_data_port("input_data_port1", "str", "default_value") output_state1 = state1.add_output_data_port("output_data_port1", "str") state2 = HierarchyState("MyFirstHierarchyState", state_id="FirstLevel1") state2.add_state(state1) state2.set_start_state(state1.state_id) state2.add_outcome("Container_Outcome", 6) state2.add_transition(state1.state_id, 3, state2.state_id, 6) input_state2 = state2.add_input_data_port("input_data_port1", "str") output_state2 = state2.add_output_data_port("output_data_port1", "str") # state2.add_data_flow(state2.state_id, # input_state2, # state1.state_id, # input_state1) state2.add_data_flow(state1.state_id, output_state1, state2.state_id, output_state2) return StateMachine(state2)
def test_scoped_data(caplog): storage_path = testing_utils.get_unique_temp_path() sm = create_state_machine() storage.save_state_machine_to_path(sm, storage_path) sm_loaded = storage.load_state_machine_from_path(storage_path) state_machine = StateMachine(sm_loaded.root_state) testing_utils.test_multithreading_lock.acquire() 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 rafcon.core.singleton.state_machine_execution_engine.start() rafcon.core.singleton.state_machine_execution_engine.join() rafcon.core.singleton.state_machine_manager.remove_state_machine( state_machine.state_machine_id) try: assert state_machine.root_state.output_data[ "data_output_port1"] == 42.0 testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release()
def create_state_machine(): from rafcon.core.state_machine import StateMachine from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.states.execution_state import ExecutionState root = HierarchyState(name='root') ex1 = ExecutionState(name='1') root.add_state(ex1) ex2 = ExecutionState(name='2') root.add_state(ex2) ex3 = ExecutionState(name='3') root.add_state(ex3) # hierarchy state at the beginning h4 = HierarchyState('H4') ex41 = ExecutionState(name='41') h4.add_state(ex41) ex42 = ExecutionState(name='42') h4.add_state(ex42) ex43 = ExecutionState(name='43') h4.add_state(ex43) h4.start_state_id = ex41.state_id h4.add_transition(ex41.state_id, 0, ex42.state_id, None) h4.add_transition(ex42.state_id, 0, ex43.state_id, None) h4.add_transition(ex43.state_id, 0, h4.state_id, 0) root.add_state(h4) root.start_state_id = ex1.state_id root.add_transition(h4.state_id, 0, ex1.state_id, None) root.add_transition(ex1.state_id, 0, ex2.state_id, None) root.add_transition(ex2.state_id, 0, ex3.state_id, None) t_id = root.add_transition(ex3.state_id, 0, root.state_id, 0) return StateMachine(root_state=root), t_id, h4.state_id
def create_state_machine(): state1 = ExecutionState("first_state", path=testing_utils.TEST_SCRIPT_PATH, filename="scoped_data_test_state1.py") state1.add_outcome("first_outcome", 3) state1.add_input_data_port("data_input_port1", "float") state1.add_output_data_port("data_output_port1", "float") state2 = ExecutionState("second_state", path=testing_utils.TEST_SCRIPT_PATH, filename="scoped_data_test_state2.py") state2.add_outcome("first_outcome", 3) state2.add_input_data_port("data_input_port1", "float") state2.add_output_data_port("data_output_port1", "float") state3 = HierarchyState("hierarchy_state") state3.add_state(state1) state3.add_state(state2) state3.set_start_state(state1.state_id) state3.add_outcome("Container_Outcome", 6) state3.add_transition(state1.state_id, 3, state2.state_id, None) state3.add_transition(state2.state_id, 3, state3.state_id, 6) state3.add_input_data_port("data_input_port1", "float", 22.0) state3.add_output_data_port("data_output_port1", "float") state3.add_data_flow(state3.state_id, state3.get_io_data_port_id_from_name_and_type("data_input_port1", InputDataPort), state1.state_id, state1.get_io_data_port_id_from_name_and_type("data_input_port1", InputDataPort)) state3.add_data_flow(state1.state_id, state1.get_io_data_port_id_from_name_and_type("data_output_port1", OutputDataPort), state2.state_id, state2.get_io_data_port_id_from_name_and_type("data_input_port1", InputDataPort)) state3.add_data_flow(state2.state_id, state2.get_io_data_port_id_from_name_and_type("data_output_port1", OutputDataPort), state3.state_id, state3.get_io_data_port_id_from_name_and_type("data_output_port1", OutputDataPort)) return StateMachine(state3)
def test_gui(number_child_states=10, number_childs_per_child=10, barrier=False, sleep=False, profile_add_state=True, caplog=None): create_gui() from rafcon.core.state_machine import StateMachine from core_performance import create_hierarchy_state, create_barrier_concurrency_state try: if barrier: state_machine = StateMachine(create_barrier_concurrency_state(number_child_states, number_childs_per_child)) else: state_machine = StateMachine(create_hierarchy_state(number_child_states, sleep=sleep)) add_state_machine_to_manager_model(state_machine, profile_add_state) except Exception: raise finally: destroy_gui(caplog)
def create_state_machine(): from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.states.execution_state import ExecutionState from rafcon.core.state_machine import StateMachine state1 = ExecutionState('State1', state_id='STATE1') state2 = ExecutionState('State2') state4 = ExecutionState('Nested') output_state4 = state4.add_output_data_port("out", "int") state5 = ExecutionState('Nested2') input_state5 = state5.add_input_data_port("in", "int", 0) state3 = HierarchyState(name='State3', state_id='STATE3') state3.add_state(state4) state3.add_state(state5) state3.set_start_state(state4) state3.add_scoped_variable("share", "int", 3) state3.add_transition(state4.state_id, 0, state5.state_id, None) state3.add_transition(state5.state_id, 0, state3.state_id, 0) state3.add_data_flow(state4.state_id, output_state4, state5.state_id, input_state5) ctr_state = HierarchyState(name="Container", state_id='ROOTSTATE') ctr_state.add_state(state1) ctr_state.add_state(state2) ctr_state.add_state(state3) ctr_state.set_start_state(state1) ctr_state.add_transition(state1.state_id, 0, state2.state_id, None) ctr_state.add_transition(state2.state_id, 0, state3.state_id, None) ctr_state.add_transition(state3.state_id, 0, ctr_state.state_id, 0) ctr_state.name = "Container" state_machine = StateMachine(ctr_state) return state_machine
def create_state_machine2(): state1 = ExecutionState("MyFirstState", state_id="FirstLevel2", path=testing_utils.TEST_SCRIPT_PATH, filename="default_data_port_test_state.py") state0 = ExecutionState("MyZeroState", state_id="ZeroLevel2", path=testing_utils.TEST_SCRIPT_PATH, filename="default_data_port_test_state.py") state0.add_outcome("first_outcome", 3) input_state0 = state0.add_input_data_port("input_data_port1", tuple, (1, 3, 2), data_port_id=1) output_state0 = state0.add_output_data_port("output_data_port1", tuple) state1.add_outcome("first_outcome", 3) input_state1 = state1.add_input_data_port("input_data_port1", tuple, (1, 3, 2), data_port_id=1) output_state1 = state1.add_output_data_port("output_data_port1", tuple) state2 = HierarchyState("MyFirstHierarchyState",state_id="FirstLevel1") state2.add_state(state1) state2.add_state(state0) state2.set_start_state(state0.state_id) state2.add_outcome("Container_Outcome", 6) state2.add_transition(state0.state_id, 3, state1.state_id, None) state2.add_transition(state1.state_id, 3, state2.state_id, 6) input_state2 = state2.add_input_data_port("input_data_port1", tuple) output_state2 = state2.add_output_data_port("output_data_port1", tuple) state2.add_data_flow(state0.state_id, output_state0, state1.state_id, input_state1) state2.add_data_flow(state1.state_id, output_state1, state2.state_id, output_state2) return StateMachine(state2)
def _test_multiple_undo_redo_bug_with_gui(gui): from gi.repository import GLib import rafcon.gui.singleton num_add = 10 num_undo = 20 num_redo = 20 sm = StateMachine(HierarchyState()) gui(rafcon.core.singleton.state_machine_manager.add_state_machine, sm) sm_m = list(rafcon.gui.singleton.state_machine_manager_model. state_machines.values())[-1] gui(sm_m.selection.set, [sm_m.root_state]) main_window_controller = rafcon.gui.singleton.main_window_controller sm_id = sm_m.state_machine.state_machine_id state_machines_editor_ctrl = main_window_controller.state_machines_editor_ctrl gui( state_machines_editor_ctrl.get_controller( sm_id).view.get_parent_widget().grab_focus) gui( state_machines_editor_ctrl.get_controller( sm_id).view.editor.grab_focus) def trigger_action_repeated(action_name, number): for _ in range(number): main_window_controller.shortcut_manager.trigger_action( action_name, None, None) gui(trigger_action_repeated, "add", num_add, priority=GLib.PRIORITY_HIGH) assert len(sm_m.history.modifications) == num_add + 1 gui(trigger_action_repeated, "undo", num_undo, priority=GLib.PRIORITY_HIGH) gui.expected_warnings += max(num_undo - num_add, 0) gui(trigger_action_repeated, "redo", num_redo, priority=GLib.PRIORITY_HIGH) gui.expected_warnings += max(num_redo - min(num_add, num_undo), 0)
def test_runtime_checks_for_data_port_data_types(caplog): storage_path = testing_utils.get_unique_temp_path() print(storage_path) sm = create_state_machine2() # test output port type check script_text = 'def execute(self, inputs, outputs, gvm):\n' \ ' outputs["output_data_port1"] = [1, 2, 3]\n' \ ' return 3' sm.get_state_by_path('FirstLevel1/ZeroLevel2').script_text = script_text # TODO comment (next 2 lines) in after final fix of tuple storing bug is applied and remove 3 line (4 storage check) # storage.save_state_machine_to_path(sm, storage_path) # sm_loaded = storage.load_state_machine_from_path(storage_path) sm_loaded = sm root_state = sm_loaded.root_state state_machine = StateMachine(root_state) testing_utils.test_multithreading_lock.acquire() rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine) rafcon.core.singleton.state_machine_execution_engine.start(state_machine.state_machine_id) rafcon.core.singleton.state_machine_execution_engine.join() rafcon.core.singleton.state_machine_manager.remove_state_machine(state_machine.state_machine_id) # 6 errors -> IN ORDER output port-, root state scoped-, input port-, output port-, root state scoped- and # root state output port-data-type-errors testing_utils.shutdown_environment_only_core(caplog=caplog, expected_errors=6)
def create_execution_state_library_state_machine(): rafcon.core.singleton.library_manager.initialize() library_container_state = HierarchyState("libContainerState", state_id="libContainerState") lib_state = LibraryState("temporary_libraries", "execution_library", "0.1", "library_execution_state", state_id="library_execution_state") library_container_state.add_state(lib_state) library_container_state.set_start_state(lib_state.state_id) library_container_state.add_transition(lib_state.state_id, 0, library_container_state.state_id, 0) lib_container_input = library_container_state.add_input_data_port( "data_input_port1", "float", 32.0) lib_container_output = library_container_state.add_output_data_port( "data_output_port1", "float") library_container_state.add_data_flow( library_container_state.state_id, lib_container_input, lib_state.state_id, lib_state.get_io_data_port_id_from_name_and_type( "data_input_port1", InputDataPort)) library_container_state.add_data_flow( lib_state.state_id, lib_state.get_io_data_port_id_from_name_and_type( "data_output_port1", OutputDataPort), library_container_state.state_id, lib_container_output) return StateMachine(library_container_state)
def test_default_values_of_data_ports(caplog): storage_path = testing_utils.get_unique_temp_path() print(storage_path) sm = create_state_machine() storage.save_state_machine_to_path(sm, storage_path) sm_loaded = storage.load_state_machine_from_path(storage_path) root_state = sm_loaded.root_state state_machine = StateMachine(root_state) testing_utils.test_multithreading_lock.acquire() rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine) rafcon.core.singleton.state_machine_execution_engine.start(state_machine.state_machine_id) rafcon.core.singleton.state_machine_execution_engine.join() rafcon.core.singleton.state_machine_manager.remove_state_machine(state_machine.state_machine_id) print(root_state.output_data) try: assert root_state.output_data["output_data_port1"] == "default_value" finally: testing_utils.shutdown_environment_only_core(caplog=caplog)
def create_models(*args, **kargs): import rafcon.core.singleton from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.states.execution_state import ExecutionState from rafcon.core.state_machine import StateMachine state1 = HierarchyState('State1', state_id="State1") state2 = ExecutionState('State2', state_id="State2") ctr_state = HierarchyState(name="Root", state_id="Root") ctr_state.add_state(state1) ctr_state.add_state(state2) ctr_state.start_state_id = state1.state_id ctr_state.add_transition(state1.state_id, from_outcome=0, to_state_id=state2.state_id, to_outcome=None) ctr_state.add_transition(state2.state_id, from_outcome=0, to_state_id=ctr_state.state_id, to_outcome=0) ctr_state.name = "Container" sm = StateMachine(ctr_state) # add new state machine rafcon.core.singleton.state_machine_manager.add_state_machine(sm) rafcon.core.singleton.state_machine_manager.active_state_machine_id = sm.state_machine_id
def run_turtle_demo(): import rafcon.core import rafcon.core.start signal.signal(signal.SIGINT, rafcon.core.start.signal_handler) global_config.load() global_gui_config.load() # set the test_libraries path temporarily to the correct value library_paths = rafcon.core.config.global_config.get_config_value( "LIBRARY_PATHS") if os.path.exists( str(os.path.sep).join( [rafcon.__path__[0], '..', '..', '..', 'share', 'libraries'])): # rm-pkg os.environ['RAFCON_LIB_PATH'] = os.path.join(rafcon.__path__[0], '..', '..', '..', 'share', 'libraries') library_paths["ros_libraries"] = os.path.join(rafcon.__path__[0], '..', '..', '..', 'share', 'examples', 'libraries', 'ros_libraries') library_paths["turtle_libraries"] = os.path.join( rafcon.__path__[0], '..', '..', '..', 'share', 'examples', 'libraries', 'turtle_libraries') example_path = os.path.join(rafcon.__path__[0], os.pardir, '..', '..', 'share', 'examples', "tutorials") else: # git repo os.environ['RAFCON_LIB_PATH'] = os.path.join( dirname(abspath(__file__)), '..', '..', '..', 'libraries') library_paths["ros_libraries"] = os.path.join( dirname(abspath(__file__)), '..', '..', 'libraries', 'ros_libraries') library_paths["turtle_libraries"] = os.path.join( dirname(abspath(__file__)), '..', '..', 'libraries', 'turtle_libraries') example_path = os.path.join(dirname(abspath(__file__)), '..', '..', "tutorials") rafcon.core.singleton.library_manager.initialize() rafcon.core.singleton.state_machine_manager.delete_all_state_machines() base_path = os.path.dirname(os.path.abspath(__file__)) basic_turtle_demo_state = create_turtle_statemachine( base_path, example_path) state_machine = StateMachine(basic_turtle_demo_state) # # load the state machine # [state_machine, version, creation_time] = storage.load_statemachine_from_path( # "../../share/examples/tutorials/basic_turtle_demo_sm") rafcon.core.singleton.library_manager.initialize() main_window_view = MainWindowView() rafcon.core.singleton.state_machine_manager.add_state_machine( state_machine) sm_manager_model = rafcon.gui.singleton.state_machine_manager_model main_window_controller = MainWindowController(sm_manager_model, main_window_view) gtk.main() logger.debug("Gtk main loop exited!")
def execute_state(root_state): state_machine = StateMachine(root_state) rafcon.core.singleton.state_machine_manager.add_state_machine( state_machine) rafcon.core.singleton.state_machine_execution_engine.start( state_machine.state_machine_id) rafcon.core.singleton.state_machine_execution_engine.join() rafcon.core.singleton.state_machine_manager.remove_state_machine( state_machine.state_machine_id)
def test_hierarchy_state_execution(caplog): hierarchy_state = create_hierarchy_state() state_machine = StateMachine(hierarchy_state) try: # Changing the data type has to fail, as the data port is already connected to a data flow state_machine.root_state.input_data_ports[42].data_type = str except Exception, e: assert isinstance(e, ValueError)
def test_lock_state_machine(caplog): state_machine = StateMachine() @lock_state_machine def custom_function(object, number): raise AttributeError("Test error") State.custom_method = custom_function state1 = ExecutionState("s1") state_machine.root_state = state1 try: state1.custom_method(5) except Exception, e: import traceback print "Could not stop state machine: {0} {1}".format( e.message, traceback.format_exc())
def create_state_machine(): state1 = ExecutionState("DummyState1", path=testing_utils.TEST_SCRIPT_PATH, filename="transition_test_state.py") state1.add_outcome('dummy_outcome_1', 3) state1.add_outcome('dummy_outcome_2', 4) state2 = ExecutionState("DummyState2", path=testing_utils.TEST_SCRIPT_PATH, filename="transition_test_state.py") state2.add_outcome('dummy_outcome_1', 3) state2.add_outcome('dummy_outcome_2', 4) state3 = ExecutionState("DummyState3", path=testing_utils.TEST_SCRIPT_PATH, filename="transition_test_state.py") state3.add_outcome('dummy_outcome_1', 3) state3.add_outcome('dummy_outcome_2', 4) state4 = HierarchyState("DummyHierarchyState") state4.add_state(state1) state4.set_start_state(state1.state_id) state4.add_state(state2) state4.add_state(state3) state4.add_outcome("final_outcome", 5) state4.add_transition(state1.state_id, 3, state2.state_id, None) state4.add_transition(state1.state_id, 4, state3.state_id, None) state4.add_transition(state2.state_id, 3, state4.state_id, 5) state4.add_transition(state3.state_id, 3, state4.state_id, 5) state4.add_transition(state3.state_id, 4, state4.state_id, 5) t = state4.add_transition(state2.state_id, 4, state1.state_id, None) state4.remove_transition(t) state4.add_transition(state2.state_id, 4, state1.state_id, None) # no target at all with raises(ValueError): state4.add_transition(state3.state_id, 4, None, None) # no to_state with raises(ValueError): state4.add_transition(state3.state_id, 4, None, 5) # start transition already existing with raises(ValueError): state4.add_transition(None, None, state3.state_id, None) state4.start_state_id = None state4.add_transition(None, None, state1.state_id, None) return StateMachine(state4)
def return_loop_state_machine(): state1 = ExecutionState("MyFirstState", path=testing_utils.TEST_SCRIPT_PATH, filename="loop_state1.py") state1.add_outcome("MyFirstOutcome", 3) state2 = ExecutionState("MySecondState", path=testing_utils.TEST_SCRIPT_PATH, filename="loop_state2.py") state2.add_outcome("FirstOutcome", 3) state3 = HierarchyState("MyFirstHierarchyState") state3.add_state(state1) state3.add_state(state2) state3.set_start_state(state1.state_id) state3.add_transition(state1.state_id, 3, state2.state_id, None) state3.add_transition(state2.state_id, 3, state1.state_id, None) return StateMachine(state3)
def test_last_wins_value_collection_for_data_ports(caplog): sm_path = testing_utils.get_test_sm_path(os.path.join("unit_test_state_machines", "last_data_wins_test")) sm_loaded = storage.load_state_machine_from_path(sm_path) root_state = sm_loaded.root_state state_machine = StateMachine(root_state) testing_utils.test_multithreading_lock.acquire() rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine) rafcon.core.singleton.state_machine_execution_engine.start(state_machine.state_machine_id) rafcon.core.singleton.state_machine_execution_engine.join() rafcon.core.singleton.state_machine_manager.remove_state_machine(state_machine.state_machine_id) testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_concurrency_barrier_state_execution(caplog): with testing_utils.test_multithreading_lock: sm = create_state_machine() root_state = sm.root_state state_machine = StateMachine(root_state) rafcon.core.singleton.state_machine_manager.add_state_machine( state_machine) rafcon.core.singleton.state_machine_execution_engine.start( state_machine.state_machine_id) rafcon.core.singleton.state_machine_execution_engine.join() rafcon.core.singleton.state_machine_manager.remove_state_machine( state_machine.state_machine_id) assert root_state.output_data["output_data_port1"] == 42 testing_utils.assert_logger_warnings_and_errors(caplog)
def create_state_machine(): state1 = ExecutionState("MyFirstState", path=testing_utils.TEST_SCRIPT_PATH, filename="global_variable_state.py") state1.add_outcome("first_outcome", 3) input_state1 = state1.add_input_data_port("input_data_port1", "float") output_state1 = state1.add_output_data_port("output_data_port1", "float") state3 = HierarchyState("MyFirstHierarchyState") state3.add_state(state1) state3.set_start_state(state1.state_id) state3.add_outcome("Container_Outcome", 6) state3.add_transition(state1.state_id, 3, state3.state_id, 6) input_state3 = state3.add_input_data_port("input_data_port1", "float", 22.0) output_state3 = state3.add_output_data_port("output_data_port1", "float") state3.add_data_flow(state3.state_id, input_state3, state1.state_id, input_state1) state3.add_data_flow(state1.state_id, output_state1, state3.state_id, output_state3) return StateMachine(state3)
def create_preemptive_wait_state_machine(): state1 = ExecutionState("state_1", path=testing_utils.TEST_SCRIPT_PATH, filename="preemptive_wait_test.py") state1.add_outcome("FirstOutcome", 3) state2 = ExecutionState("state_2", path=testing_utils.TEST_SCRIPT_PATH, filename="preemptive_wait_test.py") state2.add_outcome("FirstOutcome", 3) ctr_state = PreemptiveConcurrencyState("FirstConcurrencyState") ctr_state.add_state(state1) ctr_state.add_state(state2) ctr_state.add_outcome("end", 3) ctr_state.add_transition(state1.state_id, 3, ctr_state.state_id, 3) ctr_state.add_transition(state2.state_id, 3, ctr_state.state_id, 3) return StateMachine(ctr_state)
def create_models(*args, **kargs): import rafcon.core.singleton import rafcon.gui.singleton from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.state_machine import StateMachine state1 = HierarchyState('State1', state_id="State1") ctr_state = HierarchyState(name="Root", state_id="Root") ctr_state.add_state(state1) ctr_state.name = "Container" sm = StateMachine(ctr_state) # add new state machine rafcon.core.singleton.state_machine_manager.add_state_machine(sm) testing_utils.wait_for_gui() # select state machine rafcon.gui.singleton.state_machine_manager_model.selected_state_machine_id = sm.state_machine_id