e_tizen_testcase: Added eventItem class for containing result of event.

Added "eventItem" class is result of waitEvent method and it's for store
result of event.
TC developer can inherit eventItem to make custom result.

Changes
- Added eventItem class.
- waitEvent returns shared pointer of eventItem instead of Eina_Bool.
- legacy insertEventQueue creates eventItem and enqueue them to event
queue.
- new overloaded insertEventQueue(eventItem).
- existing testcases are changed using eventItem.

Change-Id: Ic9b65d2a3e958a0619136bf8e85a175cbfacbe01

diff --git a/src/e_test_event.cpp b/src/e_test_event.cpp
index 9c965d8..84b2929 100644 (file)
--- a/src/e_test_event.cpp
+++ b/src/e_test_event.cpp
@@ -1240,12 +1240,11 @@ etRunner::delSupportedAuxHint(const char *hint)
    return EINA_TRUE;
 }
 
-Eina_Bool
+std::shared_ptr<eventItem>
 etRunner::waitEvent(etWin *win, E_TC_Event_Type ev_type)
 {
-   E_TC_Event_Item *recv_item = NULL;
-   Eina_Bool res = EINA_FALSE;
-   Eina_List *l = NULL;
+   std::shared_ptr<eventItem> recv_item = NULL;
+   std::list<std::shared_ptr<eventItem>>::iterator itr;
 
    // swap event
    switch (ev_type)
@@ -1290,47 +1289,74 @@ etRunner::waitEvent(etWin *win, E_TC_Event_Type ev_type)
    // pre-waiting events
    work(0.5);
 
-   if (ev.wait_event_index == ev.last_event)
+   if (*ev.wait_event_index == ev.last_event)
      {
         work(0.5); // waiting additional time
-        if (ev.wait_event_index == ev.last_event)
-          return EINA_FALSE;
+        if (*ev.wait_event_index == ev.last_event)
+        {
+           std::shared_ptr<eventItem> res = std::make_shared<eventItem>(0, E_TC_EVENT_TYPE_NONE);
+           res->result = EINA_FALSE;
+           res->isTimeout = EINA_TRUE;
+          return res;
+        }
      }
 
-   EINA_LIST_CAST_FOREACH(ev.recv_queue, l, recv_item, E_TC_Event_Item*)
+   // search from latest waitEvent called point
+   itr = ev.wait_event_index;
+   if (itr == ev.recv_queue.end()) itr = ev.recv_queue.begin();
+   else itr++;
+
+   for (; itr != ev.recv_queue.end() ; itr++)
      {
-        if ((recv_item->win == (win?win->native_win:0)) &&
-            (recv_item->type == ev_type))
+        recv_item = *itr;
+        if ((recv_item->isSameWin(win?win->native_win:0)) &&
+            (recv_item->isSameType(ev_type)))
           {
-             ev.wait_event_index = recv_item;
-             res = EINA_TRUE;
-             break;
+             ev.wait_event_index = itr;
+             recv_item->result = EINA_TRUE;
+             return recv_item;
           }
      }
 
-   return res;
+   if (recv_item == NULL)
+   {
+      recv_item = std::make_shared<eventItem>(0, E_TC_EVENT_TYPE_NONE);
+      recv_item->result = EINA_FALSE;
+   }
+   return recv_item;
 }
 
 void
 etRunner::flushEventQueue()
 {
-   if (ev.recv_queue)
-     {
-        ev.recv_queue = eina_list_free(ev.recv_queue);
-        ev.recv_queue = NULL;
-     }
+   std::list<std::shared_ptr<eventItem>>::iterator itr;
+   std::shared_ptr<eventItem> ei = NULL;
+   if (!ev.recv_queue.empty())
+        ev.recv_queue.erase(ev.recv_queue.begin(), ev.recv_queue.end());
+   ev.wait_event_index = ev.recv_queue.end();
+   ev.last_event = NULL;
+   ev.last_checkpoint = NULL;
+}
+
+Eina_Bool
+etRunner::insertEventQueue(std::shared_ptr<eventItem> ei)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ei, EINA_FALSE);
+
+   ev.recv_queue.push_back(ei);
+   ev.last_event = ei;
+
+   return EINA_TRUE;
 }
 
 Eina_Bool
 etRunner::insertEventQueue(Ecore_Window id, E_TC_Event_Type ev_type)
 {
-   E_TC_Event_Item *item = E_NEW(E_TC_Event_Item, 1);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(item, EINA_FALSE);
+   std::shared_ptr<eventItem> ei = std::make_shared<eventItem>(id, ev_type);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ei, EINA_FALSE);
 
-   item->win = id;
-   item->type = ev_type;
-   ev.recv_queue = eina_list_append(ev.recv_queue, item);
-   ev.last_event = item;
+   ev.recv_queue.push_back(ei);
+   ev.last_event = ei;
 
    return EINA_TRUE;
 }
@@ -1338,16 +1364,18 @@ etRunner::insertEventQueue(Ecore_Window id, E_TC_Event_Type ev_type)
 Eina_Bool
 etRunner::isEventOccuredAfterCheckpoint(etWin *tw, E_TC_Event_Type ev_type)
 {
-   Eina_List *l = NULL;
-   E_TC_Event_Item *item = NULL;
+   std::list<std::shared_ptr<eventItem>>::iterator itr;
+   std::shared_ptr<eventItem> ei = NULL;
    Ecore_Window id = tw->native_win;
 
-   EINA_LIST_CAST_FOREACH(ev.recv_queue, l, item, E_TC_Event_Item*)
+   for(itr = ev.recv_queue.begin() ; itr != ev.recv_queue.end() ; itr++)
      {
-        if (ev.last_checkpoint && ev.last_checkpoint != item)
+        ei = *itr;
+
+        if (ev.last_checkpoint && ev.last_checkpoint != ei)
           continue;
 
-        if ((item->win == id) && (item->type == ev_type))
+        if (ei->isSameWin(id) && ei->isSameType(ev_type))
           return EINA_TRUE;
      }
 

diff --git a/src/e_test_event.h b/src/e_test_event.h
index be23b1d..908957f 100644 (file)
--- a/src/e_test_event.h
+++ b/src/e_test_event.h
@@ -7,6 +7,30 @@
 #include "e_test_util.h"
 #include "e_test_win.h"
 
+class eventItem
+{
+public:
+   eventItem() = delete;
+   eventItem(Ecore_Window win, E_TC_Event_Type type) :
+   result(EINA_FALSE),
+   isTimeout(EINA_FALSE),
+   win(win),
+   type(type){}
+
+   ~eventItem() {}
+
+public:
+   Eina_Bool isSameWin(Ecore_Window win) { return win == this->win; }
+   Eina_Bool isSameType(E_TC_Event_Type type) {return type == this->type; }
+
+   Eina_Bool result;
+   Eina_Bool isTimeout;
+
+protected:
+   Ecore_Window win;
+   E_TC_Event_Type type;
+};
+
 class etRunner
 {
 private:
@@ -70,11 +94,11 @@ public: /* TODO: make it hidden */
 
         Eina_List *sh_list;
         Eina_List *eh_list;
-        Eina_List *recv_queue;
+        std::list<std::shared_ptr<eventItem>> recv_queue;
 
-        E_TC_Event_Item *wait_event_index;
-        E_TC_Event_Item *last_event;
-        E_TC_Event_Item *last_checkpoint;
+        std::list<std::shared_ptr<eventItem>>::iterator wait_event_index;
+        std::shared_ptr<eventItem>  last_event;
+        std::shared_ptr<eventItem>  last_checkpoint;
 
         struct
           {
@@ -178,12 +202,13 @@ public:
    Eina_Bool     setWinEffect(etWin *tw);
    Eina_Bool     freezeEvent();
    Eina_Bool     thawEvent();
-   Eina_Bool     waitEvent(etWin *win, E_TC_Event_Type ev_type);
    Eina_Bool     addSupportedAuxHint(const char *hint);
    Eina_Bool     delSupportedAuxHint(const char *hint);
+   std::shared_ptr<eventItem> waitEvent(etWin *win, E_TC_Event_Type ev_type);
    Eina_Bool     requestKillWinByName(const char *name);
 
    void          flushEventQueue();
+   Eina_Bool     insertEventQueue(std::shared_ptr<eventItem> item);
    Eina_Bool     insertEventQueue(Ecore_Window id, E_TC_Event_Type ev_type);
    Eina_Bool     isEventOccuredAfterCheckpoint(etWin *tw, E_TC_Event_Type ev_type);
    void          setEventCheckpoint();

diff --git a/src/e_test_util.h b/src/e_test_util.h
index 39fff7b..280a8cd 100644 (file)
--- a/src/e_test_util.h
+++ b/src/e_test_util.h
@@ -1,10 +1,13 @@
+#ifndef E_TC_MAIN_H
+#define E_TC_MAIN_H
+
+#include <memory>
+#include <list>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#ifndef E_TC_MAIN_H
-#define E_TC_MAIN_H
-
 #include "config.h"
 #include "eina_list_ext.h"
 #include <Eldbus.h>
@@ -172,12 +175,6 @@ typedef struct _Window_Info_List
    Eina_Bool  retry;
 } Window_Info_List;
 
-typedef struct _E_TC_Event_Item
-{
-   Ecore_Window win;
-   E_TC_Event_Type type;
-} E_TC_Event_Item;
-
 #define EFL_UTIL_RETURN_TO_STRING(type)                                                 \
        ((type == EFL_UTIL_ERROR_NONE)?"None":                                           \
         (type == EFL_UTIL_ERROR_INVALID_PARAMETER)?"Invalid parameter":                 \
@@ -191,8 +188,10 @@ typedef struct _E_TC_Event_Item
         (type == EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL)?"Screenshot execution fail": \
         (type == EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE)?"No resource available":         \
         "Unknown")
-#endif // end of E_TC_MAIN_H
+
 
 #ifdef __cplusplus
 }
 #endif
+
+#endif // end of E_TC_MAIN_H

diff --git a/src/testcase/0007_rotation.cpp b/src/testcase/0007_rotation.cpp
index 0c02a6b..282812e 100644 (file)
--- a/src/testcase/0007_rotation.cpp
+++ b/src/testcase/0007_rotation.cpp
@@ -33,6 +33,7 @@ Eina_Bool
 etTestRotation::testWinRotation(etWin *tw, int rot)
 {
    Eina_Bool res = EINA_FALSE;
+   std::shared_ptr<eventItem> ei = NULL;
 
    res = etRunner::get().setZoneRotation(rot);
    if (!res)
@@ -41,9 +42,9 @@ etTestRotation::testWinRotation(etWin *tw, int rot)
         return EINA_FALSE;
      }
 
-   res = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE);
+   ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE);
 
-   if (!res)
+   if (!ei)
      {
         ERR("Failed waiting rotation change event");
         return EINA_FALSE;

diff --git a/src/testcase/0009_input.cpp b/src/testcase/0009_input.cpp
index ce802ca..5421694 100644 (file)
--- a/src/testcase/0009_input.cpp
+++ b/src/testcase/0009_input.cpp
@@ -29,13 +29,14 @@ protected:
 
 TEST_F(etTestInput, keygrab_nowin_shared)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool ret = EINA_FALSE;
    ret = ecore_wl2_window_keygrab_set(NULL, "XF86Menu", 0, 0, 0, ECORE_WL2_WINDOW_KEYGRAB_SHARED);
    ASSERT_TRUE(ret);
 
    etRunner::get().generateKeyEvent(key_name, 0.3);
-   ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
+   ASSERT_TRUE(ei != NULL);
 
    ret = ecore_wl2_window_keygrab_unset(NULL, "XF86Menu", 0, 0);
    ASSERT_TRUE(ret);
@@ -43,13 +44,15 @@ TEST_F(etTestInput, keygrab_nowin_shared)
 
 TEST_F(etTestInput, keygrab_nowin_orexcl)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool ret = EINA_FALSE;
+
    ret = ecore_wl2_window_keygrab_set(NULL, "XF86Menu", 0, 0, 0, ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE);
    ASSERT_TRUE(ret);
 
    etRunner::get().generateKeyEvent(key_name, 0.3);
-   ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
+   ASSERT_TRUE(ei != NULL);
 
    ret = ecore_wl2_window_keygrab_unset(NULL, "XF86Menu", 0, 0);
    ASSERT_TRUE(ret);
@@ -57,13 +60,15 @@ TEST_F(etTestInput, keygrab_nowin_orexcl)
 
 TEST_F(etTestInput, keygrab_nowin_excl)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool ret = EINA_FALSE;
+
    ret = ecore_wl2_window_keygrab_set(NULL, "XF86Menu", 0, 0, 0, ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE);
    ASSERT_TRUE(ret);
 
    etRunner::get().generateKeyEvent(key_name, 0.3);
-   ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
+   ASSERT_TRUE(ei != NULL);
 
    ret = ecore_wl2_window_keygrab_unset(NULL, "XF86Menu", 0, 0);
    ASSERT_TRUE(ret);
@@ -71,6 +76,7 @@ TEST_F(etTestInput, keygrab_nowin_excl)
 
 TEST_F(etTestInput, keygrab_win_shared)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool ret = EINA_FALSE;
 
    tw_shared = initNormalWin("TCWin_SharedGrab", EINA_FALSE);
@@ -91,8 +97,8 @@ TEST_F(etTestInput, keygrab_win_shared)
    ASSERT_TRUE(ret);
 
    etRunner::get().generateKeyEvent(key_name, 0.3);
-   ret = etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+   ASSERT_TRUE(ei != NULL);
 
    etRunner::get().ev.elm_win = NULL;
    etRunner::get().ev.native_win = 0;
@@ -104,6 +110,7 @@ TEST_F(etTestInput, keygrab_win_shared)
 
 TEST_F(etTestInput, keygrab_win_orexcl)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool ret = EINA_FALSE;
 
    tw_orexcl = initNormalWin("TCWin_OrexclGrab", EINA_FALSE);
@@ -124,8 +131,8 @@ TEST_F(etTestInput, keygrab_win_orexcl)
    ASSERT_TRUE(ret);
 
    etRunner::get().generateKeyEvent(key_name, 0.3);
-   ret = etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+   ASSERT_TRUE(ei);
 
    etRunner::get().ev.elm_win = NULL;
    etRunner::get().ev.native_win = 0;
@@ -137,6 +144,7 @@ TEST_F(etTestInput, keygrab_win_orexcl)
 
 TEST_F(etTestInput, keygrab_win_excl)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool ret = EINA_FALSE;
 
    tw_excl = initNormalWin("TCWin_ExclGrab", EINA_FALSE);
@@ -157,8 +165,8 @@ TEST_F(etTestInput, keygrab_win_excl)
    ASSERT_TRUE(ret);
 
    etRunner::get().generateKeyEvent(key_name, 0.3);
-   ret = etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+   ASSERT_TRUE(ei);
 
    etRunner::get().ev.elm_win = NULL;
    etRunner::get().ev.native_win = 0;
@@ -170,6 +178,7 @@ TEST_F(etTestInput, keygrab_win_excl)
 
 TEST_F(etTestInput, keygrab_win_topposition)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool ret = EINA_FALSE;
 
    tw_topposition = initNormalWin("TCWin_ToppositionGrab", EINA_TRUE);
@@ -189,8 +198,8 @@ TEST_F(etTestInput, keygrab_win_topposition)
    etRunner::get().ev.native_win = tw_topposition->native_win;
 
    etRunner::get().generateKeyEvent(key_name, 0.3);
-   ret = etRunner::get().waitEvent(tw_topposition, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(tw_topposition, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+   ASSERT_TRUE(ei);
 
    etRunner::get().ev.elm_win = NULL;
    etRunner::get().ev.native_win = 0;
@@ -202,6 +211,7 @@ TEST_F(etTestInput, keygrab_win_topposition)
 
 TEST_F(etTestInput, keygrab_win)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool ret = EINA_FALSE;
 
    tw_shared = initNormalWin("TCWin_SharedGrab", EINA_FALSE);
@@ -267,8 +277,8 @@ TEST_F(etTestInput, keygrab_win)
    etRunner::get().ev.native_win = tw_excl->native_win;
 
    etRunner::get().generateKeyEvent(key_name, 0.3);
-   ret = etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+   ASSERT_TRUE(ei != NULL);
 
    evas_object_key_ungrab(tw_excl->elm_win, "XF86Menu", 0, 0);
    ret = elm_win_keygrab_unset(tw_excl->elm_win, "XF86Menu", 0, 0);
@@ -279,8 +289,8 @@ TEST_F(etTestInput, keygrab_win)
    etRunner::get().ev.native_win = tw_orexcl->native_win;
 
    etRunner::get().generateKeyEvent(key_name, 0.3);
-   ret = etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+   ASSERT_TRUE(ei != NULL);
 
    evas_object_key_ungrab(tw_orexcl->elm_win, "XF86Menu", 0, 0);
    ret = elm_win_keygrab_unset(tw_orexcl->elm_win, "XF86Menu", 0, 0);
@@ -291,8 +301,8 @@ TEST_F(etTestInput, keygrab_win)
    etRunner::get().ev.native_win = tw_topposition->native_win;
 
    etRunner::get().generateKeyEvent(key_name, 0.3);
-   ret = etRunner::get().waitEvent(tw_topposition, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(tw_topposition, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+   ASSERT_TRUE(ei != NULL);
 
    evas_object_key_ungrab(tw_topposition->elm_win, "XF86Menu", 0, 0);
    ret = elm_win_keygrab_unset(tw_topposition->elm_win, "XF86Menu", 0, 0);
@@ -303,8 +313,8 @@ TEST_F(etTestInput, keygrab_win)
    etRunner::get().ev.native_win = tw_shared->native_win;
 
    etRunner::get().generateKeyEvent(key_name, 0.3);
-   ret = etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
+   ASSERT_TRUE(ei != NULL);
 
    evas_object_key_ungrab(tw_shared->elm_win, "XF86Menu", 0, 0);
    ret = elm_win_keygrab_unset(tw_shared->elm_win, "XF86Menu", 0, 0);
@@ -316,6 +326,7 @@ TEST_F(etTestInput, keygrab_win)
 
 TEST_F(etTestInput, gesture_tap22)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    int ret = EFL_UTIL_ERROR_NONE;
    efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler();
    efl_util_gesture_data tap_d;
@@ -331,8 +342,8 @@ TEST_F(etTestInput, gesture_tap22)
    etRunner::get().ev.gesture.tap.repeats = 2;
 
    etRunner::get().generateTapGesture();
-   ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_TAP);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_TAP);
+   ASSERT_TRUE(ei != NULL);
 
    etRunner::get().ev.gesture.tap.fingers = 0;
    etRunner::get().ev.gesture.tap.repeats = 0;
@@ -344,6 +355,7 @@ TEST_F(etTestInput, gesture_tap22)
 
 TEST_F(etTestInput, gesture_tap23)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    int ret = EFL_UTIL_ERROR_NONE;
    efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler();
    efl_util_gesture_data tap_d;
@@ -359,8 +371,8 @@ TEST_F(etTestInput, gesture_tap23)
    etRunner::get().ev.gesture.tap.repeats = 3;
 
    etRunner::get().generateTapGesture();
-   ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_TAP);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_TAP);
+   ASSERT_TRUE(ei != NULL);
 
    etRunner::get().ev.gesture.tap.fingers = 0;
    etRunner::get().ev.gesture.tap.repeats = 0;
@@ -376,6 +388,7 @@ TEST_F(etTestInput, gesture_tap23)
 static void
 _test_gesture_edge_swipe(int fingers, efl_util_gesture_edge_e edge)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    int ret = EFL_UTIL_ERROR_NONE;
    efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler();
    efl_util_gesture_data edge_swipe_d;
@@ -391,8 +404,8 @@ _test_gesture_edge_swipe(int fingers, efl_util_gesture_edge_e edge)
    etRunner::get().ev.gesture.edge.edge = edge;
 
    etRunner::get().generateEdgeSwipeGesture();
-   ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE);
+   ASSERT_TRUE(ei != NULL);
 
    etRunner::get().ev.gesture.edge.fingers = 0;
    etRunner::get().ev.gesture.edge.edge = EFL_UTIL_GESTURE_EDGE_NONE;;
@@ -449,6 +462,7 @@ TEST_F(etTestInput, gesture_edge_swipe24)
 static void
 _test_gesture_edge_drag(int fingers, efl_util_gesture_edge_e edge)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    int ret = EFL_UTIL_ERROR_NONE;
    efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler();
    efl_util_gesture_data edge_drag_d;
@@ -464,8 +478,8 @@ _test_gesture_edge_drag(int fingers, efl_util_gesture_edge_e edge)
    etRunner::get().ev.gesture.edge.edge = edge;
 
    etRunner::get().generateEdgeDragGesture();
-   ret = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG);
+   ASSERT_TRUE(ei != NULL);
 
    etRunner::get().ev.gesture.edge.fingers = 0;
    etRunner::get().ev.gesture.edge.edge = EFL_UTIL_GESTURE_EDGE_NONE;;

diff --git a/src/testcase/0010_splash.cpp b/src/testcase/0010_splash.cpp
index df8a07f..440c933 100644 (file)
--- a/src/testcase/0010_splash.cpp
+++ b/src/testcase/0010_splash.cpp
@@ -113,14 +113,14 @@ TEST_F(etTestSplash, splash_evas_callback_after_real)
 {
    etWin *tw2 = NULL;
    Eina_List *list = NULL, *l = NULL;
-   Eina_Bool ret = EINA_FALSE;
+   std::shared_ptr<eventItem> ei = NULL;
 
    initTC((char*)path_img, SPLASH_TYPE_IMG);
    etRunner::get().setSplashOwner();
 
    showTCWin(tw);
-   ret = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
-   ASSERT_TRUE(ret);
+   ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
+   ASSERT_TRUE(ei != NULL);
 
    // Expected focus res:
    list = etRunner::get().getWinInfoList();

diff --git a/src/testcase/0011_effect.cpp b/src/testcase/0011_effect.cpp
index fd7b62e..9745664 100644 (file)
--- a/src/testcase/0011_effect.cpp
+++ b/src/testcase/0011_effect.cpp
@@ -26,6 +26,7 @@ etTestEffect::initTC()
 
 TEST_F(etTestEffect, effect_show)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool res = EINA_FALSE;
 
    initTC();
@@ -35,14 +36,15 @@ TEST_F(etTestEffect, effect_show)
 
    showTCWin(tw);
 
-   res = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT);
-   ASSERT_TRUE(res);
+   ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT);
+   ASSERT_TRUE(ei != NULL);
 
    return;
 }
 
 TEST_F(etTestEffect, effect_show_evas_callback)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool res = EINA_FALSE;
 
    initTC();
@@ -52,14 +54,15 @@ TEST_F(etTestEffect, effect_show_evas_callback)
 
    showTCWin(tw);
 
-   res = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
-   ASSERT_TRUE(res);
+   ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
+   ASSERT_TRUE(ei != NULL);
 
    return;
 }
 
 TEST_F(etTestEffect, effect_hide_bylower)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool res = EINA_FALSE;
 
    initTC();
@@ -70,14 +73,15 @@ TEST_F(etTestEffect, effect_hide_bylower)
    res = etRunner::get().setWinEffect(tw);
    ASSERT_TRUE(res);
    elm_win_lower(tw->elm_win);
-   res = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT);
-   ASSERT_TRUE(res);
+   ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT);
+   ASSERT_TRUE(ei != NULL);
 
    return;
 }
 
 TEST_F(etTestEffect, effect_hide_byunmap)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool res = EINA_FALSE;
 
    initTC();
@@ -88,14 +92,15 @@ TEST_F(etTestEffect, effect_hide_byunmap)
    res = etRunner::get().setWinEffect(tw);
    ASSERT_TRUE(res);
    tw->hide();
-   res = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT);
-   ASSERT_TRUE(res);
+   ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT);
+   ASSERT_TRUE(ei != NULL);
 
    return;
 }
 
 TEST_F(etTestEffect, effect_bg)
 {
+   std::shared_ptr<eventItem> ei = NULL;
    Eina_Bool res = EINA_FALSE;
 
    initTC();
@@ -107,8 +112,8 @@ TEST_F(etTestEffect, effect_bg)
    ASSERT_TRUE(res);
    //show upper window
    showTCWin(tw_green);
-   res = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT);
-   ASSERT_TRUE(res);
+   ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT);
+   ASSERT_TRUE(ei != NULL);
 
    return;
 }