def create_models_concurrency(): from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.barrier_concurrency_state import BarrierConcurrencyState from rafcon.core.states.preemptive_concurrency_state import PreemptiveConcurrencyState from rafcon.core.states.hierarchy_state import HierarchyState [state, sm_model, state_dict] = create_models() pstate = PreemptiveConcurrencyState(name='Preemptive', state_id='PREEMPT') state_dict['Nested'].add_state(pstate) state_dict['Preemptive'] = pstate hstate = HierarchyState() estate = ExecutionState() estate.script_text = estate.script_text + "\nprint 'nochwas'" state_dict['Preemptive'].add_state(hstate) state_dict['Preemptive'].add_state(estate) bstate = BarrierConcurrencyState(name='Barrier', state_id='BARRIER') state_dict['Nested'].add_state(bstate) state_dict['Barrier'] = bstate hstate = HierarchyState() estate = ExecutionState() estate.script_text = estate.script_text + "\nprint 'irgendwas'" state_dict['Barrier'].add_state(hstate) state_dict['Barrier'].add_state(estate) return state, sm_model, state_dict
def test_create_barrier_state_with_predefined_decider_state(): decider_name = "Decision Maker" decider_state = DeciderState(decider_name) barrier_state = BarrierConcurrencyState("Barrier State", decider_state=decider_state) assert len([ state for state in barrier_state.states.values() if state.name == decider_name ]) == 1
def create_barrier_concurrency_state(number_child_states=10, number_childs_per_child=10): barrier_state = BarrierConcurrencyState("barrier_concurrency") for i in range(number_child_states): hierarchy_state = create_hierarchy_state(number_childs_per_child) barrier_state.add_state(hierarchy_state) barrier_state.add_transition(barrier_state.states[UNIQUE_DECIDER_STATE_ID].state_id, 0, barrier_state.state_id, 0) return barrier_state
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_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)