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 create_hierarchy_state(): state1 = ExecutionState("MyFirstState", path=testing_utils.TEST_SCRIPT_PATH, filename="first_execution_state.py") state1.add_outcome("MyFirstOutcome", 3) state1.add_input_data_port("data_input_port1", "float") state1.add_output_data_port("faulty_output_port", "float") state1.add_output_data_port("data_output_port1", "float") state2 = HierarchyState("MyFirstHierarchyState") state2.add_state(state1) state2.set_start_state(state1.state_id) state2.add_outcome("Container_Outcome", 6) transition_id = state2.add_transition(state1.state_id, 3, state2.state_id, 6) # print state2.transitions[transition_id] input_data_port_id = state2.add_input_data_port("input1", "float", 42.0, data_port_id=42) state2.add_output_data_port("output1", "float") state2.add_data_flow( state2.state_id, state2.get_io_data_port_id_from_name_and_type("input1", InputDataPort), state1.state_id, state1.get_io_data_port_id_from_name_and_type("data_input_port1", InputDataPort)) state2.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("output1", OutputDataPort)) return state2
def test_state_hash(): state1 = ExecutionState('ES', state_id="12345") state2 = ExecutionState('ES', state_id="12345") state1.add_output_data_port("out1", "int", data_port_id=1) state1.add_output_data_port("out2", "int", data_port_id=2) state1.add_input_data_port("in1", "int", data_port_id=3) state1.add_input_data_port("in2", "int", data_port_id=4) state1.add_outcome("o1", outcome_id=1) state1.add_outcome("o2", outcome_id=2) state2.add_outcome("o2", outcome_id=2) state2.add_outcome("o1", outcome_id=1) state2.add_input_data_port("in2", "int", data_port_id=4) state2.add_input_data_port("in1", "int", data_port_id=3) state2.add_output_data_port("out2", "int", data_port_id=2) state2.add_output_data_port("out1", "int", data_port_id=1) hash1 = hashlib.sha256() hash2 = hashlib.sha256() assert hash1.hexdigest() == hash2.hexdigest() Hashable.update_hash_from_dict(hash1, state1) Hashable.update_hash_from_dict(hash2, state2) assert hash1.hexdigest() == hash2.hexdigest()
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 create_concurrency_barrier_state(): state1 = ExecutionState("FirstState", "id_of_state_1", path=testing_utils.TEST_SCRIPT_PATH, filename="concurrency_barrier1.py") state1.add_outcome("FirstOutcomeState1", 3) state1.add_outcome("SecondOutcomeState1", 4) input_state1 = state1.add_input_data_port("input_data_port1", "float") output_state1 = state1.add_output_data_port("output_data_port1", "float") state2 = ExecutionState("SecondState", "id_of_state_2", path=testing_utils.TEST_SCRIPT_PATH, filename="concurrency_barrier2.py") state2.add_outcome("FirstOutcomeState2", 3) state2.add_outcome("SecondOutcomeState2", 4) input_state2 = state2.add_input_data_port("input_data_port1", "float") output_state2 = state2.add_output_data_port("output_data_port1", "float") barrier_state = BarrierConcurrencyState("FirstConcurrencyState", "barrier_state_id") barrier_state.add_state(state1) barrier_state.add_state(state2) input1_state3 = barrier_state.add_input_data_port("input_data_port1", "float", 0.1) input2_state3 = barrier_state.add_input_data_port("input_data_port2", "float", 0.1) barrier_state.add_data_flow(barrier_state.state_id, input1_state3, state1.state_id, input_state1) barrier_state.add_data_flow(barrier_state.state_id, input2_state3, state2.state_id, input_state2) barrier_state.add_output_data_port("output_data_port1", "str", "default_output_value") barrier_state.add_outcome("success_outcome", 3) barrier_state.add_outcome("error_outcome", 4) barrier_state.states[UNIQUE_DECIDER_STATE_ID].name = "decider_state" barrier_state.states[UNIQUE_DECIDER_STATE_ID]._script = Script( path=testing_utils.TEST_SCRIPT_PATH, filename="decider_state.py", check_path=True, parent=barrier_state.states[UNIQUE_DECIDER_STATE_ID]) barrier_state.states[UNIQUE_DECIDER_STATE_ID].add_outcome( "FirstOutcomeDecider", 3) barrier_state.states[UNIQUE_DECIDER_STATE_ID].add_outcome( "SecondOutcomeDecider", 4) barrier_state.add_transition( barrier_state.states[UNIQUE_DECIDER_STATE_ID].state_id, 3, barrier_state.state_id, 3) barrier_state.add_transition( barrier_state.states[UNIQUE_DECIDER_STATE_ID].state_id, 4, barrier_state.state_id, 4) return barrier_state
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_hierarchy_state(number_child_states=10, sleep=False): hierarchy = HierarchyState("hierarchy1") hierarchy.add_outcome("hierarchy_outcome", 1) hierarchy.add_input_data_port("hierarchy_input_port1", "float", 42.0) hierarchy.add_output_data_port("hierarchy_output_port1", "float") last_state = None for i in range(number_child_states): if sleep: state = ExecutionState("state" + str(i), path=testing_utils.TEST_SCRIPT_PATH, filename="hello_world_sleep.py") else: state = ExecutionState("state" + str(i)) hierarchy.add_state(state) state.add_input_data_port("input1", "float") state.add_output_data_port("output1", "float") if not last_state: hierarchy.set_start_state(state.state_id) hierarchy.add_data_flow( hierarchy.state_id, hierarchy.get_io_data_port_id_from_name_and_type( "hierarchy_input_port1", InputDataPort), state.state_id, state.get_io_data_port_id_from_name_and_type( "input1", InputDataPort)) else: hierarchy.add_transition(last_state.state_id, 0, state.state_id, None) # connect data ports state 1 hierarchy.add_data_flow( last_state.state_id, last_state.get_io_data_port_id_from_name_and_type( "output1", OutputDataPort), state.state_id, state.get_io_data_port_id_from_name_and_type( "input1", InputDataPort)) last_state = state hierarchy.add_data_flow( last_state.state_id, last_state.get_io_data_port_id_from_name_and_type( "output1", OutputDataPort), hierarchy.state_id, hierarchy.get_io_data_port_id_from_name_and_type( "hierarchy_output_port1", OutputDataPort)) hierarchy.add_transition(last_state.state_id, 0, hierarchy.state_id, 1) return hierarchy
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_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 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 test_group_states(caplog): container = ContainerState("Container") input_port_container_state = container.add_input_data_port( "input", "float") container.add_output_data_port("output", "float") container.add_scoped_variable("scope_1", "float") container.add_scoped_variable("scope_2", "float") state1 = ExecutionState("MyFirstState") container.add_state(state1) new_state_id = container.add_state( ExecutionState("test_execution_state", 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))) 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") container.add_data_flow(state1.state_id, output_state1, state2.state_id, input_state2) container.add_data_flow(container.state_id, input_port_container_state, state1.state_id, input_state1) container.add_data_flow(state2.state_id, output_state2, state2.state_id, input2_state2) container.add_transition(state1.state_id, -1, state2.state_id, None) container.add_transition(state1.state_id, -2, container.state_id, -2) container.add_transition(state2.state_id, -1, container.state_id, -1) group_state = container.group_states([state1.state_id, state2.state_id]) container.ungroup_state(group_state.state_id) assert_logger_warnings_and_errors(caplog)
def create_small_state_machine(): import rafcon.core.singleton import rafcon.gui.singleton from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.state_machine import StateMachine state1 = ExecutionState('State1', state_id='STATE1') state1.add_input_data_port("in", "str", "zero") state1.add_output_data_port("out", "int", 5) state2 = ExecutionState('State2', state_id='STATE2') state2.add_input_data_port("in", "int", 0) state2.add_output_data_port("out", "int", 3) root_state = HierarchyState(name='State3', state_id='STATE3') root_state.add_state(state1) root_state.add_state(state2) root_state.set_start_state(state1) root_state.add_transition(state1.state_id, 0, state2.state_id, None) sm = StateMachine(root_state) rafcon.core.singleton.state_machine_manager.add_state_machine(sm)
def test_container_state(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") 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) transition_id = 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) transition = container.get_transition_for_outcome(state1, state1.outcomes[0]) # Test transition from outcome assert (transition == container.transitions[transition_id]) # Test contains assert (transition in container) # Test dictionary dict_state = ContainerState.state_to_dict(container) # print(dict_state) container2, transitions, data_flows = ContainerState.from_dict(dict_state) print(container) print(container2) assert (container == copy.copy(container)) assert (container == copy.deepcopy(container)) new_state1 = ExecutionState("new_test_execution_state") old_state1_id = state1.state_id new_state = container.substitute_state(state1.state_id, new_state1) assert (old_state1_id == state1.state_id) assert (not new_state.state_id == old_state1_id) 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 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_unique_port_names(caplog): state = ExecutionState('execution state') state.add_input_data_port("in", "int", 0) state.add_output_data_port("out", "int", 0) # Data port name must be unique within data port set (input or output) with raises(ValueError): state.add_input_data_port("in", "int", 0) with raises(ValueError): state.add_input_data_port("in", "double", 0) with raises(ValueError): state.add_output_data_port("out", "int", 0) with raises(ValueError): state.add_output_data_port("out", "double", 0) # Names are allowed for other data port set state.add_output_data_port("in", "int", 0) state.add_input_data_port("out", "int", 0) assert len(state.input_data_ports) == 2 assert len(state.output_data_ports) == 2 state = HierarchyState('hierarchy state') in_id = state.add_input_data_port("in", "int", 0) out_id = state.add_output_data_port("out", "int", 0) scope_id = state.add_scoped_variable("scope", "int", 0) # Data port name must be unique within data port set (input, output or scope) with raises(ValueError): state.add_input_data_port("in", "int", 0) with raises(ValueError): state.add_input_data_port("in", "double", 0) with raises(ValueError): state.add_output_data_port("out", "int", 0) with raises(ValueError): state.add_output_data_port("out", "double", 0) with raises(ValueError): state.add_scoped_variable("scope", "int", 0) with raises(ValueError): state.add_scoped_variable("scope", "double", 0) # check programmatic direct data_type and default_value usage DataPort-Class state.add_input_data_port("_in", int, 0) list_op_id = state.add_output_data_port("_out", list, [1, 2, 3]) with raises(TypeError): state.add_scoped_variable("_scope", float, 0) with raises(TypeError): state.output_data_ports[list_op_id].default_value = (1, 3) # Names are allowed for other data port set state.add_output_data_port("in", "int", 0) state.add_scoped_variable("in", "int", 0) state.add_input_data_port("out", "int", 0) state.add_scoped_variable("out", "int", 0) state.add_input_data_port("scope", "int", 0) state.add_output_data_port("scope", "int", 0) # Also renaming should raise exceptions with raises(ValueError): state.input_data_ports[in_id].name = "out" with raises(ValueError): state.output_data_ports[out_id].name = "in" with raises(ValueError): state.scoped_variables[scope_id].name = "out" assert len(state.input_data_ports) == 4 assert len(state.output_data_ports) == 4 assert len(state.scoped_variables) == 3 testing_utils.assert_logger_warnings_and_errors(caplog)
def create_state_machine(): from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.state_machine import StateMachine print("create models") logger.setLevel(logging.VERBOSE) for handler in logging.getLogger('gtkmvc3').handlers: logging.getLogger('gtkmvc3').removeHandler(handler) state1 = ExecutionState('State1', state_id='STATE1') output_state1 = state1.add_output_data_port("output", "int") input_state1 = state1.add_input_data_port("input", "str", "zero") state2 = ExecutionState('State2', state_id='STATE2') input_par_state2 = state2.add_input_data_port("par", "int", 0) output_res_state2 = state2.add_output_data_port("res", "int") state4 = HierarchyState(name='Nested', state_id='NESTED') state4.add_outcome('GoGo') output_state4 = state4.add_output_data_port("out", "int") state5 = ExecutionState('Nested2', state_id='NESTED2') state5.add_outcome('HereWeGo') input_state5 = state5.add_input_data_port("in", "int", 0) state3 = HierarchyState(name='State3', state_id='STATE3') input_state3 = state3.add_input_data_port("input", "int", 0) output_state3 = state3.add_output_data_port("output", "int") 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) state3.add_outcome('Branch1') state3.add_outcome('Branch2') ctr_state = HierarchyState(name="Container", state_id='CONT2') ctr_state.add_state(state1) ctr_state.add_state(state2) ctr_state.add_state(state3) input_ctr_state = ctr_state.add_input_data_port("ctr_in", "str", "zero") output_ctr_state = ctr_state.add_output_data_port("ctr_out", "int") 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.add_data_flow(state1.state_id, output_state1, state2.state_id, input_par_state2) ctr_state.add_data_flow(state2.state_id, output_res_state2, state3.state_id, input_state3) ctr_state.add_data_flow(ctr_state.state_id, input_ctr_state, state1.state_id, input_state1) ctr_state.add_data_flow(state3.state_id, output_state3, ctr_state.state_id, output_ctr_state) ctr_state.name = "Container" ctr_state.add_input_data_port("input", "str", "default_value1") ctr_state.add_input_data_port("pos_x", "str", "default_value2") ctr_state.add_input_data_port("pos_y", "str", "default_value3") ctr_state.add_output_data_port("output", "str", "default_value1") ctr_state.add_output_data_port("result", "str", "default_value2") scoped_variable1_ctr_state = ctr_state.add_scoped_variable( "scoped", "str", "default_value1") scoped_variable2_ctr_state = ctr_state.add_scoped_variable( "my_var", "str", "default_value1") scoped_variable3_ctr_state = ctr_state.add_scoped_variable( "ctr", "int", 42) ctr_state.add_data_flow(ctr_state.state_id, input_ctr_state, ctr_state.state_id, scoped_variable1_ctr_state) ctr_state.add_data_flow(state1.state_id, output_state1, ctr_state.state_id, scoped_variable3_ctr_state) state_dict = { 'Container': ctr_state, 'State1': state1, 'State2': state2, 'State3': state3, 'Nested': state4, 'Nested2': state5 } sm = StateMachine(ctr_state) return sm
def create_state_machine(): from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.state_machine import StateMachine state1 = ExecutionState('State1', state_id="State1") output_state1 = state1.add_output_data_port("output", "int") input_state1 = state1.add_input_data_port("input", "str", "zero") state2 = ExecutionState('State2', state_id="State2") input_par_state2 = state2.add_input_data_port("par", "int", 0) output_res_state2 = state2.add_output_data_port("res", "int") state4 = HierarchyState(name='Nested', state_id="Nested") state4.add_outcome('GoGo') output_state4 = state4.add_output_data_port("out", "int") state5 = ExecutionState('Nested2', state_id="Nested2") state5.add_outcome('HereWeGo') input_state5 = state5.add_input_data_port("in", "int", 0) state3 = HierarchyState(name='State3', state_id="State3") input_state3 = state3.add_input_data_port("input", "int", 0) output_state3 = state3.add_output_data_port("output", "int") 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) state3.add_outcome('Branch1') state3.add_outcome('Branch2') ctr_state = HierarchyState(name="Root", state_id="Root") ctr_state.add_state(state1) ctr_state.add_state(state2) ctr_state.add_state(state3) input_ctr_state = ctr_state.add_input_data_port("ctr_in", "str", "zero") output_ctr_state = ctr_state.add_output_data_port("ctr_out", "int") 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.add_data_flow(state1.state_id, output_state1, state2.state_id, input_par_state2) ctr_state.add_data_flow(state2.state_id, output_res_state2, state3.state_id, input_state3) ctr_state.add_data_flow(ctr_state.state_id, input_ctr_state, state1.state_id, input_state1) ctr_state.add_data_flow(state3.state_id, output_state3, ctr_state.state_id, output_ctr_state) ctr_state.name = "Container" ctr_state.add_input_data_port("input", "str", "default_value1") ctr_state.add_input_data_port("pos_x", "str", "default_value2") ctr_state.add_input_data_port("pos_y", "str", "default_value3") ctr_state.add_output_data_port("output", "str", "default_value1") ctr_state.add_output_data_port("result", "str", "default_value2") scoped_variable1_ctr_state = ctr_state.add_scoped_variable( "scoped", "str", "default_value1") scoped_variable3_ctr_state = ctr_state.add_scoped_variable( "ctr", "int", 42) ctr_state.add_data_flow(ctr_state.state_id, input_ctr_state, ctr_state.state_id, scoped_variable1_ctr_state) ctr_state.add_data_flow(state1.state_id, output_state1, ctr_state.state_id, scoped_variable3_ctr_state) state_dict = { 'Container': ctr_state, 'State1': state1, 'State2': state2, 'State3': state3, 'Nested': state4, 'Nested2': state5 } sm = StateMachine(ctr_state) return state_dict, sm
def create_models(): import rafcon.core.singleton from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.state_machine import StateMachine state1 = ExecutionState('State1') output_state1 = state1.add_output_data_port("output", "int") input_state1 = state1.add_input_data_port("input", "str", "zero") state2 = ExecutionState('State2') input_par_state2 = state2.add_input_data_port("par", "int", 0) output_res_state2 = state2.add_output_data_port("res", "int") state4 = HierarchyState(name='Nested') state4.add_outcome('GoGo') output_state4 = state4.add_output_data_port("out", "int") state5 = ExecutionState('Nested2') state5.add_outcome('HereWeGo') input_state5 = state5.add_input_data_port("in", "int", 0) state3 = HierarchyState(name='State3') input_state3 = state3.add_input_data_port("input", "int", 0) output_state3 = state3.add_output_data_port("output", "int") 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) state3.add_outcome('Branch1') state3.add_outcome('Branch2') ctr_state = HierarchyState(name="Container") ctr_state.add_state(state1) ctr_state.add_state(state2) ctr_state.add_state(state3) input_ctr_state = ctr_state.add_input_data_port("ctr_in", "str", "zero") output_ctr_state = ctr_state.add_output_data_port("ctr_out", "int") 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.add_data_flow(state1.state_id, output_state1, state2.state_id, input_par_state2) ctr_state.add_data_flow(state2.state_id, output_res_state2, state3.state_id, input_state3) ctr_state.add_data_flow(ctr_state.state_id, input_ctr_state, state1.state_id, input_state1) ctr_state.add_data_flow(state3.state_id, output_state3, ctr_state.state_id, output_ctr_state) ctr_state.add_input_data_port("input", "str", "default_value1") ctr_state.add_input_data_port("pos_x", "str", "default_value2") ctr_state.add_input_data_port("pos_y", "str", "default_value3") ctr_state.add_output_data_port("output", "str", "default_value1") ctr_state.add_output_data_port("result", "str", "default_value2") scoped_variable1_ctr_state = ctr_state.add_scoped_variable( "scoped", "str", "default_value1") scoped_variable2_ctr_state = ctr_state.add_scoped_variable( "my_var", "str", "default_value1") scoped_variable3_ctr_state = ctr_state.add_scoped_variable( "ctr", "int", 42) ctr_state.add_data_flow(ctr_state.state_id, input_ctr_state, ctr_state.state_id, scoped_variable1_ctr_state) ctr_state.add_data_flow(state1.state_id, output_state1, ctr_state.state_id, scoped_variable3_ctr_state) state_dict = { 'Container': ctr_state, 'State1': state1, 'State2': state2, 'State3': state3, 'Nested': state4, 'Nested2': state5 } sm = StateMachine(ctr_state) rafcon.core.singleton.state_machine_manager.add_state_machine(sm) testing_utils.wait_for_gui() state_machine_model = rafcon.gui.singleton.state_machine_manager_model.state_machines[ sm.state_machine_id] return ctr_state, state_machine_model, state_dict
def do_check_for_state(state_name): sm_history.modifications.reset() # Note: The elements always need to be retrieved before performing an operation, as undo/redo operations replace # both core and model objects state_m = get_state_model_by_name(state_name, state_path_dict) ############# # outcome add & remove outcome_super, state = perform_history_action( state_m.state.add_outcome, "super") state = get_state_by_name(state_name, state_path_dict) _, state = perform_history_action(state_m.state.remove_outcome, outcome_super) ############# # add two states state4 = ExecutionState('State4', state_id='STATE4') state_path_dict['state4'] = state.get_path() + "/" + "STATE4" _, state = perform_history_action(state.add_state, state4) state5 = ExecutionState('State5', state_id='STATE5') state_path_dict['state5'] = state.get_path() + "/" + "STATE5" _, state = perform_history_action(state.add_state, state5) perform_multiple_undo_redo(2) state4 = get_state_by_name('state4', state_path_dict) outcome_state4 = state4.add_outcome('UsedHere') assert len(sm_history.modifications) == 6 state5 = get_state_by_name('state5', state_path_dict) outcome_state5 = state5.add_outcome('UsedHere') assert len(sm_history.modifications) == 7 ################ # add transition from_state_id, from_outcome, to_state_id=None, to_outcome=None, transition_id new_transition_id1, state = perform_history_action( state.add_transition, from_state_id=state4.state_id, from_outcome=outcome_state4, to_state_id=state5.state_id, to_outcome=None) _, state = perform_history_action(state.add_transition, from_state_id=state5.state_id, from_outcome=outcome_state5, to_state_id=state.state_id, to_outcome=-1) ################### # remove transition _, state = perform_history_action(state.remove_transition, new_transition_id1) ############# # remove state _, state = perform_history_action(state.remove_state, state5.state_id) ############# # add input_data_port state4 = get_state_by_name('state4', state_path_dict) input_state4_id, state4 = perform_history_action( state4.add_input_data_port, "input", "str", "zero") ############# # remove input_data_port _, state4 = perform_history_action(state4.remove_input_data_port, input_state4_id) ############# # add output_data_port output_state4_id, state4 = perform_history_action( state4.add_output_data_port, "output_" + state4.state_id, "int") ############# # remove output_data_port _, state4 = perform_history_action(state4.remove_output_data_port, output_state4_id) # prepare again state4 state4.add_output_data_port("output", "int") state4.add_input_data_port("input_new", "str", "zero") assert len(sm_history.modifications) == 17 output_state4_id = state4.add_output_data_port("output_new", "int") assert len(sm_history.modifications) == 18 state5 = ExecutionState('State5', 'STATE5') state = get_state_by_name(state_name, state_path_dict) state.add_state(state5) assert state_path_dict['state5'] == state5.get_path() assert len(sm_history.modifications) == 19 input_par_state5 = state5.add_input_data_port("par", "int", 0) assert len(sm_history.modifications) == 20 output_res_state5 = state5.add_output_data_port("res", "int") assert len(sm_history.modifications) == 21 ##################### # add scoped_variable scoped_buffer_nested, state = perform_history_action( state.add_scoped_variable, "buffer", "int") ##################### # remove scoped_variable _, state = perform_history_action(state.remove_scoped_variable, scoped_buffer_nested) ############# # add data_flow new_df_id, state = perform_history_action( state.add_data_flow, from_state_id=state4.state_id, from_data_port_id=output_state4_id, to_state_id=state5.state_id, to_data_port_id=input_par_state5) ################ # remove data_flow perform_history_action(state.remove_data_flow, new_df_id)
def test_add_data_flow_to_state(mocker): from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.states.execution_state import ExecutionState from rafcon.gui.models.container_state import ContainerStateModel from rafcon.gui.mygaphas.utils.gap_helper import add_data_flow_to_state root_state = HierarchyState("Root", "root") child_container = HierarchyState("ChildContainer", "cc") child_execution = ExecutionState("ChildExecution", "ce") root_state.add_state(child_container) root_state.add_state(child_execution) floating_state = HierarchyState("Floater", "f") root_state.add_input_data_port("ri1", int, data_port_id=0) root_state.add_input_data_port("ri2", int, data_port_id=1) root_state.add_output_data_port("ro1", int, data_port_id=2) root_state.add_scoped_variable("rs1", int, scoped_variable_id=3) child_container.add_input_data_port("ci1", int, data_port_id=0) child_container.add_output_data_port("co1", int, data_port_id=2) child_execution.add_input_data_port("ei1", int, data_port_id=0) child_execution.add_output_data_port("eo1", int, data_port_id=2) floating_state.add_input_data_port("fi1", int, data_port_id=0) floating_state.add_output_data_port("fo1", int, data_port_id=1) root_state_m = ContainerStateModel(root_state) child_container_m = root_state_m.states["cc"] child_execution_m = root_state_m.states["ce"] floating_state_m = ContainerStateModel(floating_state) ri1_m = root_state_m.get_input_data_port_m(0) ro1_m = root_state_m.get_output_data_port_m(2) rs1_m = root_state_m.get_scoped_variable_m(3) ci1_m = child_container_m.get_input_data_port_m(0) co1_m = child_container_m.get_output_data_port_m(2) ei1_m = child_execution_m.get_input_data_port_m(0) eo1_m = child_execution_m.get_output_data_port_m(2) fi1_m = floating_state_m.get_input_data_port_m(0) fo1_m = floating_state_m.get_output_data_port_m(1) mocker.patch.object(root_state, "add_data_flow") mocker.patch.object(child_container, "add_data_flow") # Data flow in root state from input to output add_data_flow_to_state(ri1_m, ro1_m) root_state.add_data_flow.assert_called_with("root", 0, "root", 2) # Data flow in root state from input to scope add_data_flow_to_state(ri1_m, rs1_m) root_state.add_data_flow.assert_called_with("root", 0, "root", 3) # Data flow in root state from scope to output add_data_flow_to_state(rs1_m, ro1_m) root_state.add_data_flow.assert_called_with("root", 3, "root", 2) # Data flow from root state input to container state input add_data_flow_to_state(ri1_m, ci1_m) root_state.add_data_flow.assert_called_with("root", 0, "cc", 0) # Data flow from root state input to execution state input add_data_flow_to_state(ri1_m, ei1_m) root_state.add_data_flow.assert_called_with("root", 0, "ce", 0) # Data flow from container state output to execution state input add_data_flow_to_state(co1_m, ei1_m) root_state.add_data_flow.assert_called_with("cc", 2, "ce", 0) # Data flow from execution state output to container state input add_data_flow_to_state(eo1_m, ci1_m) root_state.add_data_flow.assert_called_with("ce", 2, "cc", 0) # Data flow from container state output to container state input, see issue #711 add_data_flow_to_state(co1_m, ci1_m) root_state.add_data_flow.assert_called_with("cc", 2, "cc", 0) # Data flow from execution state output to container state input, see issue #711 add_data_flow_to_state(eo1_m, ei1_m) root_state.add_data_flow.assert_called_with("ce", 2, "ce", 0) # Data flow from container state output to root state output add_data_flow_to_state(co1_m, ro1_m) root_state.add_data_flow.assert_called_with("cc", 2, "root", 2) # Data flow from execution state output to root state output add_data_flow_to_state(eo1_m, ro1_m) root_state.add_data_flow.assert_called_with("ce", 2, "root", 2) # Data flow from execution state output to root state scope add_data_flow_to_state(eo1_m, rs1_m) root_state.add_data_flow.assert_called_with("ce", 2, "root", 3) # Data flow from floating state output to execution state input with pytest.raises(ValueError): add_data_flow_to_state(fo1_m, ei1_m) # Data flow from execution state output to floating state input with pytest.raises(ValueError): add_data_flow_to_state(eo1_m, fi1_m)
def test_state_property_modifications_history(caplog): ################## # state properties # TODO LibraryState test for properties like mentioned in the notification-test but also general for add and remove # change name # change parent # change states # change outcomes # change transitions # change input_data_ports # change output_data_ports # change scoped_variables # change data_flows # change script # change script_text # change description # change active # set_start_state # change start_state_id # change child_execution testing_utils.dummy_gui(None) testing_utils.initialize_environment(gui_config={ 'AUTO_BACKUP_ENABLED': False, 'HISTORY_ENABLED': True }, gui_already_started=False) sm_model, state_dict = create_state_machine_m() state1 = ExecutionState('State1', state_id="STATE1") state1.add_input_data_port("input", "str", "zero") state1.add_output_data_port("output", "int") state1.add_output_data_port("count", "int") state2 = ExecutionState('State2') state2.add_input_data_port("par", "int", 0) state2.add_input_data_port("number", "int", 5) state2.add_output_data_port("res", "int") nested_state = state_dict['Nested'] nested_state.add_state(state1) nested_state.add_state(state2) state2_path = state2.get_path() nested_state.add_output_data_port("res", "int") state1.add_outcome("again") state1.add_outcome("counted") assert len(sm_model.history.modifications) == 6 state2.add_outcome("done") state2.add_outcome("best") state2.add_outcome("full") assert len(sm_model.history.modifications) == 9 nested_state.add_outcome("great") assert len(sm_model.history.modifications) == 10 ####################################### ######## Properties of State ########## # name(self, name) _, nested_state = perform_history_action(nested_state.__setattr__, "name", "nested") # TODO: The following commented operations are not correctly supported by the history! # input_data_ports(self, input_data_ports) None or dict # _, nested_state = perform_history_action(nested_state.__setattr__, "input_data_ports", {}) # _, nested_state = perform_history_action(nested_state.__setattr__, "output_data_ports", {}) # outcomes(self, outcomes) None or dict # _, nested_state = perform_history_action(nested_state.__setattr__, "outcomes", nested_state.outcomes) # _, nested_state = perform_history_action(nested_state.__setattr__, "outcomes", {}) script_text = '\ndef execute(self, inputs, outputs, gvm):\n\tself.logger.debug("Hello World")\n\treturn 0\n' script_text1 = '\ndef execute(self, inputs, outputs, gvm):\n\tself.logger.debug("Hello NERD")\n\treturn 0\n' # script(self, script) Script -> no script setter any more only script_text !!! nested2_state = state_dict['Nested2'] _, nested2_state = perform_history_action(nested2_state.__setattr__, "script_text", script_text) # script_text(self, script_text) _, nested2_state = perform_history_action(nested2_state.__setattr__, "script_text", script_text1) # description(self, description) str _, nested_state = perform_history_action(nested_state.__setattr__, "description", "awesome") ############################################ ###### Properties of ContainerState ######## # set_start_state(self, state) State or state_id _, nested_state = perform_history_action(nested_state.set_start_state, "STATE1") # set_start_state(self, start_state) state2 = sm_model.state_machine.get_state_by_path(state2_path) _, nested_state = perform_history_action(nested_state.set_start_state, state2, additional_operations=1) # transitions(self, transitions) None or dict _, nested_state = perform_history_action(nested_state.__setattr__, "transitions", {}) # data_flows(self, data_flows) None or dict _, nested_state = perform_history_action(nested_state.__setattr__, "data_flows", {}) # scoped_variables(self, scoped_variables) None or dict _, nested_state = perform_history_action(nested_state.__setattr__, "scoped_variables", {}) # states(self, states) None or dict _, nested_state = perform_history_action(nested_state.__setattr__, "states", {}) testing_utils.shutdown_environment(caplog=caplog, unpatch_threading=False)
def test_data_flow_property_modifications(caplog): ################## # data_flow properties # change modify_origin # change from_key # change modify_target # change to_key # modify_transition_from_state # modify_transition_from_key # modify_transition_to_key # modify_transition_to_state testing_utils.dummy_gui(None) testing_utils.initialize_environment(gui_config={ 'AUTO_BACKUP_ENABLED': False, 'HISTORY_ENABLED': True }, gui_already_started=False) sm_model, state_dict = create_state_machine_m() nested_state = state_dict['Nested'] state1 = ExecutionState('State1') output_state1 = state1.add_output_data_port("output", "int") state1.add_input_data_port("input", "str", "zero") state2 = ExecutionState('State2') input_par_state2 = state2.add_input_data_port("par", "int", 0) output_res_state2 = state2.add_output_data_port("res", "int") nested_state.add_state(state1) nested_state.add_state(state2) output_res_nested = nested_state.add_output_data_port("res", "int") output_count_state1 = state1.add_output_data_port("count", "int") input_number_state2 = state2.add_input_data_port("number", "int", 5) new_df_id, nested_state = perform_history_action( nested_state.add_data_flow, from_state_id=state2.state_id, from_data_port_id=output_res_state2, to_state_id=nested_state.state_id, to_data_port_id=output_res_nested) ##### modify from data_flow ####### # modify_origin(self, from_state, from_key) _, nested_state = perform_history_action( nested_state.data_flows[new_df_id].modify_origin, from_state=state1.state_id, from_key=output_state1) # from_key(self, from_key) _, nested_state = perform_history_action( nested_state.data_flows[new_df_id].__setattr__, "from_key", output_count_state1) # modify_target(self, to_state, to_key) _, nested_state = perform_history_action( nested_state.data_flows[new_df_id].modify_target, to_state=state2.state_id, to_key=input_par_state2) # to_key(self, to_key) _, nested_state = perform_history_action( nested_state.data_flows[new_df_id].__setattr__, "to_key", input_number_state2) # reset observer and testbed _, nested_state = perform_history_action(nested_state.remove_data_flow, new_df_id) new_df_id, nested_state = perform_history_action( nested_state.add_data_flow, from_state_id=state2.state_id, from_data_port_id=output_res_state2, to_state_id=nested_state.state_id, to_data_port_id=output_res_nested) ##### modify from parent state ####### _, nested_state = perform_history_action( nested_state.data_flows[new_df_id].modify_origin, state1.state_id, output_state1) # modify_data_flow_from_key(self, data_flow_id, from_key) _, nested_state = perform_history_action( nested_state.data_flows[new_df_id].__setattr__, "from_key", output_count_state1) # modify_data_flow_to_state(self, data_flow_id, to_state, to_key) _, nested_state = perform_history_action( nested_state.data_flows[new_df_id].modify_target, state2.state_id, input_par_state2) # modify_data_flow_to_key(self, data_flow_id, to_key) _, nested_state = perform_history_action( nested_state.data_flows[new_df_id].__setattr__, "to_key", input_number_state2) testing_utils.shutdown_environment(caplog=caplog, unpatch_threading=False)
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) # Get connections for state related_transitions, related_data_flows = container.get_connections_for_state( state1.state_id) assert len(related_transitions['external']['outgoing']) == 2 assert len(related_data_flows['external']['ingoing']) == 1 container2 = ContainerState("Container 2") container2.add_state(container) related_transitions, related_data_flows = container2.get_connections_for_state( container.state_id) related_transitions_scoped, related_data_flows_scoped = container.get_connections_for_state_and_scoped_variables( [state2.state_id, state1.state_id], container.scoped_variables) # Test scoped connections assert (related_transitions['internal']['enclosed'] == related_transitions_scoped['enclosed']) assert (related_transitions['internal']['ingoing'] == related_transitions_scoped['ingoing']) assert (related_transitions['internal']['outgoing'] == related_transitions_scoped['outgoing']) assert (related_data_flows['internal']['enclosed'] == related_data_flows_scoped['enclosed']) assert (related_data_flows['internal']['ingoing'] == related_data_flows_scoped['ingoing']) assert (related_data_flows['internal']['outgoing'] == related_data_flows_scoped['outgoing']) 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( list(container.states[barrier_state_id].states.values())[0]) container.remove_state(barrier_state_id) ########################################### assert_logger_warnings_and_errors(caplog)
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 income is to be removed state1.remove_income() 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