def test_hierarchy_save_load_test(caplog):
storage_path = testing_utils.get_unique_temp_path()
hierarchy_state = create_hierarchy_state()
sm = StateMachine(hierarchy_state)
storage.save_state_machine_to_path(sm, storage_path)
sm_loaded = storage.load_state_machine_from_path(storage_path)
state_machine = StateMachine(sm_loaded.root_state)
testing_utils.test_multithreading_lock.acquire()
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
rafcon.core.singleton.state_machine_manager.active_state_machine_id = state_machine.state_machine_id
rafcon.core.singleton.state_machine_execution_engine.start()
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_manager.remove_state_machine(
state_machine.state_machine_id)
try:
assert state_machine.root_state.output_data["output1"] == 52.0
# 2 type error -> one child output port data type error and root state scoped data type error
testing_utils.assert_logger_warnings_and_errors(caplog,
expected_errors=2)
finally:
testing_utils.test_multithreading_lock.release()
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 test_concurrency_barrier_save_load(caplog):
concurrency_barrier_state = create_concurrency_barrier_state()
state_machine = StateMachine(concurrency_barrier_state)
test_path = testing_utils.get_unique_temp_path()
storage.save_state_machine_to_path(state_machine, test_path)
sm_loaded = storage.load_state_machine_from_path(test_path)
root_state = sm_loaded.root_state
input_data = {"input_data_port1": 0.1, "input_data_port2": 0.1}
output_data = {"output_data_port1": None}
root_state.input_data = input_data
root_state.output_data = output_data
state_machine = StateMachine(root_state)
testing_utils.test_multithreading_lock.acquire()
rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
try:
assert rafcon.core.singleton.global_variable_manager.get_variable("var_x") == 10
assert rafcon.core.singleton.global_variable_manager.get_variable("var_y") == 20
assert root_state.final_outcome.outcome_id == 4
with pytest.raises(ValueError):
concurrency_barrier_state.remove(UNIQUE_DECIDER_STATE_ID)
with pytest.raises(AttributeError):
concurrency_barrier_state.remove_state(UNIQUE_DECIDER_STATE_ID)
rafcon.core.singleton.state_machine_manager.remove_state_machine(state_machine.state_machine_id)
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog, expected_warnings=0, expected_errors=1)
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 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_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_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_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_scoped_data(caplog):
storage_path = testing_utils.get_unique_temp_path()
sm = create_state_machine()
storage.save_state_machine_to_path(sm, storage_path)
sm_loaded = storage.load_state_machine_from_path(storage_path)
state_machine = StateMachine(sm_loaded.root_state)
testing_utils.test_multithreading_lock.acquire()
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
rafcon.core.singleton.state_machine_manager.active_state_machine_id = state_machine.state_machine_id
rafcon.core.singleton.state_machine_execution_engine.start()
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_manager.remove_state_machine(
state_machine.state_machine_id)
try:
assert state_machine.root_state.output_data[
"data_output_port1"] == 42.0
testing_utils.assert_logger_warnings_and_errors(caplog)
finally:
testing_utils.test_multithreading_lock.release()
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 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 test_gui(number_child_states=10, number_childs_per_child=10, barrier=False, sleep=False, profile_add_state=True,
caplog=None):
create_gui()
from rafcon.core.state_machine import StateMachine
from core_performance import create_hierarchy_state, create_barrier_concurrency_state
try:
if barrier:
state_machine = StateMachine(create_barrier_concurrency_state(number_child_states, number_childs_per_child))
else:
state_machine = StateMachine(create_hierarchy_state(number_child_states, sleep=sleep))
add_state_machine_to_manager_model(state_machine, profile_add_state)
except Exception:
raise
finally:
destroy_gui(caplog)
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_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_multiple_undo_redo_bug_with_gui(gui):
from gi.repository import GLib
import rafcon.gui.singleton
num_add = 10
num_undo = 20
num_redo = 20
sm = StateMachine(HierarchyState())
gui(rafcon.core.singleton.state_machine_manager.add_state_machine, sm)
sm_m = list(rafcon.gui.singleton.state_machine_manager_model.
state_machines.values())[-1]
gui(sm_m.selection.set, [sm_m.root_state])
main_window_controller = rafcon.gui.singleton.main_window_controller
sm_id = sm_m.state_machine.state_machine_id
state_machines_editor_ctrl = main_window_controller.state_machines_editor_ctrl
gui(
state_machines_editor_ctrl.get_controller(
sm_id).view.get_parent_widget().grab_focus)
gui(
state_machines_editor_ctrl.get_controller(
sm_id).view.editor.grab_focus)
def trigger_action_repeated(action_name, number):
for _ in range(number):
main_window_controller.shortcut_manager.trigger_action(
action_name, None, None)
gui(trigger_action_repeated, "add", num_add, priority=GLib.PRIORITY_HIGH)
assert len(sm_m.history.modifications) == num_add + 1
gui(trigger_action_repeated, "undo", num_undo, priority=GLib.PRIORITY_HIGH)
gui.expected_warnings += max(num_undo - num_add, 0)
gui(trigger_action_repeated, "redo", num_redo, priority=GLib.PRIORITY_HIGH)
gui.expected_warnings += max(num_redo - min(num_add, num_undo), 0)
def test_runtime_checks_for_data_port_data_types(caplog):
storage_path = testing_utils.get_unique_temp_path()
print(storage_path)
sm = create_state_machine2()
# test output port type check
script_text = 'def execute(self, inputs, outputs, gvm):\n' \
' outputs["output_data_port1"] = [1, 2, 3]\n' \
' return 3'
sm.get_state_by_path('FirstLevel1/ZeroLevel2').script_text = script_text
# TODO comment (next 2 lines) in after final fix of tuple storing bug is applied and remove 3 line (4 storage check)
# storage.save_state_machine_to_path(sm, storage_path)
# sm_loaded = storage.load_state_machine_from_path(storage_path)
sm_loaded = sm
root_state = sm_loaded.root_state
state_machine = StateMachine(root_state)
testing_utils.test_multithreading_lock.acquire()
rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_manager.remove_state_machine(state_machine.state_machine_id)
# 6 errors -> IN ORDER output port-, root state scoped-, input port-, output port-, root state scoped- and
# root state output port-data-type-errors
testing_utils.shutdown_environment_only_core(caplog=caplog, expected_errors=6)
def create_execution_state_library_state_machine():
rafcon.core.singleton.library_manager.initialize()
library_container_state = HierarchyState("libContainerState",
state_id="libContainerState")
lib_state = LibraryState("temporary_libraries",
"execution_library",
"0.1",
"library_execution_state",
state_id="library_execution_state")
library_container_state.add_state(lib_state)
library_container_state.set_start_state(lib_state.state_id)
library_container_state.add_transition(lib_state.state_id, 0,
library_container_state.state_id, 0)
lib_container_input = library_container_state.add_input_data_port(
"data_input_port1", "float", 32.0)
lib_container_output = library_container_state.add_output_data_port(
"data_output_port1", "float")
library_container_state.add_data_flow(
library_container_state.state_id, lib_container_input,
lib_state.state_id,
lib_state.get_io_data_port_id_from_name_and_type(
"data_input_port1", InputDataPort))
library_container_state.add_data_flow(
lib_state.state_id,
lib_state.get_io_data_port_id_from_name_and_type(
"data_output_port1", OutputDataPort),
library_container_state.state_id, lib_container_output)
return StateMachine(library_container_state)
def test_default_values_of_data_ports(caplog):
storage_path = testing_utils.get_unique_temp_path()
print(storage_path)
sm = create_state_machine()
storage.save_state_machine_to_path(sm, storage_path)
sm_loaded = storage.load_state_machine_from_path(storage_path)
root_state = sm_loaded.root_state
state_machine = StateMachine(root_state)
testing_utils.test_multithreading_lock.acquire()
rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_manager.remove_state_machine(state_machine.state_machine_id)
print(root_state.output_data)
try:
assert root_state.output_data["output_data_port1"] == "default_value"
finally:
testing_utils.shutdown_environment_only_core(caplog=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 run_turtle_demo():
import rafcon.core
import rafcon.core.start
signal.signal(signal.SIGINT, rafcon.core.start.signal_handler)
global_config.load()
global_gui_config.load()
# set the test_libraries path temporarily to the correct value
library_paths = rafcon.core.config.global_config.get_config_value(
"LIBRARY_PATHS")
if os.path.exists(
str(os.path.sep).join(
[rafcon.__path__[0], '..', '..', '..', 'share',
'libraries'])): # rm-pkg
os.environ['RAFCON_LIB_PATH'] = os.path.join(rafcon.__path__[0], '..',
'..', '..', 'share',
'libraries')
library_paths["ros_libraries"] = os.path.join(rafcon.__path__[0], '..',
'..', '..', 'share',
'examples', 'libraries',
'ros_libraries')
library_paths["turtle_libraries"] = os.path.join(
rafcon.__path__[0], '..', '..', '..', 'share', 'examples',
'libraries', 'turtle_libraries')
example_path = os.path.join(rafcon.__path__[0], os.pardir, '..', '..',
'share', 'examples', "tutorials")
else: # git repo
os.environ['RAFCON_LIB_PATH'] = os.path.join(
dirname(abspath(__file__)), '..', '..', '..', 'libraries')
library_paths["ros_libraries"] = os.path.join(
dirname(abspath(__file__)), '..', '..', 'libraries',
'ros_libraries')
library_paths["turtle_libraries"] = os.path.join(
dirname(abspath(__file__)), '..', '..', 'libraries',
'turtle_libraries')
example_path = os.path.join(dirname(abspath(__file__)), '..', '..',
"tutorials")
rafcon.core.singleton.library_manager.initialize()
rafcon.core.singleton.state_machine_manager.delete_all_state_machines()
base_path = os.path.dirname(os.path.abspath(__file__))
basic_turtle_demo_state = create_turtle_statemachine(
base_path, example_path)
state_machine = StateMachine(basic_turtle_demo_state)
# # load the state machine
# [state_machine, version, creation_time] = storage.load_statemachine_from_path(
# "../../share/examples/tutorials/basic_turtle_demo_sm")
rafcon.core.singleton.library_manager.initialize()
main_window_view = MainWindowView()
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
sm_manager_model = rafcon.gui.singleton.state_machine_manager_model
main_window_controller = MainWindowController(sm_manager_model,
main_window_view)
gtk.main()
logger.debug("Gtk main loop exited!")
def execute_state(root_state):
state_machine = StateMachine(root_state)
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(
state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_manager.remove_state_machine(
state_machine.state_machine_id)
def test_hierarchy_state_execution(caplog):
hierarchy_state = create_hierarchy_state()
state_machine = StateMachine(hierarchy_state)
try:
# Changing the data type has to fail, as the data port is already connected to a data flow
state_machine.root_state.input_data_ports[42].data_type = str
except Exception, e:
assert isinstance(e, ValueError)
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 create_state_machine():
state1 = ExecutionState("DummyState1",
path=testing_utils.TEST_SCRIPT_PATH,
filename="transition_test_state.py")
state1.add_outcome('dummy_outcome_1', 3)
state1.add_outcome('dummy_outcome_2', 4)
state2 = ExecutionState("DummyState2",
path=testing_utils.TEST_SCRIPT_PATH,
filename="transition_test_state.py")
state2.add_outcome('dummy_outcome_1', 3)
state2.add_outcome('dummy_outcome_2', 4)
state3 = ExecutionState("DummyState3",
path=testing_utils.TEST_SCRIPT_PATH,
filename="transition_test_state.py")
state3.add_outcome('dummy_outcome_1', 3)
state3.add_outcome('dummy_outcome_2', 4)
state4 = HierarchyState("DummyHierarchyState")
state4.add_state(state1)
state4.set_start_state(state1.state_id)
state4.add_state(state2)
state4.add_state(state3)
state4.add_outcome("final_outcome", 5)
state4.add_transition(state1.state_id, 3, state2.state_id, None)
state4.add_transition(state1.state_id, 4, state3.state_id, None)
state4.add_transition(state2.state_id, 3, state4.state_id, 5)
state4.add_transition(state3.state_id, 3, state4.state_id, 5)
state4.add_transition(state3.state_id, 4, state4.state_id, 5)
t = state4.add_transition(state2.state_id, 4, state1.state_id, None)
state4.remove_transition(t)
state4.add_transition(state2.state_id, 4, state1.state_id, None)
# no target at all
with raises(ValueError):
state4.add_transition(state3.state_id, 4, None, None)
# no to_state
with raises(ValueError):
state4.add_transition(state3.state_id, 4, None, 5)
# start transition already existing
with raises(ValueError):
state4.add_transition(None, None, state3.state_id, None)
state4.start_state_id = None
state4.add_transition(None, None, state1.state_id, None)
return StateMachine(state4)
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_last_wins_value_collection_for_data_ports(caplog):
sm_path = testing_utils.get_test_sm_path(os.path.join("unit_test_state_machines", "last_data_wins_test"))
sm_loaded = storage.load_state_machine_from_path(sm_path)
root_state = sm_loaded.root_state
state_machine = StateMachine(root_state)
testing_utils.test_multithreading_lock.acquire()
rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_manager.remove_state_machine(state_machine.state_machine_id)
testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_concurrency_barrier_state_execution(caplog):
with testing_utils.test_multithreading_lock:
sm = create_state_machine()
root_state = sm.root_state
state_machine = StateMachine(root_state)
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(
state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_manager.remove_state_machine(
state_machine.state_machine_id)
assert root_state.output_data["output_data_port1"] == 42
testing_utils.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 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_models(*args, **kargs):
import rafcon.core.singleton
import rafcon.gui.singleton
from rafcon.core.states.hierarchy_state import HierarchyState
from rafcon.core.state_machine import StateMachine
state1 = HierarchyState('State1', state_id="State1")
ctr_state = HierarchyState(name="Root", state_id="Root")
ctr_state.add_state(state1)
ctr_state.name = "Container"
sm = StateMachine(ctr_state)
# add new state machine
rafcon.core.singleton.state_machine_manager.add_state_machine(sm)
testing_utils.wait_for_gui()
# select state machine
rafcon.gui.singleton.state_machine_manager_model.selected_state_machine_id = sm.state_machine_id
