def test_pane_positions(caplog):
testing_utils.run_gui(core_config=None,
gui_config={
'HISTORY_ENABLED': False,
'AUTO_BACKUP_ENABLED': False
},
runtime_config={
'MAIN_WINDOW_MAXIMIZED': False,
'MAIN_WINDOW_SIZE': (1500, 800),
'MAIN_WINDOW_POS': (0, 0),
'LEFT_BAR_DOCKED_POS': 400,
'RIGHT_BAR_DOCKED_POS': 800,
'CONSOLE_DOCKED_POS': 600,
'LEFT_BAR_WINDOW_UNDOCKED': False,
'RIGHT_BAR_WINDOW_UNDOCKED': False,
'CONSOLE_WINDOW_UNDOCKED': False,
'LEFT_BAR_HIDDEN': False,
'RIGHT_BAR_HIDDEN': False,
'CONSOLE_HIDDEN': False,
})
from rafcon.gui.runtime_config import global_runtime_config
original_runtime_config = global_runtime_config.as_dict()
try:
check_pane_positions()
finally:
for key, value in original_runtime_config.items():
call_gui_callback(global_runtime_config.set_config_value, key,
value)
testing_utils.close_gui()
testing_utils.shutdown_environment(caplog=caplog)
def test_recent_opened_state_machine_list(caplog):
change_in_gui_config = {
'AUTO_BACKUP_ENABLED': True,
'HISTORY_ENABLED': False
}
libraries = {
"ros":
join(testing_utils.EXAMPLES_PATH, "libraries", "ros_libraries"),
"turtle_libraries":
join(testing_utils.EXAMPLES_PATH, "libraries", "turtle_libraries"),
"generic":
join(testing_utils.LIBRARY_SM_PATH, "generic")
}
testing_utils.run_gui(gui_config=change_in_gui_config,
libraries=libraries) # , patch_threading=False)
call_gui_callback(patch_backup_threading)
try:
trigger_gui_signals()
except:
raise
finally:
call_gui_callback(unpatch_backup_threading)
testing_utils.close_gui()
testing_utils.shutdown_environment(
caplog=caplog, expected_warnings=0,
expected_errors=1) # , unpatch_threading=False)
def save_state_machine(with_gui=True):
import rafcon
from rafcon.core.singleton import state_machine_execution_engine
import rafcon.gui.singleton as gui_singleton
from rafcon.core.storage import storage
path = testing_utils.get_unique_temp_path()
if with_gui:
state_machine = call_gui_callback(create_models)
else:
state_machine = create_models()
if with_gui:
sm_model = rafcon.gui.singleton.state_machine_manager_model.state_machines[
state_machine.state_machine_id]
menubar_ctrl = gui_singleton.main_window_controller.get_controller(
'menu_bar_controller')
# sm_model.state_machine.base_path = path
call_gui_callback(menubar_ctrl.on_save_as_activate, None, None, path)
# call_gui_callback(menubar_ctrl.on_quit_activate, None)
call_gui_callback(check_that_all_files_are_there,
state_machine,
with_print=False)
else:
storage.save_state_machine_to_path(state_machine,
path,
delete_old_state_machine=False)
check_that_all_files_are_there(state_machine, with_print=False)
def test_drag_and_drop_test(caplog):
testing_utils.run_gui(
gui_config={
'AUTO_BACKUP_ENABLED': False,
'HISTORY_ENABLED': False
},
runtime_config={
'MAIN_WINDOW_MAXIMIZED': False,
'MAIN_WINDOW_SIZE': (1500, 800),
'MAIN_WINDOW_POS': (0, 0),
'LEFT_BAR_WINDOW_UNDOCKED': False,
'RIGHT_BAR_WINDOW_UNDOCKED': False,
'CONSOLE_WINDOW_UNDOCKED': False,
'LEFT_BAR_HIDDEN': True,
'RIGHT_BAR_HIDDEN': True,
'CONSOLE_HIDDEN': True,
},
libraries={
"unit_test_state_machines":
testing_utils.get_test_sm_path("unit_test_state_machines")
})
import rafcon.core.singleton
call_gui_callback(create_models)
try:
trigger_drag_and_drop_tests(
rafcon.gui.singleton.state_machine_manager_model,
rafcon.gui.singleton.main_window_controller)
finally:
testing_utils.close_gui()
testing_utils.shutdown_environment(caplog=caplog,
expected_warnings=1,
expected_errors=0)
def run_copy_test(sm_m, with_gui=False):
"""Run general test that """
import rafcon.gui.singleton
sm = sm_m.state_machine
new_sm_m = copy.copy(sm_m)
equal_check_state(sm_m.root_state.state, new_sm_m.root_state.state)
equal_check_state_model(sm_m.root_state, new_sm_m.root_state)
compare_references_to_sm_model_and_core(sm_m, new_sm_m)
# storage copy tests
if sm.file_system_path is None:
tmp_sm_system_path = join(testing_utils.RAFCON_TEMP_PATH_TEST_BASE,
'copy_test_' + str(sm.state_machine_id))
else:
tmp_sm_system_path = join(testing_utils.RAFCON_TEMP_PATH_TEST_BASE,
'copy_test' + sm.file_system_path)
new_sm_m.state_machine.root_state.name = "Copied Cont state"
testing_utils.wait_for_gui()
new_sm_m.destroy()
if with_gui:
main_window_controller = rafcon.gui.singleton.main_window_controller
menubar_ctrl = main_window_controller.get_controller(
'menu_bar_controller')
testing_utils.call_gui_callback(sm_m.state_machine.__setattr__,
"file_system_path", tmp_sm_system_path)
testing_utils.call_gui_callback(menubar_ctrl.on_save_activate, None)
def wait_for_sync_counter_change_and_wait_for_gui(current_sync_counter):
assert current_sync_counter is not None
print("##### before {0} #####".format(current_sync_counter))
while current_sync_counter == state_machine_execution_engine.synchronization_counter:
time.sleep(0.1)
print("##### in wait {0} #####".format(state_machine_execution_engine.synchronization_counter))
print("##### after {0} #####".format(state_machine_execution_engine.synchronization_counter))
testing_utils.call_gui_callback(testing_utils.wait_for_gui)
def paste(state_machine_model, state_m, main_window_controller, menu_bar_ctrl,
page):
print("Pasting")
call_gui_callback(state_machine_model.selection.set, [state_m])
main_window_controller.view['main_window'].grab_focus()
focus_graphical_editor_in_page(page)
call_gui_callback(menu_bar_ctrl.on_paste_clipboard_activate, None, None)
testing_utils.wait_for_gui()
def add_state_machine_to_manager_model(state_machine, profiling=False):
def _add_state_machine_to_manager_model():
from rafcon.gui.singleton import state_machine_manager
if profiling:
profiler.start("add_state_machine")
state_machine_manager.add_state_machine(state_machine)
testing_utils.wait_for_gui()
if profiling:
profiler.stop("add_state_machine")
testing_utils.call_gui_callback(_add_state_machine_to_manager_model)
def run_state_machine(state_machine_path):
import rafcon.core.config
import rafcon.core.singleton as singletons
import rafcon.gui.helpers.state_machine as gui_helper_statemachine
gvm = rafcon.core.singleton.global_variable_manager
execution_engine = singletons.state_machine_execution_engine
state_machine_manager = singletons.state_machine_manager
if not execution_engine.finished_or_stopped():
raise RuntimeError("The execution engine is not stopped")
print("Loading state machine from path: {}".format(state_machine_path))
state_machine = call_gui_callback(
gui_helper_statemachine.open_state_machine, state_machine_path)
call_gui_callback(testing_utils.remove_all_gvm_variables)
call_gui_callback(execution_engine.start, state_machine.state_machine_id)
if not execution_engine.join(3):
raise RuntimeError(
"State machine did not finish within the given time")
call_gui_callback(assert_correctness_of_execution)
call_gui_callback(state_machine_manager.remove_state_machine,
state_machine.state_machine_id)
def test_execution_modes(caplog):
testing_utils.run_gui(gui_config={
'HISTORY_ENABLED': False,
'AUTO_BACKUP_ENABLED': False
})
call_gui_callback(initialize_global_variables)
try:
iter_execution_modes()
except Exception as e:
raise
finally:
testing_utils.close_gui()
testing_utils.shutdown_environment(caplog=caplog, expected_warnings=1)
def trigger_gui_signals_second_run(*args):
import rafcon.gui.singleton
main_window_controller = rafcon.gui.singleton.main_window_controller
sm_manager_model = rafcon.gui.singleton.state_machine_manager_model
open_state_machines = args[0]
menubar_ctrl = main_window_controller.get_controller('menu_bar_controller')
import rafcon.gui.backup.session as backup_session
if rafcon.gui.singleton.global_gui_config.get_config_value(
"SESSION_RESTORE_ENABLED"):
call_gui_callback(backup_session.restore_session_from_runtime_config)
print("restore config",
rafcon.gui.singleton.global_runtime_config.config_file_path)
with open(rafcon.gui.singleton.global_runtime_config.config_file_path,
'r') as f:
found_flag = False
print("\n" * 5, "#" * 20)
for line in f:
if "open_tabs" in line:
found_flag = True
if found_flag:
print(line)
print("#" * 20, "\n" * 5)
call_gui_callback(testing_utils.wait_for_gui)
call_gui_callback(prepare_tab_data_of_open_state_machines,
main_window_controller, sm_manager_model,
open_state_machines)
call_gui_callback(backup_session.reset_session)
def test_bar(window, window_key):
configure_handler_id = connect_window(window, 'configure-event',
notify_on_event)
hide_handler_id = connect_window(window, 'hide', notify_on_event)
print("undocking...")
time.sleep(debug_sleep_time)
ready.clear()
call_gui_callback(
main_window_controller.view["undock_{}_button".format(
window_key.lower())].emit, "clicked")
wait_for_event_notification()
print("docking...")
time.sleep(debug_sleep_time)
ready.clear()
attribute_name_of_undocked_window_view = window_key.lower() + "_window"
undocked_window_view = getattr(main_window_controller.view,
attribute_name_of_undocked_window_view)
redock_button = undocked_window_view['redock_button']
call_gui_callback(redock_button.emit, "clicked")
wait_for_event_notification()
time.sleep(debug_sleep_time)
call_gui_callback(window.disconnect, configure_handler_id)
call_gui_callback(window.disconnect, hide_handler_id)
def select_and_paste_state(state_machine_model, source_state_model,
target_state_model, menu_bar_ctrl, operation,
main_window_controller, page):
"""Select a particular state and perform an operation on it (Copy or Cut) and paste it somewhere else. At the end,
verify that the operation was completed successfully.
:param state_machine_model: The state machine model where the operation will be conducted
:param source_state_model: The state model, on which the operation will be performed
:param target_state_model: The state model, where the source state will be pasted
:param menu_bar_ctrl: The menu_bar controller, through which copy, cut & paste actions are triggered
:param operation: String indicating the operation to be performed (Copy or Cut)
:param main_window_controller: The MainWindow Controller
:param page: The notebook page of the corresponding state machine in the state machines editor
:return: The target state model, and the child state count before pasting
"""
print("\n\n %s \n\n" % source_state_model.state.name)
call_gui_callback(state_machine_model.selection.set, [source_state_model])
call_gui_callback(
getattr(menu_bar_ctrl, 'on_{}_selection_activate'.format(operation)),
None, None)
print("\n\n %s \n\n" % target_state_model.state.name)
call_gui_callback(state_machine_model.selection.set, [target_state_model])
old_child_state_count = len(target_state_model.state.states)
main_window_controller.view['main_window'].grab_focus()
focus_graphical_editor_in_page(page)
call_gui_callback(menu_bar_ctrl.on_paste_clipboard_activate, None, None)
testing_utils.wait_for_gui()
print(list(target_state_model.state.states.keys()))
assert len(target_state_model.state.states) == old_child_state_count + 1
return target_state_model, old_child_state_count
def create_and_resize_state():
from gi.repository import Gtk
from rafcon.gui.singleton import main_window_controller
# gvm = rafcon.core.singleton.global_variable_manager
menubar_ctrl = main_window_controller.get_controller('menu_bar_controller')
# from rafcon.gui.controllers.menu_bar import MenuBarController
# assert isinstance(menubar_ctrl, MenuBarController)
# execution_engine = singletons.state_machine_execution_engine
# state_machine_manager = singletons.state_machine_manager
call_gui_callback(menubar_ctrl.on_new_activate, None)
# time.sleep(1.0)
time.sleep(0.5)
wait_for_gui()
sm_ctrls = main_window_controller.get_controller('state_machines_editor_ctrl')
graphical_editor_controller = sm_ctrls.get_controller(1)
# get first state machine page in state machines notebook
sm_page = list(sm_ctrls.tabs.items())[0][1]['page']
sm_model = list(sm_ctrls.tabs.items())[0][1]['state_machine_m']
state_view_for_root_state = graphical_editor_controller.canvas.get_view_for_model(sm_model.root_state)
x, y = south_east_coordinates_of_model(state_view_for_root_state)
# print x, y
call_gui_callback(resize_state, sm_model, sm_page, graphical_editor_controller)
# wait_for_gui()
# graphical_editor_controller.canvas.update()
new_x, new_y = south_east_coordinates_of_model(state_view_for_root_state)
sleep_time = 0.01
max_counter = 10.0 / 0.01
counter = 0
while new_x == x and new_y == y:
new_x, new_y = south_east_coordinates_of_model(state_view_for_root_state)
counter += 1
if counter > max_counter:
break
time.sleep(sleep_time)
# print new_x, new_y
assert x < new_x
assert y < new_y
def patch_notifications():
enable_debugging()
# call_gui_callback(create_bigger_state_machine)
call_gui_callback(create_small_state_machine)
# from rafcon.gui.widget.test_storage import create_models
# call_gui_callback(create_models)
testing_utils.wait_for_gui()
call_gui_callback(show_debug_graph)
disable_debugging()
from tests.utils import RAFCON_TEMP_PATH_TEST_BASE_ONLY_USER_SAVE
assert exists(
join(RAFCON_TEMP_PATH_TEST_BASE_ONLY_USER_SAVE,
'notification_output.gv'))
assert exists(
join(RAFCON_TEMP_PATH_TEST_BASE_ONLY_USER_SAVE,
'notification_print_out.txt'))
def copy_and_paste_state_into_itself(sm_m, state_m_to_copy, page,
menu_bar_ctrl):
call_gui_callback(sm_m.selection.set, [state_m_to_copy])
focus_graphical_editor_in_page(page)
call_gui_callback(menu_bar_ctrl.on_copy_selection_activate, None, None)
old_child_state_count = len(state_m_to_copy.state.states)
call_gui_callback(sm_m.selection.set, [state_m_to_copy])
focus_graphical_editor_in_page(page)
call_gui_callback(menu_bar_ctrl.on_paste_clipboard_activate, None, None)
assert len(state_m_to_copy.state.states) == old_child_state_count + 1
def open_test_state_machine():
import rafcon.gui.singleton
smm_m = rafcon.gui.singleton.state_machine_manager_model
main_window_controller = rafcon.gui.singleton.main_window_controller
menubar_ctrl = main_window_controller.get_controller('menu_bar_controller')
state_machines_ctrl = main_window_controller.get_controller("state_machines_editor_ctrl")
call_gui_callback(menubar_ctrl.on_open_activate, None, None, sm_path_recursive_resize)
time.sleep(0.5)
call_gui_callback(wait_for_gui) # Wait for gaphas view
sm_m = smm_m.state_machines[smm_m.selected_state_machine_id]
sm_id = sm_m.state_machine.state_machine_id
sm_gaphas_ctrl = state_machines_ctrl.get_controller(sm_id)
canvas = sm_gaphas_ctrl.canvas
gaphas_view = sm_gaphas_ctrl.view.editor
return sm_m, canvas, gaphas_view
def execute_preemption_of_all_state_machines_at_once():
from rafcon.core.singleton import state_machine_execution_engine, state_machine_manager
import rafcon.gui.singleton as gui_singleton
menubar_ctrl = gui_singleton.main_window_controller.get_controller(
'menu_bar_controller')
call_gui_callback(
menubar_ctrl.on_open_activate, None, None,
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"all_dialogs_parallel_preempted")))
testing_utils.wait_for_gui()
call_gui_callback(menubar_ctrl.on_start_activate, None, None)
duration_waited = 0.
period = 0.1
while not state_machine_execution_engine.finished_or_stopped():
time.sleep(period)
duration_waited += period
if duration_waited > 3.:
call_gui_callback(menubar_ctrl.on_stop_activate, None, None)
raise RuntimeError(
"The state machine should finish in less then {0}".format(
duration_waited))
print(
"Run duration of execute_preemption_of_all_state_machines_at_once was: {0}"
.format(duration_waited))
def trigger_baking_commands():
# core elements
import rafcon.core.id_generator
from rafcon.core.singleton import state_machine_manager
# gui elements
import rafcon.gui.singleton as gui_singleton
from rafcon.gui.helpers import state_machine as gui_helper_state_machine
sm_id_0 = rafcon.core.id_generator.state_machine_id_counter
menu_bar_controller = gui_singleton.main_window_controller.get_controller(
"menu_bar_controller")
call_gui_callback(
menu_bar_controller.on_open_activate, None, None,
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines", "bake_sm")))
state_machine1 = state_machine_manager.state_machines[sm_id_0 + 1]
print("#1 ", state_machine1)
print("#2 ", call_gui_callback(state_machine1.mutable_hash).hexdigest())
baking_path = os.path.join(testing_utils.RAFCON_TEMP_PATH_TEST_BASE,
"baking")
# baking_path = os.path.join(testing_utils.RAFCON_TEMP_PATH_TEST_BASE_ONLY_USER_SAVE, "baking")
call_gui_callback(gui_helper_state_machine.bake_selected_state_machine,
baking_path)
call_gui_callback(menu_bar_controller.on_open_activate, None, None,
os.path.join(baking_path, "__generated__state_machine"))
from rafcon.core.id_generator import generate_state_machine_id
state_machine2 = state_machine_manager.state_machines[sm_id_0 + 4]
print("#3 ", state_machine2)
print("#4 ", call_gui_callback(state_machine1.mutable_hash).hexdigest())
mutable_hash_sm1 = call_gui_callback(state_machine1.mutable_hash)
mutable_hash_sm2 = call_gui_callback(state_machine2.mutable_hash)
assert mutable_hash_sm1.hexdigest() == mutable_hash_sm2.hexdigest()
def run_create():
""" By searching for the WT thread number can been seen, that
"""
from rafcon.core.states.hierarchy_state import HierarchyState
from rafcon.core.state_machine import StateMachine
import rafcon.core.singleton
import rafcon.gui.singleton
print("WT_ident: ", threading.currentThread().ident)
print("CORE_singleton_init_thread_ident: ",
rafcon.core.singleton.thread_identifier)
print("GUI_singleton_init_thread_ident: ",
rafcon.gui.singleton.thread_identifier)
main_window_controller = rafcon.gui.singleton.main_window_controller
menubar_ctrl = main_window_controller.get_controller('menu_bar_controller')
call_gui_callback(menubar_ctrl.on_new_activate, None)
# negative test
# menubar_ctrl.on_new_activate(None)
print("\n" * 3, "WT generated object", "\n" * 3)
call_gui_callback(
rafcon.core.singleton.state_machine_manager.add_state_machine,
StateMachine(HierarchyState("new root state")))
def execute_dynamic_state_insertion(state_machine_name="dynamic_library_insertion"):
from rafcon.core.singleton import state_machine_execution_engine, state_machine_manager
import rafcon.gui.singleton as gui_singleton
menubar_ctrl = gui_singleton.main_window_controller.get_controller('menu_bar_controller')
sm = call_gui_callback(
menubar_ctrl.on_open_activate, None, None,
testing_utils.get_test_sm_path(os.path.join("unit_test_state_machines", state_machine_name))
)
testing_utils.wait_for_gui() # TODO check -> without call_gui_callback wait_for_gui should be without effect
call_gui_callback(menubar_ctrl.on_start_activate, None, None)
current_state_machine_id = gui_singleton.state_machine_manager.active_state_machine_id
state_machines_editor_tab_status_check(current_state_machine_id, active=True) # execution start is synchronous
testing_utils.wait_for_gui() # TODO check -> without call_gui_callback wait_for_gui should be without effect
while not state_machine_execution_engine.finished_or_stopped():
time.sleep(0.1)
# stop or finished are asynchronous but the call_gui_callback makes the check synchronous
call_gui_callback(state_machines_editor_tab_status_check, current_state_machine_id, False)
def test_all_generic_libraries_in_a_row(caplog):
testing_utils.run_gui(gui_config={
'HISTORY_ENABLED': False,
'AUTO_BACKUP_ENABLED': False
},
libraries={
'generic':
os.path.join(testing_utils.LIBRARY_SM_PATH,
'generic')
})
call_gui_callback(initialize_global_variables)
try:
with pytest.warns(
log.RAFCONDeprecationWarning) as deprecations_warnings:
execute_all_generic_libraries_with_keyboard_only()
assert len([
record for record in deprecations_warnings
if record.category is log.RAFCONDeprecationWarning
]) == 4
finally:
testing_utils.close_gui()
testing_utils.shutdown_environment(caplog=caplog, expected_warnings=0)
def add_two_states_to_root_state_of_selected_state_machine():
sm_m = sm_manager_model.get_selected_state_machine_model()
current_number_states = len(sm_m.root_state.states)
call_gui_callback(sm_m.selection.set, sm_m.root_state)
call_gui_callback(menubar_ctrl.on_add_state_activate, None)
call_gui_callback(menubar_ctrl.on_add_state_activate, None)
assert len(sm_m.root_state.states) == current_number_states + 2
assert sm_manager_model.get_selected_state_machine_model().state_machine.marked_dirty
def check_scrollbar_adjustment_to_be_at_bottom():
testing_utils.wait_for_gui()
call_gui_callback(testing_utils.wait_for_gui)
# waiting for the gui is not sufficient
# calling show(), show_now(), show_all(), realize() or reset_style() on the scrollbar does not work either
scrolled_down = False
counter = 0
while (not scrolled_down) and counter < 10:
adj = logging_console_ctrl.view['scrollable'].get_vadjustment()
if not int(adj.get_value()) == int(adj.get_upper() -
adj.get_page_size()):
testing_utils.wait_for_gui()
time.sleep(0.1)
else:
scrolled_down = False
counter += 1
if not int(
adj.get_value()) == int(adj.get_upper() - adj.get_page_size()):
logger.warning(
'The scroller seems not to be at the end of the page {0} == {1}'
''.format(int(adj.get_value()),
int(adj.get_upper() - adj.get_page_size())))
def shutdown_gui(duration_wait_for_gui):
# wait for menu bar and main window controller
menubar_ctrl = None
time.sleep(2)
while menubar_ctrl is None:
time.sleep(duration_wait_for_gui)
menubar_ctrl = rafcon.gui.singleton.main_window_controller.get_controller('menu_bar_controller') if \
rafcon.gui.singleton.main_window_controller else None
# quit rafcon by menu bar
testing_utils.call_gui_callback(menubar_ctrl.on_save_as_activate, None,
None, testing_utils.get_unique_temp_path())
testing_utils.call_gui_callback(menubar_ctrl.on_stop_activate, None)
testing_utils.call_gui_callback(menubar_ctrl.on_quit_activate, None)
def execute_all_generic_libraries_with_keyboard_only():
from rafcon.core.singleton import state_machine_execution_engine, state_machine_manager
import rafcon.gui.singleton as gui_singleton
menubar_ctrl = gui_singleton.main_window_controller.get_controller(
'menu_bar_controller')
call_gui_callback(
menubar_ctrl.on_open_activate, None, None,
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines", "all_generic_libraries")))
testing_utils.wait_for_gui()
call_gui_callback(menubar_ctrl.on_start_activate, None, None)
import time
from pykeyboard import PyKeyboard
time.sleep(0.5)
k = PyKeyboard()
k.tap_key('Return', 7, 0.5)
k.tap_key('Tab', 2, 0.5)
k.tap_key('Return', 5, 0.5)
call_gui_callback(menubar_ctrl.on_stop_activate, None, None)
def trigger_gvm_signals():
# core elements
import rafcon.core.singleton
import rafcon.gui.singleton
call_gui_callback(testing_utils.remove_all_gvm_variables)
gvm = rafcon.core.singleton.global_variable_manager
gvm_controller = rafcon.gui.singleton.main_window_controller.get_controller(
'global_variable_manager_ctrl')
view = gvm_controller.view['global_variable_tree_view']
call_gui_callback(view.grab_focus)
call_gui_callback(gvm.set_variable, 'new_0', 0)
# use gui callback to wait for gv row generation
call_gui_callback(gvm_controller.apply_new_global_variable_value, 0, '2')
def run_gvm_method0(method, return_list):
return_list.append(method())
def run_gvm_method1(method, gv_arg1, return_list):
return_list.append(method(gv_arg1))
def run_gvm_method2(method, gv_arg1, gv_arg2, return_list):
return_list.append(method(gv_arg1, gv_arg2))
return_list = list()
call_gui_callback(run_gvm_method1, gvm.get_variable, 'new_0', return_list)
assert return_list[-1] == 2
call_gui_callback(gvm_controller.apply_new_global_variable_name, 0,
'changed_global_0')
call_gui_callback(run_gvm_method1, gvm.get_variable, 'changed_global_0',
return_list)
assert return_list[-1]
call_gui_callback(gvm_controller.apply_new_global_variable_type, 0,
'float')
call_gui_callback(run_gvm_method1, gvm.get_data_type, 'changed_global_0',
return_list)
assert return_list[-1] is float
call_gui_callback(run_gvm_method1, gvm.lock_variable, 'changed_global_0',
return_list)
access_key = return_list[-1]
assert not gvm_controller.global_variable_is_editable(
'changed_global_0', 'testing...')
call_gui_callback(run_gvm_method2, gvm.unlock_variable, 'changed_global_0',
access_key, return_list)
call_gui_callback(gvm_controller.on_add, view)
call_gui_callback(run_gvm_method0, gvm.get_all_keys, return_list)
assert len(return_list[-1]) is 2
call_gui_callback(gvm_controller.remove_core_element, 'changed_global_0')
call_gui_callback(run_gvm_method0, gvm.get_all_keys, return_list)
assert len(return_list[-1]) is 1
def trigger_drag_and_drop_tests(*args):
# TODO test should use real SelectionData objects and motion to provide selection
# -> currently very limited test scenario
class StructHelper:
"""Used to imitate a SelectionData Class"""
def __init__(self, x, y, text):
self.x = x
self.y = y
self.text = text
def set_text(self, text, length):
self.text = text
def get_text(self):
return self.text
# TODO test needs check on position -> is the state drawn where it was dropped?
sm_manager_model = args[0]
main_window_controller = args[1]
states_machines_editor_controller = main_window_controller.get_controller(
'state_machines_editor_ctrl')
library_tree_controller = main_window_controller.get_controller(
'library_controller')
state_icon_controller = main_window_controller.get_controller(
'state_icon_controller')
graphical_editor_controller = states_machines_editor_controller.get_child_controllers(
)[0]
# the view is required here; as it is created asynchronously we explicitly wait for its creation
while not graphical_editor_controller.view:
testing_utils.wait_for_gui()
# wait for root state to be focused
time.sleep(.5)
call_gui_callback(library_tree_controller.view.expand_all)
# generic and unit_test_state_machines in library tree index 1 is unit_test_state_machines
call_gui_callback(library_tree_controller.view.get_selection().select_path,
(1, 0))
selection_data = StructHelper(0, 0, None)
state_machine_m = sm_manager_model.get_selected_state_machine_model()
# insert state in root_state
print("insert state in root_state")
call_gui_callback(graphical_editor_controller.on_drag_motion, None, None,
200, 200, None)
# Override selection
state_m = state_machine_m.root_state
call_gui_callback(state_machine_m.selection.set, [state_m])
call_gui_callback(library_tree_controller.on_drag_data_get,
library_tree_controller.view, None, selection_data, 0,
None)
call_gui_callback(graphical_editor_controller.on_drag_data_received, None,
None, 200, 200, selection_data, None, None)
assert len(sm_manager_model.get_selected_state_machine_model().root_state.
state.states) == 2
# insert state from IconView
print("insert state from IconView")
call_gui_callback(graphical_editor_controller.on_drag_motion, None, None,
300, 300, None)
# Override selection
state_m = state_machine_m.root_state
call_gui_callback(state_machine_m.selection.set, [state_m])
call_gui_callback(state_icon_controller.on_mouse_motion, None,
StructHelper(30, 15, None))
call_gui_callback(state_icon_controller.on_drag_data_get, None, None,
selection_data, None, None)
call_gui_callback(graphical_editor_controller.on_drag_data_received, None,
None, 300, 300, selection_data, None, None)
assert len(sm_manager_model.get_selected_state_machine_model().root_state.
state.states) == 3
# insert state next to root state
print("insert state next to root state")
# Position (0, 0) in left above the root state
call_gui_callback(graphical_editor_controller.on_drag_motion, None, None,
0, 0, None)
call_gui_callback(state_icon_controller.on_mouse_motion, None,
StructHelper(30, 15, None))
call_gui_callback(state_icon_controller.on_drag_data_get, None, None,
selection_data, None, None)
# insert state in state1
print("insert state in state1")
state_m = state_machine_m.root_state.states['State1']
call_gui_callback(state_machine_m.selection.set, [state_m])
# Selecting a state using the drag_motion event is too unreliable, as the exact position depends on the size of
# the editor. Therefore, it is now selected using the selection object directly
# if isinstance(graphical_editor_controller, GraphicalEditorGaphasController):
# call_gui_callback(graphical_editor_controller.on_drag_motion, None, None, 100, 100, None)
# else:
# call_gui_callback(graphical_editor_controller.on_drag_motion, None, None, 150, 150, None)
call_gui_callback(library_tree_controller.on_drag_data_get,
library_tree_controller.view, None, selection_data, 0,
None)
call_gui_callback(graphical_editor_controller.on_drag_data_received, None,
None, 20, 20, selection_data, None, None)
assert len(sm_manager_model.get_selected_state_machine_model().root_state.
state.states['State1'].states) == 1
def trigger_ungroup_signals():
import rafcon.core.singleton
import rafcon.gui.singleton as gui_singleton
import rafcon.gui.helpers.state as gui_helper_state
import rafcon.gui.helpers.state_machine as gui_helper_state_machine
sm_manager_model = rafcon.gui.singleton.state_machine_manager_model
main_window_controller = gui_singleton.main_window_controller
menubar_ctrl = main_window_controller.get_controller('menu_bar_controller')
state_machine = create_state_machine()
first_sm_id = state_machine.state_machine_id
call_gui_callback(
rafcon.core.singleton.state_machine_manager.add_state_machine,
state_machine)
call_gui_callback(main_window_controller.view['main_window'].grab_focus)
call_gui_callback(sm_manager_model.__setattr__,
"selected_state_machine_id", first_sm_id)
state_machines_ctrl = main_window_controller.get_controller(
'state_machines_editor_ctrl')
page_id = state_machines_ctrl.get_page_num(first_sm_id)
page = state_machines_ctrl.view.notebook.get_nth_page(page_id)
call_gui_callback(focus_graphical_editor_in_page, page)
sm_m = sm_manager_model.get_selected_state_machine_model()
assert sm_m
call_gui_callback(gui_helper_state.change_state_type,
sm_m.get_state_model_by_path("ROOTSTATE/STATE3"),
gui_helper_state.BarrierConcurrencyState)
call_gui_callback(sm_m.selection.set,
sm_m.get_state_model_by_path("ROOTSTATE/STATE3"))
call_gui_callback(gui_helper_state_machine.ungroup_selected_state)
call_gui_callback(menubar_ctrl.on_save_as_activate, None, None,
testing_utils.get_unique_temp_path())
call_gui_callback(menubar_ctrl.on_stop_activate, None)
def trigger_issue_586_reproduction_sequence():
from os.path import join
import rafcon.gui.singleton
sm_manager_model = rafcon.gui.singleton.state_machine_manager_model
main_window_controller = rafcon.gui.singleton.main_window_controller
menubar_ctrl = main_window_controller.get_controller('menu_bar_controller')
current_sm_length = len(sm_manager_model.state_machines)
assert current_sm_length == 0
# backward step barrier test is chosen to work on an existing test state machine including equal child state ids
call_gui_callback(
menubar_ctrl.on_open_activate, None, None,
join(testing_utils.TEST_ASSETS_PATH, "unit_test_state_machines",
"backward_step_barrier_test"))
sm_m = list(sm_manager_model.state_machines.values())[0]
assert sm_m.state_machine_id == sm_manager_model.selected_state_machine_id
concurrent_decimate_state_m = sm_m.get_state_model_by_path("GLSUJY/OOECFM")
# check start conditions overlapping ids -> all states have four states and those have the same ids
import rafcon.core.constants
state_ids = list(concurrent_decimate_state_m.states.keys())
state_ids.remove(rafcon.core.constants.UNIQUE_DECIDER_STATE_ID)
state_ids_set = set()
for state_id in state_ids:
for child_state_id in concurrent_decimate_state_m.states[
state_id].states.keys():
state_ids_set.add(child_state_id)
assert len(state_ids_set) == 4
call_gui_callback(sm_m.selection.set, concurrent_decimate_state_m)
call_gui_callback(menubar_ctrl.on_ungroup_state_activate, None, None)
testing_utils.wait_for_gui()
# ungroup all three child states which all have the same state ids as there child states plus data flows
for state_id in state_ids:
print("ungroup state:", state_id)
assert state_id in sm_m.root_state.states
child_state_m = sm_m.get_state_model_by_path("GLSUJY/" + state_id)
call_gui_callback(sm_m.selection.set, child_state_m)
call_gui_callback(menubar_ctrl.on_ungroup_state_activate, None, None)
# store and refresh selected
call_gui_callback(menubar_ctrl.on_save_as_activate, None, None,
testing_utils.get_unique_temp_path())
call_gui_callback(menubar_ctrl.on_refresh_selected_activate, None, None)