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)
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)
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_manager.active_state_machine_id)
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 test_window_positions(caplog):
testing_utils.run_gui(core_config=None,
runtime_config={
'LEFT_BAR_WINDOW_SIZE': (800, 800),
'RIGHT_BAR_WINDOW_SIZE': (800, 800),
'CONSOLE_WINDOW_SIZE': (800, 800),
'LEFT_BAR_WINDOW_POS': (10, 10),
'RIGHT_BAR_WINDOW_POS': (10, 10),
'CONSOLE_WINDOW_POS': (10, 10),
'LEFT_BAR_WINDOW_UNDOCKED': False,
'RIGHT_BAR_WINDOW_UNDOCKED': False,
'CONSOLE_WINDOW_UNDOCKED': False
},
gui_config={
'HISTORY_ENABLED': False,
'AUTO_BACKUP_ENABLED': False
})
from rafcon.gui.runtime_config import global_runtime_config
original_runtime_config = global_runtime_config.as_dict()
try:
undock_sidebars()
finally:
for key, value in original_runtime_config.iteritems():
call_gui_callback(global_runtime_config.set_config_value, key,
value)
testing_utils.close_gui()
testing_utils.shutdown_environment(caplog=caplog)
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 test_pane_positions(caplog):
testing_utils.run_gui(gui_config={
'HISTORY_ENABLED': False,
'AUTO_BACKUP_ENABLED': False
},
runtime_config={
'LEFT_BAR_DOCKED_POS': 500,
'RIGHT_BAR_DOCKED_POS': 950,
'CONSOLE_DOCKED_POS': 700,
'LEFT_BAR_WINDOW_UNDOCKED': False,
'RIGHT_BAR_WINDOW_UNDOCKED': False,
'CONSOLE_WINDOW_UNDOCKED': 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.iteritems():
call_gui_callback(global_runtime_config.set_config_value, key,
value)
testing_utils.close_gui()
testing_utils.shutdown_environment(caplog=caplog)
def check_scrollbar_adjustment_to_be_at_bottom():
testing_utils.wait_for_gui()
call_gui_callback(testing_utils.wait_for_gui)
adj = logging_console_ctrl.view['scrollable'].get_vadjustment()
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 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 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 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_backward_stepping_preemptive_state(caplog):
testing_utils.run_gui(gui_config={'HISTORY_ENABLED': False, 'AUTO_BACKUP_ENABLED': False})
call_gui_callback(initialize_global_variables)
try:
execute_preemptive_state_forwards_backwards()
finally:
testing_utils.close_gui()
testing_utils.shutdown_environment(caplog=caplog)
def test_backward_stepping_barrier_state(caplog):
testing_utils.run_gui(gui_config={
'HISTORY_ENABLED': False,
'AUTO_BACKUP_ENABLED': False
})
call_gui_callback(initialize_global_variables)
try:
execute_barrier_state_forwards_backwards()
except Exception, e:
raise
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 create_and_resize_state():
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)
testing_utils.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 = sm_ctrls.tabs.items()[0][1]['page']
sm_model = 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)
# testing_utils.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 test_bar(window, window_key):
output_list = list()
call_gui_callback(connect_window, window, 'configure-event',
notify_on_event, output_list)
configure_handler_id = output_list[0]
output_list = list()
call_gui_callback(connect_window, window, 'hide', notify_on_event,
output_list)
hide_handler_id = output_list[0]
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 = getattr(undocked_window_view,
"top_tool_bar")['redock_button']
call_gui_callback(redock_button.emit, "clicked")
wait_for_event_notification()
window.disconnect(configure_handler_id)
window.disconnect(hide_handler_id)
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 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 test_backward_stepping_library_state(caplog):
testing_utils.run_gui(gui_config={'HISTORY_ENABLED': False, 'AUTO_BACKUP_ENABLED': False},
libraries={'unit_test': os.path.join(testing_utils.TESTS_PATH, 'assets',
'unit_test_state_machines',
'backward_step_library_execution_test', 'test_library')
}
)
call_gui_callback(initialize_global_variables)
try:
execute_library_state_forwards_backwards()
except Exception:
raise
finally:
testing_utils.close_gui()
testing_utils.shutdown_environment(caplog=caplog)
def patch_notifications():
enable_debugging()
# call_gui_callback(create_bigger_state_machine)
# call_gui_callback(create_small_state_machine)
from gui.widget.test_storage import create_models
call_gui_callback(create_models)
show_debug_graph()
disable_debugging()
from testing_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 test_simple_state_size_resize(state_path, recursive, rel_size, caplog,
monkeypatch):
testing_utils.run_gui(gui_config={'HISTORY_ENABLED': True})
try:
from rafcon.gui.helpers.meta_data import check_gaphas_state_meta_data_consistency
sm_m, canvas, view = open_test_state_machine()
state_m = sm_m.get_state_model_by_path(state_path)
state_v = canvas.get_view_for_model(state_m)
orig_state_size = state_m.get_meta_data_editor()["size"]
check_gaphas_state_meta_data_consistency(state_m,
canvas,
recursive=True)
print "\ninitial:"
print_state_sizes(state_m, canvas, ["C"])
view_rel_size = transform_size_v2i(view, state_v, rel_size)
resize_state(view, state_v, rel_size, 3, recursive, monkeypatch)
new_state_size = add_vectors(orig_state_size, view_rel_size)
print "\nfirst resize:"
print_state_sizes(state_m, canvas, ["C"])
assert_state_size_and_meta_data_consistency(state_m, state_v,
new_state_size, canvas)
rel_size = (-rel_size[0], -rel_size[1])
view_rel_size = transform_size_v2i(view, state_v, rel_size)
resize_state(view, state_v, rel_size, 3, recursive, monkeypatch)
print "\nsecond resize:"
print_state_sizes(state_m, canvas, ["C"])
assert_state_size_and_meta_data_consistency(state_m, state_v,
orig_state_size, canvas)
call_gui_callback(sm_m.history.undo)
print "\nfirst undo:"
print_state_sizes(state_m, canvas, ["C"])
assert_state_size_and_meta_data_consistency(state_m, state_v,
new_state_size, canvas)
call_gui_callback(sm_m.history.undo)
print "\nsecond undo:"
print_state_sizes(state_m, canvas, ["C"])
assert_state_size_and_meta_data_consistency(state_m, state_v,
orig_state_size, canvas)
call_gui_callback(sm_m.history.redo)
assert_state_size_and_meta_data_consistency(state_m, state_v,
new_state_size, canvas)
call_gui_callback(sm_m.history.redo)
assert_state_size_and_meta_data_consistency(state_m, state_v,
orig_state_size, canvas)
finally:
testing_utils.close_gui()
testing_utils.shutdown_environment(caplog=caplog)
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 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)
testing_utils.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_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()
call_gui_callback(menubar_ctrl.on_start_activate, None, None)
testing_utils.wait_for_gui()
while not state_machine_execution_engine.finished_or_stopped():
time.sleep(0.1)
call_gui_callback(menubar_ctrl.on_stop_activate, None)
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 test_drag_and_drop_test(caplog):
testing_utils.run_gui(
gui_config={
'AUTO_BACKUP_ENABLED': False,
'HISTORY_ENABLED': False
},
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 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 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 resize_state(view, state_v, rel_size, num_motion_events, recursive, monkeypatch):
from gi.repository import Gdk
from rafcon.gui.mygaphas.tools import MoveHandleTool
from rafcon.gui.utils.constants import RECURSIVE_RESIZE_MODIFIER
from gaphas.item import SE, NW
def get_resize_handle(x, y, distance=None):
return state_v, state_v.handles()[SE]
monkeypatch.setattr("rafcon.gui.mygaphas.aspect.StateHandleFinder.get_handle_at_point", get_resize_handle)
monkeypatch.setattr("rafcon.gui.mygaphas.aspect.ItemHandleFinder.get_handle_at_point", get_resize_handle)
# Deactivate guides (snapping)
monkeypatch.setattr("rafcon.gui.mygaphas.guide.GuidedStateMixin.MARGIN", 0)
resize_tool = call_gui_callback(MoveHandleTool, view)
start_pos_handle = call_gui_callback(get_state_handle_pos, view, state_v, state_v.handles()[SE])
# Start resize: Press button
# Gtk TODO: Check if button can be set like this
button_press_event = Gdk.Event.new(type=Gdk.EventType.BUTTON_PRESS)
button_press_event.button = 1
call_gui_callback(resize_tool.on_button_press, button_press_event)
# Do resize: Move mouse
motion_event = Gdk.Event.new(Gdk.EventType.MOTION_NOTIFY)
motion_event.state = motion_event.get_state()[1] | Gdk.EventMask.BUTTON_PRESS_MASK
if recursive:
motion_event.state = motion_event.get_state()[1] | RECURSIVE_RESIZE_MODIFIER
print("sent motion_event.state", motion_event.get_state())
for i in range(num_motion_events):
motion_event.x = start_pos_handle[0] + rel_size[0] * (float(i + 1) / num_motion_events)
motion_event.y = start_pos_handle[1] + rel_size[1] * (float(i + 1) / num_motion_events)
call_gui_callback(resize_tool.on_motion_notify, motion_event)
# Stop resize: Release button
# Gtk TODO: Check if button can be set like this
button_release_event = Gdk.Event.new(type=Gdk.EventType.BUTTON_RELEASE)
button_release_event.button = 1
call_gui_callback(resize_tool.on_button_release, button_release_event)
monkeypatch.undo()
monkeypatch.undo()
monkeypatch.undo()
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 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)
