existing e_test_event can support only single event that registered window.
this patch makes e_test_event can support multiple event of all of testcase's window.
From now on, you can use waitEvent without registerTCWin.
but, waitEvent needs etWin pointer to check event.
Change-Id: I3cc9d92db78bc5d52d4b11a9b56af45d493a58a2
-lgtest \
@E_TEST_RUNNER_LIBS@
-e_tizen_unittests_TESTCASES = \
+tc_sources = \
testcase/0001_easy.cpp \
testcase/0002_base_operation.cpp \
testcase/0003_base_operation_multi_wins.cpp \
e_test_win.h \
e_test_win.cpp \
e_test_util.h \
-testcase/0001_easy.cpp \
-testcase/0002_base_operation.cpp \
-testcase/0003_base_operation_multi_wins.cpp \
-testcase/0004_transient_for.cpp \
-testcase/0005_notification.cpp \
-testcase/0006_tzsh.cpp \
-testcase/0007_rotation.cpp \
-testcase/0008_focus.cpp \
-testcase/0009_input.cpp \
-testcase/0010_splash.cpp \
-testcase/0011_effect.cpp
+${tc_sources}
MAINTAINERCLEANFILES = \
Makefile.in
using ::testing::Test;
+etTCBase::etTCBase()
+{
+ etRunner::get().flushEventQueue();
+ etRunner::get().setTCStart();
+}
+
etTCBase::~etTCBase()
{
etWin *tw = NULL;
numGeomTw = 0;
numTw = 0;
+ etRunner::get().setTCEnd();
+ etRunner::get().flushEventQueue();
+
// if there are any error, print list of window
if (HasFailure())
{
etRunner::get().waitForDestroy();
}
- // remove register win
- if (tw_register)
- {
- etRunner::get().deregisterWin(tw_register);
- tw_register = NULL;
- }
-
// remove all testcase win
if (tw_list)
{
{
if (tw)
{
+ deregisterTCWin(tw);
tw->hide();
delete tw;
tw = NULL;
etWin *
-etTCBase::initNormalWin(const char *name, Eina_Bool show_win, Eina_Bool usr_geom)
+etTCBase::initNormalWin(const char *name, Eina_Bool usr_geom)
{
Eina_Bool res = EINA_FALSE;
etWin *tw = new etWin();
EINA_SAFETY_ON_FALSE_GOTO(res, err);
tw->native_win = etRunner::get().getWinId(tw->elm_win);
- if (show_win)
- {
- res = showTCWin(tw);
- EINA_SAFETY_ON_FALSE_GOTO(res, err);
- }
+ res = registerTCWin(tw);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
numTw++;
if (usr_geom) numGeomTw++;
}
etWin *
-etTCBase::initNotiWin(const char *name, Eina_Bool show_win, Eina_Bool usr_geom, Eina_Bool set_noti_level_normal)
+etTCBase::initNotiWin(const char *name, Eina_Bool usr_geom, Eina_Bool set_noti_level_normal)
{
Eina_Bool res = EINA_FALSE;
etWin *tw = new etWin();
if (set_noti_level_normal)
etRunner::get().setWinNotiLevel(tw, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
- if (show_win)
- {
- res = showTCWin(tw);
- EINA_SAFETY_ON_FALSE_GOTO(res, err);
- }
+ res = registerTCWin(tw);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
numTw++;
if (usr_geom) numGeomTw++;
Eina_Bool res = EINA_FALSE;
EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
- if (tw == tw_register) return EINA_TRUE;
-
- if (tw_register)
- {
- res = etRunner::get().deregisterWin(tw_register);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
-
- tw_register = NULL;
- }
res = etRunner::get().registerWin(tw);
EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
- tw_register = tw;
-
return EINA_TRUE;
}
{
Eina_Bool res = EINA_FALSE;
- if (!tw_register) return EINA_TRUE;
EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
- EINA_SAFETY_ON_TRUE_RETURN_VAL(tw != tw_register, EINA_FALSE);
res = etRunner::get().deregisterWin(tw);
EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
- tw_register = NULL;
-
return EINA_TRUE;
}
Eina_Bool
etTCBase::showTCWin(etWin *tw)
{
- Eina_Bool res = EINA_FALSE;
-
EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(tw->elm_win, EINA_FALSE);
- res = registerTCWin(tw);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
-
tw->updateGeometry();
tw->show();
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
-
return EINA_TRUE;
}
EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(tw->elm_win, EINA_FALSE);
- res = registerTCWin(tw);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
-
tw->updateGeometry();
tw->show();
res = etRunner::get().setWinActivate(tw);
EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
-
return EINA_TRUE;
}
Eina_Bool
etTCBase::removeTCWin(etWin *tw)
{
- Eina_Bool res = EINA_FALSE;
-
EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(tw->elm_win, EINA_FALSE);
- res = registerTCWin(tw);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
-
tw->hide();
-
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_OFF);
-
- res = deregisterTCWin(tw);
- tw_list = eina_list_remove(tw_list, tw);
- delete tw;
+ deregisterTCWin(tw);
return EINA_TRUE;
}
-
class etTCBase : public ::testing::Test
{
public:
- etTCBase() { };
+ etTCBase();
~etTCBase();
public:
etWin *initFakeWin();
- etWin *initNormalWin(const char *name, Eina_Bool show_win, Eina_Bool usr_geom);
- etWin *initNotiWin(const char *name, Eina_Bool show_win, Eina_Bool usr_geom, Eina_Bool set_noti_level_normal);
+ etWin *initNormalWin(const char *name, Eina_Bool usr_geom);
+ etWin *initNotiWin(const char *name, Eina_Bool usr_geom, Eina_Bool set_noti_level_normal);
Eina_Bool registerTCWin(etWin *tw);
Eina_Bool deregisterTCWin(etWin *tw);
Eina_Bool removeTCWin(etWin *tw);
private:
- etWin *tw_register = NULL;
Eina_List *tw_list = NULL;
int numTw = 0; // number of wins
static void _cb_method_window_register(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
static void _cb_method_zone_rotation_change(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
static void _cb_method_window_effect(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
+static void _cb_method_set_tc_start_end(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
/* callbacks - signal */
static void _cb_signal_vis_changed(void *data, const Eldbus_Message *msg);
static void _cb_signal_render_while_effect_run(void *data, const Eldbus_Message *msg);
/* callbacks - ecore */
-static Eina_Bool _cb_ecore_key(void *data, int type, void *event);
-static Eina_Bool _cb_key_delay_timer(void *data);
+static Eina_Bool _cb_ecore_key_down(void *data, int type, void *event);
+static Eina_Bool _cb_ecore_key_up(void *data, int type, void *event);
/* callbacks - evas */
static void _cb_evas_key_down(void * data, Evas * evas, Evas_Object * obj, void * event_info);
/* callbacks - timer */
static Eina_Bool _cb_work_timeout(void *data);
-static Eina_Bool _ev_wait_timeout(void *data);
/* callbacks - gesture */
static Eina_Bool _cb_gesture_tap(void *data, int type, void *event);
static Eina_Bool _cb_gesture_edge_swipe(void *data, int type, void *event);
static Eina_Bool _cb_gesture_edge_drag(void *data, int type, void *event);
-/* functions - gesture */
-static void _gesture_tap_generate(etRunner *runner);
-static void _gesture_edge_swipe_generate(etRunner *runner);
-static void _gesture_edge_drag_generate(etRunner *runner);
-
/**********************
listeners
**********************/
// init input generator
inputGenerator = efl_util_input_initialize_generator(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(inputGenerator, EINA_FALSE);
+
+ // init gesture handler
+ gestureHandler = efl_util_gesture_initialize();
+ EINA_SAFETY_ON_NULL_RETURN_VAL(gestureHandler, EINA_FALSE);
+
+ // add signal handlers
+ res = addSignalHandlers();
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
return EINA_TRUE;
}
eina_log_domain_unregister(logDomain);
freeLastWinInfoList();
+ delSignalHandlers();
// deinit tizen_extension protocol
if (tzPolicy)
// deinit input generator
efl_util_input_deinitialize_generator(inputGenerator);
+
+ // deinit gesture handler
+ efl_util_gesture_deinitialize(gestureHandler);
}
Eina_Bool
}
Eina_Bool
+etRunner::setTCStart()
+{
+ Eldbus_Pending *p = NULL;
+ Eina_Bool res = EINA_FALSE;
+
+ p = eldbus_proxy_call(dbus.proxy,
+ "StartTestCase",
+ _cb_method_set_tc_start_end,
+ &res,
+ -1,
+ "");
+ EINA_SAFETY_ON_NULL_GOTO(p, err);
+
+ work();
+
+ EINA_SAFETY_ON_FALSE_GOTO(res, err);
+
+ return EINA_TRUE;
+
+err:
+ setTCEnd();
+ return EINA_FALSE;
+}
+
+Eina_Bool
+etRunner::setTCEnd()
+{
+ Eldbus_Pending *p = NULL;
+ Eina_Bool res = EINA_FALSE;
+
+ p = eldbus_proxy_call(dbus.proxy,
+ "EndTestCase",
+ _cb_method_set_tc_start_end,
+ &res,
+ -1,
+ "");
+ if (p == NULL) res = EINA_FALSE;
+
+ work();
+
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
etRunner::getWinInfo(etWin *tw)
{
Eldbus_Pending *p = NULL;
return EINA_TRUE;
}
-void
+Eina_Bool
etRunner::generateKeyEvent(const char *keyname, double delay)
{
- this->ev.key.timer = ecore_timer_add(delay,
- _cb_key_delay_timer,
- this);
+ Eina_Bool res = EINA_FALSE;
+
+ res = etRunner::get().generateKeyPress(keyname);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ res = etRunner::get().generateKeyRelease(keyname);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ return res;
}
Eina_Bool
Eldbus_Pending *p = NULL;
Eina_Bool accepted = EINA_FALSE;
- this->ev.win = tw->elm_win;
+ this->ev.elm_win = tw->elm_win;
p = eldbus_proxy_call(dbus.proxy,
"RenderTrace",
}
Eina_Bool
-etRunner::waitEvent(E_TC_Event_Type ev_type)
+etRunner::waitEvent(etWin *win, E_TC_Event_Type ev_type)
{
- Eldbus_Signal_Handler *sh = NULL;
- Ecore_Event_Handler *eh = NULL, *eh2 = NULL;
+ E_TC_Event_Item *recv_item = NULL;
Eina_Bool res = EINA_FALSE;
- EINA_SAFETY_ON_FALSE_RETURN_VAL((E_TC_EVENT_TYPE_NONE < ev_type), res);
- EINA_SAFETY_ON_FALSE_RETURN_VAL((E_TC_EVENT_TYPE_MAX > ev_type), res);
-
+ // swap event
switch (ev_type)
{
case E_TC_EVENT_TYPE_VIS_ON:
case E_TC_EVENT_TYPE_VIS_OFF:
case E_TC_EVENT_TYPE_VIS_CHANGED:
- sh = eldbus_proxy_signal_handler_add(dbus.proxy,
- "VisibilityChanged",
- _cb_signal_vis_changed,
- this);
- EINA_SAFETY_ON_NULL_GOTO(sh, finish);
+ ev_type = E_TC_EVENT_TYPE_VIS_CHANGED;
break;
-
case E_TC_EVENT_TYPE_STACK_RAISE:
case E_TC_EVENT_TYPE_STACK_LOWER:
case E_TC_EVENT_TYPE_STACK_ABOVE:
case E_TC_EVENT_TYPE_STACK_BELOW:
- sh = eldbus_proxy_signal_handler_add(dbus.proxy,
- "StackChanged",
- _cb_signal_stack_changed,
- this);
- EINA_SAFETY_ON_NULL_GOTO(sh, finish);
+ case E_TC_EVENT_TYPE_STACK_CHANGED:
+ ev_type = E_TC_EVENT_TYPE_STACK_CHANGED;
break;
+ }
- case E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE:
- sh = eldbus_proxy_signal_handler_add(dbus.proxy,
- "WinRotationChanged",
- _cb_signal_win_rot_changed,
- this);
- EINA_SAFETY_ON_NULL_GOTO(sh, finish);
- break;
+ // Add event callbacks if needs
+ if (ev_type == E_TC_EVENT_TYPE_EFFECT_EVAS_CB)
+ {
+ ev.elm_win = win->elm_win;
+ ev.native_win = win->native_win;
+ ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_NONE;
- case E_TC_EVENT_TYPE_FOCUS_CHANGED:
- sh = eldbus_proxy_signal_handler_add(dbus.proxy,
- "FocusChanged",
- _cb_signal_focus_changed,
- this);
- EINA_SAFETY_ON_NULL_GOTO(sh, finish);
- break;
+ evas_object_smart_callback_add(this->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started, this);
+ evas_object_smart_callback_add(this->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done, this);
+ evas_object_smart_callback_add(this->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done, this);
+ }
+ else if (ev_type == E_TC_EVENT_TYPE_INPUT_EVAS_KEY)
+ {
+ ev.elm_win = win->elm_win;
+ ev.native_win = win->native_win;
+ evas_object_event_callback_add(this->ev.elm_win, EVAS_CALLBACK_KEY_DOWN, _cb_evas_key_down, this);
+ evas_object_event_callback_add(this->ev.elm_win, EVAS_CALLBACK_KEY_UP, _cb_evas_key_up, this);
- case E_TC_EVENT_TYPE_INPUT_ECORE_KEY:
- eh = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _cb_ecore_key, this);
- EINA_SAFETY_ON_NULL_GOTO(eh, finish);
- eh2 = ecore_event_handler_add(ECORE_EVENT_KEY_UP, _cb_ecore_key, this);
- EINA_SAFETY_ON_NULL_GOTO(eh2, finish);
+ ev.key.evas_state = EINA_FALSE;
+ }
- this->ev.key.state = EINA_FALSE;
- this->generateKeyEvent(this->ev.key.name, 1.0);
- break;
+ // pre-waiting events
+ work(0.5);
- case E_TC_EVENT_TYPE_INPUT_EVAS_KEY:
- evas_object_event_callback_add(this->ev.win, EVAS_CALLBACK_KEY_DOWN, _cb_evas_key_down, this);
- evas_object_event_callback_add(this->ev.win, EVAS_CALLBACK_KEY_UP, _cb_evas_key_up, this);
+ if (ev.recv_queue == NULL)
+ {
+ work(0.5); // waiting additional time
+ if (ev.recv_queue == NULL)
+ return EINA_FALSE;
+ }
- this->ev.key.state = EINA_FALSE;
- this->generateKeyEvent(this->ev.key.name, 1.0);
- break;
+ EINA_LIST_CAST_FREE(ev.recv_queue, recv_item, E_TC_Event_Item*)
+ {
+ if ((recv_item->win == (win?win->native_win:0)) &&
+ (recv_item->type == ev_type))
+ {
+ ev.recv_queue = eina_list_remove(ev.recv_queue, recv_item);
+ res = EINA_TRUE;
+ break;
+ }
+ }
- case E_TC_EVENT_TYPE_EFFECT:
- sh = eldbus_proxy_signal_handler_add(dbus.proxy,
- "RenderRun",
- _cb_signal_render_while_effect_run,
- this);
- break;
+ return res;
+}
- case E_TC_EVENT_TYPE_EFFECT_EVAS_CB:
- this->ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_NONE;
- evas_object_smart_callback_add(this->ev.win, effect_started, _cb_evas_smart_cb_effect_started, this);
- evas_object_smart_callback_add(this->ev.win, effect_done, _cb_evas_smart_cb_effect_done, this);
- evas_object_smart_callback_add(this->ev.win, launch_done, _cb_evas_smart_cb_launch_done, this);
- break;
+void
+etRunner::flushEventQueue()
+{
+ if (ev.recv_queue)
+ {
+ ev.recv_queue = eina_list_free(ev.recv_queue);
+ ev.recv_queue = NULL;
+ }
+}
- case E_TC_EVENT_TYPE_GESTURE_TAP:
- eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_TAP, _cb_gesture_tap, this);
- _gesture_tap_generate(this);
- break;
+Eina_Bool
+etRunner::addEventIntoQueue(Ecore_Window id, E_TC_Event_Type ev_type)
+{
+ E_TC_Event_Item *item = E_NEW(E_TC_Event_Item, 1);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(item, EINA_FALSE);
- case E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE:
- eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, _cb_gesture_edge_swipe, this);
- _gesture_edge_swipe_generate(this);
- break;
+ item->win = id;
+ item->type = ev_type;
+ ev.recv_queue = eina_list_append(ev.recv_queue, item);
- case E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG:
- eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, _cb_gesture_edge_drag, this);
- _gesture_edge_drag_generate(this);
- break;
+ return EINA_TRUE;
+}
- default:
- goto finish;
- break;
- }
+Eina_Bool
+etRunner::addSignalHandlers()
+{
+ Eldbus_Signal_Handler *sh = NULL;
+ Ecore_Event_Handler *eh = NULL;
- if (ev.expire_timer)
- ecore_timer_del(ev.expire_timer);
+ flushEventQueue();
- ev.request = ev_type;
- ev.response = E_TC_EVENT_TYPE_NONE;
- ev.expire_timer = ecore_timer_add(5.0, _ev_wait_timeout, this);
+ sh = eldbus_proxy_signal_handler_add(dbus.proxy,
+ "VisibilityChanged",
+ _cb_signal_vis_changed,
+ this);
+ EINA_SAFETY_ON_NULL_GOTO(sh, err);
+ ev.sh_list = eina_list_append(ev.sh_list, sh);
- elm_run();
+ sh = eldbus_proxy_signal_handler_add(dbus.proxy,
+ "StackChanged",
+ _cb_signal_stack_changed,
+ this);
+ EINA_SAFETY_ON_NULL_GOTO(sh, err);
+ ev.sh_list = eina_list_append(ev.sh_list, sh);
- if (ev.expire_timer)
- {
- ecore_timer_del(ev.expire_timer);
- ev.expire_timer = NULL;
- }
+ sh = eldbus_proxy_signal_handler_add(dbus.proxy,
+ "WinRotationChanged",
+ _cb_signal_win_rot_changed,
+ this);
+ EINA_SAFETY_ON_NULL_GOTO(sh, err);
+ ev.sh_list = eina_list_append(ev.sh_list, sh);
+
+ sh = eldbus_proxy_signal_handler_add(dbus.proxy,
+ "FocusChanged",
+ _cb_signal_focus_changed,
+ this);
+ EINA_SAFETY_ON_NULL_GOTO(sh, err);
+ ev.sh_list = eina_list_append(ev.sh_list, sh);
+
+ sh = eldbus_proxy_signal_handler_add(dbus.proxy,
+ "RenderRun",
+ _cb_signal_render_while_effect_run,
+ this);
+ EINA_SAFETY_ON_NULL_GOTO(sh, err);
+ ev.sh_list = eina_list_append(ev.sh_list, sh);
+
+ eh = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _cb_ecore_key_down, this);
+ EINA_SAFETY_ON_NULL_GOTO(eh, err);
+ ev.eh_list = eina_list_append(ev.eh_list, eh);
+
+ eh = ecore_event_handler_add(ECORE_EVENT_KEY_UP, _cb_ecore_key_up, this);
+ EINA_SAFETY_ON_NULL_GOTO(eh, err);
+ ev.eh_list = eina_list_append(ev.eh_list, eh);
+
+ eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_TAP, _cb_gesture_tap, this);
+ EINA_SAFETY_ON_NULL_GOTO(eh, err);
+ ev.eh_list = eina_list_append(ev.eh_list, eh);
+
+ eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, _cb_gesture_edge_swipe, this);
+ EINA_SAFETY_ON_NULL_GOTO(eh, err);
+ ev.eh_list = eina_list_append(ev.eh_list, eh);
+
+ eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, _cb_gesture_edge_drag, this);
+ EINA_SAFETY_ON_NULL_GOTO(eh, err);
+ ev.eh_list = eina_list_append(ev.eh_list, eh);
- if (sh) eldbus_signal_handler_del(sh);
- if (this->ev.sh) eldbus_signal_handler_del(this->ev.sh);
+ ev.key.ecore_state = EINA_FALSE;
- if (eh) ecore_event_handler_del(eh);
- if (eh2) ecore_event_handler_del(eh2);
+ return EINA_TRUE;
- if (ev_type == E_TC_EVENT_TYPE_INPUT_EVAS_KEY)
+err:
+ printf("failed to init handlers\n");
+ delSignalHandlers();
+ return EINA_FALSE;
+}
+
+void
+etRunner::delSignalHandlers()
+{
+ Eldbus_Signal_Handler *sh = NULL;
+ Ecore_Event_Handler *eh = NULL;
+
+ EINA_LIST_CAST_FREE(ev.sh_list, sh, Eldbus_Signal_Handler*)
{
- evas_object_event_callback_del(this->ev.win, EVAS_CALLBACK_KEY_DOWN, _cb_evas_key_down);
- evas_object_event_callback_del(this->ev.win, EVAS_CALLBACK_KEY_UP, _cb_evas_key_up);
+ eldbus_signal_handler_del(sh);
}
- else if (ev_type == E_TC_EVENT_TYPE_EFFECT_EVAS_CB)
+
+ EINA_LIST_CAST_FREE(ev.eh_list, eh, Ecore_Event_Handler*)
{
- evas_object_smart_callback_del(this->ev.win, effect_started, _cb_evas_smart_cb_effect_started);
- evas_object_smart_callback_del(this->ev.win, effect_done, _cb_evas_smart_cb_effect_done);
- evas_object_smart_callback_del(this->ev.win, launch_done, _cb_evas_smart_cb_launch_done);
+ ecore_event_handler_del(eh);
}
- res = (ev.response == ev.request);
- EINA_SAFETY_ON_FALSE_GOTO(res, finish);
-
-finish:
- ev.request = E_TC_EVENT_TYPE_NONE;
- ev.response = E_TC_EVENT_TYPE_NONE;
-
- return res;
+ flushEventQueue();
}
void
{
const char *name = NULL, *text = NULL, *wname = NULL;
Eldbus_Message_Iter *array = NULL, *ec = NULL;
- Ecore_Window target_win = 0;
Window_Info_List *info_list = (Window_Info_List *)data;
Eina_Bool res = EINA_FALSE, animating = EINA_FALSE;
res = eldbus_message_error_get(msg, &name, &text);
EINA_SAFETY_ON_TRUE_GOTO(res, finish);
- res = eldbus_message_arguments_get(msg, "ua(" E_TC_SIGN_WIN_INFO ")", &target_win, &array);
+ res = eldbus_message_arguments_get(msg, "a(" E_TC_SIGN_WIN_INFO ")", &array);
EINA_SAFETY_ON_FALSE_GOTO(res, finish);
while (eldbus_message_iter_get_and_next(array, 'r', &ec))
etRunner::get().finishWork();
}
+static void
+_cb_method_set_tc_start_end(void *data,
+ const Eldbus_Message *msg,
+ Eldbus_Pending *p)
+{
+ const char *name = NULL, *text = NULL;
+ Eina_Bool res = EINA_FALSE;
+ Eina_Bool *accept = (Eina_Bool *)data;
+
+ *accept = EINA_FALSE;
+
+ res = eldbus_message_error_get(msg, &name, &text);
+ EINA_SAFETY_ON_TRUE_GOTO(res, finish);
+
+ res = eldbus_message_arguments_get(msg, "b", accept);
+ EINA_SAFETY_ON_FALSE_GOTO(res, finish);
+ EINA_SAFETY_ON_FALSE_GOTO(*accept, finish);
+
+finish:
+ if ((name) || (text))
+ {
+ ERR("errname: %s errmsg: %s\n", name, text);
+ }
+
+ etRunner::get().finishWork();
+}
+
/* callbacks - signal */
static void
_cb_signal_vis_changed(void *data,
res = eldbus_message_arguments_get(msg, "ub", &id, &vis);
EINA_SAFETY_ON_FALSE_GOTO(res, finish);
- /* TODO */
- if (((E_TC_EVENT_TYPE_VIS_ON == runner->ev.request) && (vis)) ||
- ((E_TC_EVENT_TYPE_VIS_OFF == runner->ev.request) && (!vis)) ||
- (E_TC_EVENT_TYPE_VIS_CHANGED == runner->ev.request))
- {
- runner->ev.response = runner->ev.request;
- elm_exit();
- }
+ runner->addEventIntoQueue(id, E_TC_EVENT_TYPE_VIS_CHANGED);
finish:
if ((name) || (text))
etRunner *runner = (etRunner *)data;
const char *name = NULL, *text = NULL;
Eina_Bool res = EINA_FALSE;
+ Ecore_Window id = 0;
res = eldbus_message_error_get(msg, &name, &text);
EINA_SAFETY_ON_TRUE_GOTO(res, finish);
- /* TODO */
- if ((E_TC_EVENT_TYPE_STACK_RAISE <= runner->ev.request) &&
- (E_TC_EVENT_TYPE_STACK_BELOW >= runner->ev.request))
- {
- runner->ev.response = runner->ev.request;
- elm_exit();
- }
+ res = eldbus_message_arguments_get(msg, "u", &id);
+ EINA_SAFETY_ON_FALSE_GOTO(res, finish);
+
+ runner->addEventIntoQueue(id, E_TC_EVENT_TYPE_STACK_CHANGED);
finish:
if ((name) || (text))
res = eldbus_message_arguments_get(msg, "ui", &id, &angle);
EINA_SAFETY_ON_FALSE_GOTO(res, finish);
- runner->ev.response = runner->ev.request;
- elm_exit();
+ runner->addEventIntoQueue(id, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE);
finish:
if ((name) || (text))
etRunner *runner = (etRunner *)data;
const char *name = NULL, *text = NULL;
Eina_Bool res = EINA_FALSE;
+ Ecore_Window id = 0;
res = eldbus_message_error_get(msg, &name, &text);
EINA_SAFETY_ON_TRUE_GOTO(res, finish);
- if (E_TC_EVENT_TYPE_FOCUS_CHANGED == runner->ev.request)
- {
- runner->ev.response = runner->ev.request;
- elm_exit();
- }
+ res = eldbus_message_arguments_get(msg, "u", &id);
+ EINA_SAFETY_ON_FALSE_GOTO(res, finish);
+
+ runner->addEventIntoQueue(id, E_TC_EVENT_TYPE_FOCUS_CHANGED);
finish:
if ((name) || (text))
etRunner *runner = (etRunner *)data;
const char *name = NULL, *text = NULL;
Eina_Bool res = EINA_FALSE;
+ Ecore_Window id = 0;
res = eldbus_message_error_get(msg, &name, &text);
EINA_SAFETY_ON_TRUE_GOTO(res, finish);
- runner->ev.response = runner->ev.request;
- elm_exit();
+ res = eldbus_message_arguments_get(msg, "u", &id);
+ EINA_SAFETY_ON_FALSE_GOTO(res, finish);
+
+ runner->addEventIntoQueue(id, E_TC_EVENT_TYPE_EFFECT);
finish:
if ((name) || (text))
return ECORE_CALLBACK_CANCEL;
}
+/* callbacks - ecore */
static Eina_Bool
-_ev_wait_timeout(void *data)
+_cb_ecore_key_down(void *data, int type, void *event)
{
+ Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
etRunner *runner = (etRunner *)data;
- runner->ev.expire_timer = NULL;
- runner->ev.response = E_TC_EVENT_TYPE_TIMEOUT;
+ if (runner->ev.key.name == NULL) return ECORE_CALLBACK_PASS_ON;
- ERR("ev:%d\n", runner->ev.request);
-
- elm_exit();
+ if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
+ {
+ if (runner->ev.key.ecore_state == EINA_FALSE &&
+ type == ECORE_EVENT_KEY_DOWN)
+ {
+ runner->ev.key.ecore_state = EINA_TRUE;
+ }
+ }
- return ECORE_CALLBACK_DONE;
+ return ECORE_CALLBACK_PASS_ON;
}
-/* callbacks - ecore */
static Eina_Bool
-_cb_ecore_key(void *data, int type, void *event)
+_cb_ecore_key_up(void *data, int type, void *event)
{
Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
etRunner *runner = (etRunner *)data;
+ if (runner->ev.key.name == NULL) return ECORE_CALLBACK_PASS_ON;
+
if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
{
- if (runner->ev.key.state == EINA_FALSE &&
- type == ECORE_EVENT_KEY_DOWN)
- {
- runner->ev.key.state = EINA_TRUE;
- }
- else if (runner->ev.key.state == EINA_TRUE &&
+ if (runner->ev.key.ecore_state == EINA_TRUE &&
type == ECORE_EVENT_KEY_UP)
{
- runner->ev.response = runner->ev.request;
- runner->ev.key.state = EINA_FALSE;
- elm_exit();
+ runner->ev.key.ecore_state = EINA_FALSE;
+ runner->addEventIntoQueue(0, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
}
}
if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
{
- if (runner->ev.key.state == EINA_FALSE &&
- runner->ev.win == obj)
+ if (runner->ev.key.evas_state == EINA_FALSE &&
+ runner->ev.elm_win == obj)
{
- runner->ev.key.state = EINA_TRUE;
+ runner->ev.key.evas_state = EINA_TRUE;
}
}
}
if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
{
- if (runner->ev.key.state == EINA_TRUE &&
- runner->ev.win == obj)
+ if (runner->ev.key.evas_state == EINA_TRUE &&
+ runner->ev.elm_win == obj)
{
- runner->ev.response = runner->ev.request;
- runner->ev.key.state = EINA_FALSE;
- runner->ev.win = NULL;
- elm_exit();
+ runner->ev.key.evas_state = EINA_FALSE;
+ runner->ev.elm_win = NULL;
+
+ runner->addEventIntoQueue(runner->ev.native_win, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
}
}
}
_cb_evas_smart_cb_effect_started(void *data, Evas_Object * obj, void *event_info)
{
etRunner *runner = (etRunner *)data;
- if (runner && runner->ev.win == obj)
+ if (runner && runner->ev.elm_win == obj)
{
runner->ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED;
}
_cb_evas_smart_cb_effect_done(void *data, Evas_Object * obj, void *event_info)
{
etRunner *runner = (etRunner *)data;
- if (runner && runner->ev.win == obj)
+ if (runner && runner->ev.elm_win == obj)
{
runner->ev.effect.state_smcb |= E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE;
- if((runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED) &&
- (runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE))
- {
- runner->ev.response = runner->ev.request;
- elm_exit();
- }
+ runner->addEventIntoQueue(runner->ev.native_win, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
+
+ evas_object_smart_callback_del(runner->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started);
+ evas_object_smart_callback_del(runner->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done);
+ evas_object_smart_callback_del(runner->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done);
}
}
_cb_evas_smart_cb_launch_done(void *data, Evas_Object * obj, void *event_info)
{
etRunner *runner = (etRunner *)data;
- if (runner && runner->ev.win == obj)
+ if (runner && runner->ev.elm_win == obj)
{
runner->ev.effect.state_smcb |= E_TC_EVAS_SMART_CB_STATE_LAUNCH_DONE;
(runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE) &&
(runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_LAUNCH_DONE))
{
- runner->ev.response = runner->ev.request;
- elm_exit();
+ runner->addEventIntoQueue(runner->ev.native_win, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
+
+ evas_object_smart_callback_del(runner->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started);
+ evas_object_smart_callback_del(runner->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done);
+ evas_object_smart_callback_del(runner->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done);
}
}
}
static Eina_Bool
-_cb_key_delay_timer(void *data)
-{
- etRunner *runner = (etRunner *)data;
-
- runner->generateKeyPress(runner->ev.key.name);
- runner->generateKeyRelease(runner->ev.key.name);
-
- runner->ev.key.timer = NULL;
-
- return ECORE_CALLBACK_CANCEL;
-}
-
-static Eina_Bool
_cb_gesture_tap(void *data, int type, void *event)
{
etRunner *runner = (etRunner *)data;
if ((ev->fingers == (unsigned int)runner->ev.gesture.tap.fingers) &&
(ev->repeats == (unsigned int)runner->ev.gesture.tap.repeats))
{
- runner->ev.response = E_TC_EVENT_TYPE_GESTURE_TAP;
- elm_exit();
+ runner->addEventIntoQueue(0, E_TC_EVENT_TYPE_GESTURE_TAP);
+ //ecore_event_handler_del(runner->ev.key.eh);
}
return ECORE_CALLBACK_PASS_ON;
return ECORE_CALLBACK_CANCEL;
}
-static void
-_gesture_tap_generate(etRunner *runner)
+Eina_Bool
+etRunner::generateTapGesture()
{
- runner->ev.gesture.tap.current_repeats = runner->ev.gesture.tap.repeats;
- runner->ev.gesture.tap.pressed = EINA_FALSE;
+ ev.gesture.tap.current_repeats = ev.gesture.tap.repeats;
+ ev.gesture.tap.pressed = EINA_FALSE;
- runner->ev.gesture.timer = ecore_timer_add(1.0,
- _cb_gesture_tap_delay_timer,
- runner);
+ ev.gesture.timer = ecore_timer_add(0.11,
+ _cb_gesture_tap_delay_timer,
+ this);
+
+ return EINA_TRUE;
}
static Eina_Bool
if ((ev->fingers == (unsigned int)runner->ev.gesture.edge.fingers) &&
(ev->edge == (unsigned int)runner->ev.gesture.edge.edge))
{
- runner->ev.response = E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE;
if (runner->ev.gesture.timer)
- {
- runner->ev.gesture.edge.get_event = EINA_TRUE;
- }
- else
- elm_exit();
+ runner->ev.gesture.edge.get_event = EINA_TRUE;
}
return ECORE_CALLBACK_PASS_ON;
runner->ev.gesture.timer = NULL;
if (runner->ev.gesture.edge.get_event)
{
- runner->ev.gesture.edge.get_event = EINA_FALSE;
- elm_exit();
+ runner->addEventIntoQueue(0, E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE);
+ //ecore_event_handler_del(runner->ev.key.eh);
}
return ECORE_CALLBACK_CANCEL;
}
return ECORE_CALLBACK_CANCEL;
}
-static void
-_gesture_edge_swipe_generate(etRunner *runner)
+Eina_Bool
+etRunner::generateEdgeSwipeGesture()
{
- runner->ev.gesture.edge.touch_count = 0;
- runner->ev.gesture.edge.get_event = EINA_FALSE;
+ ev.gesture.edge.touch_count = 0;
+ ev.gesture.edge.get_event = EINA_FALSE;
- runner->ev.gesture.timer = ecore_timer_add(1.0,
- _cb_gesture_edge_swipe_delay_timer,
- runner);
+ ev.gesture.timer = ecore_timer_add(0.11,
+ _cb_gesture_edge_swipe_delay_timer,
+ this);
+
+ return EINA_TRUE;
}
static Eina_Bool
(ev->edge == (unsigned int)runner->ev.gesture.edge.edge) &&
(ev->mode == EFL_UTIL_GESTURE_MODE_END))
{
- runner->ev.response = E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG;
- elm_exit();
+ runner->addEventIntoQueue(0, E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG);
+ //ecore_event_handler_del(runner->ev.key.eh);
}
return ECORE_CALLBACK_PASS_ON;
return ECORE_CALLBACK_CANCEL;
}
-static void
-_gesture_edge_drag_generate(etRunner *runner)
+Eina_Bool
+etRunner::generateEdgeDragGesture()
{
- runner->ev.gesture.edge.touch_count = 0;
+ ev.gesture.edge.touch_count = 0;
- runner->ev.gesture.timer = ecore_timer_add(1.0,
- _cb_gesture_edge_drag_delay_timer,
- runner);
+ ev.gesture.timer = ecore_timer_add(0.11,
+ _cb_gesture_edge_drag_delay_timer,
+ this);
+
+ return EINA_TRUE;
}
tzlaunch_effect = NULL;
tzlaunch_splash = NULL;
wlOutput = NULL;
- ev.expire_timer = NULL;
- ev.request = E_TC_EVENT_TYPE_NONE;
- ev.response = E_TC_EVENT_TYPE_NONE;
- ev.key = {0,};
+ ev = {0,};
logDomain = 0;
dbus.conn = NULL;
dbus.proxy = NULL;
public: /* TODO: make it hidden */
struct
{
- Ecore_Timer *expire_timer;
- E_TC_Event_Type request;
- E_TC_Event_Type response;
- Evas_Object *win;
- Eldbus_Signal_Handler *sh;
+ Evas_Object *elm_win;
+ Ecore_Window native_win;
+
+ Eina_List *sh_list;
+ Eina_List *eh_list;
+ Eina_List *recv_queue;
+
struct
{
Eina_Stringshare *name;
- Eina_Bool state;
+ Eina_Bool ecore_state;
+ Eina_Bool evas_state;
Ecore_Timer *timer;
} key;
struct
efl_util_notification_level_e getWinNotiLevel(etWin *tw);
Eina_Bool setFocusSkip(etWin *tw, Eina_Bool set);
Eina_Bool setZoneRotation(int angle);
+ Eina_Bool setTCStart();
+ Eina_Bool setTCEnd();
Eina_Bool getWinInfo(etWin *tw);
Eina_List *getWinInfoList();
void freeWinInfoList(Eina_List *list);
Eina_Bool generateMouseUp(int x, int y);
Eina_Bool generateKeyPress(const char *key);
Eina_Bool generateKeyRelease(const char *key);
- void generateKeyEvent(const char *keyname, double delay);
+ Eina_Bool generateKeyEvent(const char *keyname, double delay);
Eina_Bool generateTouchDown(int idx, int x, int y);
Eina_Bool generateTouchMove(int idx, int x, int y);
Eina_Bool generateTouchUp(int idx, int x, int y);
+ Eina_Bool generateTapGesture();
+ Eina_Bool generateEdgeSwipeGesture();
+ Eina_Bool generateEdgeDragGesture();
Eina_Bool setSplashLaunch(const char *path, int type);
Eina_Bool setSplashOwner();
Eina_Bool setWinEffect(etWin *tw);
Eina_Bool freezeEvent();
Eina_Bool thawEvent();
- Eina_Bool waitEvent(E_TC_Event_Type ev);
+ Eina_Bool waitEvent(etWin *win, E_TC_Event_Type ev_type);
+
+ void flushEventQueue();
+ Eina_Bool addEventIntoQueue(Ecore_Window id, E_TC_Event_Type ev_type);
+ Eina_Bool addSignalHandlers();
+ void delSignalHandlers();
Eldbus_Proxy *getDbusProxy() { return dbus.proxy; }
Eldbus_Object *getDbusObject() { return dbus.obj; }
int getLogDomain() { return logDomain; }
+ efl_util_gesture_h getGestureHandler() { return gestureHandler; }
protected:
Eina_Bool initProtocols();
efl_util_inputgen_h inputGenerator = NULL;
+ efl_util_gesture_h gestureHandler = NULL;
};
#endif // end of __ET_EVENT_LOOP_H__
E_TC_EVENT_TYPE_STACK_LOWER,
E_TC_EVENT_TYPE_STACK_ABOVE,
E_TC_EVENT_TYPE_STACK_BELOW,
+ E_TC_EVENT_TYPE_STACK_CHANGED,
E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE,
E_TC_EVENT_TYPE_FOCUS_CHANGED,
E_TC_EVENT_TYPE_INPUT_ECORE_KEY,
Eina_Bool retry;
} Window_Info_List;
-# define EFL_UTIL_RETURN_TO_STRING(type) \
+typedef struct _E_TC_Event_Item
+{
+ Ecore_Window win;
+ E_TC_Event_Type type;
+} E_TC_Event_Item;
+
+#define EFL_UTIL_RETURN_TO_STRING(type) \
((type == EFL_UTIL_ERROR_NONE)?"None": \
(type == EFL_UTIL_ERROR_INVALID_PARAMETER)?"Invalid parameter": \
(type == EFL_UTIL_ERROR_OUT_OF_MEMORY)?"Out of memory": \
(type == EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL)?"Screenshot init fail": \
(type == EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL)?"Screenshot execution fail": \
(type == EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE)?"No resource available": \
- "Unknown") \
-
+ "Unknown")
#endif // end of E_TC_MAIN_H
#ifdef __cplusplus
EINA_PREFETCH(data), \
l; \
l = l_next, \
- l_next = eina_list_prev(l), \
+ l_next = eina_list_next(l), \
EINA_PREFETCH(l_next), \
data = (caster)eina_list_data_get(l), \
EINA_PREFETCH(data))
#include "e_test_event.h"
#include "e_test_base.h"
-#define _WIN_ID 0x123456
+#define _WIN_ID1 0x123456
+#define _WIN_ID2 0x654321
class etTestEasy : public ::etTCBase
{
res = eldbus_message_arguments_get(msg, "s", &arg);
EINA_SAFETY_ON_FALSE_GOTO(res, finish);
- if ((!strstr(arg, "method name=\"RegisterWindow\"" )) ||
+ if ((!strstr(arg, "method name=\"StartTestCase\"" )) ||
+ (!strstr(arg, "method name=\"EndTestCase\"" )) ||
+ (!strstr(arg, "method name=\"RegisterWindow\"" )) ||
(!strstr(arg, "method name=\"DeregisterWindow\"" )) ||
(!strstr(arg, "method name=\"ResetRegisterWindow\"" )) ||
(!strstr(arg, "method name=\"SetWindowStack\"" )) ||
(!strstr(arg, "method name=\"HWC\"" )) ||
(!strstr(arg, "method name=\"GetCurrentZoneRotation\"" )) ||
(!strstr(arg, "method name=\"ChangeZoneRotation\"" )) ||
- (!strstr(arg, "method name=\"RenderTrace\"" )) ||
+ (!strstr(arg, "method name=\"RenderTrace\"" )) ||
(!strstr(arg, "signal name=\"VisibilityChanged\"" )) ||
(!strstr(arg, "signal name=\"StackChanged\"" )) ||
(!strstr(arg, "signal name=\"WinRotationChanged\"" )) ||
(!strstr(arg, "signal name=\"FocusChanged\"" )) ||
- (!strstr(arg, "signal name=\"RenderRun\"" )) ||
+ (!strstr(arg, "signal name=\"RenderRun\"" )) ||
(!strstr(arg, "property name=\"Registrant\"" )))
{
ERR("missing mehod, signal or property:%s\n", arg);
Eina_Bool *ret = (Eina_Bool *)data;
const char *name = NULL, *text = NULL;
Eldbus_Message_Iter *variant = NULL;
+ Eldbus_Message_Iter *arr_of_win = NULL;
Ecore_Window win;
Eina_Bool res;
char *type;
type = eldbus_message_iter_signature_get(variant);
EINA_SAFETY_ON_NULL_GOTO(type, finish);
- EINA_SAFETY_ON_FALSE_GOTO((type[0] == 'u'), finish);
+ EINA_SAFETY_ON_TRUE_GOTO(strncmp("au", type, strlen("au")) != 0, finish);
- res = eldbus_message_iter_arguments_get(variant, "u", &win);
+ res = eldbus_message_iter_arguments_get(variant, "au", &arr_of_win);
EINA_SAFETY_ON_FALSE_GOTO(res, finish);
- EINA_SAFETY_ON_FALSE_GOTO((win == _WIN_ID), finish);
*ret = EINA_TRUE;
+ while (eldbus_message_iter_get_and_next(arr_of_win, 'u', &win))
+ {
+ if (win == _WIN_ID1)
+ *ret &= EINA_TRUE;
+ else if (win == _WIN_ID2)
+ *ret &= EINA_TRUE;
+ else
+ *ret = EINA_FALSE;
+ }
+
finish:
if ((*ret) == EINA_FALSE)
{
Eina_Bool res = EINA_FALSE;
Eldbus_Pending *p = NULL;
- etWin *tw = initFakeWin();
- ASSERT_TRUE(tw != NULL);
+ etWin *tw1 = initFakeWin();
+ ASSERT_TRUE(tw1 != NULL);
+
+ etWin *tw2 = initFakeWin();
+ ASSERT_TRUE(tw2 != NULL);
- tw->native_win = _WIN_ID;
+ tw1->native_win = _WIN_ID1;
+ tw2->native_win = _WIN_ID2;
- res = etRunner::get().registerWin(tw);
+ res = etRunner::get().registerWin(tw1);
+ ASSERT_TRUE(res);
+
+ res = etRunner::get().registerWin(tw2);
ASSERT_TRUE(res);
p = eldbus_proxy_property_get(etRunner::get().getDbusProxy(),
etRunner::get().work();
ASSERT_TRUE(res);
- res = etRunner::get().deregisterWin(tw);
+ res = etRunner::get().deregisterWin(tw1);
+ ASSERT_TRUE(res);
+
+ res = etRunner::get().deregisterWin(tw2);
ASSERT_TRUE(res);
}
void
etTestBaseOperation::initTC(Eina_Bool alpha_set)
{
- tw = initNormalWin("TCWin_Normal", EINA_FALSE, EINA_TRUE);
+ tw = initNormalWin("TCWin_Normal", EINA_TRUE);
ASSERT_TRUE(tw != NULL) << "failed to initiation window";
if (alpha_set)
TEST_F(etTestBaseOperation, win_show)
{
initTC(EINA_FALSE);
+
+ showTCWin(tw);
+ etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON);
}
TEST_F(etTestBaseOperation, win_stack)
initTC(EINA_FALSE);
+ showTCWin(tw);
+ etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON);
+
list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
TEST_F(etTestBaseOperation, alpha_win_show)
{
initTC(EINA_TRUE);
+
+ showTCWin(tw);
+ etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON);
}
TEST_F(etTestBaseOperation, alpha_win_stack)
initTC(EINA_TRUE);
+ showTCWin(tw);
+ etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON);
+
list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
void
etTestBaseMulti::initTC(Eina_Bool show_win, Eina_Bool usr_geom)
{
- tw_red = initNormalWin("TCWin_Normal_red", show_win, usr_geom);
+ tw_red = initNormalWin("TCWin_Normal_red", usr_geom);
ASSERT_TRUE(tw_red != NULL) << "failed to initiation window";
+ if (show_win)
+ {
+ showTCWin(tw_red);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ }
- tw_green = initNormalWin("TCWin_Normal_green", show_win, usr_geom);
+ tw_green = initNormalWin("TCWin_Normal_green", usr_geom);
ASSERT_TRUE(tw_green != NULL) << "failed to initiation window";
+ if (show_win)
+ {
+ showTCWin(tw_green);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ }
- tw_blue = initNormalWin("TCWin_Normal_blue", show_win, usr_geom);
+ tw_blue = initNormalWin("TCWin_Normal_blue", usr_geom);
ASSERT_TRUE(tw_blue != NULL) << "failed to initiation window";
+ if (show_win)
+ {
+ showTCWin(tw_blue);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ }
}
TEST_F(etTestBaseMulti, multi_all_wins_basic)
// show red
res = showTCWin(tw_red);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// show blue
res = showTCWin(tw_blue);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON);
// show green
res = showTCWin(tw_green);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON);
// Expected stack res:
// [Top] Green -> Blue -> Red [Bottom]
// show blue
res = showTCWin(tw_blue);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON);
// show red
res = showTCWin(tw_red);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// show green
res = showTCWin(tw_green);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON);
// Expected stack res:
// [Top] Green -> Red -> Blue [Bottom]
// show green
res = showTCWin(tw_green);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON);
// show blue
res = showTCWin(tw_blue);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON);
// show red
res = showTCWin(tw_red);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// Expected stack res:
// [Top] Red -> Blue -> Green [Bottom]
// Raise Red
etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected stack res:
// [Top] Red -> Blue -> Green [Bottom]
// Raise Green
etRunner::get().setWinStack(tw_green, NULL, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_RAISE);
// Expected stack res:
// [Top] Green-> Blue -> Red [Bottom]
// Raise Red on the Green
etRunner::get().setWinStack(tw_red, tw_green, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
// Expected stack res:
// [Top] Blue -> Red -> Green [Bottom]
// Raise Blue on the Red
etRunner::get().setWinStack(tw_blue, tw_red, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_STACK_ABOVE);
// Expected stack res:
// [Top] Green-> Blue -> Red [Bottom]
// Raise Red on the Blue
etRunner::get().setWinStack(tw_red, tw_blue, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
// Expected stack res:
// [Top] Green-> Blue -> Red [Bottom]
// Lower Blue
etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_STACK_LOWER);
// Expected stack res:
// [Top] Green -> Red -> ... -> Blue [Bottom]
// Lower Green
etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_LOWER);
// Expected stack res:
// [Top] Blue -> Red -> ... -> Green [Bottom]
// show red
res = showTCWin(tw_red);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// show blue
res = showTCWin(tw_blue);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON);
// show green
res = showTCWin(tw_green);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON);
// Expected stack res:
// [Top] Green -> Blue -> Red [Bottom]
// show blue
res = showTCWin(tw_blue);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON);
// show red
res = showTCWin(tw_red);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// show green
res = showTCWin(tw_green);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON);
// Expected stack res:
// [Top] Green -> Red -> Blue [Bottom]
// show green
res = showTCWin(tw_green);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON);
// show blue
res = showTCWin(tw_blue);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON);
// show red
res = showTCWin(tw_red);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// Expected stack res:
// [Top] Red -> Blue -> Green [Bottom]
// Raise Red
etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_RAISE);
// Expected stack res:
// [Top] Red -> Blue -> Green [Bottom]
// Raise Green
etRunner::get().setWinStack(tw_green, NULL, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_RAISE);
// Expected stack res:
// [Top] Green-> Blue -> Red [Bottom]
// Raise Red on the Green
etRunner::get().setWinStack(tw_red, tw_green, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
// Expected stack res:
// [Top] Blue -> Red -> Green [Bottom]
// Raise Blue on the Red
etRunner::get().setWinStack(tw_blue, tw_red, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_STACK_ABOVE);
// Expected stack res:
// [Top] Green-> Blue -> Red [Bottom]
// Raise Red on the Blue
etRunner::get().setWinStack(tw_red, tw_blue, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
// Expected stack res:
// [Top] Green-> Blue -> Red [Bottom]
// Lower Blue
etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_STACK_LOWER);
// Expected stack res:
// [Top] Green -> Red -> ... -> Blue [Bottom]
// Lower Green
etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_LOWER);
// Expected stack res:
// [Top] Blue -> Red -> ... -> Green [Bottom]
// show green
res = showTCWin(tw_green);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON);
// show red
res = showTCWin(tw_red);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// Expected stack res:
// [Top] Red -> Green [Bottom]
// show blue
res = showTCWin(tw_blue);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON);
// show green
res = showTCWin(tw_green);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON);
// Expected stack res:
// [Top] Green -> Blue [Bottom]
// show red
res = showTCWin(tw_red);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// show blue
res = showTCWin(tw_blue);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON);
// Expected stack res:
// [Top] Blue -> Red [Bottom]
// show green
res = showTCWin(tw_green);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON);
// show red
res = showTCWin(tw_red);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// Expected stack res:
// [Top] Red -> Green [Bottom]
// show blue
res = showTCWin(tw_blue);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON);
// show green
res = showTCWin(tw_green);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON);
// Expected stack res:
// [Top] Green -> Blue [Bottom]
// show red
res = showTCWin(tw_red);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// show blue
res = showTCWin(tw_blue);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON);
// Expected stack res:
// [Top] Blue -> Red [Bottom]
void
etTestTransientFor::initTC(Eina_Bool show_win, Eina_Bool usr_geom)
{
- tw_parent = initNormalWin("TCWin_Normal_parent", show_win, usr_geom);
+ tw_parent = initNormalWin("TCWin_Normal_parent", usr_geom);
+ if (show_win)
+ {
+ showTCWin(tw_parent);
+ etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ }
ASSERT_TRUE(tw_parent != NULL) << "failed to initiation window";
- tw_child = initNormalWin("TCWin_Normal_child", show_win, usr_geom);
+ tw_child = initNormalWin("TCWin_Normal_child", usr_geom);
+ if (show_win)
+ {
+ showTCWin(tw_child);
+ etRunner::get().waitEvent(tw_child, E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ }
ASSERT_TRUE(tw_child != NULL) << "failed to initiation window";
- tw_base = initNormalWin("TCWin_Normal_normal", show_win, usr_geom);
+ tw_base = initNormalWin("TCWin_Normal_normal", usr_geom);
+ if (show_win)
+ {
+ showTCWin(tw_base);
+ etRunner::get().waitEvent(tw_base, E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ }
ASSERT_TRUE(tw_base != NULL) << "failed to initiation window";
}
// set transient_for
res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_TRUE);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_child, E_TC_EVENT_TYPE_STACK_CHANGED);
// Expected stack res:
// [Top] tw_base -> tw_child -> tw_parent [Bottom]
// set transient_for
res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_TRUE);
ASSERT_TRUE(res);
-
- res = registerTCWin(tw_parent);
- EXPECT_TRUE(res);
+ etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_STACK_CHANGED);
// tw_parent raise
res = etRunner::get().setWinStack(tw_parent, NULL, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_STACK_CHANGED);
// Expected stack res:
// [Top] tw_child -> tw_parent -> tw_base [Bottom]
// set transient_for
res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_TRUE);
ASSERT_TRUE(res);
-
- res = registerTCWin(tw_parent);
- EXPECT_TRUE(res);
+ etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_STACK_RAISE);
// tw_parent raise for prepare lower
res = etRunner::get().setWinStack(tw_parent, NULL, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_STACK_RAISE);
// tw_parent lower
res = etRunner::get().setWinStack(tw_parent, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_LOWER);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_STACK_LOWER);
// Expected stack res:
// [Top] tw_base -> ... -> tw_child -> tw_parent [Bottom]
// init TC window, show=true, geom=true
initTC(EINA_TRUE, EINA_TRUE);
- res = registerTCWin(tw_parent);
- EXPECT_TRUE(res);
-
// set transient_for
res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_TRUE);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_child, E_TC_EVENT_TYPE_STACK_CHANGED);
// tw_parent raise for prepare lower
res = etRunner::get().setWinStack(tw_parent, tw_base, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_ABOVE);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_STACK_CHANGED);
// Expected stack res:
// [Top] tw_child -> tw_parent -> tw_base [Bottom]
void
etTestNotification::initTC(Eina_Bool usr_geom)
{
- tw_normal = initNormalWin("TCWin_Normal_normal", EINA_TRUE, usr_geom);
+ tw_normal = initNormalWin("TCWin_Normal_normal", usr_geom);
+ showTCWin(tw_normal);
+ etRunner::get().waitEvent(tw_normal, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(tw_normal != NULL) << "failed to initiation window";
- tw_noti1 = initNotiWin("TCWin_Noti_1", EINA_TRUE, usr_geom, EINA_FALSE);
+ tw_noti1 = initNotiWin("TCWin_Noti_1", usr_geom, EINA_FALSE);
+ showTCWin(tw_noti1);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(tw_noti1 != NULL) << "failed to initiation window";
- tw_noti2 = initNotiWin("TCWin_Noti_2", EINA_TRUE, usr_geom, EINA_FALSE);
+ tw_noti2 = initNotiWin("TCWin_Noti_2", usr_geom, EINA_FALSE);
+ showTCWin(tw_noti2);
+ etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(tw_noti2 != NULL) << "failed to initiation window";
}
EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT, level);
EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM, level);
EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level);
EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level);
res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level);
res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_TOP);
EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level);
EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_NONE, level);
res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT, level);
res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM, level);
res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level);
res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_TOP);
EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level);
EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT, level);
EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM, level);
EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level);
EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level);
res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level);
res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_TOP);
EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level);
EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE);
level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_NONE, level);
res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_ABOVE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT, level);
res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_ABOVE);
level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM, level);
res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_ABOVE);
level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level);
res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_TOP);
EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_ABOVE);
level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level);
void
etTestTzsh::initTC()
{
- tw_base = initNormalWin("TCWin_Normal_base", EINA_FALSE, EINA_FALSE);
+ tw_base = initNormalWin("TCWin_Normal_base", EINA_FALSE);
ASSERT_TRUE(tw_base != NULL) << "failed to initiation window";
}
tz_scrsaver = tzsh_screensaver_service_create(tzsh, tz_win);
ASSERT_TRUE(tz_scrsaver != NULL);
- tw_base->updateGeometry();
- tw_base->show();
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ showTCWin(tw_base);
+ etRunner::get().waitEvent(tw_base, E_TC_EVENT_TYPE_VIS_ON);
list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
void
etTestRotation::initTC()
{
- tw_base = initNormalWin("TCWin_Normal_Rotation",EINA_TRUE, EINA_TRUE);
+ tw_base = initNormalWin("TCWin_Normal_Rotation", EINA_TRUE);
+ showTCWin(tw_base);
+ etRunner::get().waitEvent(tw_base, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(tw_base != NULL) << "failed to initiation window";
// available rotations
return EINA_FALSE;
}
- res = etRunner::get().waitEvent(E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE);
+ res = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE);
+
if (!res)
{
ERR("Failed waiting rotation change event");
void
etTestFocus::initTC(Eina_Bool show_win, Eina_Bool usr_geom)
{
- tw_red = initNormalWin("TCWin_Normal_red", show_win, usr_geom);
+ tw_red = initNormalWin("TCWin_Normal_red", usr_geom);
+ if (show_win)
+ {
+ showTCWin(tw_red);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ }
ASSERT_TRUE(tw_red != NULL) << "failed to initiation window";
- tw_green = initNormalWin("TCWin_Normal_green", show_win, usr_geom);
+ tw_green = initNormalWin("TCWin_Normal_green", usr_geom);
+ if (show_win)
+ {
+ showTCWin(tw_green);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ }
ASSERT_TRUE(tw_green != NULL) << "failed to initiation window";
- tw_blue = initNormalWin("TCWin_Normal_blue", show_win, usr_geom);
+ tw_blue = initNormalWin("TCWin_Normal_blue", usr_geom);
+ if (show_win)
+ {
+ showTCWin(tw_blue);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ }
ASSERT_TRUE(tw_blue != NULL) << "failed to initiation window";
- tw_blocker = initNotiWin("TCWin_Noti_Blocker", EINA_FALSE, EINA_FALSE, EINA_FALSE);
+ tw_blocker = initNotiWin("TCWin_Noti_Blocker", EINA_FALSE, EINA_FALSE);
ASSERT_TRUE(tw_blocker != NULL) << "failed to initiation window";
}
// make tw_blue lower
res = etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(res);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Green[focused] -> Red -> ... -> Blue [Bottom]
initTC(EINA_TRUE, EINA_TRUE);
// make tw_green lower
- res = registerTCWin(tw_green);
- EXPECT_TRUE(res);
res = etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_LOWER);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(res);
// Expected focus res:
initTC(EINA_TRUE, EINA_TRUE);
// make tw_red raise
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(res);
// Expected focus res:
// delete tw_blue
removeTCWin(tw_blue);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF);
tw_blue = NULL;
// Expected focus res:
initTC(EINA_TRUE, EINA_TRUE);
// Activate tw_red
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinActivate(tw_red);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_RAISE);
// Expected focus res:
// [Top] Red[focused] -> Blue -> Green [Bottom]
// show Blocker
showTCWin(tw_blocker);
+ etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Activate tw_red
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinActivate(tw_red);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Red[focused] -> Blocker -> Blue -> Green [Bottom]
initTC(EINA_TRUE, EINA_TRUE);
// make partial notification window
- etWin *tw_smallnoti = initNotiWin("TW_Temp_Noti", EINA_TRUE, EINA_TRUE, EINA_TRUE);
+ etWin *tw_smallnoti = initNotiWin("TW_Temp_Noti", EINA_TRUE, EINA_TRUE);
+ showTCWin(tw_smallnoti);
+ etRunner::get().waitEvent(tw_smallnoti, E_TC_EVENT_TYPE_VIS_ON);
res = etRunner::get().setWinNotiLevel(tw_smallnoti,
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
EXPECT_TRUE(res);
// Activate tw_red
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinActivate(tw_red);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_RAISE);
// Expected focus res:
// [Top] smallnoti -> ... -> Red[focused] -> Blue -> Green [Bottom]
// init TC window, show=true, geom=true
initTC(EINA_FALSE, EINA_TRUE);
- etWin *tw_small_blocker = initNotiWin("TCWin_Noti_Small_Blocker", EINA_TRUE, EINA_TRUE, EINA_TRUE);
+ etWin *tw_small_blocker = initNotiWin("TCWin_Noti_Small_Blocker", EINA_TRUE, EINA_TRUE);
+ showTCWin(tw_small_blocker);
etRunner::get().setWinNotiLevel(tw_small_blocker,
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+ etRunner::get().waitEvent(tw_small_blocker, E_TC_EVENT_TYPE_VIS_ON);
// Activate tw_red
res = showActivateTCWin(tw_red);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Red[focused] -> Blue -> Green [Bottom]
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
EXPECT_TRUE(res);
showTCWin(tw_blocker);
+ etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON);
// Activate tw_red
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinActivate(tw_red);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// Expected focus res:
// [Top] Blocker[focused] -> ... -> Red -> Blue -> Green [Bottom]
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
EXPECT_TRUE(res);
showTCWin(tw_blocker);
+ etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON);
// Activate tw_red
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinActivate(tw_red);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_RAISE);
// remove tw_blocker
removeTCWin(tw_blocker);
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_OFF);
+ tw_blocker = NULL;
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// Expected focus res:
// [Top] Red[focused] -> Blue -> Green [Bottom]
initTC(EINA_TRUE, EINA_TRUE);
// set transient_for Blue(parent) & Red(child)
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinTransientFor(tw_red, tw_blue, EINA_TRUE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_RAISE);
// Expected focus res:
// [Top] Red[focused] -> Blue -> Green [Bottom]
initTC(EINA_TRUE, EINA_TRUE);
// set transient_for Blue(parent) & Green(child)
- res = registerTCWin(tw_green);
- EXPECT_TRUE(res);
res = etRunner::get().setWinTransientFor(tw_green, tw_blue, EINA_TRUE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_RAISE);
// Expected focus res:
// [Top] Green[focused] -> Blue -> Red [Bottom]
initTC(EINA_TRUE, EINA_TRUE);
// set transient_for Green(parent) & Blue(child)
- res = registerTCWin(tw_green);
- EXPECT_TRUE(res);
res = etRunner::get().setWinTransientFor(tw_blue, tw_green, EINA_TRUE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_RAISE);
// Expected focus res:
// [Top] Blue[focused] -> Green -> Red [Bottom]
initTC(EINA_TRUE, EINA_TRUE);
// set iconify Blue
- res = registerTCWin(tw_blue);
- EXPECT_TRUE(res);
res = etRunner::get().setWinIconic(tw_blue, EINA_TRUE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_OFF);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF);
// Expected focus res:
// [Top] Blue(iconified) -> Green[focused] -> Red [Bottom]
initTC(EINA_TRUE, EINA_TRUE);
// set iconify Red
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinIconic(tw_red, EINA_TRUE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_OFF);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_OFF);
// Expected focus res:
// [Top] Blue[focused] -> Green -> Red(iconified) [Bottom]
initTC(EINA_TRUE, EINA_TRUE);
// set iconify Red
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinIconic(tw_red, EINA_TRUE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_OFF);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_OFF);
// set uniconify Red
res = etRunner::get().setWinIconic(tw_red, EINA_FALSE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().work(2.0);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// Expected focus res:
// [Top] Red[focused] -> Blue -> Green [Bottom]
initTC(EINA_TRUE, EINA_TRUE);
// set iconify Blue
- res = registerTCWin(tw_blue);
- EXPECT_TRUE(res);
res = etRunner::get().setWinIconic(tw_blue, EINA_TRUE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_OFF);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF);
// set uniconify Blue
res = etRunner::get().setWinIconic(tw_blue, EINA_FALSE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().work(2.0);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON);
// Expected focus res:
// [Top] Blue[focused] -> Green -> Red [Bottom]
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
EXPECT_TRUE(res);
showTCWin(tw_blocker);
+ etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON);
// hide blocker
removeTCWin(tw_blocker);
- res = registerTCWin(tw_blue);
- EXPECT_TRUE(res);
+ etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_OFF);
+ tw_blocker = NULL;
// Expected focus res:
// [Top] Blue[focused] -> Green -> Red [Bottom]
// move tw_blue to out of screen
tw_blue->move(2000, 2000);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_CHANGED);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_CHANGED);
// Expected focus res:
// [Top] Blue -> Green[focused] -> Red [Bottom]
// move tw_blue to out of screen
tw_blue->move(2000, 2000);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_OFF);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF);
// move tw_blue into screen
tw_blue->move(200, 200);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON);
// Expected focus res:
// [Top] Blue -> Green[focused] -> Red [Bottom]
TEST_F(etTestFocus, focus_touch_basic)
{
etWin *tw = NULL;
- Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
// init TC window, show=true, geom=true
initTC(EINA_TRUE, EINA_TRUE);
// touch red win
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
etRunner::get().generateMouseDown(50, 50);
etRunner::get().generateMouseUp(50, 50);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Blue -> Green -> Red[focused] [Bottom]
TEST_F(etTestFocus, focus_touch_history)
{
etWin *tw = NULL;
- Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
// init TC window, show=true, geom=true
initTC(EINA_TRUE, EINA_TRUE);
// touch red win
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
etRunner::get().generateMouseDown(50, 50);
etRunner::get().generateMouseUp(50, 50);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// touch blue win
- res = registerTCWin(tw_blue);
- EXPECT_TRUE(res);
etRunner::get().generateMouseDown(250, 250);
etRunner::get().generateMouseUp(250, 250);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Blue[focused] -> Green -> Red [Bottom]
// remove blue win
removeTCWin(tw_blue);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF);
+ tw_blue = NULL;
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
+
// Expected focus res:
// [Top] Green -> Red[focused] [Bottom]
// remove red win
removeTCWin(tw_red);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_OFF);
+ tw_red = NULL;
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Green[focused] [Bottom]
TEST_F(etTestFocus, DISABLED_focus_touch_history2)
{
etWin *tw = NULL;
- Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
// init TC window, show=true, geom=true
initTC(EINA_TRUE, EINA_TRUE);
// touch green win
- res = registerTCWin(tw_green);
- EXPECT_TRUE(res);
etRunner::get().generateMouseDown(150, 150);
etRunner::get().generateMouseUp(150, 150);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Red -> Green[focused] -> Blue [Bottom]
etRunner::get().freeWinInfoList(list);
// activate red win
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
etRunner::get().setWinActivate(tw_red);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_ABOVE);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
// Expected focus res:
// [Top] Red[focused] -> Blue -> Green [Bottom]
// lower red win
etRunner::get().setWinStack(tw_red, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON);
// Expected focus res:
// [Top] Blue -> Green[focused] -> ... -> Red [Bottom]
// set focus_skip on tw_blue
etRunner::get().setFocusSkip(tw_blue, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Blue -> Green[focused] -> Red [Bottom]
// set focus_skip on tw_blue
etRunner::get().setFocusSkip(tw_blue, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Blue -> Green[focused] -> Red [Bottom]
// unset focus_skip on tw_blue
etRunner::get().setFocusSkip(tw_blue, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().work(0.1); // waiting for adjust focus skip
// Expected focus res:
// [Top] Blue -> Green[focused] -> Red [Bottom]
TEST_F(etTestFocus, focus_touch_with_focus_skip)
{
etWin *tw = NULL;
- Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
// init TC window, show=true, geom=true
initTC(EINA_TRUE, EINA_TRUE);
// set focus_skip on tw_red
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
etRunner::get().setFocusSkip(tw_red, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().work(0.1); // waiting for adjust focus skip
// touch red win
etRunner::get().generateMouseDown(50, 50);
etRunner::get().generateMouseUp(50, 50);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().work(0.1); // waiting for adjust focus skip
// Expected focus res:
// [Top] Blue[focused] -> Green -> Red [Bottom]
// make tw_blue lower
res = etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(res);
// Expected focus res:
initTC(EINA_TRUE, EINA_FALSE);
// make tw_green lower
- res = registerTCWin(tw_green);
- EXPECT_TRUE(res);
res = etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_LOWER);
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_LOWER);
ASSERT_TRUE(res);
// Expected focus res:
// make tw_red raise
res = etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(res);
// Expected focus res:
// delete tw_blue
removeTCWin(tw_blue);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF);
tw_blue = NULL;
+ etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Green[focused] -> Red [Bottom]
initTC(EINA_TRUE, EINA_FALSE);
// Activate tw_red
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinActivate(tw_red);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
// Expected focus res:
// [Top] Red[focused] -> Blue -> Green [Bottom]
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
EXPECT_TRUE(res);
showTCWin(tw_blocker);
+ etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON);
// Activate tw_red
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinActivate(tw_red);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
// Expected focus res:
// [Top] Blocker[focused] -> ... -> Red -> Blue -> Green [Bottom]
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
EXPECT_TRUE(res);
showTCWin(tw_blocker);
+ etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON);
// Activate tw_red
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinActivate(tw_red);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
// remove tw_blocker
removeTCWin(tw_blocker);
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_OFF);
+ tw_blocker = NULL;
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Red[focused] -> Blue -> Green [Bottom]
initTC(EINA_TRUE, EINA_FALSE);
// set transient_for Blue(parent) & Red(child)
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinTransientFor(tw_red, tw_blue, EINA_TRUE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Red[focused] -> Blue -> Green [Bottom]
initTC(EINA_TRUE, EINA_FALSE);
// set iconify Blue
- res = registerTCWin(tw_blue);
- EXPECT_TRUE(res);
res = etRunner::get().setWinIconic(tw_blue, EINA_TRUE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_OFF);
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF);
// Expected focus res:
// [Top] Blue(iconified) -> Green[focused] -> Red [Bottom]
initTC(EINA_TRUE, EINA_FALSE);
// set iconify Red
- res = registerTCWin(tw_red);
- EXPECT_TRUE(res);
res = etRunner::get().setWinIconic(tw_red, EINA_TRUE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_OFF);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_OFF);
// set uniconify Red
res = etRunner::get().setWinIconic(tw_red, EINA_FALSE);
ASSERT_TRUE(res);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Red[focused] -> Blue -> Green [Bottom]
// set focus_skip on tw_blue
etRunner::get().setFocusSkip(tw_blue, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().work(0.1); // waiting for adjust focus skip set
// Expected focus res:
// [Top] Blue -> Green -> Red [Bottom]
// Expected focus res:
// [Top] Blue -> Green -> Red [Bottom]
etRunner::get().setFocusSkip(tw_blue, EINA_TRUE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().work(0.1); // waiting for adjust focus skip set
// unset focus_skip on tw_blue
etRunner::get().setFocusSkip(tw_blue, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().work(0.1); // waiting for adjust focus skip set
+ etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_FOCUS_CHANGED);
// Expected focus res:
// [Top] Blue[focused] -> Green -> Red [Bottom]
class etTestInput : public ::etTCBase
{
public:
- etTestInput() { };
- ~etTestInput() { };
+ etTestInput()
+ {
+ key_name = eina_stringshare_add("XF86Menu");
+ etRunner::get().ev.key.name = eina_stringshare_add("XF86Menu");
+ };
+ ~etTestInput()
+ {
+ eina_stringshare_del(key_name);
+ eina_stringshare_del(etRunner::get().ev.key.name);
+ key_name = NULL;
+ };
protected:
etWin *tw_shared = NULL;
etWin *tw_orexcl = NULL;
etWin *tw_excl = NULL;
etWin *tw_gesture = NULL;
+
+ Eina_Stringshare *key_name = NULL;
};
TEST_F(etTestInput, keygrab_nowin_shared)
ret = ecore_wl2_window_keygrab_set(NULL, "XF86Menu", 0, 0, 0, ECORE_WL2_WINDOW_KEYGRAB_SHARED);
ASSERT_TRUE(ret);
- etRunner::get().ev.key.name = eina_stringshare_add("XF86Menu");
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
+ etRunner::get().generateKeyEvent(key_name, 0.3);
+ ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
ASSERT_TRUE(ret);
- eina_stringshare_del(etRunner::get().ev.key.name);
- etRunner::get().ev.key.name = NULL;
-
ret = ecore_wl2_window_keygrab_unset(NULL, "XF86Menu", 0, 0);
ASSERT_TRUE(ret);
}
ret = ecore_wl2_window_keygrab_set(NULL, "XF86Menu", 0, 0, 0, ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE);
ASSERT_TRUE(ret);
- etRunner::get().ev.key.name = eina_stringshare_add("XF86Menu");
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
+ etRunner::get().generateKeyEvent(key_name, 0.3);
+ ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
ASSERT_TRUE(ret);
- eina_stringshare_del(etRunner::get().ev.key.name);
- etRunner::get().ev.key.name = NULL;
-
ret = ecore_wl2_window_keygrab_unset(NULL, "XF86Menu", 0, 0);
ASSERT_TRUE(ret);
}
ret = ecore_wl2_window_keygrab_set(NULL, "XF86Menu", 0, 0, 0, ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE);
ASSERT_TRUE(ret);
- etRunner::get().ev.key.name = eina_stringshare_add("XF86Menu");
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
+ etRunner::get().generateKeyEvent(key_name, 0.3);
+ ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
ASSERT_TRUE(ret);
- eina_stringshare_del(etRunner::get().ev.key.name);
- etRunner::get().ev.key.name = NULL;
-
ret = ecore_wl2_window_keygrab_unset(NULL, "XF86Menu", 0, 0);
ASSERT_TRUE(ret);
}
{
Eina_Bool ret = EINA_FALSE;
- tw_shared = initNormalWin("TCWin_SharedGrab", EINA_TRUE, EINA_FALSE);
+ tw_shared = initNormalWin("TCWin_SharedGrab", EINA_FALSE);
ASSERT_TRUE(tw_shared != NULL) << "failed to initiation window";
+ showTCWin(tw_shared);
+ etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_VIS_ON);
+
ret = elm_win_keygrab_set(tw_shared->elm_win, "XF86Menu", 0, 0, 0, ELM_WIN_KEYGRAB_SHARED);
ASSERT_TRUE(ret);
ret = evas_object_key_grab(tw_shared->elm_win, "XF86Menu", 0, 0, EINA_FALSE);
ASSERT_TRUE(ret);
- etRunner::get().ev.win = tw_shared->elm_win;
- etRunner::get().ev.key.name = eina_stringshare_add("XF86Menu");
+ etRunner::get().ev.elm_win = tw_shared->elm_win;
+ etRunner::get().ev.native_win = tw_shared->native_win;
ret = etRunner::get().setWinStack(tw_shared, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(ret);
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+ etRunner::get().generateKeyEvent(key_name, 0.3);
+ ret = etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
ASSERT_TRUE(ret);
- eina_stringshare_del(etRunner::get().ev.key.name);
- etRunner::get().ev.key.name = NULL;
- etRunner::get().ev.win = NULL;
+ etRunner::get().ev.elm_win = NULL;
+ etRunner::get().ev.native_win = 0;
evas_object_key_ungrab(tw_shared->elm_win, "XF86Menu", 0, 0);
ret = elm_win_keygrab_unset(tw_shared->elm_win, "XF86Menu", 0, 0);
{
Eina_Bool ret = EINA_FALSE;
- tw_orexcl = initNormalWin("TCWin_OrexclGrab", EINA_TRUE, EINA_FALSE);
+ tw_orexcl = initNormalWin("TCWin_OrexclGrab", EINA_FALSE);
ASSERT_TRUE(tw_orexcl != NULL) << "failed to initiation window";
+ showTCWin(tw_orexcl);
+ etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_VIS_ON);
+
ret = elm_win_keygrab_set(tw_orexcl->elm_win, "XF86Menu", 0, 0, 0, ELM_WIN_KEYGRAB_OVERRIDE_EXCLUSIVE);
ASSERT_TRUE(ret);
ret = evas_object_key_grab(tw_orexcl->elm_win, "XF86Menu", 0, 0, EINA_TRUE);
ASSERT_TRUE(ret);
- etRunner::get().ev.win = tw_orexcl->elm_win;
- etRunner::get().ev.key.name = eina_stringshare_add("XF86Menu");
+ etRunner::get().ev.elm_win = tw_orexcl->elm_win;
+ etRunner::get().ev.native_win = tw_orexcl->native_win;
ret = etRunner::get().setWinStack(tw_orexcl, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(ret);
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+ etRunner::get().generateKeyEvent(key_name, 0.3);
+ ret = etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
ASSERT_TRUE(ret);
- eina_stringshare_del(etRunner::get().ev.key.name);
- etRunner::get().ev.key.name = NULL;
- etRunner::get().ev.win = NULL;
+ etRunner::get().ev.elm_win = NULL;
+ etRunner::get().ev.native_win = 0;
evas_object_key_ungrab(tw_orexcl->elm_win, "XF86Menu", 0, 0);
ret = elm_win_keygrab_unset(tw_orexcl->elm_win, "XF86Menu", 0, 0);
{
Eina_Bool ret = EINA_FALSE;
- tw_excl = initNormalWin("TCWin_ExclGrab", EINA_TRUE, EINA_FALSE);
+ tw_excl = initNormalWin("TCWin_ExclGrab", EINA_FALSE);
ASSERT_TRUE(tw_excl != NULL) << "failed to initiation window";
+ showTCWin(tw_excl);
+ etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_VIS_ON);
+
ret = elm_win_keygrab_set(tw_excl->elm_win, "XF86Menu", 0, 0, 0, ELM_WIN_KEYGRAB_EXCLUSIVE);
ASSERT_TRUE(ret);
ret = evas_object_key_grab(tw_excl->elm_win, "XF86Menu", 0, 0, EINA_TRUE);
ASSERT_TRUE(ret);
- etRunner::get().ev.win = tw_excl->elm_win;
- etRunner::get().ev.key.name = eina_stringshare_add("XF86Menu");
+ etRunner::get().ev.elm_win = tw_excl->elm_win;
+ etRunner::get().ev.native_win = tw_excl->native_win;
ret = etRunner::get().setWinStack(tw_excl, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(ret);
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+ etRunner::get().generateKeyEvent(key_name, 0.3);
+ ret = etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
ASSERT_TRUE(ret);
- eina_stringshare_del(etRunner::get().ev.key.name);
- etRunner::get().ev.key.name = NULL;
- etRunner::get().ev.win = NULL;
+ etRunner::get().ev.elm_win = NULL;
+ etRunner::get().ev.native_win = 0;
evas_object_key_ungrab(tw_excl->elm_win, "XF86Menu", 0, 0);
ret = elm_win_keygrab_unset(tw_excl->elm_win, "XF86Menu", 0, 0);
{
Eina_Bool ret = EINA_FALSE;
- tw_topposition = initNormalWin("TCWin_ToppositionGrab", EINA_TRUE, EINA_TRUE);
+ tw_topposition = initNormalWin("TCWin_ToppositionGrab", EINA_TRUE);
ASSERT_TRUE(tw_topposition != NULL) << "failed to initiation window";
+ showTCWin(tw_topposition);
+ etRunner::get().waitEvent(tw_topposition, E_TC_EVENT_TYPE_VIS_ON);
+
ecore_evas_focus_skip_set(ecore_evas_ecore_evas_get(evas_object_evas_get(tw_topposition->elm_win)), EINA_TRUE);
ret = elm_win_keygrab_set(tw_topposition->elm_win, "XF86Menu", 0, 0, 0, ELM_WIN_KEYGRAB_TOPMOST);
ret = evas_object_key_grab(tw_topposition->elm_win, "XF86Menu", 0, 0, EINA_FALSE);
ASSERT_TRUE(ret);
- etRunner::get().ev.win = tw_topposition->elm_win;
- etRunner::get().ev.key.name = eina_stringshare_add("XF86Menu");
+ etRunner::get().ev.elm_win = tw_topposition->elm_win;
+ etRunner::get().ev.native_win = tw_topposition->native_win;
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+ etRunner::get().generateKeyEvent(key_name, 0.3);
+ ret = etRunner::get().waitEvent(tw_topposition, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
ASSERT_TRUE(ret);
- eina_stringshare_del(etRunner::get().ev.key.name);
- etRunner::get().ev.key.name = NULL;
- etRunner::get().ev.win = NULL;
+ etRunner::get().ev.elm_win = NULL;
+ etRunner::get().ev.native_win = 0;
evas_object_key_ungrab(tw_topposition->elm_win, "XF86Menu", 0, 0);
ret = elm_win_keygrab_unset(tw_topposition->elm_win, "XF86Menu", 0, 0);
{
Eina_Bool ret = EINA_FALSE;
- tw_shared = initNormalWin("TCWin_SharedGrab", EINA_TRUE, EINA_FALSE);
+ tw_shared = initNormalWin("TCWin_SharedGrab", EINA_FALSE);
ASSERT_TRUE(tw_shared != NULL) << "failed to initiation window";
- tw_orexcl = initNormalWin("TCWin_OrexclGrab", EINA_TRUE, EINA_FALSE);
+ showTCWin(tw_shared);
+ etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_VIS_ON);
+
+ tw_orexcl = initNormalWin("TCWin_OrexclGrab", EINA_FALSE);
ASSERT_TRUE(tw_orexcl != NULL) << "failed to initiation window";
- tw_excl = initNormalWin("TCWin_ExclGrab", EINA_TRUE, EINA_FALSE);
+ showTCWin(tw_orexcl);
+ etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_VIS_ON);
+
+ tw_excl = initNormalWin("TCWin_ExclGrab", EINA_FALSE);
ASSERT_TRUE(tw_excl != NULL) << "failed to initiation window";
- tw_topposition = initNormalWin("TCWin_ToppositionGrab", EINA_TRUE, EINA_TRUE);
+ showTCWin(tw_excl);
+ etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_VIS_ON);
+
+ tw_topposition = initNormalWin("TCWin_ToppositionGrab", EINA_TRUE);
ASSERT_TRUE(tw_topposition != NULL) << "failed to initiation window";
+ showTCWin(tw_topposition);
+ etRunner::get().waitEvent(tw_topposition, E_TC_EVENT_TYPE_VIS_ON);
+
ecore_evas_focus_skip_set(ecore_evas_ecore_evas_get(evas_object_evas_get(tw_topposition->elm_win)), EINA_TRUE);
ret = elm_win_keygrab_set(tw_excl->elm_win, "XF86Menu", 0, 0, 0, ELM_WIN_KEYGRAB_EXCLUSIVE);
ASSERT_TRUE(ret);
ret = etRunner::get().setWinStack(tw_excl, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(ret);
ret = etRunner::get().setWinStack(tw_orexcl, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(ret);
ret = etRunner::get().setWinStack(tw_shared, NULL, EINA_FALSE);
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_FOCUS_CHANGED);
ASSERT_TRUE(ret);
// test exclusive grab
- etRunner::get().ev.win = tw_excl->elm_win;
- etRunner::get().ev.key.name = eina_stringshare_add("XF86Menu");
+ etRunner::get().ev.elm_win = tw_excl->elm_win;
+ etRunner::get().ev.native_win = tw_excl->native_win;
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+ etRunner::get().generateKeyEvent(key_name, 0.3);
+ ret = etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
ASSERT_TRUE(ret);
- eina_stringshare_del(etRunner::get().ev.key.name);
-
evas_object_key_ungrab(tw_excl->elm_win, "XF86Menu", 0, 0);
ret = elm_win_keygrab_unset(tw_excl->elm_win, "XF86Menu", 0, 0);
ASSERT_TRUE(ret);
// test override exclusive grab
- etRunner::get().ev.win = tw_orexcl->elm_win;
- etRunner::get().ev.key.name = eina_stringshare_add("XF86Menu");
+ etRunner::get().ev.elm_win = tw_orexcl->elm_win;
+ etRunner::get().ev.native_win = tw_orexcl->native_win;
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+ etRunner::get().generateKeyEvent(key_name, 0.3);
+ ret = etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
ASSERT_TRUE(ret);
- eina_stringshare_del(etRunner::get().ev.key.name);
-
evas_object_key_ungrab(tw_orexcl->elm_win, "XF86Menu", 0, 0);
ret = elm_win_keygrab_unset(tw_orexcl->elm_win, "XF86Menu", 0, 0);
ASSERT_TRUE(ret);
// test top position grab
- etRunner::get().ev.win = tw_topposition->elm_win;
- etRunner::get().ev.key.name = eina_stringshare_add("XF86Menu");
+ etRunner::get().ev.elm_win = tw_topposition->elm_win;
+ etRunner::get().ev.native_win = tw_topposition->native_win;
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+ etRunner::get().generateKeyEvent(key_name, 0.3);
+ ret = etRunner::get().waitEvent(tw_topposition, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
ASSERT_TRUE(ret);
- eina_stringshare_del(etRunner::get().ev.key.name);
-
evas_object_key_ungrab(tw_topposition->elm_win, "XF86Menu", 0, 0);
ret = elm_win_keygrab_unset(tw_topposition->elm_win, "XF86Menu", 0, 0);
ASSERT_TRUE(ret);
// test shared grab
- etRunner::get().ev.win = tw_shared->elm_win;
- etRunner::get().ev.key.name = eina_stringshare_add("XF86Menu");
+ etRunner::get().ev.elm_win = tw_shared->elm_win;
+ etRunner::get().ev.native_win = tw_shared->native_win;
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+ etRunner::get().generateKeyEvent(key_name, 0.3);
+ ret = etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
ASSERT_TRUE(ret);
- eina_stringshare_del(etRunner::get().ev.key.name);
-
evas_object_key_ungrab(tw_shared->elm_win, "XF86Menu", 0, 0);
ret = elm_win_keygrab_unset(tw_shared->elm_win, "XF86Menu", 0, 0);
ASSERT_TRUE(ret);
etRunner::get().ev.key.name = NULL;
- etRunner::get().ev.win = NULL;
+ etRunner::get().ev.elm_win = NULL;
}
TEST_F(etTestInput, gesture_tap22)
{
int ret = EFL_UTIL_ERROR_NONE;
- efl_util_gesture_h gesture_h;
+ efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler();
efl_util_gesture_data tap_d;
- gesture_h = efl_util_gesture_initialize();
- ASSERT_TRUE(gesture_h != NULL) << "failed to initiation gesture system";
-
tap_d = efl_util_gesture_tap_new(gesture_h, 2, 2);
ASSERT_TRUE(tap_d != NULL) << "failed to generate tap grab data";
etRunner::get().ev.gesture.tap.fingers = 2;
etRunner::get().ev.gesture.tap.repeats = 2;
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_GESTURE_TAP);
+ etRunner::get().generateTapGesture();
+ ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_TAP);
ASSERT_TRUE(ret);
etRunner::get().ev.gesture.tap.fingers = 0;
ret = efl_util_gesture_ungrab(gesture_h, tap_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to ungrab tap gesture: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
-
- efl_util_gesture_tap_free(gesture_h, tap_d);
- ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to free tap grab data: (ret: "
- << EFL_UTIL_RETURN_TO_STRING(ret) << ")";
}
TEST_F(etTestInput, gesture_tap23)
{
int ret = EFL_UTIL_ERROR_NONE;
- efl_util_gesture_h gesture_h;
+ efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler();
efl_util_gesture_data tap_d;
- gesture_h = efl_util_gesture_initialize();
- ASSERT_TRUE(gesture_h != NULL) << "failed to initiation gesture system";
-
tap_d = efl_util_gesture_tap_new(gesture_h, 2, 3);
ASSERT_TRUE(tap_d != NULL) << "failed to generate tap grab data";
etRunner::get().ev.gesture.tap.fingers = 2;
etRunner::get().ev.gesture.tap.repeats = 3;
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_GESTURE_TAP);
+ etRunner::get().generateTapGesture();
+ ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_TAP);
ASSERT_TRUE(ret);
etRunner::get().ev.gesture.tap.fingers = 0;
etRunner::get().ev.gesture.tap.repeats = 0;
-
ret = efl_util_gesture_ungrab(gesture_h, tap_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to ungrab tap gesture: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
_test_gesture_edge_swipe(int fingers, efl_util_gesture_edge_e edge)
{
int ret = EFL_UTIL_ERROR_NONE;
- efl_util_gesture_h gesture_h;
+ efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler();
efl_util_gesture_data edge_swipe_d;
- gesture_h = efl_util_gesture_initialize();
- ASSERT_TRUE(gesture_h != NULL) << "failed to initialize gesture system";
-
edge_swipe_d = efl_util_gesture_edge_swipe_new(gesture_h, fingers, edge);
ASSERT_TRUE(edge_swipe_d != NULL) << "failed to generate edge swipe grab data";
etRunner::get().ev.gesture.edge.fingers = fingers;
etRunner::get().ev.gesture.edge.edge = edge;
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE);
+ etRunner::get().generateEdgeSwipeGesture();
+ ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE);
ASSERT_TRUE(ret);
etRunner::get().ev.gesture.edge.fingers = 0;
ret = efl_util_gesture_edge_swipe_free(gesture_h, edge_swipe_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to free tap grab data: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
-
- ret = efl_util_gesture_deinitialize(gesture_h);
- ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to deinitialize gesture system: (ret: "
- << EFL_UTIL_RETURN_TO_STRING(ret) << ")";
}
TEST_F(etTestInput, gesture_edge_swipe11)
_test_gesture_edge_drag(int fingers, efl_util_gesture_edge_e edge)
{
int ret = EFL_UTIL_ERROR_NONE;
- efl_util_gesture_h gesture_h;
+ efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler();
efl_util_gesture_data edge_drag_d;
- gesture_h = efl_util_gesture_initialize();
- ASSERT_TRUE(gesture_h != NULL) << "failed to initialize gesture system";
-
edge_drag_d = efl_util_gesture_edge_drag_new(gesture_h, fingers, edge);
ASSERT_TRUE(edge_drag_d != NULL) << "failed to generate edge drag grab data";
etRunner::get().ev.gesture.edge.fingers = fingers;
etRunner::get().ev.gesture.edge.edge = edge;
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG);
+ etRunner::get().generateEdgeDragGesture();
+ ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG);
ASSERT_TRUE(ret);
etRunner::get().ev.gesture.edge.fingers = 0;
ret = efl_util_gesture_edge_drag_free(gesture_h, edge_drag_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to free tap grab data: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
-
- ret = efl_util_gesture_deinitialize(gesture_h);
- ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to deinitialize gesture system: (ret: "
- << EFL_UTIL_RETURN_TO_STRING(ret) << ")";
}
TEST_F(etTestInput, gesture_edge_drag11)
TEST_F(etTestInput, gesture_edge_drag24)
{
_test_gesture_edge_drag(2, EFL_UTIL_GESTURE_EDGE_LEFT);
-}
\ No newline at end of file
+}
{
Eina_Bool ret = EINA_FALSE;
- tw = initNormalWin("TCWin_Splash", EINA_FALSE, EINA_FALSE);
+ tw = initNormalWin("TCWin_Splash", EINA_FALSE);
ASSERT_TRUE(tw != NULL) << "failed to initiation window";
ret = etRunner::get().setSplashLaunch(path, type);
Eina_List *list = NULL, *l = NULL;
initTC((char*)path_edc, SPLASH_TYPE_EDC);
+ etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON);
// find Launchscreen from toplv windows
list = etRunner::get().getWinInfoList();
Eina_List *list = NULL, *l = NULL;
initTC((char*)path_img, SPLASH_TYPE_IMG);
+ etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON);
// find Launchscreen from toplv windows
list = etRunner::get().getWinInfoList();
initTC((char*)path_img, SPLASH_TYPE_IMG);
etRunner::get().setSplashOwner();
- tw->updateGeometry();
- tw->show();
- etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ showTCWin(tw);
+ etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON);
// Expected focus res:
list = etRunner::get().getWinInfoList();
initTC((char*)path_img, SPLASH_TYPE_IMG);
etRunner::get().setSplashOwner();
- tw->updateGeometry();
- tw->show();
-
- etRunner::get().ev.win = tw->elm_win;
- ret = etRunner::get().waitEvent(E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
+ showTCWin(tw);
+ ret = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
ASSERT_TRUE(ret);
// Expected focus res:
etWin *tw = NULL;
etWin *tw_green = NULL;
+ void initTC();
};
+void
+etTestEffect::initTC()
+{
+ tw = initNormalWin("TCWin_Effect_Show1", EINA_FALSE);
+ ASSERT_TRUE(tw != NULL) << "failed to initiation window";
+
+ tw_green = initNormalWin("TCWin_Effect_GREEN", EINA_FALSE);
+ ASSERT_TRUE(tw_green != NULL) << "failed to initiation window";
+}
+
TEST_F(etTestEffect, effect_show)
{
Eina_Bool res = EINA_FALSE;
- tw = initNormalWin("TCWin_Effect_Show1", EINA_FALSE, EINA_FALSE);
- ASSERT_TRUE(tw != NULL) << "failed to initiation window";
- res = registerTCWin(tw);
- ASSERT_TRUE(res);
+ initTC();
res = etRunner::get().setWinEffect(tw);
ASSERT_TRUE(res);
- tw->updateGeometry();
- tw->show();
+ showTCWin(tw);
- res = etRunner::get().waitEvent(E_TC_EVENT_TYPE_EFFECT);
+ res = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT);
ASSERT_TRUE(res);
return;
TEST_F(etTestEffect, effect_show_evas_callback)
{
Eina_Bool res = EINA_FALSE;
- tw = initNormalWin("TCWin_Effect_Show2", EINA_FALSE, EINA_FALSE);
- ASSERT_TRUE(tw != NULL) << "failed to initiation window";
- res = registerTCWin(tw);
- ASSERT_TRUE(res);
+ initTC();
res = etRunner::get().setWinEffect(tw);
ASSERT_TRUE(res);
- tw->updateGeometry();
- tw->show();
+ showTCWin(tw);
- res = etRunner::get().waitEvent(E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
+ res = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
ASSERT_TRUE(res);
return;
TEST_F(etTestEffect, effect_hide_bylower)
{
Eina_Bool res = EINA_FALSE;
- tw = initNormalWin("TCWin_Effect_Hide_Lower", EINA_FALSE, EINA_FALSE);
- ASSERT_TRUE(tw != NULL) << "failed to initiation window";
- res = registerTCWin(tw);
- ASSERT_TRUE(res);
+ initTC();
- tw->updateGeometry();
- tw->show();
- etRunner::get().work(1.1);
+ showTCWin(tw);
+ etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON);
res = etRunner::get().setWinEffect(tw);
ASSERT_TRUE(res);
- etRunner::get().work(1.1);
-
elm_win_lower(tw->elm_win);
-
- res = etRunner::get().waitEvent(E_TC_EVENT_TYPE_EFFECT);
+ res = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT);
ASSERT_TRUE(res);
return;
TEST_F(etTestEffect, effect_hide_byunmap)
{
Eina_Bool res = EINA_FALSE;
- tw = initNormalWin("TCWin_Effect_Hide_Unmap", EINA_FALSE, EINA_FALSE);
- ASSERT_TRUE(tw != NULL) << "failed to initiation window";
- res = registerTCWin(tw);
- ASSERT_TRUE(res);
+ initTC();
- tw->updateGeometry();
- tw->show();
- etRunner::get().work(1.1);
+ showTCWin(tw);
+ etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON);
res = etRunner::get().setWinEffect(tw);
ASSERT_TRUE(res);
- etRunner::get().work(1.1);
-
tw->hide();
-
- res = etRunner::get().waitEvent(E_TC_EVENT_TYPE_EFFECT);
+ res = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT);
ASSERT_TRUE(res);
return;
TEST_F(etTestEffect, effect_bg)
{
Eina_Bool res = EINA_FALSE;
- tw = initNormalWin("TCWin_Effect_Effect_BG", EINA_FALSE, EINA_FALSE);
- ASSERT_TRUE(tw != NULL) << "failed to initiation window";
-
- tw_green = initNormalWin("TCWin_Effect_GREEN", EINA_FALSE, EINA_FALSE);
- ASSERT_TRUE(tw_green != NULL) << "failed to initiation window";
- res = registerTCWin(tw);
- ASSERT_TRUE(res);
+ initTC();
- tw->updateGeometry();
- tw->show();
- etRunner::get().work(1.1);
+ showTCWin(tw);
+ etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON);
res = etRunner::get().setWinEffect(tw);
ASSERT_TRUE(res);
-
- tw_green->updateGeometry();
- tw_green->show();
-
- res = etRunner::get().waitEvent(E_TC_EVENT_TYPE_EFFECT);
+ //show upper window
+ showTCWin(tw_green);
+ res = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT);
ASSERT_TRUE(res);
return;
projects / platform / core / uifw / e-tizen-testcase.git / commitdiff