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_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 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_state_machine2():
state1 = ExecutionState("MyFirstState", state_id="FirstLevel2", path=testing_utils.TEST_SCRIPT_PATH,
filename="default_data_port_test_state.py")
state0 = ExecutionState("MyZeroState", state_id="ZeroLevel2", path=testing_utils.TEST_SCRIPT_PATH,
filename="default_data_port_test_state.py")
state0.add_outcome("first_outcome", 3)
input_state0 = state0.add_input_data_port("input_data_port1", tuple, (1, 3, 2), data_port_id=1)
output_state0 = state0.add_output_data_port("output_data_port1", tuple)
state1.add_outcome("first_outcome", 3)
input_state1 = state1.add_input_data_port("input_data_port1", tuple, (1, 3, 2), data_port_id=1)
output_state1 = state1.add_output_data_port("output_data_port1", tuple)
state2 = HierarchyState("MyFirstHierarchyState",state_id="FirstLevel1")
state2.add_state(state1)
state2.add_state(state0)
state2.set_start_state(state0.state_id)
state2.add_outcome("Container_Outcome", 6)
state2.add_transition(state0.state_id, 3, state1.state_id, None)
state2.add_transition(state1.state_id, 3, state2.state_id, 6)
input_state2 = state2.add_input_data_port("input_data_port1", tuple)
output_state2 = state2.add_output_data_port("output_data_port1", tuple)
state2.add_data_flow(state0.state_id,
output_state0,
state1.state_id,
input_state1)
state2.add_data_flow(state1.state_id,
output_state1,
state2.state_id,
output_state2)
return StateMachine(state2)
def test_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 create_preemption_state_machine():
state1 = ExecutionState("FirstState",
path=testing_utils.TEST_SCRIPT_PATH,
filename="concurrence_preemption1.py")
state1.add_outcome("FirstOutcome", 3)
input_state1 = state1.add_input_data_port("input_data_port1", "float")
state2 = ExecutionState("SecondState",
path=testing_utils.TEST_SCRIPT_PATH,
filename="concurrence_preemption2.py")
state2.add_outcome("FirstOutcome", 3)
input_state2 = state2.add_input_data_port("input_data_port1", "float")
state3 = PreemptiveConcurrencyState("FirstConcurrencyState")
state3.add_state(state1)
state3.add_state(state2)
state3.add_outcome("State1 preempted", 3)
input_state3 = state3.add_input_data_port("input_data_port1", "float", 0.1)
input2_state3 = state3.add_input_data_port("input_data_port2", "float",
0.1)
state3.add_data_flow(state3.state_id, input_state3, state1.state_id,
input_state1)
state3.add_data_flow(state3.state_id, input2_state3, state2.state_id,
input_state2)
state3.add_transition(state1.state_id, 3, state3.state_id, 3)
return StateMachine(state3)
def create_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
