def test_reset_to_history_id(gui):
state_machine_m, state_dict = create_state_machine_m(gui)
sm_history = state_machine_m.history
state1_id = state_dict["State1"].state_id
state2_id = state_dict["State2"].state_id
# Remove two child states of root state
gui(state_machine_m.root_state.state.remove_state, state1_id) # history id 1
gui(state_machine_m.root_state.state.remove_state, state2_id) # history id 2
history_2_hash = state_machine_m.mutable_hash().hexdigest()
# Undo removal
gui(state_machine_m.history.undo)
gui(state_machine_m.history.undo)
# Create new history branch by adding two new states
state4 = ExecutionState("State4")
state5 = ExecutionState("State5")
gui(state_machine_m.root_state.state.add_state, state4) # history id 3
gui(state_machine_m.root_state.state.add_state, state5) # history id 4
assert state_machine_m.history.modifications.current_history_element.history_id == 4
history_4_hash = state_machine_m.mutable_hash().hexdigest()
# Activate old branch
gui(state_machine_m.history.reset_to_history_id, 2)
reset_history_2_hash = state_machine_m.mutable_hash().hexdigest()
assert history_2_hash == reset_history_2_hash
# Activate new branch
gui(state_machine_m.history.reset_to_history_id, 4)
reset_history_4_hash = state_machine_m.mutable_hash().hexdigest()
assert history_4_hash == reset_history_4_hash
def test_simple_undo_redo(caplog):
testing_utils.dummy_gui(None)
testing_utils.initialize_environment(gui_config={
'AUTO_BACKUP_ENABLED': False,
'HISTORY_ENABLED': True
},
gui_already_started=False)
state_machine_m, state_dict = create_state_machine_m()
state1 = ExecutionState('state1', state_id='STATE1')
state2 = ExecutionState('state2', state_id='STATE2')
state3 = ExecutionState('state2', state_id='STATE2')
state4 = ExecutionState('state2', state_id='STATE2')
state_machine_m.root_state.state.add_state(state1)
state_machine_m.root_state.state.add_state(state2)
state_machine_m.root_state.state.add_state(state3)
state_machine_m.root_state.state.add_state(state4)
assert len(state_machine_m.history.modifications) == 5
perform_multiple_undo(2)
perform_multiple_redo(1)
perform_multiple_redo(1)
assert len(state_machine_m.history.modifications) == 5
testing_utils.shutdown_environment(caplog=caplog,
unpatch_threading=False,
expected_errors=0)
def __init__(self,
name=None,
state_id=None,
input_data_ports=None,
output_data_ports=None,
income=None,
outcomes=None,
path=None,
filename=None,
safe_init=True):
if state_id is None:
state_id = UNIQUE_DECIDER_STATE_ID
ExecutionState.__init__(self,
name,
state_id,
input_data_ports,
output_data_ports,
income,
outcomes,
path,
filename,
safe_init=safe_init)
self.child_errors = {}
self.final_outcomes_dict = {}
def test_multiple_future_element():
testing_utils.dummy_gui(None)
from rafcon.core.states.hierarchy_state import HierarchyState
from rafcon.core.states.execution_state import ExecutionState
from rafcon.gui.models.state import StateModel
from rafcon.gui.models.container_state import ContainerStateModel
parent_state = HierarchyState()
parent_state_m = ContainerStateModel(parent_state)
child_state_a = ExecutionState("A")
child_state_a_m = StateModel(child_state_a)
child_state_b = ExecutionState("B")
child_state_b_m = StateModel(child_state_b)
parent_state_m.expected_future_models.add(child_state_a_m)
parent_state_m.expected_future_models.add(child_state_b_m)
parent_state.add_state(child_state_a)
assert len(parent_state_m.states) == 1
new_child_state_a_m = list(parent_state_m.states.values())[0]
assert new_child_state_a_m is child_state_a_m
assert new_child_state_a_m.core_element is child_state_a
assert len(parent_state_m.expected_future_models) == 1
parent_state.add_state(child_state_b)
assert len(parent_state_m.states) == 2
new_child_states_m = list(parent_state_m.states.values())
assert new_child_states_m[0] is child_state_b_m or new_child_states_m[
1] is child_state_b_m
assert new_child_states_m[
0].core_element is child_state_b or new_child_states_m[
1].core_element is child_state_b
assert len(parent_state_m.expected_future_models) == 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 test_connections_from_object_type(caplog):
parent_state = HierarchyState("parent")
child_state = ExecutionState("child")
parent_state.add_state(child_state)
parent_obj_port_id = parent_state.add_input_data_port("obj",
data_type=object,
default_value=None)
parent_int_port_id = parent_state.add_input_data_port("int",
data_type=int,
default_value=None)
child_obj_port_id = child_state.add_input_data_port("obj",
data_type=object,
default_value=0)
child_int_port_id = child_state.add_input_data_port("int",
data_type=int,
default_value=0)
# Connection from specific type int to generic type object
parent_state.add_data_flow(parent_state.state_id, parent_int_port_id,
child_state.state_id, child_obj_port_id)
# Connection from generic type object to specific type int
parent_state.add_data_flow(parent_state.state_id, parent_obj_port_id,
child_state.state_id, child_int_port_id)
testing_utils.assert_logger_warnings_and_errors(caplog,
expected_warnings=0,
expected_errors=0)
def test_state_type_change_bugs_with_gui(gui):
sm_manager_model = gui.singletons.state_machine_manager_model
sm_m, state_dict = create_state_machine_m(gui)
check_elements_ignores.append("internal_transitions")
# General Type Change inside of a state machine (NO ROOT STATE) ############
state_of_type_change = 'State3'
parent_of_type_change = 'Container'
# do state_type_change with gui
gui(sm_m.history.modifications.reset)
state_m = sm_m.get_state_model_by_path(
state_dict[state_of_type_change].get_path())
gui(sm_m.selection.set, [state_m])
current_sm_length = len(sm_manager_model.state_machines)
# print "1:", sm_manager_model.state_machines.keys()
logger.debug('number of sm is : {0}'.format(
sm_manager_model.state_machines.keys()))
def create_simple_state_machine():
root_state = HierarchyState("new root state", state_id="ROOT")
state_machine = StateMachine(root_state)
sm_manager_model.state_machine_manager.add_state_machine(state_machine)
return state_machine
state_machine = gui(create_simple_state_machine)
logger.debug('number of sm is : {0}'.format(
sm_manager_model.state_machines.keys()))
assert len(sm_manager_model.state_machines) == current_sm_length + 1
sm_m = sm_manager_model.state_machines[state_machine.state_machine_id]
h_state1 = HierarchyState(state_id='HSTATE1')
gui(sm_m.state_machine.root_state.add_state, h_state1)
h_state2 = HierarchyState(state_id='HSTATE2')
gui(h_state1.add_state, h_state2)
ex_state1 = ExecutionState(state_id='EXSTATE1')
gui(h_state1.add_state, ex_state1)
ex_state2 = ExecutionState(state_id='EXSTATE2')
gui(h_state2.add_state, ex_state2)
logger.info("DO_TYPE_CHANGE")
h_state1_m = sm_m.get_state_model_by_path(h_state1.get_path())
do_type_change(sm_m, h_state1_m, ExecutionState, gui)
logger.info("UNDO")
gui(sm_m.history.undo)
logger.info("UNDO finished")
logger.info("REDO")
gui(sm_m.history.redo)
logger.info("REDO finished")
check_elements_ignores.remove("internal_transitions")
print(check_elements_ignores)
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 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 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_models(*args, **kargs):
import rafcon.core.singleton
from rafcon.core.states.hierarchy_state import HierarchyState
from rafcon.core.states.execution_state import ExecutionState
from rafcon.core.state_machine import StateMachine
state1 = HierarchyState('State1', state_id="State1")
state2 = ExecutionState('State2', state_id="State2")
ctr_state = HierarchyState(name="Root", state_id="Root")
ctr_state.add_state(state1)
ctr_state.add_state(state2)
ctr_state.start_state_id = state1.state_id
ctr_state.add_transition(state1.state_id,
from_outcome=0,
to_state_id=state2.state_id,
to_outcome=None)
ctr_state.add_transition(state2.state_id,
from_outcome=0,
to_state_id=ctr_state.state_id,
to_outcome=0)
ctr_state.name = "Container"
sm = StateMachine(ctr_state)
# add new state machine
rafcon.core.singleton.state_machine_manager.add_state_machine(sm)
rafcon.core.singleton.state_machine_manager.active_state_machine_id = sm.state_machine_id
def execute(self, inputs, outputs, gvm):
self.logger.debug("Insert state")
e = ExecutionState()
self.parent.add_state(e)
self.parent.add_transition(self.state_id, 0, e.state_id, None)
self.parent.add_transition(e.state_id, 0, self.parent.state_id, 0)
return 0
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_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 test_lock_state_machine(caplog):
state_machine = StateMachine()
@lock_state_machine
def custom_function(object, number):
raise AttributeError("Test error")
State.custom_method = custom_function
state1 = ExecutionState("s1")
state_machine.root_state = state1
try:
state1.custom_method(5)
except Exception, e:
import traceback
print "Could not stop state machine: {0} {1}".format(
e.message, traceback.format_exc())
def get_models():
from rafcon.core.states.execution_state import ExecutionState
from rafcon.core.states.hierarchy_state import HierarchyState
from rafcon.gui.models.container_state import ContainerStateModel
def get_outcome_with_name(state_m, outcome_name):
return [
outcome_m for outcome_m in state_m.outcomes
if outcome_m.outcome.name == outcome_name
][0]
def get_state_with_name(parent_state_m, state_name):
return [
state_m for state_m in parent_state_m.states.values()
if state_m.state.name == state_name
][0]
execution_state = ExecutionState("ex1")
execution_state.add_outcome("oe1")
child_state = ExecutionState("ex2")
hierarchy_state = HierarchyState("h1")
hierarchy_state.add_outcome("oh1")
hierarchy_state.add_state(child_state)
root_state = HierarchyState("root")
root_state.add_state(execution_state)
root_state.add_state(hierarchy_state)
root_state_m = ContainerStateModel(root_state)
execution_state_m = get_state_with_name(root_state_m, "ex1")
hierarchy_state_m = get_state_with_name(root_state_m, "h1")
child_state_m = get_state_with_name(hierarchy_state_m, "ex2")
outcome_e_success_m = get_outcome_with_name(execution_state_m, "success")
outcome_e_1_m = get_outcome_with_name(execution_state_m, "oe1")
outcome_h_success_m = get_outcome_with_name(hierarchy_state_m, "success")
outcome_h_1_m = get_outcome_with_name(hierarchy_state_m, "oh1")
return (root_state_m, execution_state_m, hierarchy_state_m, child_state_m), (outcome_e_success_m, outcome_e_1_m), \
(outcome_h_success_m, outcome_h_1_m)
def test_save_libraries(caplog):
s = storage
state1 = ExecutionState("library_execution_state1",
path=testing_utils.TEST_SCRIPT_PATH,
filename="library_execution_state1.py")
input_state1 = state1.add_input_data_port("data_input_port1", "float")
output_state1 = state1.add_output_data_port("data_output_port1", "float")
state2 = ExecutionState("library_execution_state2",
path=testing_utils.TEST_SCRIPT_PATH,
filename="library_execution_state2.py")
input_state2 = state2.add_input_data_port("data_input_port1", "float")
output_state2 = state2.add_output_data_port("data_output_port1", "float")
state3 = HierarchyState("library_hierarchy_state1")
state3.add_state(state1)
state3.add_state(state2)
state3.set_start_state(state1.state_id)
state3.add_transition(state1.state_id, 0, state2.state_id, None)
state3.add_transition(state2.state_id, 0, state3.state_id, 0)
input_state3 = state3.add_input_data_port("data_input_port1", "float", 1.0)
output_state3 = state3.add_output_data_port("data_output_port1", "float",
2.0)
state3.add_data_flow(state3.state_id, input_state3, state1.state_id,
input_state1)
state3.add_data_flow(state1.state_id, output_state1, state2.state_id,
input_state2)
state3.add_data_flow(state2.state_id, output_state2, state3.state_id,
output_state3)
# save hierarchy state as state machine
s.save_state_machine_to_path(StateMachine(state3),
join(TEST_LIBRARY_PATH, "hierarchy_library"))
# save execution state as state machine
s.save_state_machine_to_path(StateMachine(state1),
join(TEST_LIBRARY_PATH, "execution_library"))
# save hierarchy state as nested state machines
state3.name = "library_nested1"
s.save_state_machine_to_path(StateMachine(state3),
join(TEST_LIBRARY_PATH, "library_container",
"library_nested1"),
delete_old_state_machine=True)
state3.name = "library_nested2"
s.save_state_machine_to_path(StateMachine(state3),
join(TEST_LIBRARY_PATH, "library_container",
"library_nested2"),
delete_old_state_machine=True)
testing_utils.assert_logger_warnings_and_errors(caplog)
def test_state_machine_manager(caplog):
state_machine = StateMachine()
state1 = ExecutionState("s1")
state_machine.root_state = state1
manager = StateMachineManager.instance([state_machine])
sm_id = manager.get_sm_id_for_root_state_id('FakeId')
assert (sm_id is None)
assert_logger_warnings_and_errors(caplog)
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 test_lock_state_machine(caplog):
state_machine = StateMachine()
@lock_state_machine
def custom_function(object, number):
raise AttributeError("Test error")
State.custom_method = custom_function
state1 = ExecutionState("s1")
state_machine.root_state = state1
try:
state1.custom_method(5)
except Exception as e:
import traceback
print("Could not stop state machine: {0} {1}".format(
e, traceback.format_exc()))
assert global_lock_counter == 0
state1.add_outcome("outcome1", 3)
assert len(state1.outcomes) == 4
assert_logger_warnings_and_errors(caplog)
def 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_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 create_state_machine():
from rafcon.core.state_machine import StateMachine
from rafcon.core.states.hierarchy_state import HierarchyState
from rafcon.core.states.execution_state import ExecutionState
root = HierarchyState(name='root')
ex1 = ExecutionState(name='1')
root.add_state(ex1)
ex2 = ExecutionState(name='2')
root.add_state(ex2)
ex3 = ExecutionState(name='3')
root.add_state(ex3)
# hierarchy state at the beginning
h4 = HierarchyState('H4')
ex41 = ExecutionState(name='41')
h4.add_state(ex41)
ex42 = ExecutionState(name='42')
h4.add_state(ex42)
ex43 = ExecutionState(name='43')
h4.add_state(ex43)
h4.start_state_id = ex41.state_id
h4.add_transition(ex41.state_id, 0, ex42.state_id, None)
h4.add_transition(ex42.state_id, 0, ex43.state_id, None)
h4.add_transition(ex43.state_id, 0, h4.state_id, 0)
root.add_state(h4)
root.start_state_id = ex1.state_id
root.add_transition(h4.state_id, 0, ex1.state_id, None)
root.add_transition(ex1.state_id, 0, ex2.state_id, None)
root.add_transition(ex2.state_id, 0, ex3.state_id, None)
t_id = root.add_transition(ex3.state_id, 0, root.state_id, 0)
return StateMachine(root_state=root), t_id, h4.state_id
def return_loop_state_machine():
state1 = ExecutionState("MyFirstState", path=testing_utils.TEST_SCRIPT_PATH, filename="loop_state1.py")
state1.add_outcome("MyFirstOutcome", 3)
state2 = ExecutionState("MySecondState", path=testing_utils.TEST_SCRIPT_PATH, filename="loop_state2.py")
state2.add_outcome("FirstOutcome", 3)
state3 = HierarchyState("MyFirstHierarchyState")
state3.add_state(state1)
state3.add_state(state2)
state3.set_start_state(state1.state_id)
state3.add_transition(state1.state_id, 3, state2.state_id, None)
state3.add_transition(state2.state_id, 3, state1.state_id, None)
return StateMachine(state3)
def test_default():
testing_utils.dummy_gui(None)
from rafcon.core.states.hierarchy_state import HierarchyState
from rafcon.core.states.execution_state import ExecutionState
from rafcon.gui.models.container_state import ContainerStateModel
parent_state = HierarchyState()
parent_state_m = ContainerStateModel(parent_state)
child_state_a = ExecutionState("A")
parent_state.add_state(child_state_a)
assert len(parent_state_m.states) == 1
child_state_a_m = list(parent_state_m.states.values())[0]
assert child_state_a_m.core_element is child_state_a
def create_preemptive_wait_state_machine():
state1 = ExecutionState("state_1",
path=testing_utils.TEST_SCRIPT_PATH,
filename="preemptive_wait_test.py")
state1.add_outcome("FirstOutcome", 3)
state2 = ExecutionState("state_2",
path=testing_utils.TEST_SCRIPT_PATH,
filename="preemptive_wait_test.py")
state2.add_outcome("FirstOutcome", 3)
ctr_state = PreemptiveConcurrencyState("FirstConcurrencyState")
ctr_state.add_state(state1)
ctr_state.add_state(state2)
ctr_state.add_outcome("end", 3)
ctr_state.add_transition(state1.state_id, 3, ctr_state.state_id, 3)
ctr_state.add_transition(state2.state_id, 3, ctr_state.state_id, 3)
return StateMachine(ctr_state)
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 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 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_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)
