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_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 test_references(caplog): gvm = GlobalVariableManager() d = {'a': 1, 'b': 2} # Test access by reference gvm.set_variable('d', d, per_reference=True) _d = gvm.get_variable('d', per_reference=True) d['a'] = 3 assert d['a'] == _d['a'] == 3 __d = gvm.get_variable('d', per_reference=True) assert d['a'] == __d['a'] == 3 ___d = gvm.get_variable('d') d['a'] = 4 assert d['a'] == __d['a'] == ___d['a'] == 4 # Test set by reference, get by copy gvm.set_variable('x', d, per_reference=True) cd = gvm.get_variable('x', per_reference=False) d['a'] = 5 assert d['a'] == 5 and cd['a'] == 4 # Test access by copy dc = gvm.get_variable('d', per_reference=False) d['b'] = 5 assert d['a'] == dc['a'] assert d['b'] != dc['b'] gvm.set_variable('c', d) cc = gvm.get_variable('c') d['a'] = 10 assert d['a'] != cc['a'] with raises(RuntimeError): gvm.get_variable('c', per_reference=True) testing_utils.assert_logger_warnings_and_errors(caplog)
def test_start_stop_pause_step(caplog): sm = return_loop_state_machine() rafcon.core.singleton.global_variable_manager.set_variable("counter", 0) testing_utils.test_multithreading_lock.acquire() rafcon.core.singleton.state_machine_manager.add_state_machine(sm) rafcon.core.singleton.state_machine_manager.active_state_machine_id = sm.state_machine_id rafcon.core.singleton.state_machine_execution_engine.step_mode() for i in range(5): time.sleep(0.2) rafcon.core.singleton.state_machine_execution_engine.step_into() # give the state machine time to execute time.sleep(0.2) 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( "counter") == 5 rafcon.core.singleton.state_machine_manager.remove_state_machine( sm.state_machine_id) testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release()
def test_invalid_locale_setting(caplog, monkeypatch): create_mo_files() with use_locale("invalid", monkeypatch): i18n.setup_l10n() testing_utils.assert_logger_warnings_and_errors(caplog=caplog, expected_warnings=1)
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_connections_from_object_type(caplog): parent_state = HierarchyState("parent") child_state = ExecutionState("child") parent_state.add_state(child_state) parent_obj_port_id = parent_state.add_input_data_port("obj", data_type=object, default_value=None) parent_int_port_id = parent_state.add_input_data_port("int", data_type=int, default_value=None) child_obj_port_id = child_state.add_input_data_port("obj", data_type=object, default_value=0) child_int_port_id = child_state.add_input_data_port("int", data_type=int, default_value=0) # Connection from specific type int to generic type object parent_state.add_data_flow(parent_state.state_id, parent_int_port_id, child_state.state_id, child_obj_port_id) # Connection from generic type object to specific type int parent_state.add_data_flow(parent_state.state_id, parent_obj_port_id, child_state.state_id, child_int_port_id) testing_utils.assert_logger_warnings_and_errors(caplog, expected_warnings=0, expected_errors=0)
def test_default_run(self, caplog): gvm.set_variable("wait_inner_observer_1", 1) gvm.set_variable("wait_inner_observer_2", 1) gvm.set_variable("wait_observer_1", 1) gvm.set_variable("wait_observer_2", 1) self.run_state_machine() self.assert_no_errors() testing_utils.assert_logger_warnings_and_errors(caplog, 0)
def test_save_nested_library_state(caplog): library_with_nested_library_sm = create_hierarchy_state_library_state_machine( ) storage.save_state_machine_to_path(library_with_nested_library_sm, join(TEST_LIBRARY_PATH, "library_with_nested_library"), delete_old_state_machine=True) testing_utils.assert_logger_warnings_and_errors(caplog)
def test_observer_1_exception(self, caplog): gvm.set_variable("wait_observer_1", 0.1) gvm.set_variable("observer_1_exception", True) self.run_state_machine() self.assert_no_errors() assert_all_false(gvm.get_variable("inner_observer_1_finish"), gvm.get_variable("observer_1_finish"), gvm.get_variable("observer_1_finish"), gvm.get_variable("observer_2_finish")) testing_utils.assert_logger_warnings_and_errors(caplog, 0, 1)
def test_runtime_values(caplog): state_machine_manager.delete_all_state_machines() sm = state_machine_execution_engine.execute_state_machine_from_path( path=testing_utils.get_test_sm_path( os.path.join("unit_test_state_machines", "library_runtime_value_test"))) state_machine_manager.remove_state_machine(sm.state_machine_id) assert sm.root_state.output_data["data_output_port1"] == 114 testing_utils.assert_logger_warnings_and_errors(caplog)
def test_slim_observer(caplog): testing_utils.dummy_gui(None) test_observer = ObserverTest() test_observer.test_observable.first_var = 20.0 assert test_observer.test_value == 20 test_observer.test_observable.complex_method(1, 3, "Hello world") assert test_observer.test_observable.observable_test_var == 4 assert test_observer.test_value2 == 4 assert test_observer.test_value3 == 30 testing_utils.assert_logger_warnings_and_errors(caplog)
def test_inner_observer_1_finish(self, caplog): gvm.set_variable("wait_inner_observer_1", 0.1) self.run_state_machine() self.assert_no_errors() assert_gvm("inner_observer_1_finish") assert_gvm("inner_exit_handler") assert_gvm("exit_handler") assert_gvm("exit_handler_2", False) assert_all_false(gvm.get_variable("inner_observer_2_finish"), gvm.get_variable("observer_1_finish"), gvm.get_variable("observer_2_finish")) testing_utils.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 test_locks(caplog): gvm = GlobalVariableManager() gvm.set_variable('a', 1) a = gvm.get_variable('a') assert a == 1 access_key = gvm.lock_variable('a') gvm.lock_variable('a') a = gvm.get_variable('a', access_key=access_key) assert a == 1 gvm.set_variable('a', 2, access_key=access_key) assert gvm.get_variable('a', access_key=access_key) == 2 gvm.unlock_variable('a', access_key) gvm.unlock_variable('a', access_key) testing_utils.assert_logger_warnings_and_errors(caplog, expected_errors=2)
def test_concurrency_barrier_state_execution(caplog): testing_utils.test_multithreading_lock.acquire() 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_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 root_state.output_data["output_data_port1"] == 42 testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release()
def test_preemptive_wait2_timeout(caplog): testing_utils.test_multithreading_lock.acquire() gvm.set_variable('state_2_wait', 0.5) gvm.set_variable('state_1_wait', 1.) run_state_machine() try: assert 0.5 < gvm.get_variable('state_2_wait_time') assert gvm.get_variable('state_1_preempted') assert not gvm.get_variable('state_2_preempted') testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release()
def test_preemptive_wait_daemon(caplog): testing_utils.test_multithreading_lock.acquire() gvm.set_variable('state_1_wait', 0.5) gvm.set_variable('state_2_wait', None) run_state_machine() try: assert 0.5 < gvm.get_variable('state_1_wait_time') # cannot assert this as state 2 may be launched later and will thus have a shorter execution time # assert 0.5 < gvm.get_variable('state_2_wait_time') assert not gvm.get_variable('state_1_preempted') assert gvm.get_variable('state_2_preempted') testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release()
def test_port_and_outcome_removal(caplog): container = ContainerState("Container") input_container_state = container.add_input_data_port("input", "float") output_container_state = container.add_output_data_port("output", "float") scoped_variable_container_state = container.add_scoped_variable( "scope", "float") assert len(container.transitions) == 0 assert len(container.data_flows) == 0 assert len(container.outcomes) == 3 assert len(container.input_data_ports) == 1 assert len(container.output_data_ports) == 1 assert len(container.scoped_variables) == 1 state1 = ExecutionState("test_execution_state") input_state1 = state1.add_input_data_port("input", "float") output_state1 = state1.add_output_data_port("output", "float") container.add_state(state1) container.add_transition(state1.state_id, 0, container.state_id, -2) container.add_data_flow(container.state_id, input_container_state, state1.state_id, input_state1) container.add_data_flow(state1.state_id, output_state1, container.state_id, output_container_state) container.add_data_flow(container.state_id, input_container_state, container.state_id, scoped_variable_container_state) assert len(container.transitions) == 1 assert len(container.data_flows) == 3 state1.remove_outcome(0) assert len(container.transitions) == 0 state1.remove_output_data_port(output_state1) assert len(container.data_flows) == 2 state1.remove_input_data_port(input_state1) assert len(container.data_flows) == 1 container.remove_scoped_variable(scoped_variable_container_state) assert len(container.data_flows) == 0 assert_logger_warnings_and_errors(caplog)
def test_hierarchy_state_library(caplog): testing_utils.test_multithreading_lock.acquire() library_container_state_sm = create_hierarchy_state_library_state_machine() rafcon.core.singleton.state_machine_manager.add_state_machine( library_container_state_sm) rafcon.core.singleton.state_machine_execution_engine.start( library_container_state_sm.state_machine_id) rafcon.core.singleton.state_machine_execution_engine.join() # print output_data["data_output_port1"] try: assert library_container_state_sm.root_state.output_data[ "data_output_port1"] == 42.0 rafcon.core.singleton.state_machine_manager.remove_state_machine( library_container_state_sm.state_machine_id) testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release()
def test_concurrency_preemption_state_execution(caplog): preemption_state_sm = create_preemption_state_machine() testing_utils.test_multithreading_lock.acquire() rafcon.core.singleton.state_machine_manager.add_state_machine( preemption_state_sm) rafcon.core.singleton.state_machine_execution_engine.start( preemption_state_sm.state_machine_id) rafcon.core.singleton.state_machine_execution_engine.join() try: assert rafcon.core.singleton.global_variable_manager.get_variable( "preempted_state2_code") == "DF3LFXD34G" assert preemption_state_sm.root_state.final_outcome.outcome_id == 3 rafcon.core.singleton.state_machine_manager.remove_state_machine( preemption_state_sm.state_machine_id) testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release()
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 as e: assert isinstance(e, ValueError) 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) try: assert hierarchy_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_nested_library_state_machine(caplog): testing_utils.test_multithreading_lock.acquire() # TODO: the library_manager is initialized a second time here rafcon.core.singleton.library_manager.initialize() nested_library_state = LibraryState("temporary_libraries", "library_with_nested_library", "0.1", "nested_library_state_name", "nested_library_state_id") state_machine = StateMachine(nested_library_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() # print output_data["data_output_port1"] try: assert nested_library_state.output_data["data_output_port1"] == 42.0 rafcon.core.singleton.state_machine_manager.remove_state_machine( state_machine.state_machine_id) testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release()
def test_transition_creation(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) 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_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() try: testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release() rafcon.core.singleton.state_machine_manager.delete_all_state_machines()
def test_concurrency_preemption_save_load(caplog): testing_utils.test_multithreading_lock.acquire() storage_path = testing_utils.get_unique_temp_path() preemption_state_sm = create_preemption_state_machine() storage.save_state_machine_to_path(preemption_state_sm, storage_path) storage.load_state_machine_from_path(storage_path) rafcon.core.singleton.state_machine_manager.add_state_machine( preemption_state_sm) rafcon.core.singleton.state_machine_execution_engine.start( preemption_state_sm.state_machine_id) rafcon.core.singleton.state_machine_execution_engine.join() try: assert rafcon.core.singleton.global_variable_manager.get_variable( "preempted_state2_code") == "DF3LFXD34G" rafcon.core.singleton.state_machine_manager.remove_state_machine( preemption_state_sm.state_machine_id) testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release()
def test_create_container_state(caplog): container = ContainerState("Container") assert len(container.states) == 0 input_port_container_state = container.add_input_data_port( "input", "float") output_port_container_state = container.add_output_data_port( "output", "float") scoped_var_1_container_state = container.add_scoped_variable( "scope_1", "float") scoped_var_2_container_state = container.add_scoped_variable( "scope_2", "float") state1 = ExecutionState("MyFirstState") container.add_state(state1) assert len(container.states) == 1 # As the ID of two states is identical, the add method should adapt the state_id and return the new state_id new_state_id = container.add_state( ExecutionState("test_execution_state", state_id=state1.state_id)) assert len(container.states) == 2 assert not new_state_id == state1.state_id container.remove_state(new_state_id) state2 = ExecutionState("2nd State", state_id=container.state_id) logger.debug("Old state id: {0}".format(str(state2.state_id))) new_state_id = container.add_state(state2) logger.debug("New state id: {0}".format(str(new_state_id))) assert len(container.states) == 2 input_state1 = state1.add_input_data_port("input", "float") output_state1 = state1.add_output_data_port("output", "float") input_state2 = state2.add_input_data_port("input", "float") input2_state2 = state2.add_input_data_port("input2", "float") output_state2 = state2.add_output_data_port("output", "float") assert len(container.data_flows) == 0 container.add_data_flow(state1.state_id, output_state1, state2.state_id, input_state2) assert len(container.data_flows) == 1 with raises(ValueError): # Data flow to connected input port container.add_data_flow(state1.state_id, input_state1, state2.state_id, input_state2) with raises(ValueError): # Data flow to non-existing port wrong_data_port_id = 218347 container.add_data_flow(state1.state_id, output_state1, state2.state_id, wrong_data_port_id) with raises(ValueError): # Data flow from non-existing port wrong_data_port_id = 239847 container.add_data_flow(state1.state_id, wrong_data_port_id, state2.state_id, input_state2) with raises(ValueError): # Data flow from non-existing state container.add_data_flow(-1, output_state1, state2.state_id, input_state2) with raises(ValueError): # Data flow to non-existing state container.add_data_flow(state1.state_id, output_state1, -1, input_state2) with raises(ValueError): # Connect port to itself container.add_data_flow(state1.state_id, output_state1, state1.state_id, output_state1) with raises(ValueError): # Connect two scoped variable container.add_data_flow(container.state_id, scoped_var_1_container_state, container.state_id, scoped_var_2_container_state) container.add_data_flow(container.state_id, input_port_container_state, state1.state_id, input_state1) # with raises(ValueError): # cannot connect data flow to same child state container.add_data_flow(state2.state_id, output_state2, state2.state_id, input2_state2) assert len(container.data_flows) == 3 assert len(container.transitions) == 0 container.add_transition(state1.state_id, -1, state2.state_id, None) assert len(container.transitions) == 1 container.add_transition(state1.state_id, -2, container.state_id, -2) assert len(container.transitions) == 2 t3 = container.add_transition(state2.state_id, -1, container.state_id, -1) assert len(container.transitions) == 3 with raises(ValueError): # Transition from connected outcome container.add_transition(state1.state_id, -1, state2.state_id, None) with raises(ValueError): # Non-existing from state id container.add_transition(-1, -1, state2.state_id, None) with raises(ValueError): # Non-existing from outcome container.add_transition(state1.state_id, -3, state2.state_id, None) with raises(ValueError): # Non-existing to state id container.add_transition(state1.state_id, -1, -1, None) with raises(ValueError): # Non-existing to outcome container.add_transition(state1.state_id, -1, container.state_id, -3) with raises(ValueError): # Transition pointing to the state itself container.add_transition(state1.state_id, -2, state1.state_id, None) with raises(ValueError): # to_state_id and to_outcome not None container.add_transition(state1.state_id, -2, state1.state_id, -1) with raises(ValueError): # Transition from connected outcome container.add_transition(state2.state_id, -1, state2.state_id, -2) with raises(ValueError): # Transition going from one outcome to another outcome of the same state container.add_transition(state2.state_id, -1, state2.state_id, -2) with raises(AttributeError): # The removal of an undefined transition should throw an AttributeError container.remove_transition(-1) container.remove_transition(t3) assert len(container.transitions) == 2 with raises(AttributeError): # The removal of an undefined transition should throw an AttributeError container.remove_transition(t3) container.add_transition(state2.state_id, -1, container.state_id, -1) assert len(container.transitions) == 3 container.remove_state(state1.state_id) assert len(container.states) == 1 assert len(container.transitions) == 1 assert len(container.data_flows) == 1 # barrier state remove test and bug test elements for issue #346 barrier_state_id = container.add_state(BarrierConcurrencyState()) container.remove(container.states[barrier_state_id]) barrier_state_id = container.add_state(BarrierConcurrencyState()) with raises(AttributeError): container.states[barrier_state_id].remove( container.states[barrier_state_id].states.values()[0]) container.remove_state(barrier_state_id) ########################################### assert_logger_warnings_and_errors(caplog)
def test_basic_string_translation(caplog, monkeypatch): with use_locale("de_DE.UTF-8", monkeypatch): i18n.setup_l10n() assert _("Remove") == "Entfernen" testing_utils.assert_logger_warnings_and_errors(caplog=caplog)
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()) assert global_lock_counter == 0 state1.add_outcome("outcome1", 3) assert len(state1.outcomes) == 4 assert_logger_warnings_and_errors(caplog) if __name__ == '__main__': test_lock_state_machine(None)
def test_create_state(caplog): state1 = ExecutionState("MyFirstState") assert len(state1.outcomes) == 3 out = state1.add_outcome("MyFirstOutcome", 3) assert len(state1.outcomes) == 4 state1.remove_outcome(out) with raises(AttributeError): # AttributeError should be raised if not existing outcome ID is to be removed state1.remove_outcome(out) with raises(AttributeError): # AttributeError should be raised if outcome preempted is to be removed state1.remove_outcome(-1) with raises(AttributeError): # AttributeError should be raised if outcome aborted is to be removed state1.remove_outcome(-2) assert len(state1.outcomes) == 3 assert len(state1.input_data_ports) == 0 assert len(state1.output_data_ports) == 0 input_port_id = state1.add_input_data_port("input", "str") output_port_id = state1.add_output_data_port("output", "float") assert len(state1.input_data_ports) == 1 assert len(state1.output_data_ports) == 1 state1.remove_input_data_port(input_port_id) state1.remove_output_data_port(output_port_id) assert len(state1.input_data_ports) == 0 assert len(state1.output_data_ports) == 0 with raises(AttributeError): # AttributeError should be raised if not existing input is to be removed state1.remove_input_data_port(input_port_id) with raises(AttributeError): # AttributeError should be raised if not existing output is to be removed state1.remove_output_data_port(output_port_id) state2 = ExecutionState(name="State2", state_id=state1.state_id) # This should work, as data_type and default_value are optional parameters port = InputDataPort('input', data_port_id=99) with raises(AttributeError): # The name of the port differs in key and class member ExecutionState("test_execution_state", input_data_ports={'diff_input': port}) # UTF8 strings should be allowed at least for descriptions state1.description = u'My English is not v\xc3ry good' assert_logger_warnings_and_errors(caplog) a = ExecutionState("test", state_id=10) b = ExecutionState("test", state_id=10) assert a == b assert a is not b
def test_type_check(caplog): # valid gvm = GlobalVariableManager() gvm.set_variable("a", 1, data_type=int) a = gvm.get_variable("a") assert a == 1 gvm.set_variable("b", "test", data_type=str) b = gvm.get_variable("b") assert b == "test" gvm.set_variable("c", 12.0, data_type=float) c = gvm.get_variable("c") assert c == 12.0 gvm.set_variable("d", True, data_type=bool) d = gvm.get_variable("d") assert d e_list = [1, 2, 3] gvm.set_variable("e", e_list, data_type=list) e = gvm.get_variable("e") assert e == e_list f_dict = {'a': 1, 'b': 2} gvm.set_variable("f", f_dict, data_type=dict) f = gvm.get_variable("f") assert f == f_dict # invalid with raises(TypeError): gvm.set_variable("g", "test", data_type=int) testing_utils.assert_logger_warnings_and_errors(caplog) with raises(TypeError): gvm.set_variable("g", "test", data_type=float) testing_utils.assert_logger_warnings_and_errors(caplog) # overwriting gvm.set_variable("a", 3, data_type=int) a = gvm.get_variable("a") assert a == 3 # invalid overwriting with raises(TypeError): gvm.set_variable("a", "string", data_type=int) a = gvm.get_variable("a") assert a == 3 # invalid overwriting with raises(TypeError): gvm.set_variable("a", "any_string") a = gvm.get_variable("a") assert a == 3 # backward compatibility gvm.delete_variable("a") gvm.set_variable("a", "test") a = gvm.get_variable("a") assert a == "test" gvm.set_variable("a", 123) a = gvm.get_variable("a") assert a == 123