#define E_TEST_WORK_TIME 3.0
#define E_TC_SIGN_WIN_INFO "usiiiiibbbiibbbbbi"
-/**********************
- callbacks
- **********************/
/* callbacks - event */
-static void _cb_resource_id(void *data,
- struct tizen_resource *tizen_resource,
- uint32_t id)
+static void
+_cb_resource_id(void *data,
+ struct tizen_resource *tizen_resource,
+ uint32_t id)
{
Ecore_Window *res_id = (Ecore_Window *)data;
-
*res_id = id;
-
elm_exit();
}
};
/**********************
- class EtEventLoop
+ class etRunner
**********************/
+etRunner etRunner::inst;
-/* public methods */
-EtEventLoop::EtEventLoop()
-{
- this->log_dom_ = -1;
- this->Worker.work_timer_ = NULL;
- this->Worker.time_for_wait_work_ = E_TEST_WORK_TIME;
-
- this->tizen_policy_ = NULL;
- this->tizen_surface_ = NULL;
-
- this->Ev.expire_timer = NULL;
- this->Ev.expect = E_TC_EVENT_TYPE_NONE;
- this->Ev.response = E_TC_EVENT_TYPE_NONE;
-
- this->Dbus.conn = NULL;
- this->Dbus.obj = NULL;
- this->Dbus.proxy = NULL;
-}
-
-EtEventLoop::~EtEventLoop()
+Eina_Bool
+etRunner::init()
{
- // TODO:: release resources
- this->FreeLastWinInfoList();
-
- if (this->tizen_policy_)
- {
- tizen_policy_destroy(this->tizen_policy_);
- this->tizen_policy_ = NULL;
- }
- if (this->tizen_surface_)
- {
- tizen_surface_destroy(this->tizen_surface_);
- this->tizen_surface_ = NULL;
- }
-
- // deinit eldbus
- if (this->Dbus.proxy)
- {
- eldbus_proxy_unref(this->Dbus.proxy);
- this->Dbus.proxy = NULL;
- }
- if (this->Dbus.obj)
- {
- eldbus_object_unref(this->Dbus.obj);
- this->Dbus.obj = NULL;
- }
- if (this->Dbus.conn)
- {
- eldbus_connection_unref(this->Dbus.conn);
- this->Dbus.conn = NULL;
- }
-}
+ Eina_Bool res = EINA_FALSE;
-Eina_Bool EtEventLoop::Init()
-{
- Eina_Bool result = EINA_FALSE;
+ worker.waitTime = E_TEST_WORK_TIME;
- this->log_dom_ = eina_log_domain_register("e-tc", EINA_COLOR_BLUE);
+ logDomain = eina_log_domain_register("e-tc", EINA_COLOR_BLUE);
// Init Ecore_Wl2
if (!ecore_wl2_connected_display_get(NULL))
ecore_wl2_display_connect(NULL);
// init tizen_extension protocol
- result = GetTizenPolicy();
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- result = GetTizenSurface();
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
+ res = initProtocols();
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
// init eldbus
eldbus_init();
- this->Dbus.conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->Dbus.conn, EINA_FALSE);
- this->Dbus.obj = eldbus_object_get(this->Dbus.conn,
- "org.enlightenment.wm",
- "/org/enlightenment/wm");
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->Dbus.obj, EINA_FALSE);
+ dbus.conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.conn, EINA_FALSE);
- this->Dbus.proxy = eldbus_proxy_get(this->Dbus.obj,
- "org.enlightenment.wm.Test");
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->Dbus.proxy, EINA_FALSE);
+ dbus.obj = eldbus_object_get(dbus.conn,
+ "org.enlightenment.wm",
+ "/org/enlightenment/wm");
+ EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.obj, EINA_FALSE);
+
+ dbus.proxy = eldbus_proxy_get(dbus.obj,
+ "org.enlightenment.wm.Test");
+ EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.proxy, EINA_FALSE);
// reset registered window of e_test_helper
- result = this->ResetRegisterWin();
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
+ res = resetRegisterWin();
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
return EINA_TRUE;
}
-void EtEventLoop::Shutdown()
+void
+etRunner::shutdown()
{
- eina_log_domain_unregister(this->log_dom_);
+ eina_log_domain_unregister(logDomain);
- this->FreeLastWinInfoList();
+ freeLastWinInfoList();
// deinit tizen_extension protocol
- if (this->tizen_policy_)
+ if (tzPolicy)
{
- tizen_policy_destroy(this->tizen_policy_);
- this->tizen_policy_ = NULL;
+ tizen_policy_destroy(tzPolicy);
+ tzPolicy = NULL;
}
- if (this->tizen_surface_)
+
+ if (tzSurface)
{
- tizen_surface_destroy(this->tizen_surface_);
- this->tizen_surface_ = NULL;
+ tizen_surface_destroy(tzSurface);
+ tzSurface = NULL;
}
// deinit eldbus
- if (this->Dbus.proxy)
- {
- eldbus_proxy_unref(this->Dbus.proxy);
- this->Dbus.proxy = NULL;
- }
- if (this->Dbus.obj)
- {
- eldbus_object_unref(this->Dbus.obj);
- this->Dbus.obj = NULL;
- }
- if (this->Dbus.conn)
- {
- eldbus_connection_unref(this->Dbus.conn);
- this->Dbus.conn = NULL;
- }
+ eldbus_proxy_unref(dbus.proxy);
+ eldbus_object_unref(dbus.obj);
+ eldbus_connection_unref(dbus.conn);
eldbus_shutdown();
}
-Eina_Bool EtEventLoop::RegisterWin(EtWin *tw)
+Eina_Bool
+etRunner::registerWin(etWin *tw)
{
Eldbus_Pending *p = NULL;
Eina_Bool accepted = EINA_FALSE;
- p = eldbus_proxy_call(this->Dbus.proxy,
+ p = eldbus_proxy_call(dbus.proxy,
"RegisterWindow",
_cb_method_window_register,
&accepted,
return accepted;
}
-Eina_Bool EtEventLoop::DeregisterWin(EtWin *tw)
+Eina_Bool
+etRunner::deregisterWin(etWin *tw)
{
Eldbus_Pending *p = NULL;
Eina_Bool accepted = EINA_FALSE;
- p = eldbus_proxy_call(this->Dbus.proxy,
+ p = eldbus_proxy_call(dbus.proxy,
"DeregisterWindow",
_cb_method_window_register,
&accepted,
return accepted;
}
-Eina_Bool EtEventLoop::ResetRegisterWin()
+Eina_Bool
+etRunner::resetRegisterWin()
{
Eldbus_Pending *p = NULL;
Eina_Bool accepted = EINA_FALSE;
- p = eldbus_proxy_call(this->Dbus.proxy,
+ p = eldbus_proxy_call(dbus.proxy,
"ResetRegisterWindow",
_cb_method_window_register,
&accepted,
return accepted;
}
-Eina_Bool EtEventLoop::SetWinStack(EtWin *tw,
- EtWin *sibiling,
- Eina_Bool above)
+Eina_Bool
+etRunner::setWinStack(etWin *tw,
+ etWin *sibiling,
+ Eina_Bool above)
{
Eldbus_Pending *p = NULL;
- p = eldbus_proxy_call(this->Dbus.proxy,
+ p = eldbus_proxy_call(dbus.proxy,
"SetWindowStack",
NULL,
NULL,
return EINA_TRUE;
}
-Eina_Bool EtEventLoop::SetWinTransientFor(EtWin *tw_child,
- EtWin *tw_parent,
- Eina_Bool set)
+Eina_Bool
+etRunner::setWinTransientFor(etWin *tw_child,
+ etWin *tw_parent,
+ Eina_Bool set)
{
// TODO:: change to send dbus message
EINA_SAFETY_ON_NULL_RETURN_VAL(tw_child, EINA_FALSE);
- if (!this->tizen_policy_)
- this->GetTizenPolicy();
-
if (set)
- {
- tizen_policy_set_transient_for(this->tizen_policy_,
- tw_child->native_win,
- tw_parent->native_win);
- }
+ tizen_policy_set_transient_for(tzPolicy,
+ tw_child->native_win,
+ tw_parent->native_win);
else
- {
- tizen_policy_unset_transient_for(this->tizen_policy_,
- tw_child->native_win);
- }
+ tizen_policy_unset_transient_for(tzPolicy,
+ tw_child->native_win);
return EINA_TRUE;
}
-Eina_Bool EtEventLoop::SetWinNotiLevel(EtWin *tw,
- efl_util_notification_level_e level)
+Eina_Bool
+etRunner::setWinNotiLevel(etWin *tw,
+ efl_util_notification_level_e lv)
{
// TODO:: change to send dbus message
- Eina_Bool result = EINA_FALSE;
+ Eina_Bool res = EINA_FALSE;
EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
- result = efl_util_set_notification_window_level(tw->elm_win, level);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result == EFL_UTIL_ERROR_NONE, EINA_FALSE);
+ res = efl_util_set_notification_window_level(tw->elm_win, lv);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res == EFL_UTIL_ERROR_NONE, EINA_FALSE);
return EINA_TRUE;
}
-efl_util_notification_level_e EtEventLoop::GetWinNotiLevel(EtWin *tw)
+efl_util_notification_level_e
+etRunner::getWinNotiLevel(etWin *tw)
{
// TODO:: change to send dbus message
- Eina_Bool result = EINA_FALSE;
- efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
+ Eina_Bool res = EINA_FALSE;
+ efl_util_notification_level_e lv = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
- result = efl_util_get_notification_window_level(tw->elm_win, &level);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result == EFL_UTIL_ERROR_NONE, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
+ res = efl_util_get_notification_window_level(tw->elm_win, &lv);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res == EFL_UTIL_ERROR_NONE, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
- return level;
+ return lv;
}
-Eina_Bool EtEventLoop::SetZoneRotation(int angle)
+Eina_Bool
+etRunner::setZoneRotation(int angle)
{
Eldbus_Pending *p = NULL;
Eina_Bool allowed = EINA_FALSE;
- p = eldbus_proxy_call(this->Dbus.proxy,
+ p = eldbus_proxy_call(dbus.proxy,
"ChangeZoneRotation",
_cb_method_zone_rotation_change,
&allowed,
return allowed;
}
-Eina_Bool EtEventLoop::GetWinInfo(EtWin *tw)
+Eina_Bool
+etRunner::getWinInfo(etWin *tw)
{
Eldbus_Pending *p = NULL;
Ecore_Window win;
while (retry)
{
- p = eldbus_proxy_call(this->Dbus.proxy,
+ p = eldbus_proxy_call(dbus.proxy,
"GetWinInfo",
_cb_method_win_info_get,
tw,
return EINA_FALSE;
}
-Eina_List *EtEventLoop::GetWinInfoList()
+Eina_List *
+etRunner::getWinInfoList()
{
Eldbus_Pending *p = NULL;
Window_Info_List *info_list = NULL;
- EtWin *tw = NULL;
+ etWin *tw = NULL;
Eina_List *result = NULL;
info_list = E_NEW(Window_Info_List, 1);
while (info_list)
{
- p = eldbus_proxy_call(this->Dbus.proxy,
+ p = eldbus_proxy_call(dbus.proxy,
"GetWinsInfo",
_cb_method_win_info_list_get,
info_list,
if (info_list->retry)
{
info_list->retry = EINA_FALSE;
- EINA_LIST_CAST_FREE(info_list->list, tw, EtWin*)
+ EINA_LIST_CAST_FREE(info_list->list, tw, etWin*)
{
if (tw)
delete tw;
result = eina_list_clone(info_list->list);
E_FREE(info_list);
- this->FreeLastWinInfoList();
- this->last_win_info_list_ = result;
+ freeLastWinInfoList();
+ listWinInfo = result;
return result;
}
-void EtEventLoop::FreeWinInfoList(Eina_List *list)
+void
+etRunner::freeWinInfoList(Eina_List *list)
{
- EtWin *tw = NULL;
+ etWin *tw = NULL;
EINA_SAFETY_ON_NULL_RETURN(list);
- if (this->last_win_info_list_ == list)
- this->last_win_info_list_ = NULL;
+ if (listWinInfo == list)
+ listWinInfo = NULL;
- EINA_LIST_CAST_FREE(list, tw, EtWin*)
+ EINA_LIST_CAST_FREE(list, tw, etWin*)
{
if (tw != NULL)
delete tw;
list = NULL;
}
-Eina_Bool EtEventLoop::SetDpms(Eina_Bool on)
+void
+etRunner::freeLastWinInfoList()
{
- Eldbus_Pending *p = NULL;
- p = eldbus_proxy_call(this->Dbus.proxy,
- "DPMS",
- NULL,
- NULL,
- -1,
- "u",
- on);
- EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
- return EINA_TRUE;
+ if (listWinInfo)
+ freeWinInfoList(listWinInfo);
+
+ listWinInfo = NULL;
}
-Eina_Bool EtEventLoop::FreezeEvent()
+void
+etRunner::setLastWinInfoList(Eina_List *list)
{
- Eldbus_Pending *p = NULL;
- p = eldbus_proxy_call(this->Dbus.proxy,
- "EventFreeze",
- NULL,
- NULL,
- -1,
- "u",
- 1);
- EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
- return EINA_TRUE;
+ EINA_SAFETY_ON_NULL_RETURN(list);
+
+ freeLastWinInfoList();
+
+ listWinInfo = list;
+}
+
+Ecore_Window
+etRunner::getWinId(Evas_Object *elm_win)
+{
+ Ecore_Wl2_Window *wlwin = NULL;
+ struct wl_surface *surf = NULL;
+ Ecore_Window id = 0;
+ struct tizen_resource *tzres = NULL;
+
+ wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(elm_win);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, 0);
+
+ surf = ecore_wl2_window_surface_get(wlwin);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(surf, 0);
+
+ tzres = tizen_surface_get_tizen_resource(tzSurface, surf);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tzres, 0);
+
+ tizen_resource_add_listener(tzres,
+ &_e_test_tizen_resource_listener, &id);
+
+ elm_run();
+
+ if (tzres) tizen_resource_destroy(tzres);
+
+ return id;
}
-Eina_Bool EtEventLoop::ThawEvent()
+Eina_Bool
+etRunner::setDpms(Eina_Bool on)
{
Eldbus_Pending *p = NULL;
- p = eldbus_proxy_call(this->Dbus.proxy,
- "EventFreeze",
+ p = eldbus_proxy_call(dbus.proxy,
+ "DPMS",
NULL,
NULL,
-1,
"u",
- 0);
+ on);
EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
return EINA_TRUE;
}
-Eina_Bool EtEventLoop::FeedMouseDown(int x, int y)
+Eina_Bool
+etRunner::feedMouseDown(int x, int y)
{
Eldbus_Pending *p = NULL;
- p = eldbus_proxy_call(this->Dbus.proxy,
+ p = eldbus_proxy_call(dbus.proxy,
"EventMouse",
NULL,
NULL,
return EINA_TRUE;
}
-Eina_Bool EtEventLoop::FeedMouseMove(int x, int y)
+Eina_Bool
+etRunner::feedMouseMove(int x, int y)
{
Eldbus_Pending *p = NULL;
- p = eldbus_proxy_call(this->Dbus.proxy,
+ p = eldbus_proxy_call(dbus.proxy,
"EventMouse",
NULL,
NULL,
return EINA_TRUE;
}
-Eina_Bool EtEventLoop::FeedMouseUp(int x, int y)
+Eina_Bool
+etRunner::feedMouseUp(int x, int y)
{
Eldbus_Pending *p = NULL;
- p = eldbus_proxy_call(this->Dbus.proxy,
+ p = eldbus_proxy_call(dbus.proxy,
"EventMouse",
NULL,
NULL,
return EINA_TRUE;
}
-Eina_Bool EtEventLoop::FeedKeyDown(const char *key)
+Eina_Bool
+etRunner::feedKeyDown(const char *key)
{
Eldbus_Pending *p = NULL;
- p = eldbus_proxy_call(this->Dbus.proxy,
+ p = eldbus_proxy_call(dbus.proxy,
"EventKey",
NULL,
NULL,
return EINA_TRUE;
}
-Eina_Bool EtEventLoop::FeedKeyUp(const char *key)
+Eina_Bool
+etRunner::feedKeyUp(const char *key)
{
Eldbus_Pending *p = NULL;
- p = eldbus_proxy_call(this->Dbus.proxy,
+ p = eldbus_proxy_call(dbus.proxy,
"EventKey",
NULL,
NULL,
return EINA_TRUE;
}
-void EtEventLoop::SetLastWinInfoList(Eina_List *list)
+Eina_Bool
+etRunner::freezeEvent()
{
- EINA_SAFETY_ON_NULL_RETURN(list);
-
- this->FreeLastWinInfoList();
-
- this->last_win_info_list_ = list;
+ Eldbus_Pending *p = NULL;
+ p = eldbus_proxy_call(dbus.proxy,
+ "EventFreeze",
+ NULL,
+ NULL,
+ -1,
+ "u",
+ 1);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
+ return EINA_TRUE;
}
-void EtEventLoop::FreeLastWinInfoList()
+Eina_Bool
+etRunner::thawEvent()
{
- if (this->last_win_info_list_)
- this->FreeWinInfoList(this->last_win_info_list_);
-
- this->last_win_info_list_ = NULL;
+ Eldbus_Pending *p = NULL;
+ p = eldbus_proxy_call(dbus.proxy,
+ "EventFreeze",
+ NULL,
+ NULL,
+ -1,
+ "u",
+ 0);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
+ return EINA_TRUE;
}
-Eina_Bool EtEventLoop::WaitEvent(E_TC_Event_Type ev)
+Eina_Bool
+etRunner::waitEvent(E_TC_Event_Type ev_type)
{
Eldbus_Signal_Handler *sh;
Eina_Bool res = EINA_FALSE;
- EINA_SAFETY_ON_FALSE_RETURN_VAL((E_TC_EVENT_TYPE_NONE < ev), res);
- EINA_SAFETY_ON_FALSE_RETURN_VAL((E_TC_EVENT_TYPE_MAX > ev), res);
+ 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);
- switch (ev)
+ 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(this->Dbus.proxy,
+ sh = eldbus_proxy_signal_handler_add(dbus.proxy,
"VisibilityChanged",
_cb_signal_vis_changed,
this);
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(this->Dbus.proxy,
+ sh = eldbus_proxy_signal_handler_add(dbus.proxy,
"StackChanged",
_cb_signal_stack_changed,
this);
break;
case E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE:
- sh = eldbus_proxy_signal_handler_add(this->Dbus.proxy,
+ sh = eldbus_proxy_signal_handler_add(dbus.proxy,
"WinRotationChanged",
_cb_signal_win_rot_changed,
this);
break;
case E_TC_EVENT_TYPE_FOCUS_CHANGED:
- sh = eldbus_proxy_signal_handler_add(this->Dbus.proxy,
+ sh = eldbus_proxy_signal_handler_add(dbus.proxy,
"FocusChanged",
_cb_signal_focus_changed,
this);
break;
}
- if (this->Ev.expire_timer)
- ecore_timer_del(this->Ev.expire_timer);
+ if (ev.expire_timer)
+ ecore_timer_del(ev.expire_timer);
- this->Ev.expect = ev;
- this->Ev.response = E_TC_EVENT_TYPE_NONE;
- this->Ev.expire_timer = ecore_timer_add(5.0, _ev_wait_timeout, this);
+ ev.request = ev_type;
+ ev.response = E_TC_EVENT_TYPE_NONE;
+ ev.expire_timer = ecore_timer_add(5.0, _ev_wait_timeout, this);
elm_run();
- if (this->Ev.expire_timer)
+ if (ev.expire_timer)
{
- ecore_timer_del(this->Ev.expire_timer);
- this->Ev.expire_timer = NULL;
+ ecore_timer_del(ev.expire_timer);
+ ev.expire_timer = NULL;
}
eldbus_signal_handler_del(sh);
- res = (this->Ev.response == this->Ev.expect);
+ res = (ev.response == ev.request);
EINA_SAFETY_ON_FALSE_GOTO(res, finish);
finish:
- this->Ev.expect = E_TC_EVENT_TYPE_NONE;
- this->Ev.response = E_TC_EVENT_TYPE_NONE;
+ ev.request = E_TC_EVENT_TYPE_NONE;
+ ev.response = E_TC_EVENT_TYPE_NONE;
return res;
}
-void EtEventLoop::Work()
+void
+etRunner::work()
{
/* give a turn to deal with deferred job for E_TEST_WORK_TIME */
- this->Worker.work_timer_ = ecore_timer_add(this->Worker.time_for_wait_work_, _cb_work_timeout, this);
+ worker.timer = ecore_timer_add(worker.waitTime,
+ _cb_work_timeout,
+ this);
elm_run();
}
-void EtEventLoop::FinishWork()
+void
+etRunner::finishWork()
{
- if (this->Worker.work_timer_)
+ if (worker.timer)
{
- ecore_timer_del(this->Worker.work_timer_);
- this->Worker.work_timer_ = NULL;
+ ecore_timer_del(worker.timer);
+ worker.timer = NULL;
}
elm_exit();
}
-void EtEventLoop::PrintWinInfoList()
+void
+etRunner::printWinInfoList()
{
- EtWin *tw = NULL;
+ etWin *tw = NULL;
Eina_List *l = NULL, *ll = NULL;
printf("--------------------------------------------------------------------------------------------------------------------------\n");
- l = this->GetWinInfoList();
- EINA_LIST_CAST_FOREACH(l, ll, tw, EtWin*)
+ l = getWinInfoList();
+ EINA_LIST_CAST_FOREACH(l, ll, tw, etWin*)
{
printf("%04d WinID:%5u alpha:%d %5d,%5d (%5dx%5d) vis(Win:%d Obj:%d Opaque:%2d Type:%2d Skip:%d) Icon:%d Focus(Win:%d Obj:%d) :: %20s\n",
tw->layer,
tw->Focus.obj,
tw->name);
}
- this->FreeWinInfoList(l);
+ freeWinInfoList(l);
printf("--------------------------------------------------------------------------------------------------------------------------\n");
}
-void EtEventLoop::DelTimer()
-{
- if (this->Worker.work_timer_)
- {
- ecore_timer_del(this->Worker.work_timer_);
- this->Worker.work_timer_ = NULL;
- }
-}
-
-void EtEventLoop::RunTimer()
+void
+etRunner::delTimer()
{
- if (this->Worker.work_timer_)
- this->DelTimer();
+ if (!worker.timer) return;
- this->Worker.work_timer_ = ecore_timer_add(this->Worker.time_for_wait_work_, _cb_work_timeout, this);
+ ecore_timer_del(worker.timer);
+ worker.timer = NULL;
}
-void EtEventLoop::WaitForDestroy()
+void
+etRunner::addTimer()
{
- this->SetWaitWorkTime(E_TEST_WORK_TIME);
- this->RunTimer();
- elm_run();
+ delTimer();
+
+ worker.timer = ecore_timer_add(worker.waitTime,
+ _cb_work_timeout,
+ this);
}
-Ecore_Window EtEventLoop::GetWinId(Evas_Object *elm_win)
+void
+etRunner::waitForDestroy()
{
- Ecore_Wl2_Window *wlwin = NULL;
- struct wl_surface *surf = NULL;
- Ecore_Window id = 0;
- struct tizen_resource *tzres = NULL;
-
- wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(elm_win);
- EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, 0);
-
- surf = ecore_wl2_window_surface_get(wlwin);
- EINA_SAFETY_ON_NULL_RETURN_VAL(surf, 0);
-
- if (!this->tizen_surface_)
- this->GetTizenSurface();
-
- tzres = tizen_surface_get_tizen_resource(this->tizen_surface_, surf);
- EINA_SAFETY_ON_NULL_RETURN_VAL(tzres, 0);
-
- tizen_resource_add_listener(tzres,
- &_e_test_tizen_resource_listener, &id);
+ setWaitTime(E_TEST_WORK_TIME);
+ addTimer();
elm_run();
-
- if (tzres) tizen_resource_destroy(tzres);
-
- return id;
}
-Eina_Bool EtEventLoop::GetTizenPolicy()
+Eina_Bool
+etRunner::initProtocols()
{
Eina_Iterator *globals = NULL;
Ecore_Wl2_Global *global = NULL;
struct wl_registry *registry = NULL;
- if (!this->tizen_policy_)
- {
- registry = ecore_wl2_display_registry_get(ecore_wl2_connected_display_get(NULL));
- globals = ecore_wl2_display_globals_get(ecore_wl2_connected_display_get(NULL));
+ registry = ecore_wl2_display_registry_get(ecore_wl2_connected_display_get(NULL));
+ globals = ecore_wl2_display_globals_get(ecore_wl2_connected_display_get(NULL));
- EINA_SAFETY_ON_NULL_RETURN_VAL(registry, EINA_FALSE);
- EINA_SAFETY_ON_NULL_RETURN_VAL(globals, EINA_FALSE);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(registry, EINA_FALSE);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(globals, EINA_FALSE);
- EINA_ITERATOR_FOREACH(globals, global)
+ EINA_ITERATOR_FOREACH(globals, global)
+ {
+ if (!strcmp(global->interface, "tizen_policy"))
{
- if (!strcmp(global->interface, "tizen_policy"))
- {
- this->tizen_policy_ = (struct tizen_policy *)
- wl_registry_bind(registry,
- global->id,
- &tizen_policy_interface,
- (global->version > 7)? 7 : global->version);
- }
+ tzPolicy = (struct tizen_policy *)
+ wl_registry_bind(registry,
+ global->id,
+ &tizen_policy_interface,
+ (global->version > 7)? 7 : global->version);
}
-
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->tizen_policy_, EINA_FALSE);
- }
-
- return EINA_TRUE;
-}
-
-Eina_Bool EtEventLoop::GetTizenSurface()
-{
- Eina_Iterator *globals = NULL;
- Ecore_Wl2_Global *global = NULL;
- struct wl_registry *registry = NULL;
-
- if (!this->tizen_surface_)
- {
- registry = ecore_wl2_display_registry_get(ecore_wl2_connected_display_get(NULL));
- globals = ecore_wl2_display_globals_get(ecore_wl2_connected_display_get(NULL));
-
- EINA_SAFETY_ON_NULL_RETURN_VAL(registry, EINA_FALSE);
- EINA_SAFETY_ON_NULL_RETURN_VAL(globals, EINA_FALSE);
-
- EINA_ITERATOR_FOREACH(globals, global)
+ if (!strcmp(global->interface, "tizen_surface"))
{
- if (!strcmp(global->interface, "tizen_surface"))
- {
- this->tizen_surface_ = (struct tizen_surface *)
- wl_registry_bind(registry,
- global->id,
- &tizen_surface_interface,
- (global->version > 1)? 1 : global->version);
- }
+ tzSurface = (struct tizen_surface *)
+ wl_registry_bind(registry,
+ global->id,
+ &tizen_surface_interface,
+ (global->version > 1)? 1 : global->version);
}
-
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->tizen_surface_, EINA_FALSE);
}
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tzPolicy, EINA_FALSE);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tzSurface, EINA_FALSE);
+
return EINA_TRUE;
}
/* callbacks - method */
-static void _cb_method_win_info_get(void *data,
- const Eldbus_Message *msg,
- Eldbus_Pending *p)
+static void
+_cb_method_win_info_get(void *data,
+ const Eldbus_Message *msg,
+ Eldbus_Pending *p)
{
const char *name = NULL, *text = NULL, *wname = NULL;
- EtWin *tw = NULL;
+ etWin *tw = NULL;
Eina_Bool res = EINA_FALSE;
- tw = (EtWin *)data;
+ tw = (etWin *)data;
res = eldbus_message_error_get(msg, &name, &text);
EINA_SAFETY_ON_TRUE_GOTO(res, finish);
elm_exit();
}
-static void _cb_method_win_info_list_get(void *data,
- const Eldbus_Message *msg,
- Eldbus_Pending *p)
+static void
+_cb_method_win_info_list_get(void *data,
+ const Eldbus_Message *msg,
+ Eldbus_Pending *p)
{
const char *name = NULL, *text = NULL, *wname = NULL;
Eldbus_Message_Iter *array = NULL, *ec = NULL;
while (eldbus_message_iter_get_and_next(array, 'r', &ec))
{
- EtWin *tw = new EtWin();
+ etWin *tw = new etWin();
if (!tw) continue;
res = eldbus_message_iter_arguments_get(
elm_exit();
}
-static void _cb_method_zone_rotation_change(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)
{
const char *name = NULL, *text = NULL;
Eina_Bool res = EINA_FALSE;
elm_exit();
}
-static void _cb_signal_vis_changed(void *data,
- const Eldbus_Message *msg)
+static void
+_cb_signal_vis_changed(void *data,
+ const Eldbus_Message *msg)
{
- EtEventLoop *runner = (EtEventLoop *)data;
+ etRunner *runner = (etRunner *)data;
const char *name = NULL, *text = NULL;
Eina_Bool res = EINA_FALSE;
int vis = 0;
EINA_SAFETY_ON_FALSE_GOTO(res, finish);
/* TODO */
- if (((E_TC_EVENT_TYPE_VIS_ON == runner->Ev.expect) && (vis)) ||
- ((E_TC_EVENT_TYPE_VIS_OFF == runner->Ev.expect) && (!vis)) ||
- (E_TC_EVENT_TYPE_VIS_CHANGED == runner->Ev.expect))
+ 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.expect;
+ runner->ev.response = runner->ev.request;
elm_exit();
}
}
}
-static void _cb_signal_stack_changed(void *data,
- const Eldbus_Message *msg)
+static void
+_cb_signal_stack_changed(void *data,
+ const Eldbus_Message *msg)
{
- EtEventLoop *runner = (EtEventLoop *)data;
+ etRunner *runner = (etRunner *)data;
const char *name = NULL, *text = NULL;
Eina_Bool res = EINA_FALSE;
EINA_SAFETY_ON_TRUE_GOTO(res, finish);
/* TODO */
- if ((E_TC_EVENT_TYPE_STACK_RAISE <= runner->Ev.expect) &&
- (E_TC_EVENT_TYPE_STACK_BELOW >= runner->Ev.expect))
+ if ((E_TC_EVENT_TYPE_STACK_RAISE <= runner->ev.request) &&
+ (E_TC_EVENT_TYPE_STACK_BELOW >= runner->ev.request))
{
- runner->Ev.response = runner->Ev.expect;
+ runner->ev.response = runner->ev.request;
elm_exit();
}
}
}
-static void _cb_signal_win_rot_changed(void *data,
- const Eldbus_Message *msg)
+static void
+_cb_signal_win_rot_changed(void *data,
+ const Eldbus_Message *msg)
{
- EtEventLoop *runner = (EtEventLoop *)data;
+ etRunner *runner = (etRunner *)data;
const char *name = NULL, *text = NULL;
Eina_Bool res = EINA_FALSE;
int angle = 0;
res = eldbus_message_arguments_get(msg, "ui", &id, &angle);
EINA_SAFETY_ON_FALSE_GOTO(res, finish);
- runner->Ev.response = runner->Ev.expect;
+ runner->ev.response = runner->ev.request;
elm_exit();
finish:
}
}
-static void _cb_signal_focus_changed(void *data,
- const Eldbus_Message *msg)
+static void
+_cb_signal_focus_changed(void *data,
+ const Eldbus_Message *msg)
{
- EtEventLoop *runner = (EtEventLoop *)data;
+ etRunner *runner = (etRunner *)data;
const char *name = NULL, *text = NULL;
Eina_Bool res = EINA_FALSE;
res = eldbus_message_error_get(msg, &name, &text);
EINA_SAFETY_ON_TRUE_GOTO(res, finish);
- if (E_TC_EVENT_TYPE_FOCUS_CHANGED == runner->Ev.expect)
+ if (E_TC_EVENT_TYPE_FOCUS_CHANGED == runner->ev.request)
{
- runner->Ev.response = runner->Ev.expect;
+ runner->ev.response = runner->ev.request;
elm_exit();
}
}
}
-static Eina_Bool _cb_work_timeout(void *data)
+static Eina_Bool
+_cb_work_timeout(void *data)
{
- EtEventLoop *ev_loop = (EtEventLoop *)data;
-
- ev_loop->FinishWork();
-
+ etRunner *ev_loop = (etRunner *)data;
+ ev_loop->finishWork();
return ECORE_CALLBACK_CANCEL;
}
-static Eina_Bool _ev_wait_timeout(void *data)
+static Eina_Bool
+_ev_wait_timeout(void *data)
{
- EtEventLoop *runner = (EtEventLoop *)data;
+ etRunner *runner = (etRunner *)data;
- runner->Ev.expire_timer = NULL;
- runner->Ev.response = E_TC_EVENT_TYPE_TIMEOUT;
+ runner->ev.expire_timer = NULL;
+ runner->ev.response = E_TC_EVENT_TYPE_TIMEOUT;
- ERR("ev:%d\n", runner->Ev.expect);
+ ERR("ev:%d\n", runner->ev.request);
elm_exit();
return ECORE_CALLBACK_DONE;
}
-
#include "e_test_util.h"
#include "e_test_win.h"
-class EtEventLoop
+class etRunner
{
- public: // TODO:: Change to private and add getter & setter
- Eina_List *last_win_info_list_ = NULL;
-
- struct tizen_policy *tizen_policy_ = NULL;
- struct tizen_surface *tizen_surface_ = NULL;
-
- int log_dom_ = -1;
-
- struct
- {
- Ecore_Timer *expire_timer;
- E_TC_Event_Type expect;
- E_TC_Event_Type response;
- } Ev;
-
- struct
- {
- Ecore_Timer *work_timer_;
- double time_for_wait_work_;
- } Worker;
-
- struct
- {
- Eldbus_Connection *conn;
- Eldbus_Proxy *proxy;
- Eldbus_Object *obj;
- } Dbus;
-
- public:
- /* initializer */
- EtEventLoop();
-
- /* deinitializer */
- ~EtEventLoop();
-
- /* requests */
- Eina_Bool RegisterWin(EtWin *tw);
- Eina_Bool DeregisterWin(EtWin *tw);
- Eina_Bool ResetRegisterWin();
- Eina_Bool SetWinStack(EtWin *tw,
- EtWin *sibiling,
- Eina_Bool above);
- Eina_Bool SetWinTransientFor(EtWin *tw_child,
- EtWin *tw_parent,
- Eina_Bool set);
- Eina_Bool SetWinNotiLevel(EtWin *tw,
- efl_util_notification_level_e level);
- efl_util_notification_level_e GetWinNotiLevel(EtWin *tw);
- Eina_Bool SetZoneRotation(int angle);
- Eina_Bool GetWinInfo(EtWin *tw);
- Eina_List *GetWinInfoList();
- void FreeWinInfoList(Eina_List *list);
- Ecore_Window GetWinId(Evas_Object *elm_win);
- Eina_Bool SetDpms(Eina_Bool on);
- Eina_Bool FreezeEvent();
- Eina_Bool ThawEvent();
- Eina_Bool FeedMouseDown(int x, int y);
- Eina_Bool FeedMouseMove(int x, int y);
- Eina_Bool FeedMouseUp(int x, int y);
- Eina_Bool FeedKeyDown(const char *key);
- Eina_Bool FeedKeyUp(const char *key);
- Eina_Bool HasLastWinInfoList() { return !!this->last_win_info_list_; };
- void SetLastWinInfoList(Eina_List *list);
- void FreeLastWinInfoList();
-
- /* events */
- Eina_Bool WaitEvent(E_TC_Event_Type ev);
-
- /* methods */
- Eina_Bool Init();
- void Shutdown();
- void Work();
- void FinishWork();
- void PrintWinInfoList();
- void SetWaitWorkTime(double time) { this->Worker.time_for_wait_work_ = time; };
- void DelTimer();
- void RunTimer();
- void WaitForDestroy();
-
- /* getter & setter */
- Eldbus_Connection *GetEldbusConnection() { return this->Dbus.conn; };
- Eldbus_Proxy *GetEldbusProxy() { return this->Dbus.proxy; };
- Eldbus_Object *GetEldbusObject() { return this->Dbus.obj; };
- void SetEldbusConnection(Eldbus_Connection *conn) { this->Dbus.conn = conn; };
- void SetEldbusProxy(Eldbus_Proxy *proxy) { this->Dbus.proxy = proxy; };
- void SetEldbusObject(Eldbus_Object *obj) { this->Dbus.obj = obj; };
- int GetLogDomain() { return this->log_dom_; };
-
- protected:
- Eina_Bool GetTizenPolicy();
- Eina_Bool GetTizenSurface();
+private:
+ etRunner()
+ {
+ worker.timer = NULL;
+ worker.waitTime = 0.0;
+ tzPolicy = NULL;
+ tzSurface = NULL;
+ ev.expire_timer = NULL;
+ ev.request = E_TC_EVENT_TYPE_NONE;
+ ev.response = E_TC_EVENT_TYPE_NONE;
+ logDomain = 0;
+ dbus.obj = NULL;
+ listWinInfo = NULL;
+ };
+
+ ~etRunner() {}
+
+ static etRunner inst;
+
+public:
+ static etRunner &get() { return inst; }
+
+private:
+ int logDomain;
+ struct
+ {
+ Ecore_Timer *timer;
+ double waitTime;
+ } worker;
+
+ struct
+ {
+ Eldbus_Connection *conn;
+ Eldbus_Proxy *proxy;
+ Eldbus_Object *obj;
+ } dbus;
+
+ struct tizen_policy *tzPolicy;
+ struct tizen_surface *tzSurface;
+
+ Eina_List *listWinInfo;
+
+public: /* TODO: make it hidden */
+ struct
+ {
+ Ecore_Timer *expire_timer;
+ E_TC_Event_Type request;
+ E_TC_Event_Type response;
+ } ev;
+
+public:
+ Eina_Bool init();
+ void shutdown();
+ void work();
+ void finishWork();
+ void printWinInfoList();
+ void setWaitTime(double time) { worker.waitTime = time; };
+ void delTimer();
+ void addTimer();
+ void waitForDestroy();
+
+ Eina_Bool registerWin(etWin *tw);
+ Eina_Bool deregisterWin(etWin *tw);
+ Eina_Bool resetRegisterWin();
+ Eina_Bool setWinStack(etWin *tw, etWin *sibiling, Eina_Bool above);
+ Eina_Bool setWinTransientFor(etWin *tw_child, etWin *tw_parent, Eina_Bool set);
+ Eina_Bool setWinNotiLevel(etWin *tw, efl_util_notification_level_e lv);
+ efl_util_notification_level_e getWinNotiLevel(etWin *tw);
+ Eina_Bool setZoneRotation(int angle);
+ Eina_Bool getWinInfo(etWin *tw);
+ Eina_List *getWinInfoList();
+ void freeWinInfoList(Eina_List *list);
+ void freeLastWinInfoList();
+ Eina_Bool hasLastWinInfoList() { return !!listWinInfo; };
+ void setLastWinInfoList(Eina_List *list);
+ Ecore_Window getWinId(Evas_Object *elm_win);
+ Eina_Bool setDpms(Eina_Bool on);
+ Eina_Bool feedMouseDown(int x, int y);
+ Eina_Bool feedMouseMove(int x, int y);
+ Eina_Bool feedMouseUp(int x, int y);
+ Eina_Bool feedKeyDown(const char *key);
+ Eina_Bool feedKeyUp(const char *key);
+ Eina_Bool freezeEvent();
+ Eina_Bool thawEvent();
+ Eina_Bool waitEvent(E_TC_Event_Type ev);
+
+ Eldbus_Proxy *getDbusProxy() { return dbus.proxy; }
+ Eldbus_Object *getDbusObject() { return dbus.obj; }
+ int getLogDomain() { return logDomain; }
+
+protected:
+ Eina_Bool initProtocols();
};
#endif // end of __ET_EVENT_LOOP_H__
-/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * @file e_test_main.cpp
- * @author Window System
- * @version 1.0
- * @brief Enlightenment Unit_test with gtest framework
- */
-
#include "e_test_event.h"
#include <gtest/gtest.h>
using ::testing::Test;
-EtEventLoop *gLoop = NULL;
-
-int _GetLogDomain() { return gLoop->GetLogDomain(); } // wrapper func for EINA_LOG
-
-int
-elm_main(int argc, char **argv) {
+EAPI_MAIN int
+elm_main(int argc, char **argv)
+{
int ret = 0;
+ Eina_Bool res;
- gLoop = new EtEventLoop();
- gLoop->Init();
+ res = etRunner::get().init();
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, 1);
::testing::InitGoogleTest(&argc, argv);
ret = RUN_ALL_TESTS();
- gLoop->Shutdown();
-
- delete gLoop;
+ etRunner::get().shutdown();
return ret;
}
-ELM_MAIN();
+ELM_MAIN()
#include <wayland-client.h>
#include <tizen-extension-client-protocol.h>
-int _GetLogDomain();
-
#ifdef ERR
# undef ERR
#endif
-#define ERR(...) EINA_LOG_DOM_ERR(_GetLogDomain(), __VA_ARGS__)
+#define ERR(...) EINA_LOG_DOM_ERR(etRunner::get().getLogDomain(), __VA_ARGS__)
#ifdef DBG
# undef DBG
#endif
-#define DBG(...) EINA_LOG_DOM_DBG(_GetLogDomain(), __VA_ARGS__)
+#define DBG(...) EINA_LOG_DOM_DBG(etRunner::get().getLogDomain(), __VA_ARGS__)
#ifdef INF
# undef INF
#endif
-#define INF(...) EINA_LOG_DOM_INFO(_GetLogDomain(), __VA_ARGS__)
+#define INF(...) EINA_LOG_DOM_INFO(etRunner::get().getLogDomain(), __VA_ARGS__)
#ifdef WRN
# undef WRN
#endif
-#define WRN(...) EINA_LOG_DOM_WARN(_GetLogDomain(), __VA_ARGS__)
+#define WRN(...) EINA_LOG_DOM_WARN(etRunner::get().getLogDomain(), __VA_ARGS__)
#ifdef CRI
# undef CRI
#endif
-#define CRI(...) EINA_LOG_DOM_CRIT(_GetLogDomain(), __VA_ARGS__)
+#define CRI(...) EINA_LOG_DOM_CRIT(etRunner::get().getLogDomain(), __VA_ARGS__)
#ifdef E_NEW
# undef E_NEW
#include "e_test_win.h"
/**********************
- class EtWin
+ class etWin
**********************/
-EtWin::EtWin()
+etWin::etWin()
{
// nothing to do. you should use initializer with args.
- this->elm_win = NULL;
- this->animating = EINA_FALSE;
- this->native_win = 0;
+ elm_win = NULL;
+ animating = EINA_FALSE;
+ native_win = 0;
}
-EtWin::~EtWin()
+etWin::~etWin()
{
- this->DeInit();
+ deInit();
}
-Eina_Bool EtWin::Init(EtWin *parent,
- Elm_Win_Type type,
- Eina_Bool alpha,
- const char *name,
- int x, int y,
- int w, int h,
- Eina_Bool usr_geom,
- E_Layer layer,
- E_TC_Win_Color color)
+Eina_Bool
+etWin::init(etWin *parent,
+ Elm_Win_Type type,
+ Eina_Bool alpha,
+ const char *name,
+ int x, int y,
+ int w, int h,
+ Eina_Bool usr_geom,
+ E_Layer layer,
+ E_TC_Win_Color color)
{
Evas_Object *bg = NULL;
int screen_width = 0, screen_height = 0;
- this->parent = parent;
+ parent = parent;
- this->elm_win = elm_win_add(NULL, name, type);
- EINA_SAFETY_ON_NULL_GOTO(this->elm_win, error);
+ elm_win = elm_win_add(NULL, name, type);
+ EINA_SAFETY_ON_NULL_GOTO(elm_win, error);
if (alpha)
- elm_win_alpha_set(this->elm_win, EINA_TRUE);
+ elm_win_alpha_set(elm_win, EINA_TRUE);
- elm_win_title_set(this->elm_win, name);
- elm_win_autodel_set(this->elm_win, EINA_FALSE);
- elm_win_borderless_set(this->elm_win, EINA_TRUE);
+ elm_win_title_set(elm_win, name);
+ elm_win_autodel_set(elm_win, EINA_FALSE);
+ elm_win_borderless_set(elm_win, EINA_TRUE);
if (usr_geom)
elm_win_aux_hint_add(elm_win, "wm.policy.win.user.geometry", "1");
- bg = elm_bg_add(this->elm_win);
+ bg = elm_bg_add(elm_win);
evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
elm_win_resize_object_add(elm_win, bg);
}
evas_object_show(bg);
- elm_win_screen_size_get(this->elm_win, NULL, NULL, &screen_width, &screen_height);
+ elm_win_screen_size_get(elm_win, NULL, NULL, &screen_width, &screen_height);
goto finish;
error:
// TODO:: add error case
- printf("ERROR OCCURED IN EtWin INITIALIZATION\n");
+ printf("ERROR OCCURED IN etWin INITIALIZATION\n");
return EINA_FALSE;
finish:
// set information
- this->animating = EINA_FALSE;
- this->native_win = 0; // TODO:: get Ecore_Window from static get_win_id function
- this->name = eina_stringshare_add(name);
- this->x = usr_geom? x : 0;
- this->y = usr_geom? y : 0;
- this->w = usr_geom? w : screen_width;
- this->h = usr_geom? h : screen_height;
+ animating = EINA_FALSE;
+ native_win = 0; // TODO:: get Ecore_Window from static get_win_id function
+ name = eina_stringshare_add(name);
+ this->x = usr_geom ? x : 0;
+ this->y = usr_geom ? y : 0;
+ this->w = usr_geom ? w : screen_width;
+ this->h = usr_geom ? h : screen_height;
return EINA_TRUE;
}
-void EtWin::DeInit()
+void etWin::deInit()
{
- if (this->elm_win)
+ if (elm_win)
{
- evas_object_del(this->elm_win);
- this->elm_win = NULL;
+ evas_object_del(elm_win);
+ elm_win = NULL;
}
- if (this->name)
+ if (name)
{
eina_stringshare_del(name);
- this->name = NULL;
+ name = NULL;
}
}
#include "e_test_util.h"
-class EtWin
+class etWin
{
- public: // TODO:: Change to private and add getter & setter
- EtWin *parent = NULL;
- Evas_Object *elm_win = NULL;
- Eina_Bool animating = EINA_FALSE;
- Ecore_Window native_win = 0;
- const char *name = NULL;
- int x = 0, y = 0, w = 0, h = 0;
- int rot = 0;
- E_Layer layer = E_LAYER_CLIENT_NORMAL;
- Eina_Bool effect = EINA_FALSE;
- struct
- {
- Eina_Bool win = EINA_FALSE;
- Eina_Bool obj = EINA_FALSE;
- int opaque = 0;
- E_Visibility type = E_VISIBILITY_UNKNOWN;
- Eina_Bool skip = EINA_FALSE;
- } Vis;
- Eina_Bool iconic = EINA_FALSE;
- Eina_Bool alpha = EINA_FALSE;
- struct
- {
- Eina_Bool win = EINA_FALSE;
- Eina_Bool obj = EINA_FALSE;
- } Focus;
+public: // TODO:: Change to private and add getter & setter
+ etWin *parent = NULL;
+ Evas_Object *elm_win = NULL;
+ Eina_Bool animating = EINA_FALSE;
+ Ecore_Window native_win = 0;
+ const char *name = NULL;
+ int x = 0, y = 0, w = 0, h = 0;
+ int rot = 0;
+ E_Layer layer = E_LAYER_CLIENT_NORMAL;
+ Eina_Bool effect = EINA_FALSE;
+ struct
+ {
+ Eina_Bool win = EINA_FALSE;
+ Eina_Bool obj = EINA_FALSE;
+ int opaque = 0;
+ E_Visibility type = E_VISIBILITY_UNKNOWN;
+ Eina_Bool skip = EINA_FALSE;
+ } Vis;
+ Eina_Bool iconic = EINA_FALSE;
+ Eina_Bool alpha = EINA_FALSE;
+ struct
+ {
+ Eina_Bool win = EINA_FALSE;
+ Eina_Bool obj = EINA_FALSE;
+ } Focus;
- public:
- EtWin();
- ~EtWin();
+public:
+ etWin();
+ ~etWin();
- /* methods */
- Eina_Bool Init(EtWin *parent,
- Elm_Win_Type type,
- Eina_Bool alpha,
- const char *name,
- int x, int y, int w, int h,
- Eina_Bool usr_geom,
- E_Layer layer,
- E_TC_Win_Color color);
- void DeInit();
- void UpdateGeometry()
- {
- EINA_SAFETY_ON_NULL_RETURN(elm_win);
- evas_object_move(elm_win, x, y);
- evas_object_resize(elm_win, w, h);
- }
- void Show()
- {
- EINA_SAFETY_ON_NULL_RETURN(elm_win);
- evas_object_show(elm_win);
- }
- void Hide()
- {
- EINA_SAFETY_ON_NULL_RETURN(elm_win);
- evas_object_hide(elm_win);
- }
+ /* methods */
+ Eina_Bool init(etWin *parent,
+ Elm_Win_Type type,
+ Eina_Bool alpha,
+ const char *name,
+ int x, int y, int w, int h,
+ Eina_Bool usr_geom,
+ E_Layer layer,
+ E_TC_Win_Color color);
+ void deInit();
+ void updateGeometry()
+ {
+ EINA_SAFETY_ON_NULL_RETURN(elm_win);
+ evas_object_move(elm_win, x, y);
+ evas_object_resize(elm_win, w, h);
+ }
+ void show()
+ {
+ EINA_SAFETY_ON_NULL_RETURN(elm_win);
+ evas_object_show(elm_win);
+ }
+ void hide()
+ {
+ EINA_SAFETY_ON_NULL_RETURN(elm_win);
+ evas_object_hide(elm_win);
+ }
- /* getter&setter */
- Evas_Object *GetElmWin()
- {
- return elm_win;
- }
- Ecore_Window GetNativeWin()
- {
- return native_win;
- }
-
- protected:
+ /* getter&setter */
+ Evas_Object *getElmWin() { return elm_win; }
+ Ecore_Window getNativeWin() { return native_win; }
};
#endif // end of __ET_WIN_H__
using ::testing::Test;
-extern EtEventLoop *gLoop;
-
-class EtTestEasy : public ::testing::Test
+class etTestEasy : public ::testing::Test
{
- public:
- EtTestEasy()
- {
- };
- ~EtTestEasy()
- {
- if (HasFailure())
- gLoop->WaitForDestroy();
- };
-
- protected:
- static void SetUpTestCase() {};
- static void TearDownTestCase() {};
+public:
+ etTestEasy() { };
+ ~etTestEasy()
+ {
+ if (HasFailure()) etRunner::get().waitForDestroy();
+ };
};
static void
const Eldbus_Message *msg,
Eldbus_Pending *pending EINA_UNUSED)
{
- Eina_Bool *result = (Eina_Bool *)data;
+ Eina_Bool *ret = (Eina_Bool *)data;
const char *arg, *name = NULL, *text = NULL;
Eina_Bool res;
goto finish;
}
- *result = EINA_TRUE;
+ *ret = EINA_TRUE;
finish:
- if (*result == EINA_FALSE)
+ if (*ret == EINA_FALSE)
ERR("errname:%s errmsg:%s\n", name, text);
- gLoop->FinishWork();
+ etRunner::get().finishWork();
}
static void
const Eldbus_Message *msg,
Eldbus_Pending *p EINA_UNUSED)
{
- Eina_Bool *result = (Eina_Bool *)data;
+ Eina_Bool *ret = (Eina_Bool *)data;
const char *name = NULL, *text = NULL;
Eldbus_Message_Iter *variant = NULL;
Ecore_Window win;
Eina_Bool res;
char *type;
- EINA_SAFETY_ON_NULL_GOTO(result, finish);
+ EINA_SAFETY_ON_NULL_GOTO(ret, err_null);
- *result = EINA_FALSE;
+ *ret = EINA_FALSE;
res = eldbus_message_error_get(msg, &name, &text);
EINA_SAFETY_ON_TRUE_GOTO(res, finish);
EINA_SAFETY_ON_FALSE_GOTO(res, finish);
EINA_SAFETY_ON_FALSE_GOTO((win == _WIN_ID), finish);
- *result = EINA_TRUE;
+ *ret = EINA_TRUE;
finish:
- if (!(*result))
+ if ((*ret) == EINA_FALSE)
{
ERR("errname:%s errmsg:%s\n", name, text);
}
- gLoop->FinishWork();
+err_null:
+ etRunner::get().finishWork();
}
-TEST_F(EtTestEasy, base_pass)
+TEST_F(etTestEasy, base_pass)
{
- Eina_Bool result = EINA_TRUE;
+ Eina_Bool res = EINA_TRUE;
- ASSERT_TRUE(result);
+ ASSERT_TRUE(res);
}
-TEST_F(EtTestEasy, base_fail)
+TEST_F(etTestEasy, base_fail)
{
- Eina_Bool result = EINA_FALSE;
+ Eina_Bool res = EINA_FALSE;
- ASSERT_FALSE(result);
+ ASSERT_FALSE(res);
}
-TEST_F(EtTestEasy, introspect)
+TEST_F(etTestEasy, introspect)
{
- Eina_Bool result = EINA_FALSE;
+ Eina_Bool res = EINA_FALSE;
Eldbus_Pending *p = NULL;
Eldbus_Object *obj = NULL;
- obj = gLoop->GetEldbusObject();
+ obj = etRunner::get().getDbusObject();
ASSERT_TRUE(obj != NULL);
p = eldbus_object_introspect(obj,
_cb_introspect,
- &result);
+ &res);
ASSERT_TRUE(p != NULL);
- gLoop->Work();
- ASSERT_TRUE(result);
+ etRunner::get().work();
+ ASSERT_TRUE(res);
}
-TEST_F(EtTestEasy, win_register)
+TEST_F(etTestEasy, win_register)
{
- Eina_Bool result = EINA_FALSE;
+ Eina_Bool res = EINA_FALSE;
Eldbus_Pending *p = NULL;
- EtWin *tw = new EtWin();
+ etWin *tw = new etWin();
ASSERT_TRUE(tw != NULL);
tw->native_win = _WIN_ID;
- result = gLoop->RegisterWin(tw);
- ASSERT_TRUE(result);
+ res = etRunner::get().registerWin(tw);
+ ASSERT_TRUE(res);
- p = eldbus_proxy_property_get(gLoop->GetEldbusProxy(),
+ p = eldbus_proxy_property_get(etRunner::get().getDbusProxy(),
"Registrant",
_cb_prop_registrant,
- &result);
+ &res);
ASSERT_TRUE(p != NULL);
- gLoop->Work();
- ASSERT_TRUE(result);
+ etRunner::get().work();
+ ASSERT_TRUE(res);
- result = gLoop->DeregisterWin(tw);
- ASSERT_TRUE(result);
+ res = etRunner::get().deregisterWin(tw);
+ ASSERT_TRUE(res);
}
using ::testing::Test;
-extern EtEventLoop *gLoop;
-
-class EtTestBaseOperation : public ::testing::Test
+class etTestBaseOperation : public ::testing::Test
{
- public:
- EtTestBaseOperation()
- {
- };
- ~EtTestBaseOperation()
- {
- if (HasFailure())
- gLoop->WaitForDestroy();
-
- if (tw)
- {
- gLoop->DeregisterWin(tw);
- tw->DeInit();
- delete tw;
- tw = NULL;
- }
-
- if (gLoop->HasLastWinInfoList())
- gLoop->FreeLastWinInfoList();
- };
-
- protected:
- EtWin *tw = NULL;
-
- static void SetUpTestCase()
- {
- };
- static void TearDownTestCase()
- {
- };
-
- Eina_Bool InitTC(Eina_Bool alpha)
- {
- Eina_Bool result = EINA_FALSE;
-
- this->tw = new EtWin();
- this->tw->Init(NULL,
- ELM_WIN_BASIC,
- alpha,
- "E_Testcase_Window",
- 0, 0, 320, 320, EINA_FALSE,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_GREEN);
- EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
- this->tw->native_win = gLoop->GetWinId(this->tw->elm_win);
-
- result = gLoop->RegisterWin(this->tw);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- this->tw->UpdateGeometry();
- this->tw->Show();
-
- gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_ON);
-
- return EINA_TRUE;
- };
+public:
+ etTestBaseOperation() { };
+ ~etTestBaseOperation()
+ {
+ if (HasFailure()) etRunner::get().waitForDestroy();
+
+ if (tw)
+ {
+ etRunner::get().deregisterWin(tw);
+ tw->deInit();
+ delete tw;
+ tw = NULL;
+ }
+
+ if (etRunner::get().hasLastWinInfoList())
+ etRunner::get().freeLastWinInfoList();
+ };
+
+protected:
+ etWin *tw = NULL;
+
+ Eina_Bool initTC(Eina_Bool alpha);
};
-TEST_F(EtTestBaseOperation, win_show)
+Eina_Bool
+etTestBaseOperation::initTC(Eina_Bool alpha)
+{
+ Eina_Bool res = EINA_FALSE;
+
+ tw = new etWin();
+ tw->init(NULL,
+ ELM_WIN_BASIC,
+ alpha,
+ "E_Testcase_Window",
+ 0, 0, 320, 320, EINA_FALSE,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_GREEN);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
+ tw->native_win = etRunner::get().getWinId(tw->elm_win);
+
+ res = etRunner::get().registerWin(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;
+}
+
+TEST_F(etTestBaseOperation, win_show)
{
- Eina_Bool result = EINA_FALSE;
+ Eina_Bool res = EINA_FALSE;
- result = this->InitTC(EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE);
+ ASSERT_TRUE(res);
}
-TEST_F(EtTestBaseOperation, win_stack)
+TEST_F(etTestBaseOperation, win_stack)
{
- EtWin *tw2 = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw2 = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
- result = this->InitTC(EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE);
+ ASSERT_TRUE(res);
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw2, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw2, etWin*)
{
if (tw2->layer > tw->layer) continue;
if (tw2->layer < tw->layer) break;
if (!strncmp(tw2->name, tw->name, strlen(tw2->name)))
- result = EINA_TRUE;
+ res = EINA_TRUE;
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
- ASSERT_TRUE(result);
+ ASSERT_TRUE(res);
}
-TEST_F(EtTestBaseOperation, alpha_win_show)
+TEST_F(etTestBaseOperation, alpha_win_show)
{
- Eina_Bool result = EINA_FALSE;
+ Eina_Bool res = EINA_FALSE;
- result = this->InitTC(EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE);
+ ASSERT_TRUE(res);
}
-TEST_F(EtTestBaseOperation, alpha_win_stack)
+TEST_F(etTestBaseOperation, alpha_win_stack)
{
- EtWin *tw2 = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw2 = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
- result = this->InitTC(EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE);
+ ASSERT_TRUE(res);
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw2, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw2, etWin*)
{
if (tw2->layer > tw->layer) continue;
if (tw2->layer < tw->layer) break;
if (!strncmp(tw2->name, tw->name, strlen(tw2->name)))
- result = EINA_TRUE;
+ res = EINA_TRUE;
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_TRUE(EINA_TRUE);
}
-
using ::testing::Test;
-extern EtEventLoop *gLoop;
-
-class EtTestBaseMulti : public ::testing::Test
+class etTestBaseMulti : public ::testing::Test
{
- public:
- EtTestBaseMulti()
- {
- };
- ~EtTestBaseMulti()
- {
- if (HasFailure())
- gLoop->WaitForDestroy();
-
- if (tw_register)
- gLoop->DeregisterWin(tw_register);
-
- if (tw_red)
- delete tw_red;
-
- if (tw_blue)
- delete tw_blue;
-
- if (tw_green)
- delete tw_green;
-
- if (gLoop->HasLastWinInfoList())
- gLoop->FreeLastWinInfoList();
- };
-
- protected:
- EtWin *tw_red = NULL;
- EtWin *tw_green = NULL;
- EtWin *tw_blue = NULL;
-
- EtWin *tw_register = NULL;
-
- static void SetUpTestCase()
- {
- };
- static void TearDownTestCase()
- {
- };
-
- Eina_Bool RegisterTCWin(EtWin *tw)
- {
- Eina_Bool result = EINA_FALSE;
-
- EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
- EINA_SAFETY_ON_TRUE_RETURN_VAL(tw == tw_register, EINA_TRUE);
-
- if (this->tw_register)
- {
- gLoop->DeregisterWin(this->tw_register);
- this->tw_register = NULL;
- }
-
- result = gLoop->RegisterWin(tw);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- this->tw_register = tw;
-
- return EINA_TRUE;
- }
-
- Eina_Bool InitTC(Eina_Bool show_win, Eina_Bool use_geom)
- {
- this->tw_red = new EtWin();
- this->tw_red->Init(NULL,
- ELM_WIN_BASIC,
- EINA_FALSE,
- "EtWin Red",
- 0, 0, 400, 400, use_geom,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_RED);
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->tw_red, EINA_FALSE);
- this->tw_red->native_win = gLoop->GetWinId(this->tw_red->elm_win);
-
- if (show_win)
- {
- this->tw_red->UpdateGeometry();
- this->tw_red->Show();
- }
-
- this->tw_green = new EtWin();
- this->tw_green->Init(NULL,
- ELM_WIN_BASIC,
- EINA_FALSE,
- "EtWin Green",
- 50, 50, 400, 400, use_geom,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_GREEN);
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->tw_green, EINA_FALSE);
- this->tw_green->native_win = gLoop->GetWinId(this->tw_green->elm_win);
-
- if (show_win)
- {
- this->tw_green->UpdateGeometry();
- this->tw_green->Show();
- }
-
- this->tw_blue = new EtWin();
- this->tw_blue->Init(NULL,
- ELM_WIN_BASIC,
- EINA_FALSE,
- "EtWin Blue",
- 100, 100, 400, 400, use_geom,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_BLUE);
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->tw_blue, EINA_FALSE);
- this->tw_blue->native_win = gLoop->GetWinId(this->tw_blue->elm_win);
-
- if (show_win)
- {
- this->RegisterTCWin(this->tw_blue);
-
- this->tw_blue->UpdateGeometry();
- this->tw_blue->Show();
-
- gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_ON);
- }
-
- return EINA_TRUE;
- };
-
- Eina_Bool ShowTCWin(EtWin *tw)
- {
- Eina_Bool result = EINA_FALSE;
-
- EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
-
- result = this->RegisterTCWin(tw);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- tw->UpdateGeometry();
- tw->Show();
- gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_ON);
-
- return EINA_TRUE;
- }
+public:
+ etTestBaseMulti() { };
+ ~etTestBaseMulti()
+ {
+ if (HasFailure()) etRunner::get().waitForDestroy();
+ if (tw_register) etRunner::get().deregisterWin(tw_register);
+ if (tw_red) delete tw_red;
+ if (tw_blue) delete tw_blue;
+ if (tw_green) delete tw_green;
+ if (etRunner::get().hasLastWinInfoList()) etRunner::get().freeLastWinInfoList();
+ };
+
+protected:
+ etWin *tw_red = NULL;
+ etWin *tw_green = NULL;
+ etWin *tw_blue = NULL;
+ etWin *tw_register = NULL;
+
+ Eina_Bool registerTCWin(etWin *tw);
+ Eina_Bool initTC(Eina_Bool show_win, Eina_Bool use_geom);
+ Eina_Bool showTCWin(etWin *tw);
};
-TEST_F(EtTestBaseMulti, multi_all_wins_basic)
+Eina_Bool
+etTestBaseMulti::registerTCWin(etWin *tw)
+{
+ Eina_Bool res = EINA_FALSE;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
+ EINA_SAFETY_ON_TRUE_RETURN_VAL(tw == tw_register, EINA_TRUE);
+
+ if (tw_register)
+ {
+ etRunner::get().deregisterWin(tw_register);
+ 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
+etTestBaseMulti::initTC(Eina_Bool show_win,
+ Eina_Bool use_geom)
+{
+ tw_red = new etWin();
+ tw_red->init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "etWin Red",
+ 0, 0, 400, 400, use_geom,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_RED);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw_red, EINA_FALSE);
+ tw_red->native_win = etRunner::get().getWinId(tw_red->elm_win);
+
+ if (show_win)
+ {
+ tw_red->updateGeometry();
+ tw_red->show();
+ }
+
+ tw_green = new etWin();
+ tw_green->init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "etWin Green",
+ 50, 50, 400, 400, use_geom,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_GREEN);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw_green, EINA_FALSE);
+
+ tw_green->native_win = etRunner::get().getWinId(tw_green->elm_win);
+
+ if (show_win)
+ {
+ tw_green->updateGeometry();
+ tw_green->show();
+ }
+
+ tw_blue = new etWin();
+ tw_blue->init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "etWin Blue",
+ 100, 100, 400, 400, use_geom,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_BLUE);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw_blue, EINA_FALSE);
+
+ tw_blue->native_win = etRunner::get().getWinId(tw_blue->elm_win);
+
+ if (show_win)
+ {
+ registerTCWin(tw_blue);
+
+ tw_blue->updateGeometry();
+ tw_blue->show();
+
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ }
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+etTestBaseMulti::showTCWin(etWin *tw)
+{
+ Eina_Bool res = EINA_FALSE;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw, 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;
+}
+
+TEST_F(etTestBaseMulti, multi_all_wins_basic)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_TRUE);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Blue -> Green -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_wins_show1)
+TEST_F(etTestBaseMulti, multi_all_wins_show1)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE, EINA_TRUE);
+ ASSERT_TRUE(res);
// show red
- result = this->ShowTCWin(this->tw_red);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_red);
+ ASSERT_TRUE(res);
// show blue
- result = this->ShowTCWin(this->tw_blue);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_blue);
+ ASSERT_TRUE(res);
// show green
- result = this->ShowTCWin(this->tw_green);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_green);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green -> Blue -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_wins_show2)
+TEST_F(etTestBaseMulti, multi_all_wins_show2)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE, EINA_TRUE);
+ ASSERT_TRUE(res);
// show blue
- result = this->ShowTCWin(this->tw_blue);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_blue);
+ ASSERT_TRUE(res);
// show red
- result = this->ShowTCWin(this->tw_red);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_red);
+ ASSERT_TRUE(res);
// show green
- result = this->ShowTCWin(this->tw_green);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_green);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green -> Red -> Blue [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_wins_show3)
+TEST_F(etTestBaseMulti, multi_all_wins_show3)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE, EINA_TRUE);
+ ASSERT_TRUE(res);
// show green
- result = this->ShowTCWin(this->tw_green);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_green);
+ ASSERT_TRUE(res);
// show blue
- result = this->ShowTCWin(this->tw_blue);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_blue);
+ ASSERT_TRUE(res);
// show red
- result = this->ShowTCWin(this->tw_red);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_red);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Red -> Blue -> Green [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_wins_raise1)
+TEST_F(etTestBaseMulti, multi_all_wins_raise1)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_TRUE);
+ ASSERT_TRUE(res);
// Raise Red
- gLoop->SetWinStack(tw_red, NULL, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Red -> Blue -> Green [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_wins_raise2)
+TEST_F(etTestBaseMulti, multi_all_wins_raise2)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_TRUE);
+ ASSERT_TRUE(res);
// Raise Green
- gLoop->SetWinStack(tw_green, NULL, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_green, NULL, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green-> Blue -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_wins_stack_above1)
+TEST_F(etTestBaseMulti, multi_all_wins_stack_above1)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_TRUE);
+ ASSERT_TRUE(res);
// Raise Red on the Green
- gLoop->SetWinStack(tw_red, tw_green, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_red, tw_green, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Blue -> Red -> Green [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_wins_stack_above2)
+TEST_F(etTestBaseMulti, multi_all_wins_stack_above2)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_TRUE);
+ ASSERT_TRUE(res);
// Raise Blue on the Red
- gLoop->SetWinStack(tw_blue, tw_red, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_blue, tw_red, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green-> Blue -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_wins_stack_above3)
+TEST_F(etTestBaseMulti, multi_all_wins_stack_above3)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_TRUE);
+ ASSERT_TRUE(res);
// Raise Red on the Blue
- gLoop->SetWinStack(tw_red, tw_blue, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_red, tw_blue, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green-> Blue -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_wins_lower1)
+TEST_F(etTestBaseMulti, multi_all_wins_lower1)
{
- EtWin *tw = NULL, *tw_above = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL, *tw_above = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_TRUE);
+ ASSERT_TRUE(res);
// Lower Blue
- gLoop->SetWinStack(tw_blue, NULL, EINA_FALSE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green -> Red -> ... -> Blue [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
{
if (tw->layer < 200)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
}
else
if (tw == NULL)
{
ASSERT_TRUE(tw_above != NULL);
- ASSERT_EQ(tw_above->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw_above->native_win, tw_blue->native_win);
pass_count++;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_wins_lower2)
+TEST_F(etTestBaseMulti, multi_all_wins_lower2)
{
- EtWin *tw = NULL, *tw_above = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL, *tw_above = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_TRUE);
+ ASSERT_TRUE(res);
// Lower Green
- gLoop->SetWinStack(tw_green, NULL, EINA_FALSE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Blue -> Red -> ... -> Green [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
{
if (tw->layer < 200)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
}
else
if (tw == NULL)
{
ASSERT_TRUE(tw_above != NULL);
- ASSERT_EQ(tw_above->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw_above->native_win, tw_green->native_win);
pass_count++;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_full_wins_basic)
+TEST_F(etTestBaseMulti, multi_all_full_wins_basic)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Blue -> Green -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_full_wins_show1)
+TEST_F(etTestBaseMulti, multi_all_full_wins_show1)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE, EINA_FALSE);
+ ASSERT_TRUE(res);
// show red
- result = this->ShowTCWin(this->tw_red);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_red);
+ ASSERT_TRUE(res);
// show blue
- result = this->ShowTCWin(this->tw_blue);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_blue);
+ ASSERT_TRUE(res);
// show green
- result = this->ShowTCWin(this->tw_green);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_green);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green -> Blue -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_full_wins_show2)
+TEST_F(etTestBaseMulti, multi_all_full_wins_show2)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE, EINA_FALSE);
+ ASSERT_TRUE(res);
// show blue
- result = this->ShowTCWin(this->tw_blue);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_blue);
+ ASSERT_TRUE(res);
// show red
- result = this->ShowTCWin(this->tw_red);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_red);
+ ASSERT_TRUE(res);
// show green
- result = this->ShowTCWin(this->tw_green);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_green);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green -> Red -> Blue [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_full_wins_show3)
+TEST_F(etTestBaseMulti, multi_all_full_wins_show3)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE, EINA_FALSE);
+ ASSERT_TRUE(res);
// show green
- result = this->ShowTCWin(this->tw_green);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_green);
+ ASSERT_TRUE(res);
// show blue
- result = this->ShowTCWin(this->tw_blue);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_blue);
+ ASSERT_TRUE(res);
// show red
- result = this->ShowTCWin(this->tw_red);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_red);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Red -> Blue -> Green [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_full_wins_raise1)
+TEST_F(etTestBaseMulti, multi_all_full_wins_raise1)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(res);
// Raise Red
- gLoop->SetWinStack(tw_red, NULL, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Red -> Blue -> Green [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_full_wins_raise2)
+TEST_F(etTestBaseMulti, multi_all_full_wins_raise2)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(res);
// Raise Green
- gLoop->SetWinStack(tw_green, NULL, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_green, NULL, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green-> Blue -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_full_wins_stack_above1)
+TEST_F(etTestBaseMulti, multi_all_full_wins_stack_above1)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(res);
// Raise Red on the Green
- gLoop->SetWinStack(tw_red, tw_green, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_red, tw_green, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Blue -> Red -> Green [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_full_wins_stack_above2)
+TEST_F(etTestBaseMulti, multi_all_full_wins_stack_above2)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(res);
// Raise Blue on the Red
- gLoop->SetWinStack(tw_blue, tw_red, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_blue, tw_red, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green-> Blue -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_full_wins_stack_above3)
+TEST_F(etTestBaseMulti, multi_all_full_wins_stack_above3)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(res);
// Raise Red on the Blue
- gLoop->SetWinStack(tw_red, tw_blue, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_red, tw_blue, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green-> Blue -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_full_wins_lower1)
+TEST_F(etTestBaseMulti, multi_all_full_wins_lower1)
{
- EtWin *tw = NULL, *tw_above = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL, *tw_above = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(res);
// Lower Blue
- gLoop->SetWinStack(tw_blue, NULL, EINA_FALSE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green -> Red -> ... -> Blue [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
{
if (tw->layer < 200)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
}
else
if (tw == NULL)
{
ASSERT_TRUE(tw_above != NULL);
- ASSERT_EQ(tw_above->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw_above->native_win, tw_blue->native_win);
pass_count++;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_all_full_wins_lower2)
+TEST_F(etTestBaseMulti, multi_all_full_wins_lower2)
{
- EtWin *tw = NULL, *tw_above = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL, *tw_above = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(res);
// Lower Green
- gLoop->SetWinStack(tw_green, NULL, EINA_FALSE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // Expected stack result:
+ // Expected stack res:
// [Top] Blue -> Red -> ... -> Green [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
{
if (tw->layer < 200)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
}
else
if (tw == NULL)
{
ASSERT_TRUE(tw_above != NULL);
- ASSERT_EQ(tw_above->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw_above->native_win, tw_green->native_win);
pass_count++;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_2wins_show1)
+TEST_F(etTestBaseMulti, multi_2wins_show1)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE, EINA_TRUE);
+ ASSERT_TRUE(res);
// show green
- result = this->ShowTCWin(this->tw_green);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_green);
+ ASSERT_TRUE(res);
// show red
- result = this->ShowTCWin(this->tw_red);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_red);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Red -> Green [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(2, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_2wins_show2)
+TEST_F(etTestBaseMulti, multi_2wins_show2)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE, EINA_TRUE);
+ ASSERT_TRUE(res);
// show blue
- result = this->ShowTCWin(this->tw_blue);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_blue);
+ ASSERT_TRUE(res);
// show green
- result = this->ShowTCWin(this->tw_green);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_green);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green -> Blue [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(2, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_2wins_show3)
+TEST_F(etTestBaseMulti, multi_2wins_show3)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE, EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE, EINA_TRUE);
+ ASSERT_TRUE(res);
// show red
- result = this->ShowTCWin(this->tw_red);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_red);
+ ASSERT_TRUE(res);
// show blue
- result = this->ShowTCWin(this->tw_blue);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_blue);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Blue -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(2, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_full_2wins_show1)
+TEST_F(etTestBaseMulti, multi_full_2wins_show1)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE, EINA_FALSE);
+ ASSERT_TRUE(res);
// show green
- result = this->ShowTCWin(this->tw_green);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_green);
+ ASSERT_TRUE(res);
// show red
- result = this->ShowTCWin(this->tw_red);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_red);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Red -> Green [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(2, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_full_2wins_show2)
+TEST_F(etTestBaseMulti, multi_full_2wins_show2)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE, EINA_FALSE);
+ ASSERT_TRUE(res);
// show blue
- result = this->ShowTCWin(this->tw_blue);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_blue);
+ ASSERT_TRUE(res);
// show green
- result = this->ShowTCWin(this->tw_green);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_green);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Green -> Blue [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_green->native_win);
+ ASSERT_EQ(tw->native_win, tw_green->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(2, pass_count);
}
-TEST_F(EtTestBaseMulti, multi_full_2wins_show3)
+TEST_F(etTestBaseMulti, multi_full_2wins_show3)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE, EINA_FALSE);
+ ASSERT_TRUE(res);
// show red
- result = this->ShowTCWin(this->tw_red);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_red);
+ ASSERT_TRUE(res);
// show blue
- result = this->ShowTCWin(this->tw_blue);
- ASSERT_TRUE(result);
+ res = showTCWin(tw_blue);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] Blue -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_blue->native_win);
+ ASSERT_EQ(tw->native_win, tw_blue->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_red->native_win);
+ ASSERT_EQ(tw->native_win, tw_red->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(2, pass_count);
}
using ::testing::Test;
-extern EtEventLoop *gLoop;
-
-class EtTestTransientFor : public ::testing::Test
+class etTestTransientFor : public ::testing::Test
{
- public:
- EtTestTransientFor()
- {
- };
- ~EtTestTransientFor()
- {
- if (HasFailure())
- gLoop->WaitForDestroy();
-
- if (tw_register)
- gLoop->DeregisterWin(tw_register);
-
- if (tw_base)
- delete tw_base;
-
- if (tw_parent)
- delete tw_parent;
-
- if (tw_child)
- delete tw_child;
-
- if (gLoop->HasLastWinInfoList())
- gLoop->FreeLastWinInfoList();
- };
-
- protected:
- EtWin *tw_base = NULL;
- EtWin *tw_parent = NULL;
- EtWin *tw_child = NULL;
-
- EtWin *tw_register = NULL;
-
- static void SetUpTestCase()
- {
- };
- static void TearDownTestCase()
- {
- };
-
- Eina_Bool RegisterTCWin(EtWin *tw)
- {
- Eina_Bool result = EINA_FALSE;
-
- EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
-
- if (this->tw_register)
- {
- gLoop->DeregisterWin(this->tw_register);
- this->tw_register = NULL;
- }
-
- result = gLoop->RegisterWin(tw);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- this->tw_register = tw;
-
- return EINA_TRUE;
- };
-
- Eina_Bool InitTC()
- {
- Eina_Bool result = EINA_FALSE;
-
- this->tw_parent = new EtWin();
- this->tw_parent->Init(NULL,
- ELM_WIN_BASIC,
- EINA_FALSE,
- "EtWin Parent",
- 0, 0, 400, 400, EINA_FALSE,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_BLUE);
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->tw_parent, EINA_FALSE);
- this->tw_parent->native_win = gLoop->GetWinId(this->tw_parent->elm_win);
-
- result = this->ShowTCWin(this->tw_parent);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- this->tw_child = new EtWin();
- this->tw_child->Init(NULL,
- ELM_WIN_BASIC,
- EINA_FALSE,
- "EtWin Child",
- 0, 0, 320, 320, EINA_FALSE,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_RED);
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->tw_child, EINA_FALSE);
- this->tw_child->native_win = gLoop->GetWinId(this->tw_child->elm_win);
-
- result = this->ShowTCWin(this->tw_child);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- this->tw_base = new EtWin();
- this->tw_base->Init(NULL,ELM_WIN_BASIC,
- EINA_FALSE,
- "EtWin Base",
- 200, 200, 500, 500, EINA_FALSE,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_RED);
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->tw_base, EINA_FALSE);
- this->tw_base->native_win = gLoop->GetWinId(this->tw_base->elm_win);
-
- result = this->ShowTCWin(this->tw_base);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- // set transient_for
- result = gLoop->SetWinTransientFor(this->tw_child,
- this->tw_parent,
- EINA_TRUE);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- // TODO:: have to write this->work()?
-
- return EINA_TRUE;
- };
-
- Eina_Bool ShowTCWin(EtWin *tw)
- {
- Eina_Bool result = EINA_FALSE;
-
- result = this->RegisterTCWin(tw);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- tw->UpdateGeometry();
- tw->Show();
- gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_ON);
-
- return EINA_TRUE;
- };
+public:
+ etTestTransientFor() { };
+ ~etTestTransientFor()
+ {
+ if (HasFailure()) etRunner::get().waitForDestroy();
+ if (tw_register) etRunner::get().deregisterWin(tw_register);
+ if (tw_base) delete tw_base;
+ if (tw_parent) delete tw_parent;
+ if (tw_child) delete tw_child;
+ if (etRunner::get().hasLastWinInfoList()) etRunner::get().freeLastWinInfoList();
+ };
+
+protected:
+ etWin *tw_base = NULL;
+ etWin *tw_parent = NULL;
+ etWin *tw_child = NULL;
+ etWin *tw_register = NULL;
+
+ Eina_Bool registerTCWin(etWin *tw);
+ Eina_Bool initTC();
+ Eina_Bool showTCWin(etWin *tw);
};
-TEST_F(EtTestTransientFor, transient_for_basic)
+Eina_Bool
+etTestTransientFor::registerTCWin(etWin *tw)
+{
+ Eina_Bool res = EINA_FALSE;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
+
+ if (tw_register)
+ {
+ etRunner::get().deregisterWin(tw_register);
+ 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
+etTestTransientFor::initTC()
+{
+ Eina_Bool res = EINA_FALSE;
+
+ tw_parent = new etWin();
+ tw_parent->init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "etWin Parent",
+ 0, 0, 400, 400, EINA_FALSE,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_BLUE);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw_parent, EINA_FALSE);
+
+ tw_parent->native_win = etRunner::get().getWinId(tw_parent->elm_win);
+
+ res = showTCWin(tw_parent);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ tw_child = new etWin();
+ tw_child->init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "etWin Child",
+ 0, 0, 320, 320, EINA_FALSE,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_RED);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw_child, EINA_FALSE);
+ tw_child->native_win = etRunner::get().getWinId(tw_child->elm_win);
+
+ res = showTCWin(tw_child);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ tw_base = new etWin();
+ tw_base->init(NULL,ELM_WIN_BASIC,
+ EINA_FALSE,
+ "etWin Base",
+ 200, 200, 500, 500, EINA_FALSE,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_RED);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw_base, EINA_FALSE);
+ tw_base->native_win = etRunner::get().getWinId(tw_base->elm_win);
+
+ res = showTCWin(tw_base);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ // set transient_for
+ res = etRunner::get().setWinTransientFor(tw_child,
+ tw_parent,
+ EINA_TRUE);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ // TODO:: have to write work()?
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+etTestTransientFor::showTCWin(etWin *tw)
+{
+ Eina_Bool res = 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;
+}
+
+TEST_F(etTestTransientFor, transient_for_basic)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC();
- ASSERT_TRUE(result);
+ res = initTC();
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] tw_base -> tw_child -> tw_parent [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
- if (tw->layer > 200)
- continue;
+ if (tw->layer > 200) continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_base->native_win);
+ ASSERT_EQ(tw->native_win, tw_base->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_child->native_win);
+ ASSERT_EQ(tw->native_win, tw_child->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_parent->native_win);
+ ASSERT_EQ(tw->native_win, tw_parent->native_win);
pass_count++;
}
+
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestTransientFor, transient_for_raise)
+TEST_F(etTestTransientFor, transient_for_raise)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC();
- ASSERT_TRUE(result);
+ res = initTC();
+ ASSERT_TRUE(res);
- result = this->RegisterTCWin(this->tw_parent);
- EXPECT_TRUE(result);
+ res = registerTCWin(tw_parent);
+ EXPECT_TRUE(res);
// tw_parent raise
- result = gLoop->SetWinStack(this->tw_parent, NULL, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- ASSERT_TRUE(result);
+ res = etRunner::get().setWinStack(tw_parent, NULL, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] tw_child -> tw_parent -> tw_base [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
- if (tw->layer > 200)
- continue;
+ if (tw->layer > 200) continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_child->native_win);
+ ASSERT_EQ(tw->native_win, tw_child->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_parent->native_win);
+ ASSERT_EQ(tw->native_win, tw_parent->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_base->native_win);
+ ASSERT_EQ(tw->native_win, tw_base->native_win);
pass_count++;
}
+
break;
}
- gLoop->FreeWinInfoList(list);
+
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestTransientFor, transient_for_lower)
+TEST_F(etTestTransientFor, transient_for_lower)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC();
- ASSERT_TRUE(result);
+ res = initTC();
+ ASSERT_TRUE(res);
- result = this->RegisterTCWin(this->tw_parent);
- EXPECT_TRUE(result);
+ res = registerTCWin(tw_parent);
+ EXPECT_TRUE(res);
// tw_parent raise for prepare lower
- result = gLoop->SetWinStack(this->tw_parent, NULL, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- ASSERT_TRUE(result);
+ res = etRunner::get().setWinStack(tw_parent, NULL, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ ASSERT_TRUE(res);
// tw_parent lower
- result = gLoop->SetWinStack(this->tw_parent, NULL, EINA_FALSE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_LOWER);
- ASSERT_TRUE(result);
+ res = etRunner::get().setWinStack(tw_parent, NULL, EINA_FALSE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_LOWER);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] tw_base -> ... -> tw_child -> tw_parent [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
- if (tw->layer > 200)
- continue;
+ if (tw->layer > 200) continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_base->native_win);
+ ASSERT_EQ(tw->native_win, tw_base->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- if (tw->native_win != this->tw_child->native_win)
+ if (tw->native_win != tw_child->native_win)
continue; // skip for find lower layer
- ASSERT_EQ(tw->native_win, this->tw_child->native_win);
+ ASSERT_EQ(tw->native_win, tw_child->native_win);
pass_count++;
continue;
}
else if (pass_count == 2)
{
- ASSERT_EQ(tw->native_win, this->tw_parent->native_win);
+ ASSERT_EQ(tw->native_win, tw_parent->native_win);
pass_count++;
}
else
if (tw->layer < 200)
break;
else
- // expected stack result is tw_parent is lowest window.
+ // expected stack res is tw_parent is lowest window.
// so, it is failed testcase.
ASSERT_FALSE(EINA_TRUE);
}
+
break;
}
- gLoop->FreeWinInfoList(list);
+
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestTransientFor, transient_for_above)
+TEST_F(etTestTransientFor, transient_for_above)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
int pass_count = 0;
- result = this->InitTC();
- ASSERT_TRUE(result);
+ res = initTC();
+ ASSERT_TRUE(res);
- result = this->RegisterTCWin(this->tw_parent);
- EXPECT_TRUE(result);
+ res = registerTCWin(tw_parent);
+ EXPECT_TRUE(res);
// tw_parent raise for prepare lower
- result = gLoop->SetWinStack(this->tw_parent, this->tw_base, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_ABOVE);
- ASSERT_TRUE(result);
+ res = etRunner::get().setWinStack(tw_parent, tw_base, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_ABOVE);
+ ASSERT_TRUE(res);
- // Expected stack result:
+ // Expected stack res:
// [Top] tw_child -> tw_parent -> tw_base [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
- if (tw->layer > 200)
- continue;
+ if (tw->layer > 200) continue;
if (pass_count == 0)
{
- ASSERT_EQ(tw->native_win, this->tw_child->native_win);
+ ASSERT_EQ(tw->native_win, tw_child->native_win);
pass_count++;
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_parent->native_win);
+ ASSERT_EQ(tw->native_win, tw_parent->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_base->native_win);
+ ASSERT_EQ(tw->native_win, tw_base->native_win);
pass_count++;
}
+
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
using ::testing::Test;
-extern EtEventLoop *gLoop;
-
-class EtTestNotification : public ::testing::Test
+class etTestNotification : public ::testing::Test
{
- public:
- EtTestNotification()
- {
- };
- ~EtTestNotification()
- {
- if (HasFailure())
- gLoop->WaitForDestroy();
-
- if (tw_register)
- gLoop->DeregisterWin(tw_register);
-
- if (tw_normal)
- delete tw_normal;
-
- if (tw_noti1)
- delete tw_noti1;
-
- if (tw_noti2)
- delete tw_noti2;
-
- if (gLoop->HasLastWinInfoList())
- gLoop->FreeLastWinInfoList();
- };
-
- protected:
- EtWin *tw_normal = NULL;
- EtWin *tw_noti1 = NULL;
- EtWin *tw_noti2 = NULL;
-
- EtWin *tw_register = NULL;
-
- Eina_Bool InitTC(Eina_Bool use_geom)
- {
- Eina_Bool result = EINA_FALSE;
- this->tw_normal = new EtWin();
- this->tw_normal->Init(NULL,
- ELM_WIN_BASIC,
- EINA_FALSE,
- "EtWin Normal",
- 0, 0, 400, 400, use_geom,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_RED);
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->tw_normal, EINA_FALSE);
- this->tw_normal->native_win = gLoop->GetWinId(this->tw_normal->elm_win);
-
- this->tw_normal->UpdateGeometry();
- this->tw_normal->Show();
-
- this->tw_noti1 = new EtWin();
- this->tw_noti1->Init(NULL,
- ELM_WIN_NOTIFICATION,
- EINA_FALSE,
- "EtWin Noti_1",
- 100, 100, 400, 400, use_geom,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_GREEN);
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->tw_noti1, EINA_FALSE);
- this->tw_noti1->native_win = gLoop->GetWinId(this->tw_noti1->elm_win);
-
- this->tw_noti1->UpdateGeometry();
- this->tw_noti1->Show();
-
- this->tw_noti2 = new EtWin();
- this->tw_noti2->Init(NULL,
- ELM_WIN_NOTIFICATION,
- EINA_FALSE,
- "EtWin Noti_2",
- 50, 200, 400, 400, use_geom,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_BLUE);
- EINA_SAFETY_ON_NULL_RETURN_VAL(this->tw_noti2, EINA_FALSE);
- this->tw_noti2->native_win = gLoop->GetWinId(this->tw_noti2->elm_win);
-
- this->tw_noti2->UpdateGeometry();
- this->tw_noti2->Show();
-
- // register window
- result = this->RegisterTCWin(this->tw_normal);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_ON);
-
- return EINA_TRUE;
- };
-
- Eina_Bool RegisterTCWin(EtWin *tw)
- {
- Eina_Bool result = EINA_FALSE;
- EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
-
- if (this->tw_register)
- {
- gLoop->DeregisterWin(this->tw_register);
- this->tw_register = NULL;
- }
-
- result = gLoop->RegisterWin(tw);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- this->tw_register = tw;
-
- return EINA_TRUE;
- }
+public:
+ etTestNotification() { };
+ ~etTestNotification()
+ {
+ if (HasFailure()) etRunner::get().waitForDestroy();
+ if (tw_register) etRunner::get().deregisterWin(tw_register);
+ if (tw_normal) delete tw_normal;
+ if (tw_noti1) delete tw_noti1;
+ if (tw_noti2) delete tw_noti2;
+ if (etRunner::get().hasLastWinInfoList()) etRunner::get().freeLastWinInfoList();
+ };
+
+protected:
+ etWin *tw_normal = NULL;
+ etWin *tw_noti1 = NULL;
+ etWin *tw_noti2 = NULL;
+ etWin *tw_register = NULL;
+
+ Eina_Bool initTC(Eina_Bool use_geom);
+ Eina_Bool registerTCWin(etWin *tw);
};
-TEST_F(EtTestNotification, notification_level_default)
+Eina_Bool
+etTestNotification::initTC(Eina_Bool use_geom)
+{
+ Eina_Bool res = EINA_FALSE;
+ tw_normal = new etWin();
+ tw_normal->init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "etWin Normal",
+ 0, 0, 400, 400, use_geom,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_RED);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw_normal, EINA_FALSE);
+ tw_normal->native_win = etRunner::get().getWinId(tw_normal->elm_win);
+
+ tw_normal->updateGeometry();
+ tw_normal->show();
+
+ tw_noti1 = new etWin();
+ tw_noti1->init(NULL,
+ ELM_WIN_NOTIFICATION,
+ EINA_FALSE,
+ "etWin Noti_1",
+ 100, 100, 400, 400, use_geom,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_GREEN);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw_noti1, EINA_FALSE);
+ tw_noti1->native_win = etRunner::get().getWinId(tw_noti1->elm_win);
+
+ tw_noti1->updateGeometry();
+ tw_noti1->show();
+
+ tw_noti2 = new etWin();
+ tw_noti2->init(NULL,
+ ELM_WIN_NOTIFICATION,
+ EINA_FALSE,
+ "etWin Noti_2",
+ 50, 200, 400, 400, use_geom,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_BLUE);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw_noti2, EINA_FALSE);
+ tw_noti2->native_win = etRunner::get().getWinId(tw_noti2->elm_win);
+
+ tw_noti2->updateGeometry();
+ tw_noti2->show();
+
+ // register window
+ res = registerTCWin(tw_normal);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+etTestNotification::registerTCWin(etWin *tw)
+{
+ Eina_Bool res = EINA_FALSE;
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
+
+ if (tw_register)
+ {
+ etRunner::get().deregisterWin(tw_register);
+ tw_register = NULL;
+ }
+
+ res = etRunner::get().registerWin(tw);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ tw_register = tw;
+
+ return EINA_TRUE;
+}
+
+TEST_F(etTestNotification, notification_level_default)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE);
+ ASSERT_TRUE(res);
// set tw_noti1 to notification layer
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
- EXPECT_TRUE(result);
+ EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> Noti2 -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (pass_count == 0)
{
// check notification level
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_LOW)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
}
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestNotification, notification_level_medium)
+TEST_F(etTestNotification, notification_level_medium)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE);
+ ASSERT_TRUE(res);
// set tw_noti1 to notification layer
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
- EXPECT_TRUE(result);
+ EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> Noti2 -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (pass_count == 0)
{
// check notification level
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_NORMAL)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
}
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestNotification, notification_level_high)
+TEST_F(etTestNotification, notification_level_high)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE);
+ ASSERT_TRUE(res);
// set tw_noti1 to notification layer
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
- EXPECT_TRUE(result);
+ EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> Noti2 -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (pass_count == 0)
{
// check notification level
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_HIGH)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
}
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestNotification, notification_level_top)
+TEST_F(etTestNotification, notification_level_top)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE);
+ ASSERT_TRUE(res);
// set tw_noti1 to notification layer
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_TOP);
- EXPECT_TRUE(result);
+ EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> Noti2 -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (pass_count == 0)
{
// check notification level
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_TOP)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
}
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestNotification, notification_level_none)
+TEST_F(etTestNotification, notification_level_none)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE);
+ ASSERT_TRUE(res);
// set tw_noti1 to notification high
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
- EXPECT_TRUE(result);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ EXPECT_TRUE(res);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level);
// set tw_noti2 to notification top
- result = gLoop->SetWinNotiLevel(this->tw_noti2,
+ res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_TOP);
- EXPECT_TRUE(result);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti2);
+ EXPECT_TRUE(res);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> Noti2 -> ... -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
{
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_TOP)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_HIGH)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
continue;
}
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
pass_count = 0;
// set tw_noti2 to notification none
- result = gLoop->SetWinNotiLevel(this->tw_noti2,
+ res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_NONE);
- EXPECT_TRUE(result);
+ EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti2);
+ level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_NONE, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> ... -> Noti2 -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (pass_count == 0)
{
// check notification level
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_HIGH)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
}
continue;
{
if (tw->layer > 200)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestNotification, notification_level_change)
+TEST_F(etTestNotification, notification_level_change)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
int pass_count = 0;
- result = this->InitTC(EINA_TRUE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE);
+ ASSERT_TRUE(res);
// set tw_noti1 to notification default
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
- EXPECT_TRUE(result);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ EXPECT_TRUE(res);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT, level);
// set tw_noti2 to notification medium
- result = gLoop->SetWinNotiLevel(this->tw_noti2,
+ res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
- EXPECT_TRUE(result);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti2);
+ EXPECT_TRUE(res);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti2 -> Noti1 -> ... -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
{
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_NORMAL)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_LOW)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
continue;
}
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
pass_count = 0;
// set tw_noti1 to notification high
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
- EXPECT_TRUE(result);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ EXPECT_TRUE(res);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> Noti2 -> ... -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
{
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_HIGH)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
continue;
}
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_NORMAL)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
pass_count = 0;
// set tw_noti2 to notification top
- result = gLoop->SetWinNotiLevel(this->tw_noti2,
+ res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_TOP);
- EXPECT_TRUE(result);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti2);
+ EXPECT_TRUE(res);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti2 -> Noti1 -> ... -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
{
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_TOP)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_HIGH)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
continue;
}
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestNotification, notification_fullsize_level_default)
+TEST_F(etTestNotification, notification_fullsize_level_default)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE);
+ ASSERT_TRUE(res);
// set tw_noti1 to notification layer
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
- EXPECT_TRUE(result);
+ EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> Noti2 -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (pass_count == 0)
{
// check notification level
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_LOW)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
}
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestNotification, notification_fullsize_level_medium)
+TEST_F(etTestNotification, notification_fullsize_level_medium)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE);
+ ASSERT_TRUE(res);
// set tw_noti1 to notification layer
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
- EXPECT_TRUE(result);
+ EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> Noti2 -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (pass_count == 0)
{
// check notification level
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_NORMAL)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
}
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestNotification, notification_fullsize_level_high)
+TEST_F(etTestNotification, notification_fullsize_level_high)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE);
+ ASSERT_TRUE(res);
// set tw_noti1 to notification layer
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
- EXPECT_TRUE(result);
+ EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> Noti2 -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (pass_count == 0)
{
// check notification level
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_HIGH)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
}
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestNotification, notification_fullsize_level_top)
+TEST_F(etTestNotification, notification_fullsize_level_top)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE);
+ ASSERT_TRUE(res);
// set tw_noti1 to notification layer
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_TOP);
- EXPECT_TRUE(result);
+ EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> Noti2 -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (pass_count == 0)
{
// check notification level
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_TOP)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
}
continue;
}
else if (pass_count == 1)
{
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestNotification, notification_fullsize_level_none)
+TEST_F(etTestNotification, notification_fullsize_level_none)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE);
+ ASSERT_TRUE(res);
// set tw_noti1 to notification high
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
- EXPECT_TRUE(result);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ EXPECT_TRUE(res);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level);
// set tw_noti2 to notification top
- result = gLoop->SetWinNotiLevel(this->tw_noti2,
+ res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_TOP);
- EXPECT_TRUE(result);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti2);
+ EXPECT_TRUE(res);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> Noti2 -> ... -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
{
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_TOP)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_HIGH)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
continue;
}
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
pass_count = 0;
// set tw_noti2 to notification none
- result = gLoop->SetWinNotiLevel(this->tw_noti2,
+ res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_NONE);
- EXPECT_TRUE(result);
+ EXPECT_TRUE(res);
// TODO:: add ev_wait for notification level
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti2);
+ level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_NONE, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> ... -> Noti2 -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (pass_count == 0)
{
// check notification level
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_HIGH)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
}
continue;
{
if (tw->layer > 200)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-TEST_F(EtTestNotification, notification_fullsize_level_change)
+TEST_F(etTestNotification, notification_fullsize_level_change)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
efl_util_notification_level_e level = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
int pass_count = 0;
- result = this->InitTC(EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_FALSE);
+ ASSERT_TRUE(res);
// set tw_noti1 to notification default
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
- EXPECT_TRUE(result);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ EXPECT_TRUE(res);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT, level);
// set tw_noti2 to notification medium
- result = gLoop->SetWinNotiLevel(this->tw_noti2,
+ res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
- EXPECT_TRUE(result);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti2);
+ EXPECT_TRUE(res);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti2 -> Noti1 -> ... -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
{
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_NORMAL)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_LOW)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
continue;
}
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
pass_count = 0;
// set tw_noti1 to notification high
- result = gLoop->SetWinNotiLevel(this->tw_noti1,
+ res = etRunner::get().setWinNotiLevel(tw_noti1,
EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
- EXPECT_TRUE(result);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti1);
+ EXPECT_TRUE(res);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ level = etRunner::get().getWinNotiLevel(tw_noti1);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti1 -> Noti2 -> ... -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
{
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_HIGH)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
continue;
}
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_NORMAL)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
pass_count = 0;
// set tw_noti2 to notification top
- result = gLoop->SetWinNotiLevel(this->tw_noti2,
+ res = etRunner::get().setWinNotiLevel(tw_noti2,
EFL_UTIL_NOTIFICATION_LEVEL_TOP);
- EXPECT_TRUE(result);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
- level = gLoop->GetWinNotiLevel(this->tw_noti2);
+ EXPECT_TRUE(res);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_STACK_RAISE);
+ level = etRunner::get().getWinNotiLevel(tw_noti2);
ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level);
- // Expected stack result:
+ // Expected stack res:
// [Top] Noti2 -> Noti1 -> ... -> Normal [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
if (tw->layer > 200)
{
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_TOP)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti2->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti2->native_win);
pass_count++;
continue;
}
{
if (tw->layer != E_LAYER_CLIENT_NOTIFICATION_HIGH)
continue;
- ASSERT_EQ(tw->native_win, this->tw_noti1->native_win);
+ ASSERT_EQ(tw->native_win, tw_noti1->native_win);
pass_count++;
continue;
}
}
else
{
- ASSERT_EQ(tw->native_win, this->tw_normal->native_win);
+ ASSERT_EQ(tw->native_win, tw_normal->native_win);
pass_count++;
}
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
ASSERT_EQ(3, pass_count);
}
-
using ::testing::Test;
-extern EtEventLoop *gLoop;
-
-class EtTestTzsh : public :: testing::Test
+class etTestTzsh : public :: testing::Test
{
- public:
- Eina_Bool chk_timeout_val_ = EINA_FALSE;
- Eina_Bool chk_ev_state_idle_timeout_ = EINA_FALSE;
- Eina_Bool chk_ev_state_not_idle_ = EINA_FALSE;
- int chk_cb_called_ = 0;
-
- tzsh_h tzsh = NULL;
- tzsh_window tz_win = 0x0;
- tzsh_screensaver_service_h tz_scrsaver = NULL;
- tzsh_screensaver_manager_service_h tz_scrsaver_mng = NULL;
-
- EtTestTzsh()
- {
- chk_timeout_val_ = EINA_FALSE;
- chk_ev_state_idle_timeout_ = EINA_FALSE;
- chk_ev_state_not_idle_ = EINA_FALSE;
- chk_cb_called_ = 0;
- };
- ~EtTestTzsh()
- {
- if (HasFailure())
- gLoop->WaitForDestroy();
-
- if (tz_scrsaver_mng)
- tzsh_screensaver_manager_service_destroy(tz_scrsaver_mng);
-
- if (tz_scrsaver)
- tzsh_screensaver_service_destroy(tz_scrsaver);
-
- if (tzsh)
- tzsh_destroy(tzsh);
-
- if (tw_base)
- {
- gLoop->DeregisterWin(tw_base);
- delete tw_base;
- }
-
- if (gLoop->HasLastWinInfoList())
- gLoop->FreeLastWinInfoList();
- };
- protected:
- EtWin *tw_base = NULL;
-
- Eina_Bool InitTC()
- {
- Eina_Bool result = EINA_FALSE;
-
- this->tw_base = new EtWin();
- result = this->tw_base->Init(NULL,
- ELM_WIN_BASIC,
- EINA_FALSE,
- "EtWin Tzsh",
- 0, 0, 0, 0, EINA_FALSE,
- (E_Layer) 0,
- E_TC_WIN_COLOR_RED);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
- this->tw_base->native_win = gLoop->GetWinId(this->tw_base->elm_win);
-
- result = gLoop->RegisterWin(this->tw_base);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- return EINA_TRUE;
- };
+public:
+ Eina_Bool chk_timeout_val_ = EINA_FALSE;
+ Eina_Bool chk_ev_state_idle_timeout_ = EINA_FALSE;
+ Eina_Bool chk_ev_state_not_idle_ = EINA_FALSE;
+ int chk_cb_called_ = 0;
+
+ tzsh_h tzsh = NULL;
+ tzsh_window tz_win = 0x0;
+ tzsh_screensaver_service_h tz_scrsaver = NULL;
+ tzsh_screensaver_manager_service_h tz_scrsaver_mng = NULL;
+
+ etTestTzsh()
+ {
+ chk_timeout_val_ = EINA_FALSE;
+ chk_ev_state_idle_timeout_ = EINA_FALSE;
+ chk_ev_state_not_idle_ = EINA_FALSE;
+ chk_cb_called_ = 0;
+ };
+
+ ~etTestTzsh()
+ {
+ if (HasFailure()) etRunner::get().waitForDestroy();
+ if (tz_scrsaver_mng) tzsh_screensaver_manager_service_destroy(tz_scrsaver_mng);
+ if (tz_scrsaver) tzsh_screensaver_service_destroy(tz_scrsaver);
+ if (tzsh) tzsh_destroy(tzsh);
+ if (tw_base)
+ {
+ etRunner::get().deregisterWin(tw_base);
+ delete tw_base;
+ }
+
+ if (etRunner::get().hasLastWinInfoList()) etRunner::get().freeLastWinInfoList();
+ };
+
+protected:
+ etWin *tw_base = NULL;
+
+ Eina_Bool initTC();
};
+Eina_Bool
+etTestTzsh::initTC()
+{
+ Eina_Bool res = EINA_FALSE;
+
+ tw_base = new etWin();
+ res = tw_base->init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "etWin Tzsh",
+ 0, 0, 0, 0, EINA_FALSE,
+ (E_Layer) 0,
+ E_TC_WIN_COLOR_RED);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ tw_base->native_win = etRunner::get().getWinId(tw_base->elm_win);
+
+ res = etRunner::get().registerWin(tw_base);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ return EINA_TRUE;
+}
+
/******************
callbacks
*******************/
tzsh_screensaver_manager_service_h service,
int states)
{
- EtTestTzsh *tc_data = (EtTestTzsh *)data;
+ etTestTzsh *tc_data = (etTestTzsh *)data;
unsigned int time;
tc_data->chk_cb_called_++;
{
EINA_SAFETY_ON_FALSE_RETURN(tc_data->chk_cb_called_ == 1);
- gLoop->RunTimer();
+ etRunner::get().addTimer();
tc_data->chk_ev_state_idle_timeout_ = EINA_TRUE;
- gLoop->ThawEvent();
- gLoop->FeedMouseDown(1, 1);
- gLoop->FeedMouseUp(1, 1);
- gLoop->FreezeEvent();
+ etRunner::get().thawEvent();
+ etRunner::get().feedMouseDown(1, 1);
+ etRunner::get().feedMouseUp(1, 1);
+ etRunner::get().freezeEvent();
}
else if (states & TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_NOT_IDLE)
{
EINA_SAFETY_ON_FALSE_RETURN(tc_data->chk_cb_called_ == 2);
- gLoop->DelTimer();
+ etRunner::get().delTimer();
tc_data->chk_ev_state_not_idle_ = EINA_TRUE;
tc_data->chk_timeout_val_ = EINA_TRUE;
- gLoop->FinishWork();
+ etRunner::get().finishWork();
}
else
{
}
/* Name:
- * EtTestTzsh.scrsaver_basic
+ * etTestTzsh.scrsaver_basic
* Description:
* Check screensaver type window that is shown on the notification layer.
* Steps:
* Expected results:
* A window is shown on the notification layer.
*/
-TEST_F(EtTestTzsh, scrsaver_basic)
+TEST_F(etTestTzsh, scrsaver_basic)
{
Eina_List *list = NULL, *l = NULL;
- EtWin *tw = NULL;
+ etWin *tw = NULL;
- this->InitTC();
+ initTC();
- this->tzsh = tzsh_create(TZSH_TOOLKIT_TYPE_EFL);
- ASSERT_TRUE(this->tzsh != NULL);
+ tzsh = tzsh_create(TZSH_TOOLKIT_TYPE_EFL);
+ ASSERT_TRUE(tzsh != NULL);
- this->tz_win = elm_win_window_id_get(this->tw_base->elm_win);
- ASSERT_NE(0, this->tz_win);
+ tz_win = elm_win_window_id_get(tw_base->elm_win);
+ ASSERT_NE(0, tz_win);
- this->tz_scrsaver = tzsh_screensaver_service_create(this->tzsh, this->tz_win);
+ tz_scrsaver = tzsh_screensaver_service_create(tzsh, tz_win);
ASSERT_TRUE(tz_scrsaver != NULL);
- this->tw_base->UpdateGeometry();
- this->tw_base->Show();
- gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_ON);
+ tw_base->updateGeometry();
+ tw_base->show();
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
- if (tw->native_win != this->tw_base->native_win)
+ if (tw->native_win != tw_base->native_win)
continue;
// check layer
break;
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
}
/* Name:
- * EtTestTzsh.Screensaver_manager_basic
+ * etTestTzsh.Screensaver_manager_basic
* Description:
* Check screensaver manager APIs and 'state changed' callback
* Steps:
* TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_IDLE_TIMEOUT_EXPIRED event occurs.
* TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_NOT_IDLE event occurs.
*/
-TEST_F(EtTestTzsh, scrsaver_mng_basic)
+TEST_F(etTestTzsh, scrsaver_mng_basic)
{
- Eina_Bool result = EINA_FALSE;
-
- result = this->InitTC();
- ASSERT_TRUE(result);
+ Eina_Bool res = EINA_FALSE;
- this->tzsh = tzsh_create(TZSH_TOOLKIT_TYPE_EFL);
- ASSERT_TRUE(this->tzsh != NULL);
+ res = initTC();
+ ASSERT_TRUE(res);
- this->tz_win = elm_win_window_id_get(this->tw_base->elm_win);
- ASSERT_NE(0, this->tz_win);
+ tzsh = tzsh_create(TZSH_TOOLKIT_TYPE_EFL);
+ ASSERT_TRUE(tzsh != NULL);
- this->tz_scrsaver_mng = tzsh_screensaver_manager_service_create(this->tzsh, this->tz_win);
- ASSERT_TRUE(this->tz_scrsaver_mng != NULL);
+ tz_win = elm_win_window_id_get(tw_base->elm_win);
+ ASSERT_NE(0, tz_win);
- result = tzsh_screensaver_manager_service_idle_timeout_set(this->tz_scrsaver_mng, 1000);
- ASSERT_EQ(TZSH_ERROR_NONE, result);
+ tz_scrsaver_mng = tzsh_screensaver_manager_service_create(tzsh, tz_win);
+ ASSERT_TRUE(tz_scrsaver_mng != NULL);
- result = tzsh_screensaver_manager_service_enable(this->tz_scrsaver_mng);
- ASSERT_EQ(TZSH_ERROR_NONE, result);
+ res = tzsh_screensaver_manager_service_idle_timeout_set(tz_scrsaver_mng, 1000);
+ ASSERT_EQ(TZSH_ERROR_NONE, res);
- result = tzsh_screensaver_manager_service_state_change_cb_set(this->tz_scrsaver_mng,
- _cb_state_change,
- this);
- ASSERT_EQ(TZSH_ERROR_NONE, result);
+ res = tzsh_screensaver_manager_service_enable(tz_scrsaver_mng);
+ ASSERT_EQ(TZSH_ERROR_NONE, res);
- gLoop->SetWaitWorkTime(1.1);
- gLoop->FreezeEvent();
- gLoop->Work();
- gLoop->ThawEvent();
- gLoop->SetWaitWorkTime(E_TEST_WORK_TIME);
+ res = tzsh_screensaver_manager_service_state_change_cb_set(tz_scrsaver_mng,
+ _cb_state_change,
+ this);
+ ASSERT_EQ(TZSH_ERROR_NONE, res);
- ASSERT_TRUE(this->chk_ev_state_idle_timeout_);
- ASSERT_TRUE(this->chk_ev_state_not_idle_);
- ASSERT_TRUE(this->chk_timeout_val_);
- ASSERT_EQ(2, this->chk_cb_called_);
+ etRunner::get().setWaitTime(1.1);
+ etRunner::get().freezeEvent();
+ etRunner::get().work();
+ etRunner::get().thawEvent();
+ etRunner::get().setWaitTime(E_TEST_WORK_TIME);
+ ASSERT_TRUE(chk_ev_state_idle_timeout_);
+ ASSERT_TRUE(chk_ev_state_not_idle_);
+ ASSERT_TRUE(chk_timeout_val_);
+ ASSERT_EQ(2, chk_cb_called_);
}
using ::testing::Test;
-extern EtEventLoop *gLoop;
-
-class EtTestRotation : public ::testing::Test
+class etTestRotation : public ::testing::Test
{
- public:
- EtTestRotation()
- {
- };
- ~EtTestRotation()
- {
- if (HasFailure())
- gLoop->WaitForDestroy();
-
- if (tw_register)
- gLoop->DeregisterWin(tw_register);
-
- if (tw_base)
- {
- delete tw_base;
- }
-
- if (gLoop->HasLastWinInfoList())
- gLoop->FreeLastWinInfoList();
- };
-
- protected:
- const int rots[4] = {0, 90, 180, 270};
- EtWin *tw_base = NULL;
- EtWin *tw_register = NULL;
-
- int saved_rot_ = 0;
-
- Eina_Bool InitTC()
- {
- Eina_Bool result = EINA_FALSE;
-
- this->tw_base = new EtWin();
- result = this->tw_base->Init(NULL,
- ELM_WIN_BASIC,
- EINA_FALSE,
- "EtWin Rotation",
- 0, 0, 400, 400, EINA_FALSE,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_BLUE);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
- this->tw_base->native_win = gLoop->GetWinId(this->tw_base->elm_win);
-
- // available rotations
- elm_win_wm_rotation_available_rotations_set(this->tw_base->elm_win,
- this->rots, 4);
-
- result = gLoop->RegisterWin(this->tw_base);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- this->tw_register = this->tw_base;
-
- this->tw_base->UpdateGeometry();
- this->tw_base->Show();
- gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_ON);
-
- return EINA_TRUE;
- };
-
- Eina_Bool TestWinRotation(EtWin *tw, int rot)
- {
- Eina_Bool result = EINA_FALSE;
-
- result = gLoop->SetZoneRotation(rot);
- if (!result)
- {
- ERR("Changing rotation is denied.");
- return EINA_FALSE;
- }
-
- result = gLoop->WaitEvent(E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE);
- if (!result)
- {
- ERR("Failed waiting rotation change event");
- return EINA_FALSE;
- }
-
- result = gLoop->GetWinInfo(tw);
- if ((!result) || (tw->rot != rot))
- {
- ERR("Failed to rotate res %d, pass %d, result %d", result, rot, tw->rot);
- return EINA_FALSE;
- }
- return EINA_TRUE;
- };
+public:
+ etTestRotation() { };
+ ~etTestRotation()
+ {
+ if (HasFailure()) etRunner::get().waitForDestroy();
+ if (tw_register) etRunner::get().deregisterWin(tw_register);
+ if (tw_base) delete tw_base;
+
+ if (etRunner::get().hasLastWinInfoList())
+ etRunner::get().freeLastWinInfoList();
+ };
+
+protected:
+ const int rots[4] = {0, 90, 180, 270};
+ etWin *tw_base = NULL;
+ etWin *tw_register = NULL;
+
+ int saved_rot_ = 0;
+
+ Eina_Bool initTC();
+ Eina_Bool testWinRotation(etWin *tw, int rot);
};
-TEST_F(EtTestRotation, available_rotations)
+Eina_Bool
+etTestRotation::initTC()
+{
+ Eina_Bool res = EINA_FALSE;
+
+ tw_base = new etWin();
+ res = tw_base->init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "etWin Rotation",
+ 0, 0, 400, 400, EINA_FALSE,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_BLUE);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+ tw_base->native_win = etRunner::get().getWinId(tw_base->elm_win);
+
+ // available rotations
+ elm_win_wm_rotation_available_rotations_set(tw_base->elm_win, rots, 4);
+
+ res = etRunner::get().registerWin(tw_base);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ tw_register = tw_base;
+
+ tw_base->updateGeometry();
+ tw_base->show();
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+etTestRotation::testWinRotation(etWin *tw, int rot)
+{
+ Eina_Bool res = EINA_FALSE;
+
+ res = etRunner::get().setZoneRotation(rot);
+ if (!res)
+ {
+ ERR("Changing rotation is denied.");
+ return EINA_FALSE;
+ }
+
+ res = etRunner::get().waitEvent(E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE);
+ if (!res)
+ {
+ ERR("Failed waiting rotation change event");
+ return EINA_FALSE;
+ }
+
+ res = etRunner::get().getWinInfo(tw);
+ if ((!res) || (tw->rot != rot))
+ {
+ ERR("Failed to rotate res %d, pass %d, res %d", res, rot, tw->rot);
+ return EINA_FALSE;
+ }
+
+ return EINA_TRUE;
+}
+
+TEST_F(etTestRotation, available_rotations)
{
- Eina_Bool result = EINA_FALSE;
+ Eina_Bool res = EINA_FALSE;
int rot = 0;
- result = this->InitTC();
- ASSERT_TRUE(result);
+ res = initTC();
+ ASSERT_TRUE(res);
- result = gLoop->GetWinInfo(this->tw_base);
- ASSERT_TRUE(result);
+ res = etRunner::get().getWinInfo(tw_base);
+ ASSERT_TRUE(res);
- this->saved_rot_ = this->tw_base->rot;
+ saved_rot_ = tw_base->rot;
- for (rot = ((this->saved_rot_ + 90) % 360);
- rot == this->saved_rot_;
+ for (rot = ((saved_rot_ + 90) % 360);
+ rot == saved_rot_;
rot = ((rot + 90) % 360))
{
/* hard coded, reverse portrait(180) mode is disabled in mobile */
if (rot == 180) continue;
- result = this->TestWinRotation(this->tw_base, rot);
- ASSERT_TRUE(result);
+ res = testWinRotation(tw_base, rot);
+ ASSERT_TRUE(res);
}
}
using ::testing::Test;
-extern EtEventLoop *gLoop;
-
-class EtTestFocus : public ::testing::Test
+class etTestFocus : public ::testing::Test
{
- public:
- EtTestFocus()
- {
- };
- ~EtTestFocus()
- {
- if (HasFailure())
- gLoop->WaitForDestroy();
-
- if (this->tw_register)
- {
- gLoop->DeregisterWin(this->tw_register);
- this->tw_register = NULL;
- }
-
- if (this->tw_red)
- {
- delete this->tw_red;
- this->tw_red = NULL;
- }
-
- if (this->tw_green)
- {
- delete this->tw_green;
- this->tw_green = NULL;
- }
-
- if (this->tw_blue)
- {
- delete this->tw_blue;
- this->tw_blue = NULL;
- }
-
- if (gLoop->HasLastWinInfoList())
- gLoop->FreeLastWinInfoList();
- };
-
- protected:
- EtWin *tw_red = NULL;
- EtWin *tw_green = NULL;
- EtWin *tw_blue = NULL;
-
- EtWin *tw_register = NULL;
-
- Eina_Bool InitTC(Eina_Bool show_win, Eina_Bool use_geom)
- {
- Eina_Bool result = EINA_FALSE;
-
- this->tw_red = new EtWin();
- result = this->tw_red->Init(NULL,
- ELM_WIN_BASIC,
- EINA_FALSE,
- "EtWin Red",
- 0, 0, 720, 640, EINA_FALSE,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_RED);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
- this->tw_red->native_win = gLoop->GetWinId(this->tw_red->elm_win);
-
- if (show_win)
- {
- this->tw_red->UpdateGeometry();
- this->tw_red->Show();
- }
-
- this->tw_green = new EtWin();
- result = this->tw_green->Init(NULL,
- ELM_WIN_BASIC,
- EINA_FALSE,
- "EtWin Green",
- 0, 0, 720, 640, EINA_FALSE,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_GREEN);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
- this->tw_green->native_win = gLoop->GetWinId(this->tw_green->elm_win);
-
- if (show_win)
- {
- this->tw_green->UpdateGeometry();
- this->tw_green->Show();
- }
-
- this->tw_blue = new EtWin();
- result = this->tw_blue->Init(NULL,
- ELM_WIN_BASIC,
- EINA_FALSE,
- "EtWin Blue",
- 0, 0, 720, 640, use_geom,
- E_LAYER_CLIENT_NORMAL,
- E_TC_WIN_COLOR_GREEN);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
- this->tw_blue->native_win = gLoop->GetWinId(this->tw_blue->elm_win);
-
- if (show_win)
- {
- this->tw_blue->UpdateGeometry();
- this->tw_blue->Show();
-
- this->RegisterTCWin(this->tw_blue);
- }
-
- gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_ON);
-
- return EINA_TRUE;
- };
-
- Eina_Bool RegisterTCWin(EtWin *tw)
- {
- Eina_Bool result = EINA_FALSE;
-
- EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
-
- if (this->tw_register)
- {
- result = gLoop->DeregisterWin(this->tw_register);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- this->tw_register = NULL;
- }
-
- result = gLoop->RegisterWin(tw);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- this->tw_register = tw;
-
- return EINA_TRUE;
- };
-
- Eina_Bool ShowTCWin(EtWin *tw)
- {
- Eina_Bool result = EINA_FALSE;
-
- EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
-
- result = this->RegisterTCWin(tw);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
-
- tw->UpdateGeometry();
- tw->Show();
-
- return EINA_TRUE;
- };
+public:
+ etTestFocus() { };
+ ~etTestFocus()
+ {
+ if (HasFailure()) etRunner::get().waitForDestroy();
+ if (tw_register)
+ {
+ etRunner::get().deregisterWin(tw_register);
+ tw_register = NULL;
+ }
+ if (tw_red)
+ {
+ delete tw_red;
+ tw_red = NULL;
+ }
+ if (tw_green)
+ {
+ delete tw_green;
+ tw_green = NULL;
+ }
+ if (tw_blue)
+ {
+ delete tw_blue;
+ tw_blue = NULL;
+ }
+ if (etRunner::get().hasLastWinInfoList())
+ etRunner::get().freeLastWinInfoList();
+ };
+
+protected:
+ etWin *tw_red = NULL;
+ etWin *tw_green = NULL;
+ etWin *tw_blue = NULL;
+ etWin *tw_register = NULL;
+
+ Eina_Bool initTC(Eina_Bool show_win, Eina_Bool use_geom);
+ Eina_Bool registerTCWin(etWin *tw);
+ Eina_Bool showTCWin(etWin *tw);
};
-TEST_F(EtTestFocus, focus_basic)
+Eina_Bool
+etTestFocus::initTC(Eina_Bool show_win, Eina_Bool use_geom)
+{
+ Eina_Bool res = EINA_FALSE;
+
+ tw_red = new etWin();
+ res = tw_red->init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "etWin Red",
+ 0, 0, 720, 640, EINA_FALSE,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_RED);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+ tw_red->native_win = etRunner::get().getWinId(tw_red->elm_win);
+
+ if (show_win)
+ {
+ tw_red->updateGeometry();
+ tw_red->show();
+ }
+
+ tw_green = new etWin();
+ res = tw_green->init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "etWin Green",
+ 0, 0, 720, 640, EINA_FALSE,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_GREEN);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+ tw_green->native_win = etRunner::get().getWinId(tw_green->elm_win);
+
+ if (show_win)
+ {
+ tw_green->updateGeometry();
+ tw_green->show();
+ }
+
+ tw_blue = new etWin();
+ res = tw_blue->init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "etWin Blue",
+ 0, 0, 720, 640, use_geom,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_GREEN);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+ tw_blue->native_win = etRunner::get().getWinId(tw_blue->elm_win);
+
+ if (show_win)
+ {
+ tw_blue->updateGeometry();
+ tw_blue->show();
+
+ registerTCWin(tw_blue);
+ }
+
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_ON);
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+etTestFocus::registerTCWin(etWin *tw)
+{
+ Eina_Bool res = EINA_FALSE;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
+
+ 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
+etTestFocus::showTCWin(etWin *tw)
+{
+ Eina_Bool res = EINA_FALSE;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
+
+ res = registerTCWin(tw);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ tw->updateGeometry();
+ tw->show();
+
+ return EINA_TRUE;
+}
+
+TEST_F(etTestFocus, focus_basic)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
- result = this->InitTC(EINA_TRUE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(res);
- // Expected focus result:
+ // Expected focus res:
// [Top] Blue[focused] -> Green -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
- if (tw->native_win == this->tw_blue->native_win)
+ if (tw->native_win == tw_blue->native_win)
ASSERT_TRUE(tw->Focus.obj);
else
ASSERT_FALSE(tw->Focus.obj);
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
}
-TEST_F(EtTestFocus, focus_lower)
+TEST_F(etTestFocus, focus_lower)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
- result = this->InitTC(EINA_TRUE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(res);
// make tw_blue lower
- result = gLoop->SetWinStack(this->tw_blue, NULL, EINA_FALSE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
- ASSERT_TRUE(result);
+ res = etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ ASSERT_TRUE(res);
- // Expected focus result:
+ // Expected focus res:
// [Top] Green[focused] -> Red -> ... -> Blue [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
- if (tw->native_win == this->tw_green->native_win)
+ if (tw->native_win == tw_green->native_win)
ASSERT_TRUE(tw->Focus.obj);
else
ASSERT_FALSE(tw->Focus.obj);
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
}
-TEST_F(EtTestFocus, focus_raise)
+TEST_F(etTestFocus, focus_raise)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
- result = this->InitTC(EINA_TRUE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(res);
// make tw_red raise
- result = gLoop->SetWinStack(this->tw_red, NULL, EINA_TRUE);
- gLoop->WaitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
- ASSERT_TRUE(result);
+ res = etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE);
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ ASSERT_TRUE(res);
- // Expected focus result:
+ // Expected focus res:
// [Top] Red[focused] -> Blue -> Green [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
- if (tw->native_win == this->tw_red->native_win)
+ if (tw->native_win == tw_red->native_win)
ASSERT_TRUE(tw->Focus.obj);
else
ASSERT_FALSE(tw->Focus.obj);
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
}
-TEST_F(EtTestFocus, focus_destroy)
+TEST_F(etTestFocus, focus_destroy)
{
- EtWin *tw = NULL;
- Eina_Bool result = EINA_FALSE;
+ etWin *tw = NULL;
+ Eina_Bool res = EINA_FALSE;
Eina_List *list = NULL, *l = NULL;
- result = this->InitTC(EINA_TRUE, EINA_FALSE);
- ASSERT_TRUE(result);
+ res = initTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(res);
// delete tw_blue
- this->tw_blue->Hide();
- delete this->tw_blue;
- this->tw_blue = NULL;
- gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_OFF);
+ tw_blue->hide();
+ delete tw_blue;
+ tw_blue = NULL;
+ etRunner::get().waitEvent(E_TC_EVENT_TYPE_VIS_OFF);
- // Expected focus result:
+ // Expected focus res:
// [Top] Green[focused] -> Red [Bottom]
- list = gLoop->GetWinInfoList();
+ list = etRunner::get().getWinInfoList();
ASSERT_TRUE(list != NULL);
- EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
{
- if (tw->native_win == this->tw_green->native_win)
+ if (tw->native_win == tw_green->native_win)
ASSERT_TRUE(tw->Focus.obj);
else
ASSERT_FALSE(tw->Focus.obj);
}
- gLoop->FreeWinInfoList(list);
+ etRunner::get().freeWinInfoList(list);
}
projects / platform / core / uifw / e-tizen-testcase.git / commitdiff