def test_references(caplog):
gvm = GlobalVariableManager()
d = {'a': 1, 'b': 2}
# Test access by reference
gvm.set_variable('d', d, per_reference=True)
_d = gvm.get_variable('d', per_reference=True)
d['a'] = 3
assert d['a'] == _d['a'] == 3
__d = gvm.get_variable('d', per_reference=True)
assert d['a'] == __d['a'] == 3
___d = gvm.get_variable('d')
d['a'] = 4
assert d['a'] == __d['a'] == ___d['a'] == 4
# Test set by reference, get by copy
gvm.set_variable('x', d, per_reference=True)
cd = gvm.get_variable('x', per_reference=False)
d['a'] = 5
assert d['a'] == 5 and cd['a'] == 4
# Test access by copy
dc = gvm.get_variable('d', per_reference=False)
d['b'] = 5
assert d['a'] == dc['a']
assert d['b'] != dc['b']
gvm.set_variable('c', d)
cc = gvm.get_variable('c')
d['a'] = 10
assert d['a'] != cc['a']
with raises(RuntimeError):
gvm.get_variable('c', per_reference=True)
testing_utils.assert_logger_warnings_and_errors(caplog)
def test_locks(caplog):
gvm = GlobalVariableManager.instance()
gvm.set_variable('a', 1)
a = gvm.get_variable('a')
assert a == 1
assert (not gvm.is_locked("a"))
access_key = gvm.lock_variable('a')
gvm.lock_variable('a')
assert (gvm.is_locked("a"))
a = gvm.get_variable('a', access_key=access_key)
assert a == 1
gvm.set_variable('a', 2, access_key=access_key)
assert gvm.get_variable('a', access_key=access_key) == 2
gvm.set_locked_variable('a', access_key=access_key, value=4)
assert gvm.get_locked_variable('a', access_key=access_key) == 4
gvm.unlock_variable('a', access_key)
gvm.unlock_variable('a', access_key)
assert (not gvm.is_locked("a"))
testing_utils.assert_logger_warnings_and_errors(caplog,
expected_warnings=1,
expected_errors=1)
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_invalid_locale_setting(caplog, monkeypatch):
create_mo_files()
with use_locale("invalid", monkeypatch):
i18n.setup_l10n()
testing_utils.assert_logger_warnings_and_errors(caplog=caplog, expected_warnings=1)
def test_runtime_values(caplog):
state_machine_manager.delete_all_state_machines()
sm = state_machine_execution_engine.execute_state_machine_from_path(
path=testing_utils.get_test_sm_path(os.path.join("unit_test_state_machines", "library_runtime_value_test")))
state_machine_manager.remove_state_machine(sm.state_machine_id)
assert sm.root_state.output_data["data_output_port1"] == 114
testing_utils.assert_logger_warnings_and_errors(caplog)
def test_observer_1_exception(self, caplog):
gvm.set_variable("wait_observer_1", 0.1)
gvm.set_variable("observer_1_exception", True)
self.run_state_machine()
self.assert_no_errors()
assert_all_false(gvm.get_variable("inner_observer_1_finish"), gvm.get_variable("observer_1_finish"),
gvm.get_variable("observer_1_finish"), gvm.get_variable("observer_2_finish"))
testing_utils.assert_logger_warnings_and_errors(caplog, 0, 1)
def test_default_run(self, caplog):
gvm.set_variable("wait_inner_observer_1", 1)
gvm.set_variable("wait_inner_observer_2", 1)
gvm.set_variable("wait_observer_1", 1)
gvm.set_variable("wait_observer_2", 1)
self.run_state_machine()
self.assert_no_errors()
testing_utils.assert_logger_warnings_and_errors(caplog, 0)
def test_save_nested_library_state(caplog):
library_with_nested_library_sm = create_hierarchy_state_library_state_machine(
)
storage.save_state_machine_to_path(library_with_nested_library_sm,
join(TEST_LIBRARY_PATH,
"library_with_nested_library"),
delete_old_state_machine=True)
testing_utils.assert_logger_warnings_and_errors(caplog)
def test_inner_observer_1_error(self, caplog):
gvm.set_variable("wait_inner_observer_1", 0.1)
gvm.set_variable("inner_observer_1_abort", True)
self.run_state_machine()
assert_gvm("inner_error_handler", False)
assert_gvm("error_handler")
assert_gvm("error_handler_2")
assert_all_false(gvm.get_variable("inner_observer_1_finish"), gvm.get_variable("observer_1_finish"),
gvm.get_variable("observer_1_finish"), gvm.get_variable("observer_2_finish"))
testing_utils.assert_logger_warnings_and_errors(caplog, 0)
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_observer_2_finish(self, caplog):
gvm.set_variable("wait_observer_2", 0.1)
self.run_state_machine()
self.assert_no_errors()
assert_gvm("observer_2_finish")
assert_gvm("inner_exit_handler")
assert_gvm("exit_handler")
assert_gvm("exit_handler_2")
assert_all_false(gvm.get_variable("inner_observer_2_finish"), gvm.get_variable("inner_observer_1_finish"),
gvm.get_variable("observer_1_finish"))
testing_utils.assert_logger_warnings_and_errors(caplog, 0)
def test_preemptive_wait2_timeout(caplog):
with testing_utils.test_multithreading_lock:
gvm.set_variable('state_2_wait', 0.5)
gvm.set_variable('state_1_wait', 1.)
run_state_machine()
assert 0.5 < gvm.get_variable('state_2_wait_time')
assert gvm.get_variable('state_1_preempted')
assert not gvm.get_variable('state_2_preempted')
testing_utils.assert_logger_warnings_and_errors(caplog)
def test_keys(caplog):
gvm = GlobalVariableManager.instance()
gvm.set_variable('a', 1)
gvm.set_variable('ab', 2)
gvm.set_variable('abc', 3)
gvm.set_variable('def', 4)
key_start_a = gvm.get_all_keys_starting_with('a')
assert (len(gvm.get_all_keys()) == 33)
assert (len(key_start_a) == 20)
testing_utils.assert_logger_warnings_and_errors(caplog)
def test_slim_observer(caplog):
testing_utils.dummy_gui(None)
test_observer = ObserverTest()
test_observer.test_observable.first_var = 20.0
assert test_observer.test_value == 20
test_observer.test_observable.complex_method(1, 3, "Hello world")
assert test_observer.test_observable.observable_test_var == 4
assert test_observer.test_value2 == 4
assert test_observer.test_value3 == 30
testing_utils.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 test_basic_string_translation(caplog, monkeypatch):
# target_locale = "de_DE.UTF-8"
# on debian systems the german utf locale is: "de_DE.utf8"
target_locale = "de_DE.utf8"
if testing_utils.check_if_locale_exists(target_locale):
logger.info("Execute locale test as locale was found on system")
with use_locale(target_locale, monkeypatch):
i18n.setup_l10n(logger)
assert _("Remove") == "Entfernen"
testing_utils.assert_logger_warnings_and_errors(caplog=caplog)
else:
logger.info(
"Locale test is not executed as locale was NOT found on system")
def test_preemptive_wait_daemon(caplog):
with testing_utils.test_multithreading_lock:
gvm.set_variable('state_1_wait', 0.5)
gvm.set_variable('state_2_wait', None)
run_state_machine()
assert 0.5 < gvm.get_variable('state_1_wait_time')
# cannot assert this as state 2 may be launched later and will thus have a shorter execution time
# assert 0.5 < gvm.get_variable('state_2_wait_time')
assert not gvm.get_variable('state_1_preempted')
assert gvm.get_variable('state_2_preempted')
testing_utils.assert_logger_warnings_and_errors(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 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 test_hierarchy_state_library(caplog):
with testing_utils.test_multithreading_lock:
library_container_state_sm = create_hierarchy_state_library_state_machine(
)
rafcon.core.singleton.state_machine_manager.add_state_machine(
library_container_state_sm)
rafcon.core.singleton.state_machine_execution_engine.start(
library_container_state_sm.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
# print output_data["data_output_port1"]
assert library_container_state_sm.root_state.output_data[
"data_output_port1"] == 42.0
rafcon.core.singleton.state_machine_manager.remove_state_machine(
library_container_state_sm.state_machine_id)
testing_utils.assert_logger_warnings_and_errors(caplog)
def test_locks(caplog):
gvm = GlobalVariableManager()
gvm.set_variable('a', 1)
a = gvm.get_variable('a')
assert a == 1
access_key = gvm.lock_variable('a')
gvm.lock_variable('a')
a = gvm.get_variable('a', access_key=access_key)
assert a == 1
gvm.set_variable('a', 2, access_key=access_key)
assert gvm.get_variable('a', access_key=access_key) == 2
gvm.unlock_variable('a', access_key)
gvm.unlock_variable('a', access_key)
testing_utils.assert_logger_warnings_and_errors(caplog,
expected_warnings=1,
expected_errors=1)
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)
with testing_utils.test_multithreading_lock:
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 state_machine.root_state.output_data["data_output_port1"] == 42.0
testing_utils.assert_logger_warnings_and_errors(caplog)
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_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_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_observer(caplog):
testing_utils.dummy_gui(None)
observer_test = ObserverTest()
observer_test.test_observable.first_var = 20.0
assert observer_test.test_value == 20
observer_test.test_observable.complex_method(1, 3, "Hello world")
assert observer_test.test_observable.observable_test_var == 4
assert observer_test.test_value2 == 4
assert observer_test.test_value3 == 30
test_model = TestModel()
TestObserver(test_model)
test_model.a += 1
assert test_model.passed
testing_utils.assert_logger_warnings_and_errors(caplog)
def test_transition_creation(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)
root_state = sm_loaded.root_state
state_machine = StateMachine(root_state)
with testing_utils.test_multithreading_lock:
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()
testing_utils.assert_logger_warnings_and_errors(caplog)
rafcon.core.singleton.state_machine_manager.delete_all_state_machines()
def test_nested_library_state_machine(caplog):
with testing_utils.test_multithreading_lock:
# TODO: the library_manager is initialized a second time here
rafcon.core.singleton.library_manager.initialize()
nested_library_state = LibraryState("temporary_libraries",
"library_with_nested_library",
"0.1", "nested_library_state_name",
"nested_library_state_id")
state_machine = StateMachine(nested_library_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()
# print output_data["data_output_port1"]
assert nested_library_state.output_data["data_output_port1"] == 42.0
rafcon.core.singleton.state_machine_manager.remove_state_machine(
state_machine.state_machine_id)
testing_utils.assert_logger_warnings_and_errors(caplog)
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)
with testing_utils.test_multithreading_lock:
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 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)
def test_start_stop_pause_step(caplog):
sm = return_loop_state_machine()
rafcon.core.singleton.global_variable_manager.set_variable("counter", 0)
with testing_utils.test_multithreading_lock:
rafcon.core.singleton.state_machine_manager.add_state_machine(sm)
rafcon.core.singleton.state_machine_execution_engine.step_mode(
sm.state_machine_id)
for i in range(5):
time.sleep(0.2)
rafcon.core.singleton.state_machine_execution_engine.step_into()
# give the state machine time to execute
time.sleep(0.2)
rafcon.core.singleton.state_machine_execution_engine.stop()
rafcon.core.singleton.state_machine_execution_engine.join()
assert rafcon.core.singleton.global_variable_manager.get_variable(
"counter") == 5
rafcon.core.singleton.state_machine_manager.remove_state_machine(
sm.state_machine_id)
testing_utils.assert_logger_warnings_and_errors(caplog)
