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)
