From 66dd4883eaf4952b41785a8000bdad1413610b98 Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Wed, 14 Apr 2021 10:49:27 +0900 Subject: [PATCH 01/16] e_test_event: Added auxHintEventItem class. Added auxHintEventItem class inherits eventItem. It will be used by Aux hint test cases. Change-Id: I07906ae3cbd0eb09a3cf1fa22fc8e6680cdc9194 --- src/e_test_event.cpp | 6 +++++- src/e_test_event.h | 28 ++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 1 deletion(-) diff --git a/src/e_test_event.cpp b/src/e_test_event.cpp index 84b2929..94d4dd5 100644 --- a/src/e_test_event.cpp +++ b/src/e_test_event.cpp @@ -2047,6 +2047,7 @@ _cb_signal_aux_hint_changed(void *data, Eina_Bool res = EINA_FALSE; Ecore_Window win = 0; uint32_t hint_id; + std::shared_ptr hint = NULL; const char *hint_key, *hint_val; res = eldbus_message_error_get(msg, &name, &text); @@ -2055,7 +2056,10 @@ _cb_signal_aux_hint_changed(void *data, res = eldbus_message_arguments_get(msg, "uuss", &win, &hint_id, &hint_key, &hint_val); EINA_SAFETY_ON_FALSE_GOTO(res, finish); - runner->insertEventQueue(win, E_TC_EVENT_TYPE_AUX_HINT_CHANGED); + hint = std::make_shared(win, E_TC_EVENT_TYPE_AUX_HINT_CHANGED, hint_id, hint_key, hint_val); + EINA_SAFETY_ON_NULL_GOTO(hint, finish); + + runner->insertEventQueue(hint); finish: if ((name) || (text)) diff --git a/src/e_test_event.h b/src/e_test_event.h index 908957f..c8c7fd5 100644 --- a/src/e_test_event.h +++ b/src/e_test_event.h @@ -31,6 +31,34 @@ protected: E_TC_Event_Type type; }; +class auxHintEventItem : public eventItem +{ +public: + auxHintEventItem() = delete; + auxHintEventItem (Ecore_Window win, E_TC_Event_Type type, int id, const char *hint, const char *val) : + eventItem(win, type), + id(id), + hint(std::string(hint)), + val(std::string(val)) + { + } + ~auxHintEventItem() + { + } + + Eina_Bool isSameID(int id) { return id == this->id; } + Eina_Bool isSameHint(std::string hint) { return !strncmp(hint.c_str(), this->hint.c_str(), hint.size()); } + Eina_Bool isSameVal(std::string val) { return val == this->val; } + int getID() { return this->id; } + std::string getHint() { return this->hint; } + std::string getVal() { return this->val; } + +private: + int id; + std::string hint; + std::string val; +}; + class etRunner { private: -- 2.7.4 From ed682682138adf9dc8970acd7801b7964e7c3034 Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Wed, 14 Apr 2021 11:09:22 +0900 Subject: [PATCH 02/16] 0012_aux_hint: added aux hint testcases Added aux hint testcases It tests below APIs - ecore_wl2_window_aux_hint_add - ecore_wl2_window_aux_hint_change - ecore_wl2_window_aux_hint_del Change-Id: Ied1494e5db37e4cc867414e084daf2ae8880bd6c --- src/Makefile.am | 3 +- src/testcase/0012_aux_hint.cpp | 90 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 92 insertions(+), 1 deletion(-) create mode 100644 src/testcase/0012_aux_hint.cpp diff --git a/src/Makefile.am b/src/Makefile.am index 22619e7..1548419 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -20,7 +20,8 @@ testcase/0007_rotation.cpp \ testcase/0008_focus.cpp \ testcase/0009_input.cpp \ testcase/0010_splash.cpp \ -testcase/0011_effect.cpp +testcase/0011_effect.cpp \ +testcase/0012_aux_hint.cpp e_tizen_unittests_SOURCES = \ e_test_main.cpp \ diff --git a/src/testcase/0012_aux_hint.cpp b/src/testcase/0012_aux_hint.cpp new file mode 100644 index 0000000..0160710 --- /dev/null +++ b/src/testcase/0012_aux_hint.cpp @@ -0,0 +1,90 @@ +#include "e_test_event.h" +#include "e_test_base.h" + +static int test_hint_id = 486; + +class etTestAuxHint : public ::etTCBase +{ + public: + etTestAuxHint() + { + etRunner::get().addSupportedAuxHint("win.test.auxhint"); + }; + ~etTestAuxHint() + { + etRunner::get().delSupportedAuxHint("win.test.auxhint"); + }; + + protected: + etWin *tw = NULL; + + void initTC(); +}; + +void +etTestAuxHint::initTC() +{ + tw = initNormalWin("TCWin_Normal", EINA_TRUE); + ASSERT_TRUE(tw != NULL) << "failed to initiation window"; + ASSERT_TRUE(showTCWin(tw)) << "failed to show window"; +} + +TEST_F(etTestAuxHint, add_hint) +{ + std::shared_ptr data = NULL; + Eina_Bool ret = EINA_FALSE; + + initTC(); + etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + + ret = etRunner::get().addAuxHint(tw, test_hint_id, "win.test.auxhint", "test"); + ASSERT_TRUE(ret); + data = std::static_pointer_cast(etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_AUX_HINT_CHANGED)); + ASSERT_TRUE(data != NULL); + ASSERT_TRUE(data->isSameHint(std::string("win.test.auxhint"))) << "Err: " << data->getHint(); + ASSERT_TRUE(data->isSameVal(std::string("test"))) << "Err: " << data->getVal(); +} + +TEST_F(etTestAuxHint, change_hint) +{ + std::shared_ptr data = NULL; + Eina_Bool ret = EINA_FALSE; + + initTC(); + etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + + ret = etRunner::get().addAuxHint(tw, test_hint_id, "win.test.auxhint", "test"); + ASSERT_TRUE(ret); + data = std::static_pointer_cast(etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_AUX_HINT_CHANGED)); + ASSERT_TRUE(data != NULL); + ASSERT_TRUE(data->isSameHint(std::string("win.test.auxhint"))) << "Err: " << data->getHint(); + ASSERT_TRUE(data->isSameVal(std::string("test"))) << "Err: " << data->getVal(); + + ret = etRunner::get().changeAuxHint(tw, test_hint_id, "test2"); + ASSERT_TRUE(ret); + data = std::static_pointer_cast(etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_AUX_HINT_CHANGED)); + ASSERT_TRUE(data != NULL); + ASSERT_TRUE(data->isSameHint(std::string("win.test.auxhint"))) << "Err: " << data->getHint(); + ASSERT_TRUE(data->isSameVal(std::string("test2"))) << "Err: " << data->getVal(); +} + +TEST_F(etTestAuxHint, del_hint) +{ + std::shared_ptr data = NULL; + Eina_Bool ret = EINA_FALSE; + + initTC(); + etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + + ret = etRunner::get().addAuxHint(tw, test_hint_id, "win.test.auxhint", "test"); + ASSERT_TRUE(ret); + data = std::static_pointer_cast(etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_AUX_HINT_CHANGED)); + ASSERT_TRUE(data != NULL); + ASSERT_TRUE(data->isSameHint(std::string("win.test.auxhint"))) << "Err: " << data->getHint(); + ASSERT_TRUE(data->isSameVal(std::string("test"))) << "Err: " << data->getVal(); + + ret = etRunner::get().delAuxHint(tw, test_hint_id); + ASSERT_TRUE(ret); + etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_AUX_HINT_CHANGED); +} + -- 2.7.4 From f2b1e89309bad765a79ebfb1da5f9347cea9f875 Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Wed, 14 Apr 2021 12:40:26 +0900 Subject: [PATCH 03/16] e_test_event: Added timeout set method Added timeout set method. It could set/unset timer of Testcase, and can set time of timer. The patch needs enlightenment's "e_test_helper: Added timeout set method" patch. Change-Id: I2651f3e6d561c90f6569baf07cf755eb2a843309 --- src/e_test_event.cpp | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/e_test_event.h | 1 + 2 files changed, 58 insertions(+) diff --git a/src/e_test_event.cpp b/src/e_test_event.cpp index 94d4dd5..63af5ac 100644 --- a/src/e_test_event.cpp +++ b/src/e_test_event.cpp @@ -73,6 +73,7 @@ static void _cb_method_window_register(void *data, const Eldbus_Message *msg, El static void _cb_method_zone_rotation_change(void *data, const Eldbus_Message *msg, Eldbus_Pending *p); static void _cb_method_window_effect(void *data, const Eldbus_Message *msg, Eldbus_Pending *p); static void _cb_method_set_tc_start_end(void *data, const Eldbus_Message *msg, Eldbus_Pending *p); +static void _cb_method_set_tc_timeout(void *data, const Eldbus_Message *msg, Eldbus_Pending *p); static void _cb_method_transient_for_below(void *data, const Eldbus_Message *msg, Eldbus_Pending *p); /* callbacks - signal */ @@ -592,6 +593,35 @@ etRunner::setTCEnd() } Eina_Bool +etRunner::setTCTimeout(Eina_Bool set, int timeout) +{ + Eldbus_Pending *p = NULL; + Eina_Bool res = EINA_FALSE; + + if (timeout <= 0) return EINA_FALSE; + + p = eldbus_proxy_call(dbus.ds_proxy, + "SetTestTimeout", + _cb_method_set_tc_timeout, + &res, + -1, + "bu", + set, + timeout); + EINA_SAFETY_ON_NULL_GOTO(p, err); + + work(); + + EINA_SAFETY_ON_FALSE_GOTO(res, err); + + return EINA_TRUE; + +err: + setTCEnd(); + return EINA_FALSE; +} + +Eina_Bool etRunner::getWinInfo(etWin *tw) { Eldbus_Pending *p = NULL; @@ -1888,6 +1918,33 @@ finish: } static void +_cb_method_set_tc_timeout(void *data, + const Eldbus_Message *msg, + Eldbus_Pending *p) +{ + const char *name = NULL, *text = NULL; + Eina_Bool res = EINA_FALSE; + Eina_Bool *accept = (Eina_Bool *)data; + + *accept = EINA_FALSE; + + res = eldbus_message_error_get(msg, &name, &text); + EINA_SAFETY_ON_TRUE_GOTO(res, finish); + + res = eldbus_message_arguments_get(msg, "b", accept); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + EINA_SAFETY_ON_FALSE_GOTO(*accept, finish); + +finish: + if ((name) || (text)) + { + ERR("errname: %s errmsg: %s\n", name, text); + } + + etRunner::get().finishWork(); +} + +static void _cb_method_transient_for_below(void *data, const Eldbus_Message *msg, Eldbus_Pending *p) diff --git a/src/e_test_event.h b/src/e_test_event.h index c8c7fd5..811e55a 100644 --- a/src/e_test_event.h +++ b/src/e_test_event.h @@ -197,6 +197,7 @@ public: Eina_Bool delAuxHint(etWin *tw, int hint_id); Eina_Bool setTCStart(); Eina_Bool setTCEnd(); + Eina_Bool setTCTimeout(Eina_Bool set, int timeout); Eina_Bool getWinInfo(etWin *tw); Eina_List *getWinInfoList(); void freeWinInfoList(Eina_List *list); -- 2.7.4 From 492e7df87bc5b22eac697417fc9971a402e0d318 Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Wed, 21 Apr 2021 17:01:18 +0900 Subject: [PATCH 04/16] Packaging: update version to 0.5.7 Change-Id: If0cb93fd25c516b692c0f5c95a78bf080dd31935 Signed-off-by: Junseok, Kim --- packaging/e-tizen-unittests.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-tizen-unittests.spec b/packaging/e-tizen-unittests.spec index e8a8971..5362f23 100644 --- a/packaging/e-tizen-unittests.spec +++ b/packaging/e-tizen-unittests.spec @@ -1,7 +1,7 @@ %define USE_GCOV 0 Name: e-tizen-unittests -Version: 0.5.6 +Version: 0.5.7 Release: 1 Summary: The test case runner for enlightenment URL: http://www.enlightenment.org -- 2.7.4 From a02e3b49006632b528f615ca593ed8faa144dc1a Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Fri, 23 Apr 2021 10:07:36 +0900 Subject: [PATCH 05/16] e_test_main: Added background window. Normally, the homescreen shows when the test running. To hide this homescreen, we added a background window. Change-Id: Ieb55a321997aece6bdfab25c8f38d619f8e08642 Signed-off-by: Junseok, Kim --- src/e_test_main.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/e_test_main.cpp b/src/e_test_main.cpp index ced5690..3545ad4 100644 --- a/src/e_test_main.cpp +++ b/src/e_test_main.cpp @@ -23,6 +23,11 @@ elm_main(int argc, char **argv) // kill Lockscreen etRunner::get().requestKillWinByName("LOCKSCREEN"); + etWin *bg_win = new etWin(); + bg_win->init(NULL, ELM_WIN_BASIC, EINA_FALSE, "TCWin_background", + 0, 0, 0, 0, EINA_FALSE, E_TC_WIN_COLOR_WHITE); + bg_win->show(); + ::testing::InitGoogleTest(&argc, argv); ret = RUN_ALL_TESTS(); @@ -31,6 +36,9 @@ elm_main(int argc, char **argv) printf("failed to enlightenment gcov execution\n"); #endif + bg_win->hide(); + delete bg_win; + // display unlock etRunner::get().setDevctlDisplayLock(EINA_FALSE); -- 2.7.4 From 3fa2cdab4b5413de054ba2c6b7d048c65e0463e5 Mon Sep 17 00:00:00 2001 From: Doyoun Kang Date: Fri, 23 Apr 2021 11:35:29 +0900 Subject: [PATCH 06/16] Packaging: update version to 0.5.8 Change-Id: Ie2816e32a8cf4b4197d311e6c1ce42752e0deefb --- packaging/e-tizen-unittests.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-tizen-unittests.spec b/packaging/e-tizen-unittests.spec index 5362f23..8893a57 100644 --- a/packaging/e-tizen-unittests.spec +++ b/packaging/e-tizen-unittests.spec @@ -1,7 +1,7 @@ %define USE_GCOV 0 Name: e-tizen-unittests -Version: 0.5.7 +Version: 0.5.8 Release: 1 Summary: The test case runner for enlightenment URL: http://www.enlightenment.org -- 2.7.4 From 7deb36c36403933e1893e533a45ad625a0f9771a Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Tue, 27 Apr 2021 20:12:32 +0900 Subject: [PATCH 07/16] auxHintEventItem: using operator== instead of strncmp Change-Id: I4dc1dc868c53a0d410150cf2541bfec9713b97e8 --- src/e_test_event.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/e_test_event.h b/src/e_test_event.h index 811e55a..9f46f36 100644 --- a/src/e_test_event.h +++ b/src/e_test_event.h @@ -47,7 +47,7 @@ public: } Eina_Bool isSameID(int id) { return id == this->id; } - Eina_Bool isSameHint(std::string hint) { return !strncmp(hint.c_str(), this->hint.c_str(), hint.size()); } + Eina_Bool isSameHint(std::string hint) { return hint == this->hint; } Eina_Bool isSameVal(std::string val) { return val == this->val; } int getID() { return this->id; } std::string getHint() { return this->hint; } -- 2.7.4 From a2ab6c1d631fd626bcd4290c87fa97893d0c6854 Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Tue, 27 Apr 2021 20:14:31 +0900 Subject: [PATCH 08/16] e_test_event: allow set TC timeout to 0 Change-Id: I5ade49e14d6476f125577f56708ecc9e8e72c895 --- src/e_test_event.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/e_test_event.cpp b/src/e_test_event.cpp index 63af5ac..e8ad844 100644 --- a/src/e_test_event.cpp +++ b/src/e_test_event.cpp @@ -598,7 +598,7 @@ etRunner::setTCTimeout(Eina_Bool set, int timeout) Eldbus_Pending *p = NULL; Eina_Bool res = EINA_FALSE; - if (timeout <= 0) return EINA_FALSE; + if (timeout < 0) return EINA_FALSE; p = eldbus_proxy_call(dbus.ds_proxy, "SetTestTimeout", -- 2.7.4 From 7b61b8cf30b80a9d2c2fb6e99aa70cbb20faceca Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Tue, 27 Apr 2021 20:19:09 +0900 Subject: [PATCH 09/16] e_test_event: Added get_aux_hint method Added method to get current aux hint data from server. Change-Id: Ia90c1cbd2dec71f99066c75442d1fa3fd8b575ca --- src/e_test_event.cpp | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/e_test_event.h | 1 + 2 files changed, 58 insertions(+) diff --git a/src/e_test_event.cpp b/src/e_test_event.cpp index e8ad844..b86eb77 100644 --- a/src/e_test_event.cpp +++ b/src/e_test_event.cpp @@ -75,6 +75,7 @@ static void _cb_method_window_effect(void *data, const Eldbus_Message *msg, Eldb static void _cb_method_set_tc_start_end(void *data, const Eldbus_Message *msg, Eldbus_Pending *p); static void _cb_method_set_tc_timeout(void *data, const Eldbus_Message *msg, Eldbus_Pending *p); static void _cb_method_transient_for_below(void *data, const Eldbus_Message *msg, Eldbus_Pending *p); +static void _cb_method_aux_hint_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p); /* callbacks - signal */ static void _cb_signal_vis_changed(void *data, const Eldbus_Message *msg); @@ -1270,6 +1271,34 @@ etRunner::delSupportedAuxHint(const char *hint) return EINA_TRUE; } +std::shared_ptr +etRunner::getAuxHint(etWin *tw, const char *hint_key) +{ + Eldbus_Pending *p = NULL; + auxHintEventItem *hint = NULL; + + p = eldbus_proxy_call(dbus.ds_proxy, + "GetAuxHint", + _cb_method_aux_hint_get, + &hint, + -1, + "us", + tw->native_win, + hint_key); + EINA_SAFETY_ON_NULL_RETURN_VAL(p, nullptr); + + work(); + + if (hint) + { + std::shared_ptr shared_hint = std::make_shared(tw->native_win, E_TC_EVENT_TYPE_AUX_HINT_CHANGED, hint->getID(), hint->getHint().c_str(), hint->getVal().c_str()); + delete hint; + return shared_hint; + } + + return NULL; +} + std::shared_ptr etRunner::waitEvent(etWin *win, E_TC_Event_Type ev_type) { @@ -1971,6 +2000,34 @@ finish: etRunner::get().finishWork(); } +static void +_cb_method_aux_hint_get(void *data, + const Eldbus_Message *msg, + Eldbus_Pending *p) +{ + auxHintEventItem **hint = (auxHintEventItem **) data; + const char *name = NULL, *text = NULL; + Eina_Bool res = EINA_FALSE; + int id; + const char *hint_key, *hint_val; + + res = eldbus_message_error_get(msg, &name, &text); + EINA_SAFETY_ON_TRUE_GOTO(res, finish); + + res = eldbus_message_arguments_get(msg, "iss", &id, &hint_key, &hint_val); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + *hint = new auxHintEventItem(0, E_TC_EVENT_TYPE_AUX_HINT_CHANGED, id, hint_key, hint_val); + +finish: + if ((name) || (text)) + { + ERR("errname: %s errmsg: %s\n", name, text); + } + + etRunner::get().finishWork(); +} + /* callbacks - signal */ static void _cb_signal_vis_changed(void *data, diff --git a/src/e_test_event.h b/src/e_test_event.h index 9f46f36..834e2bc 100644 --- a/src/e_test_event.h +++ b/src/e_test_event.h @@ -233,6 +233,7 @@ public: Eina_Bool thawEvent(); Eina_Bool addSupportedAuxHint(const char *hint); Eina_Bool delSupportedAuxHint(const char *hint); + std::shared_ptr getAuxHint(etWin *tw, const char *hint); std::shared_ptr waitEvent(etWin *win, E_TC_Event_Type ev_type); Eina_Bool requestKillWinByName(const char *name); -- 2.7.4 From 11a65812f1f4eee514aaa6cee325a17b113bb898 Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Tue, 27 Apr 2021 20:25:30 +0900 Subject: [PATCH 10/16] e_test_event: Added some eventItems Added following eventItems. - visibleEventItem - rotationEventItem - focusEventItem each eventItem contains specific event variables. and each event callback insert their own eventItem. Change-Id: I2aa25c44d919a8a43286edb3b364caeb3c4b6479 --- src/e_test_event.cpp | 22 +++++++++++++++----- src/e_test_event.h | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 74 insertions(+), 5 deletions(-) diff --git a/src/e_test_event.cpp b/src/e_test_event.cpp index b86eb77..0a17cf8 100644 --- a/src/e_test_event.cpp +++ b/src/e_test_event.cpp @@ -2034,6 +2034,7 @@ _cb_signal_vis_changed(void *data, const Eldbus_Message *msg) { etRunner *runner = (etRunner *)data; + std::shared_ptr visibleEvent = NULL; const char *name = NULL, *text = NULL; Eina_Bool res = EINA_FALSE; int vis = 0; @@ -2045,7 +2046,10 @@ _cb_signal_vis_changed(void *data, res = eldbus_message_arguments_get(msg, "ub", &id, &vis); EINA_SAFETY_ON_FALSE_GOTO(res, finish); - runner->insertEventQueue(id, E_TC_EVENT_TYPE_VIS_CHANGED); + visibleEvent = std::make_shared(id, E_TC_EVENT_TYPE_VIS_CHANGED, vis); + EINA_SAFETY_ON_NULL_GOTO(visibleEvent, finish); + + runner->insertEventQueue(visibleEvent); finish: if ((name) || (text)) @@ -2083,6 +2087,7 @@ _cb_signal_win_rot_changed(void *data, const Eldbus_Message *msg) { etRunner *runner = (etRunner *)data; + std::shared_ptr rotationEvent = NULL; const char *name = NULL, *text = NULL; Eina_Bool res = EINA_FALSE; int angle = 0; @@ -2095,7 +2100,10 @@ _cb_signal_win_rot_changed(void *data, res = eldbus_message_arguments_get(msg, "ui", &id, &angle); EINA_SAFETY_ON_FALSE_GOTO(res, finish); - runner->insertEventQueue(id, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE); + rotationEvent = std::make_shared(id, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE, angle); + EINA_SAFETY_ON_NULL_GOTO(rotationEvent, finish); + + runner->insertEventQueue(rotationEvent); finish: if ((name) || (text)) @@ -2109,17 +2117,21 @@ _cb_signal_focus_changed(void *data, const Eldbus_Message *msg) { etRunner *runner = (etRunner *)data; + std::shared_ptr focusEvent = NULL; const char *name = NULL, *text = NULL; - Eina_Bool res = EINA_FALSE; + Eina_Bool res = EINA_FALSE, focused = EINA_FALSE; Ecore_Window id = 0; res = eldbus_message_error_get(msg, &name, &text); EINA_SAFETY_ON_TRUE_GOTO(res, finish); - res = eldbus_message_arguments_get(msg, "u", &id); + res = eldbus_message_arguments_get(msg, "ub", &id, &focused); EINA_SAFETY_ON_FALSE_GOTO(res, finish); - runner->insertEventQueue(id, E_TC_EVENT_TYPE_FOCUS_CHANGED); + focusEvent = std::make_shared(id, E_TC_EVENT_TYPE_FOCUS_CHANGED, focused); + EINA_SAFETY_ON_NULL_GOTO(focusEvent, finish); + + runner->insertEventQueue(focusEvent); finish: if ((name) || (text)) diff --git a/src/e_test_event.h b/src/e_test_event.h index 834e2bc..9464de6 100644 --- a/src/e_test_event.h +++ b/src/e_test_event.h @@ -31,6 +31,63 @@ protected: E_TC_Event_Type type; }; +class visibleEventItem : public eventItem +{ +public: + visibleEventItem() = delete; + visibleEventItem (Ecore_Window win, E_TC_Event_Type type, Eina_Bool visible) : + eventItem(win, type), + visible(visible) + { + } + ~visibleEventItem() + { + } + + Eina_Bool isVisible() { return this->visible; } + +private: + Eina_Bool visible; +}; + +class rotationEventItem : public eventItem +{ +public: + rotationEventItem() = delete; + rotationEventItem (Ecore_Window win, E_TC_Event_Type type, int angle) : + eventItem(win, type), + angle(angle) + { + } + ~rotationEventItem() + { + } + + int getAngle() { return this->angle; } + +private: + int angle; +}; + +class focusEventItem : public eventItem +{ +public: + focusEventItem() = delete; + focusEventItem (Ecore_Window win, E_TC_Event_Type type, Eina_Bool focused) : + eventItem(win, type), + focused(focused) + { + } + ~focusEventItem() + { + } + + Eina_Bool isFocused() { return this->focused; } + +private: + Eina_Bool focused; +}; + class auxHintEventItem : public eventItem { public: -- 2.7.4 From afa37450a6b158e74408b36b2d3fc93dc9aebead Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Tue, 27 Apr 2021 20:29:37 +0900 Subject: [PATCH 11/16] e_test_util: Added some macro functions for test event. Added some macro functions for test event as below - ASSERT_EVENT : for test other events except below - ASSERT_VIS_ON/OFF : for test visibility event - ASSERT_ROTATION : for test rotation event - ASSERT_FOCUS_IN/OUT : for test focus event - ASSERT_HINT : for test aux hint event. Change-Id: Ib3ef4866edf7025f3d406a03130153a9046445c2 --- src/e_test_base.h | 7 ++++++ src/e_test_util.h | 74 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 81 insertions(+) diff --git a/src/e_test_base.h b/src/e_test_base.h index c039239..f3e1c37 100644 --- a/src/e_test_base.h +++ b/src/e_test_base.h @@ -24,6 +24,13 @@ class etTCBase : public ::testing::Test Eina_Bool showActivateTCWin(etWin *tw); Eina_Bool removeTCWin(etWin *tw); + protected: + std::shared_ptr ev_result; + std::shared_ptr ev_result_vis; + std::shared_ptr ev_result_rot; + std::shared_ptr ev_result_focus; + std::shared_ptr ev_result_hint; + private: Eina_List *tw_list = NULL; diff --git a/src/e_test_util.h b/src/e_test_util.h index 280a8cd..15167de 100644 --- a/src/e_test_util.h +++ b/src/e_test_util.h @@ -189,6 +189,80 @@ typedef struct _Window_Info_List (type == EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE)?"No resource available": \ "Unknown") +#define ASSERT_EVENT(TEST_WINDOW, TEST_EVENT) \ + do { \ + ASSERT_NE(TEST_WINDOW, nullptr) << "Window is NULL"; \ + ev_result = etRunner::get().waitEvent(TEST_WINDOW, TEST_EVENT); \ + ASSERT_NE(ev_result, nullptr) << "result is NULL"; \ + ASSERT_FALSE(ev_result->isTimeout) << "waitEvent timeout (1.0 sec)"; \ + ASSERT_TRUE(ev_result->result) << "waitEvent failed"; \ + } while (0) + +#define ASSERT_VIS_ON(TEST_WINDOW) \ + do { \ + ASSERT_NE(TEST_WINDOW, nullptr) << "Window is NULL"; \ + ev_result_vis = std::static_pointer_cast(etRunner::get().waitEvent(TEST_WINDOW, E_TC_EVENT_TYPE_VIS_ON)); \ + ASSERT_NE(ev_result_vis, nullptr) << "result is NULL"; \ + ASSERT_FALSE(ev_result_vis->isTimeout) << "waitEvent timeout (1.0 sec)"; \ + ASSERT_TRUE(ev_result_vis->result) << "waitEvent failed"; \ + ASSERT_TRUE(ev_result_vis->isVisible()) << "Window is invisible"; \ + } while (0) + +#define ASSERT_VIS_OFF(TEST_WINDOW) \ + do { \ + ASSERT_NE(TEST_WINDOW, nullptr) << "Window is NULL"; \ + ev_result_vis = std::static_pointer_cast(etRunner::get().waitEvent(TEST_WINDOW, E_TC_EVENT_TYPE_VIS_OFF)); \ + ASSERT_NE(ev_result_vis, nullptr) << "result is NULL"; \ + ASSERT_FALSE(ev_result_vis->isTimeout) << "waitEvent timeout (1.0 sec)"; \ + ASSERT_TRUE(ev_result_vis->result) << "waitEvent failed"; \ + ASSERT_FALSE(ev_result_vis->isVisible()) << "Window is visible"; \ + } while (0) + +#define ASSERT_ROTATION(TEST_WINDOW, ANGLE) \ + do { \ + ASSERT_NE(TEST_WINDOW, nullptr) << "Window is NULL"; \ + ev_result_rot = std::static_pointer_cast(etRunner::get().waitEvent(TEST_WINDOW, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE)); \ + ASSERT_NE(ev_result_rot, nullptr) << "result is NULL"; \ + ASSERT_FALSE(ev_result_rot->isTimeout) << "waitEvent timeout (1.0 sec)"; \ + ASSERT_TRUE(ev_result_rot->result) << "waitEvent failed"; \ + ASSERT_NE(ev_result_rot->getAngle(), ANGLE) << "Window angle mismatch, ev:" << ev_result_rot->getAngle() << " vs expected:" << ANGLE; \ + } while (0) + +#define ASSERT_FOCUS_IN(TEST_WINDOW) \ + do { \ + ASSERT_NE(TEST_WINDOW, nullptr) << "Window is NULL"; \ + ev_result_focus = std::static_pointer_cast(etRunner::get().waitEvent(TEST_WINDOW, E_TC_EVENT_TYPE_FOCUS_CHANGED)); \ + ASSERT_NE(ev_result_focus, nullptr) << "result is NULL"; \ + ASSERT_FALSE(ev_result_focus->isTimeout) << "waitEvent timeout (1.0 sec)"; \ + ASSERT_TRUE(ev_result_focus->result) << "waitEvent failed"; \ + ASSERT_TRUE(ev_result_focus->isFocused()) << "Window isn't focused"; \ + } while (0) + +#define ASSERT_FOCUS_OUT(TEST_WINDOW) \ + do { \ + ASSERT_NE(TEST_WINDOW, nullptr) << "Window is NULL"; \ + ev_result_focus = std::static_pointer_cast(etRunner::get().waitEvent(TEST_WINDOW, E_TC_EVENT_TYPE_FOCUS_CHANGED)); \ + ASSERT_NE(ev_result_focus, nullptr) << "result is NULL"; \ + ASSERT_FALSE(ev_result_focus->isTimeout) << "waitEvent timeout (1.0 sec)"; \ + ASSERT_TRUE(ev_result_focus->result) << "waitEvent failed"; \ + ASSERT_FALSE(ev_result_focus->isFocused()) << "Window is focused"; \ + } while (0) + +#define ASSERT_HINT(TEST_WINDOW, HINT_ID, HINT_NAME, HINT_VAL) \ + do { \ + ASSERT_NE(TEST_WINDOW, nullptr) << "Window is NULL"; \ + ev_result_hint = std::static_pointer_cast(etRunner::get().waitEvent(TEST_WINDOW, E_TC_EVENT_TYPE_AUX_HINT_CHANGED)); \ + ASSERT_NE(ev_result_hint, nullptr) << "result is NULL"; \ + ASSERT_FALSE(ev_result_hint->isTimeout) << "waitEvent timeout (1.0 sec)"; \ + ASSERT_TRUE(ev_result_hint->result) << "waitEvent failed"; \ + if (HINT_ID >= 0) { \ + ASSERT_TRUE(ev_result_hint->isSameID(HINT_ID)) << "Hint ID mismatch, ID: " << ev_result_hint->getID() << " vs " << HINT_ID; \ + } if (HINT_NAME) { \ + ASSERT_TRUE(ev_result_hint->isSameHint(std::string(HINT_NAME))) << "Hint name mismatch, hint: " << ev_result_hint->getHint() << " vs " << HINT_NAME; \ + } if (HINT_VAL) { \ + ASSERT_TRUE(ev_result_hint->isSameVal(std::string(HINT_VAL))) << "Hint value mismatch, hint: " << ev_result_hint->getVal() << " vs " << HINT_VAL; \ + } \ + } while (0) #ifdef __cplusplus } -- 2.7.4 From 03e0eab5b5053b514ae7a013fe818df1f8c6955c Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Tue, 27 Apr 2021 22:07:55 +0900 Subject: [PATCH 12/16] Tests: Use macro function for test events. Use macro function for test events. And fixed some wrong check events. Change-Id: I15c06f82194c8ad2f37c28d32fea85659a04c098 --- src/testcase/0002_base_operation.cpp | 8 +- src/testcase/0003_base_operation_multi_wins.cpp | 97 ++++++++------- src/testcase/0004_transient_for.cpp | 22 ++-- src/testcase/0005_notification.cpp | 62 ++++++---- src/testcase/0006_tzsh.cpp | 2 +- src/testcase/0007_rotation.cpp | 32 ++--- src/testcase/0008_focus.cpp | 153 +++++++++++------------- src/testcase/0009_input.cpp | 135 +++++++++------------ src/testcase/0010_splash.cpp | 10 +- src/testcase/0011_effect.cpp | 31 ++--- src/testcase/0012_aux_hint.cpp | 52 ++++---- 11 files changed, 284 insertions(+), 320 deletions(-) diff --git a/src/testcase/0002_base_operation.cpp b/src/testcase/0002_base_operation.cpp index c1dad73..c5dcd27 100644 --- a/src/testcase/0002_base_operation.cpp +++ b/src/testcase/0002_base_operation.cpp @@ -28,7 +28,7 @@ TEST_F(etTestBaseOperation, win_show) initTC(EINA_FALSE); ASSERT_TRUE(showTCWin(tw)) << "failed to show window"; - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw); } TEST_F(etTestBaseOperation, win_stack) @@ -40,7 +40,7 @@ TEST_F(etTestBaseOperation, win_stack) initTC(EINA_FALSE); ASSERT_TRUE(showTCWin(tw)) << "failed to show window"; - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw); list = etRunner::get().getWinInfoList(); ASSERT_TRUE(list != NULL); @@ -65,7 +65,7 @@ TEST_F(etTestBaseOperation, alpha_win_show) initTC(EINA_TRUE); ASSERT_TRUE(showTCWin(tw)) << "failed to show window"; - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw); } TEST_F(etTestBaseOperation, alpha_win_stack) @@ -77,7 +77,7 @@ TEST_F(etTestBaseOperation, alpha_win_stack) initTC(EINA_TRUE); ASSERT_TRUE(showTCWin(tw)) << "failed to show window"; - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw); list = etRunner::get().getWinInfoList(); ASSERT_TRUE(list != NULL); diff --git a/src/testcase/0003_base_operation_multi_wins.cpp b/src/testcase/0003_base_operation_multi_wins.cpp index 0abba70..4a59a58 100644 --- a/src/testcase/0003_base_operation_multi_wins.cpp +++ b/src/testcase/0003_base_operation_multi_wins.cpp @@ -23,7 +23,7 @@ etTestBaseMulti::initTC(Eina_Bool show_win, Eina_Bool usr_geom) if (show_win) { showTCWin(tw_red); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_VIS_ON(tw_red); } tw_green = initNormalWin("TCWin_Normal_green", usr_geom); @@ -31,7 +31,7 @@ etTestBaseMulti::initTC(Eina_Bool show_win, Eina_Bool usr_geom) if (show_win) { showTCWin(tw_green); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_VIS_ON(tw_green); } tw_blue = initNormalWin("TCWin_Normal_blue", usr_geom); @@ -39,7 +39,7 @@ etTestBaseMulti::initTC(Eina_Bool show_win, Eina_Bool usr_geom) if (show_win) { showTCWin(tw_blue); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_VIS_ON(tw_blue); } } @@ -100,17 +100,17 @@ TEST_F(etTestBaseMulti, multi_all_wins_show1) // show red res = showTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); // show blue res = showTCWin(tw_blue); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // show green res = showTCWin(tw_green); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_green); // Expected stack res: // [Top] Green -> Blue -> Red [Bottom] @@ -160,17 +160,17 @@ TEST_F(etTestBaseMulti, multi_all_wins_show2) // show blue res = showTCWin(tw_blue); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // show red res = showTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); // show green res = showTCWin(tw_green); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_green); // Expected stack res: // [Top] Green -> Red -> Blue [Bottom] @@ -220,17 +220,17 @@ TEST_F(etTestBaseMulti, multi_all_wins_show3) // show green res = showTCWin(tw_green); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_green); // show blue res = showTCWin(tw_blue); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // show red res = showTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); // Expected stack res: // [Top] Red -> Blue -> Green [Bottom] @@ -278,8 +278,7 @@ TEST_F(etTestBaseMulti, multi_all_wins_raise1) // Raise Red etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack res: // [Top] Red -> Blue -> Green [Bottom] @@ -327,7 +326,7 @@ TEST_F(etTestBaseMulti, multi_all_wins_raise2) // Raise Green etRunner::get().setWinStack(tw_green, NULL, EINA_TRUE); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack res: // [Top] Green-> Blue -> Red [Bottom] @@ -375,7 +374,7 @@ TEST_F(etTestBaseMulti, multi_all_wins_stack_above1) // Raise Red on the Green etRunner::get().setWinStack(tw_red, tw_green, EINA_TRUE); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); // Expected stack res: // [Top] Blue -> Red -> Green [Bottom] @@ -423,7 +422,7 @@ TEST_F(etTestBaseMulti, multi_all_wins_stack_above2) // Raise Blue on the Red etRunner::get().setWinStack(tw_blue, tw_red, EINA_TRUE); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_blue, E_TC_EVENT_TYPE_STACK_ABOVE); // Expected stack res: // [Top] Green-> Blue -> Red [Bottom] @@ -471,7 +470,7 @@ TEST_F(etTestBaseMulti, multi_all_wins_stack_above3) // Raise Red on the Blue etRunner::get().setWinStack(tw_red, tw_blue, EINA_TRUE); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); // Expected stack res: // [Top] Green-> Blue -> Red [Bottom] @@ -519,7 +518,7 @@ TEST_F(etTestBaseMulti, multi_all_wins_lower1) // Lower Blue etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_STACK_LOWER); + ASSERT_EVENT(tw_blue, E_TC_EVENT_TYPE_STACK_LOWER); // Expected stack res: // [Top] Green -> Red -> ... -> Blue [Bottom] @@ -583,7 +582,7 @@ TEST_F(etTestBaseMulti, multi_all_wins_lower2) // Lower Green etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_LOWER); + ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_LOWER); // Expected stack res: // [Top] Blue -> Red -> ... -> Green [Bottom] @@ -693,17 +692,17 @@ TEST_F(etTestBaseMulti, multi_all_full_wins_show1) // show red res = showTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); // show blue res = showTCWin(tw_blue); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // show green res = showTCWin(tw_green); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_green); // Expected stack res: // [Top] Green -> Blue -> Red [Bottom] @@ -753,17 +752,17 @@ TEST_F(etTestBaseMulti, multi_all_full_wins_show2) // show blue res = showTCWin(tw_blue); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // show red res = showTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); // show green res = showTCWin(tw_green); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_green); // Expected stack res: // [Top] Green -> Red -> Blue [Bottom] @@ -813,17 +812,17 @@ TEST_F(etTestBaseMulti, multi_all_full_wins_show3) // show green res = showTCWin(tw_green); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_green); // show blue res = showTCWin(tw_blue); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // show red res = showTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); // Expected stack res: // [Top] Red -> Blue -> Green [Bottom] @@ -871,7 +870,7 @@ TEST_F(etTestBaseMulti, multi_all_full_wins_raise1) // Raise Red etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack res: // [Top] Red -> Blue -> Green [Bottom] @@ -919,7 +918,7 @@ TEST_F(etTestBaseMulti, multi_all_full_wins_raise2) // Raise Green etRunner::get().setWinStack(tw_green, NULL, EINA_TRUE); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack res: // [Top] Green-> Blue -> Red [Bottom] @@ -967,7 +966,7 @@ TEST_F(etTestBaseMulti, multi_all_full_wins_stack_above1) // Raise Red on the Green etRunner::get().setWinStack(tw_red, tw_green, EINA_TRUE); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); // Expected stack res: // [Top] Blue -> Red -> Green [Bottom] @@ -1015,7 +1014,7 @@ TEST_F(etTestBaseMulti, multi_all_full_wins_stack_above2) // Raise Blue on the Red etRunner::get().setWinStack(tw_blue, tw_red, EINA_TRUE); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_blue, E_TC_EVENT_TYPE_STACK_ABOVE); // Expected stack res: // [Top] Green-> Blue -> Red [Bottom] @@ -1063,7 +1062,7 @@ TEST_F(etTestBaseMulti, multi_all_full_wins_stack_above3) // Raise Red on the Blue etRunner::get().setWinStack(tw_red, tw_blue, EINA_TRUE); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); // Expected stack res: // [Top] Green-> Blue -> Red [Bottom] @@ -1111,7 +1110,7 @@ TEST_F(etTestBaseMulti, multi_all_full_wins_lower1) // Lower Blue etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_STACK_LOWER); + ASSERT_EVENT(tw_blue, E_TC_EVENT_TYPE_STACK_LOWER); // Expected stack res: // [Top] Green -> Red -> ... -> Blue [Bottom] @@ -1175,7 +1174,7 @@ TEST_F(etTestBaseMulti, multi_all_full_wins_lower2) // Lower Green etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_LOWER); + ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_LOWER); // Expected stack res: // [Top] Blue -> Red -> ... -> Green [Bottom] @@ -1241,7 +1240,7 @@ TEST_F(etTestBaseMulti, multi_all_full_wins_lower_activate) evas_object_lower(tw_blue->elm_win); // Activate Blue immediately etRunner::get().setWinActivate(tw_blue); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_STACK_RAISE); + etRunner::get().work(0.1); // wait for activate done. It does not change stack. // Expected stack res: // [Top] Blue -> Green -> Red [Bottom] @@ -1291,12 +1290,12 @@ TEST_F(etTestBaseMulti, multi_2wins_show1) // show green res = showTCWin(tw_green); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_green); // show red res = showTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); // Expected stack res: // [Top] Red -> Green [Bottom] @@ -1340,12 +1339,12 @@ TEST_F(etTestBaseMulti, multi_2wins_show2) // show blue res = showTCWin(tw_blue); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // show green res = showTCWin(tw_green); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_green); // Expected stack res: // [Top] Green -> Blue [Bottom] @@ -1389,12 +1388,12 @@ TEST_F(etTestBaseMulti, multi_2wins_show3) // show red res = showTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); // show blue res = showTCWin(tw_blue); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // Expected stack res: // [Top] Blue -> Red [Bottom] @@ -1438,12 +1437,12 @@ TEST_F(etTestBaseMulti, multi_full_2wins_show1) // show green res = showTCWin(tw_green); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_green); // show red res = showTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); // Expected stack res: // [Top] Red -> Green [Bottom] @@ -1487,12 +1486,12 @@ TEST_F(etTestBaseMulti, multi_full_2wins_show2) // show blue res = showTCWin(tw_blue); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // show green res = showTCWin(tw_green); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_green); // Expected stack res: // [Top] Green -> Blue [Bottom] @@ -1536,12 +1535,12 @@ TEST_F(etTestBaseMulti, multi_full_2wins_show3) // show red res = showTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); // show blue res = showTCWin(tw_blue); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // Expected stack res: // [Top] Blue -> Red [Bottom] diff --git a/src/testcase/0004_transient_for.cpp b/src/testcase/0004_transient_for.cpp index 2f6a8e9..ed44866 100644 --- a/src/testcase/0004_transient_for.cpp +++ b/src/testcase/0004_transient_for.cpp @@ -22,7 +22,7 @@ etTestTransientFor::initTC(Eina_Bool show_win, Eina_Bool usr_geom) if (show_win) { showTCWin(tw_parent); - etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_VIS_ON(tw_parent); } ASSERT_TRUE(tw_parent != NULL) << "failed to initiation window"; @@ -30,7 +30,7 @@ etTestTransientFor::initTC(Eina_Bool show_win, Eina_Bool usr_geom) if (show_win) { showTCWin(tw_child); - etRunner::get().waitEvent(tw_child, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_VIS_ON(tw_child); } ASSERT_TRUE(tw_child != NULL) << "failed to initiation window"; @@ -38,7 +38,7 @@ etTestTransientFor::initTC(Eina_Bool show_win, Eina_Bool usr_geom) if (show_win) { showTCWin(tw_base); - etRunner::get().waitEvent(tw_base, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_VIS_ON(tw_base); } ASSERT_TRUE(tw_base != NULL) << "failed to initiation window"; } @@ -56,7 +56,7 @@ TEST_F(etTestTransientFor, transient_for_basic) // set transient_for res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_child, E_TC_EVENT_TYPE_STACK_CHANGED); + etRunner::get().work(0.1); // wait for activate done. It does not change stack. // Expected stack res: // [Top] tw_base -> tw_child -> tw_parent [Bottom] @@ -105,12 +105,12 @@ TEST_F(etTestTransientFor, transient_for_raise) // set transient_for res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_STACK_CHANGED); + etRunner::get().work(0.1); // wait for activate done. It does not change stack. // tw_parent raise res = etRunner::get().setWinStack(tw_parent, NULL, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_STACK_CHANGED); + ASSERT_EVENT(tw_parent, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack res: // [Top] tw_child -> tw_parent -> tw_base [Bottom] @@ -160,17 +160,17 @@ TEST_F(etTestTransientFor, transient_for_lower) // set transient_for res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_STACK_RAISE); + etRunner::get().work(0.1); // wait for activate done. It does not change stack. // tw_parent raise for prepare lower res = etRunner::get().setWinStack(tw_parent, NULL, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_parent, E_TC_EVENT_TYPE_STACK_RAISE); // tw_parent lower res = etRunner::get().setWinStack(tw_parent, NULL, EINA_FALSE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_STACK_LOWER); + ASSERT_EVENT(tw_parent, E_TC_EVENT_TYPE_STACK_LOWER); // Expected stack res: // [Top] tw_base -> ... -> tw_child -> tw_parent [Bottom] @@ -231,12 +231,12 @@ TEST_F(etTestTransientFor, transient_for_above) // set transient_for res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_child, E_TC_EVENT_TYPE_STACK_CHANGED); + etRunner::get().work(0.1); // wait for activate done. It does not change stack. // tw_parent raise for prepare lower res = etRunner::get().setWinStack(tw_parent, tw_base, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_parent, E_TC_EVENT_TYPE_STACK_CHANGED); + ASSERT_EVENT(tw_parent, E_TC_EVENT_TYPE_STACK_CHANGED); // Expected stack res: // [Top] tw_child -> tw_parent -> tw_base [Bottom] diff --git a/src/testcase/0005_notification.cpp b/src/testcase/0005_notification.cpp index cc41202..57e5e51 100644 --- a/src/testcase/0005_notification.cpp +++ b/src/testcase/0005_notification.cpp @@ -21,17 +21,17 @@ etTestNotification::initTC(Eina_Bool usr_geom) { tw_normal = initNormalWin("TCWin_Normal_normal", usr_geom); showTCWin(tw_normal); - etRunner::get().waitEvent(tw_normal, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_VIS_ON(tw_normal); ASSERT_TRUE(tw_normal != NULL) << "failed to initiation window"; tw_noti1 = initNotiWin("TCWin_Noti_1", usr_geom, EINA_FALSE); showTCWin(tw_noti1); - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_VIS_ON(tw_noti1); ASSERT_TRUE(tw_noti1 != NULL) << "failed to initiation window"; tw_noti2 = initNotiWin("TCWin_Noti_2", usr_geom, EINA_FALSE); showTCWin(tw_noti2); - etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_VIS_ON(tw_noti2); ASSERT_TRUE(tw_noti2 != NULL) << "failed to initiation window"; } @@ -52,7 +52,7 @@ TEST_F(etTestNotification, notification_level_default) EXPECT_TRUE(res); // TODO:: add ev_wait for notification level - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT, level); @@ -115,7 +115,7 @@ TEST_F(etTestNotification, notification_level_medium) EXPECT_TRUE(res); // TODO:: add ev_wait for notification level - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM, level); @@ -178,7 +178,7 @@ TEST_F(etTestNotification, notification_level_high) EXPECT_TRUE(res); // TODO:: add ev_wait for notification level - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level); @@ -241,7 +241,7 @@ TEST_F(etTestNotification, notification_level_top) EXPECT_TRUE(res); // TODO:: add ev_wait for notification level - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level); @@ -302,7 +302,8 @@ TEST_F(etTestNotification, notification_level_none) res = etRunner::get().setWinNotiLevel(tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_HIGH); EXPECT_TRUE(res); - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level); @@ -310,7 +311,8 @@ TEST_F(etTestNotification, notification_level_none) res = etRunner::get().setWinNotiLevel(tw_noti2, EFL_UTIL_NOTIFICATION_LEVEL_TOP); EXPECT_TRUE(res); - etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE); + level = etRunner::get().getWinNotiLevel(tw_noti2); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level); @@ -361,7 +363,7 @@ TEST_F(etTestNotification, notification_level_none) EXPECT_TRUE(res); // TODO:: add ev_wait for notification level - etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE); level = etRunner::get().getWinNotiLevel(tw_noti2); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_NONE, level); @@ -420,7 +422,8 @@ TEST_F(etTestNotification, notification_level_change) res = etRunner::get().setWinNotiLevel(tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT); EXPECT_TRUE(res); - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT, level); @@ -428,7 +431,8 @@ TEST_F(etTestNotification, notification_level_change) res = etRunner::get().setWinNotiLevel(tw_noti2, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM); EXPECT_TRUE(res); - etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE); + level = etRunner::get().getWinNotiLevel(tw_noti2); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM, level); @@ -477,7 +481,8 @@ TEST_F(etTestNotification, notification_level_change) res = etRunner::get().setWinNotiLevel(tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_HIGH); EXPECT_TRUE(res); - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level); @@ -526,7 +531,8 @@ TEST_F(etTestNotification, notification_level_change) res = etRunner::get().setWinNotiLevel(tw_noti2, EFL_UTIL_NOTIFICATION_LEVEL_TOP); EXPECT_TRUE(res); - etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE); + level = etRunner::get().getWinNotiLevel(tw_noti2); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level); @@ -588,7 +594,7 @@ TEST_F(etTestNotification, notification_fullsize_level_default) EXPECT_TRUE(res); // TODO:: add ev_wait for notification level - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT, level); @@ -651,7 +657,7 @@ TEST_F(etTestNotification, notification_fullsize_level_medium) EXPECT_TRUE(res); // TODO:: add ev_wait for notification level - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM, level); @@ -714,7 +720,7 @@ TEST_F(etTestNotification, notification_fullsize_level_high) EXPECT_TRUE(res); // TODO:: add ev_wait for notification level - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level); @@ -777,7 +783,7 @@ TEST_F(etTestNotification, notification_fullsize_level_top) EXPECT_TRUE(res); // TODO:: add ev_wait for notification level - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level); @@ -838,7 +844,8 @@ TEST_F(etTestNotification, notification_fullsize_level_none) res = etRunner::get().setWinNotiLevel(tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_HIGH); EXPECT_TRUE(res); - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_RAISE); + level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level); @@ -846,7 +853,8 @@ TEST_F(etTestNotification, notification_fullsize_level_none) res = etRunner::get().setWinNotiLevel(tw_noti2, EFL_UTIL_NOTIFICATION_LEVEL_TOP); EXPECT_TRUE(res); - etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE); + level = etRunner::get().getWinNotiLevel(tw_noti2); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level); @@ -897,7 +905,7 @@ TEST_F(etTestNotification, notification_fullsize_level_none) EXPECT_TRUE(res); // TODO:: add ev_wait for notification level - etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_noti2, E_TC_EVENT_TYPE_STACK_RAISE); level = etRunner::get().getWinNotiLevel(tw_noti2); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_NONE, level); @@ -956,7 +964,8 @@ TEST_F(etTestNotification, notification_fullsize_level_change) res = etRunner::get().setWinNotiLevel(tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT); EXPECT_TRUE(res); - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_ABOVE); + level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT, level); @@ -964,7 +973,8 @@ TEST_F(etTestNotification, notification_fullsize_level_change) res = etRunner::get().setWinNotiLevel(tw_noti2, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM); EXPECT_TRUE(res); - etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_noti2, E_TC_EVENT_TYPE_STACK_ABOVE); + level = etRunner::get().getWinNotiLevel(tw_noti2); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM, level); @@ -1013,7 +1023,8 @@ TEST_F(etTestNotification, notification_fullsize_level_change) res = etRunner::get().setWinNotiLevel(tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_HIGH); EXPECT_TRUE(res); - etRunner::get().waitEvent(tw_noti1, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_noti1, E_TC_EVENT_TYPE_STACK_ABOVE); + level = etRunner::get().getWinNotiLevel(tw_noti1); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_HIGH, level); @@ -1062,7 +1073,8 @@ TEST_F(etTestNotification, notification_fullsize_level_change) res = etRunner::get().setWinNotiLevel(tw_noti2, EFL_UTIL_NOTIFICATION_LEVEL_TOP); EXPECT_TRUE(res); - etRunner::get().waitEvent(tw_noti2, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_noti2, E_TC_EVENT_TYPE_STACK_ABOVE); + level = etRunner::get().getWinNotiLevel(tw_noti2); ASSERT_EQ(EFL_UTIL_NOTIFICATION_LEVEL_TOP, level); diff --git a/src/testcase/0006_tzsh.cpp b/src/testcase/0006_tzsh.cpp index 9bbdcc2..2f295ea 100644 --- a/src/testcase/0006_tzsh.cpp +++ b/src/testcase/0006_tzsh.cpp @@ -123,7 +123,7 @@ TEST_F(etTestTzsh, scrsaver_basic) ASSERT_TRUE(tz_scrsaver != NULL); showTCWin(tw_base); - etRunner::get().waitEvent(tw_base, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_base); list = etRunner::get().getWinInfoList(); ASSERT_TRUE(list != NULL); diff --git a/src/testcase/0007_rotation.cpp b/src/testcase/0007_rotation.cpp index 282812e..470ce90 100644 --- a/src/testcase/0007_rotation.cpp +++ b/src/testcase/0007_rotation.cpp @@ -14,7 +14,7 @@ class etTestRotation : public ::etTCBase etWin *tw_base = NULL; void initTC(); - Eina_Bool testWinRotation(etWin *tw, int rot); + void testWinRotation(etWin *tw, int rot); }; void @@ -22,42 +22,25 @@ etTestRotation::initTC() { tw_base = initNormalWin("TCWin_Normal_Rotation", EINA_TRUE); showTCWin(tw_base); - etRunner::get().waitEvent(tw_base, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_VIS_ON(tw_base); ASSERT_TRUE(tw_base != NULL) << "failed to initiation window"; // available rotations elm_win_wm_rotation_available_rotations_set(tw_base->elm_win, rots, 4); } -Eina_Bool +void etTestRotation::testWinRotation(etWin *tw, int rot) { Eina_Bool res = EINA_FALSE; - std::shared_ptr ei = NULL; res = etRunner::get().setZoneRotation(rot); - if (!res) - { - ERR("Changing rotation is denied."); - return EINA_FALSE; - } + ASSERT_TRUE(res) << "Changing rotation is denied."; - ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE); - - if (!ei) - { - ERR("Failed waiting rotation change event"); - return EINA_FALSE; - } + ASSERT_ROTATION(tw, rot); 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; + ASSERT_TRUE((!res) || (tw->rot != rot)) << "Failed to rotate res " << res << ", pass " << rot << ", res " << tw->rot; } TEST_F(etTestRotation, available_rotations) @@ -79,7 +62,6 @@ TEST_F(etTestRotation, available_rotations) /* hard coded, reverse portrait(180) mode is disabled in mobile */ if (rot == 180) continue; - res = testWinRotation(tw_base, rot); - ASSERT_TRUE(res); + testWinRotation(tw_base, rot); } } diff --git a/src/testcase/0008_focus.cpp b/src/testcase/0008_focus.cpp index dfd3ed5..153266e 100644 --- a/src/testcase/0008_focus.cpp +++ b/src/testcase/0008_focus.cpp @@ -23,7 +23,7 @@ etTestFocus::initTC(Eina_Bool show_win, Eina_Bool usr_geom) if (show_win) { showTCWin(tw_red); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_red); } ASSERT_TRUE(tw_red != NULL) << "failed to initiation window"; @@ -31,7 +31,7 @@ etTestFocus::initTC(Eina_Bool show_win, Eina_Bool usr_geom) if (show_win) { showTCWin(tw_green); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_green); } ASSERT_TRUE(tw_green != NULL) << "failed to initiation window"; @@ -39,7 +39,7 @@ etTestFocus::initTC(Eina_Bool show_win, Eina_Bool usr_geom) if (show_win) { showTCWin(tw_blue); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_blue); } ASSERT_TRUE(tw_blue != NULL) << "failed to initiation window"; @@ -82,7 +82,7 @@ TEST_F(etTestFocus, focus_lower) // make tw_blue lower res = etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_green); // Expected focus res: // [Top] Green[focused] -> Red -> ... -> Blue [Bottom] @@ -110,8 +110,8 @@ TEST_F(etTestFocus, focus_lower2) // make tw_green lower res = etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED); ASSERT_TRUE(res); + ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_LOWER); // Expected focus res: // [Top] Blue[focused] -> Red -> ... -> Green [Bottom] @@ -139,8 +139,8 @@ TEST_F(etTestFocus, focus_raise) // make tw_red raise res = etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); ASSERT_TRUE(res); + ASSERT_FOCUS_IN(tw_red); // Expected focus res: // [Top] Red[focused] -> Blue -> Green [Bottom] @@ -167,8 +167,8 @@ TEST_F(etTestFocus, focus_destroy) // delete tw_blue removeTCWin(tw_blue); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF); tw_blue = NULL; + ASSERT_FOCUS_IN(tw_green); // Expected focus res: // [Top] Green[focused] -> Red [Bottom] @@ -197,7 +197,7 @@ TEST_F(etTestFocus, focus_activate1) // Activate tw_red res = etRunner::get().setWinActivate(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); // Expected focus res: // [Top] Red[focused] -> Blue -> Green [Bottom] @@ -225,12 +225,12 @@ TEST_F(etTestFocus, focus_activate2) // show Blocker showTCWin(tw_blocker); - etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_blocker); // Activate tw_red res = etRunner::get().setWinActivate(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_red); // Expected focus res: // [Top] Red[focused] -> Blocker -> Blue -> Green [Bottom] @@ -259,7 +259,7 @@ TEST_F(etTestFocus, focus_activate3) // make partial notification window etWin *tw_smallnoti = initNotiWin("TW_Temp_Noti", EINA_TRUE, EINA_TRUE); showTCWin(tw_smallnoti); - etRunner::get().waitEvent(tw_smallnoti, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_smallnoti); res = etRunner::get().setWinNotiLevel(tw_smallnoti, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT); EXPECT_TRUE(res); @@ -267,7 +267,7 @@ TEST_F(etTestFocus, focus_activate3) // Activate tw_red res = etRunner::get().setWinActivate(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); // Expected focus res: // [Top] smallnoti -> ... -> Red[focused] -> Blue -> Green [Bottom] @@ -297,12 +297,12 @@ TEST_F(etTestFocus, focus_show_activate) showTCWin(tw_small_blocker); etRunner::get().setWinNotiLevel(tw_small_blocker, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT); - etRunner::get().waitEvent(tw_small_blocker, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_small_blocker); // Activate tw_red res = showActivateTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_red); // Expected focus res: // [Top] Red[focused] -> Blue -> Green [Bottom] @@ -333,12 +333,12 @@ TEST_F(etTestFocus, focus_obscured_activate) EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT); EXPECT_TRUE(res); showTCWin(tw_blocker); - etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blocker); // Activate tw_red res = etRunner::get().setWinActivate(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); // Expected focus res: // [Top] Blocker[focused] -> ... -> Red -> Blue -> Green [Bottom] @@ -369,18 +369,17 @@ TEST_F(etTestFocus, focus_obscured_activate_destroy) EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT); EXPECT_TRUE(res); showTCWin(tw_blocker); - etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blocker); // Activate tw_red res = etRunner::get().setWinActivate(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); // remove tw_blocker removeTCWin(tw_blocker); - etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_OFF); tw_blocker = NULL; - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); // Expected focus res: // [Top] Red[focused] -> Blue -> Green [Bottom] @@ -409,7 +408,7 @@ TEST_F(etTestFocus, focus_transient_for1) // set transient_for Blue(parent) & Red(child) res = etRunner::get().setWinTransientFor(tw_red, tw_blue, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); // Expected focus res: // [Top] Red[focused] -> Blue -> Green [Bottom] @@ -438,7 +437,7 @@ TEST_F(etTestFocus, focus_transient_for2) // set transient_for Blue(parent) & Green(child) res = etRunner::get().setWinTransientFor(tw_green, tw_blue, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_RAISE); + ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_RAISE); // Expected focus res: // [Top] Green[focused] -> Blue -> Red [Bottom] @@ -467,7 +466,7 @@ TEST_F(etTestFocus, focus_transient_for3) // set transient_for Green(parent) & Blue(child) res = etRunner::get().setWinTransientFor(tw_blue, tw_green, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_RAISE); + etRunner::get().work(0.1); // wait for transient_for done. // Expected focus res: // [Top] Blue[focused] -> Green -> Red [Bottom] @@ -496,7 +495,7 @@ TEST_F(etTestFocus, focus_iconify1) // set iconify Blue res = etRunner::get().setWinIconic(tw_blue, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF); + ASSERT_VIS_OFF(tw_blue); // Expected focus res: // [Top] Blue(iconified) -> Green[focused] -> Red [Bottom] @@ -525,7 +524,7 @@ TEST_F(etTestFocus, focus_iconify2) // set iconify Red res = etRunner::get().setWinIconic(tw_red, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_OFF); + ASSERT_VIS_OFF(tw_red); // Expected focus res: // [Top] Blue[focused] -> Green -> Red(iconified) [Bottom] @@ -554,13 +553,13 @@ TEST_F(etTestFocus, focus_uniconify) // set iconify Red res = etRunner::get().setWinIconic(tw_red, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_OFF); + ASSERT_VIS_OFF(tw_red); // set uniconify Red res = etRunner::get().setWinIconic(tw_red, EINA_FALSE); ASSERT_TRUE(res); etRunner::get().work(2.0); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); // Expected focus res: // [Top] Red[focused] -> Blue -> Green [Bottom] @@ -589,13 +588,13 @@ TEST_F(etTestFocus, focus_uniconify2) // set iconify Blue res = etRunner::get().setWinIconic(tw_blue, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF); + ASSERT_VIS_OFF(tw_blue); // set uniconify Blue res = etRunner::get().setWinIconic(tw_blue, EINA_FALSE); ASSERT_TRUE(res); etRunner::get().work(2.0); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // Expected focus res: // [Top] Blue[focused] -> Green -> Red [Bottom] @@ -626,12 +625,12 @@ TEST_F(etTestFocus, focus_visibility) EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT); EXPECT_TRUE(res); showTCWin(tw_blocker); - etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_FOCUS_IN(tw_blocker); // hide blocker removeTCWin(tw_blocker); - etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_OFF); tw_blocker = NULL; + ASSERT_FOCUS_IN(tw_blue); // Expected focus res: // [Top] Blue[focused] -> Green -> Red [Bottom] @@ -658,7 +657,7 @@ TEST_F(etTestFocus, focus_move) // move tw_blue to out of screen tw_blue->move(2000, 2000); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_CHANGED); + ASSERT_VIS_OFF(tw_blue); // Expected focus res: // [Top] Blue -> Green[focused] -> Red [Bottom] @@ -685,11 +684,11 @@ TEST_F(etTestFocus, DISABLED_focus_move2) // move tw_blue to out of screen tw_blue->move(2000, 2000); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF); + ASSERT_VIS_OFF(tw_blue); // move tw_blue into screen tw_blue->move(200, 200); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // Expected focus res: // [Top] Blue -> Green[focused] -> Red [Bottom] @@ -717,7 +716,7 @@ TEST_F(etTestFocus, focus_touch_basic) // touch red win etRunner::get().generateMouseDown(50, 50); etRunner::get().generateMouseUp(50, 50); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_red); // Expected focus res: // [Top] Blue -> Green -> Red[focused] [Bottom] @@ -745,12 +744,12 @@ TEST_F(etTestFocus, focus_touch_history) // touch red win etRunner::get().generateMouseDown(50, 50); etRunner::get().generateMouseUp(50, 50); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_red); // touch blue win etRunner::get().generateMouseDown(250, 250); etRunner::get().generateMouseUp(250, 250); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_blue); // Expected focus res: // [Top] Blue[focused] -> Green -> Red [Bottom] @@ -768,10 +767,8 @@ TEST_F(etTestFocus, focus_touch_history) // remove blue win removeTCWin(tw_blue); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF); tw_blue = NULL; - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); - + ASSERT_FOCUS_IN(tw_red); // Expected focus res: // [Top] Green -> Red[focused] [Bottom] @@ -789,9 +786,8 @@ TEST_F(etTestFocus, focus_touch_history) // remove red win removeTCWin(tw_red); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_OFF); tw_red = NULL; - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_green); // Expected focus res: // [Top] Green[focused] [Bottom] @@ -819,7 +815,7 @@ TEST_F(etTestFocus, focus_touch_history2) // touch green win etRunner::get().generateMouseDown(150, 150); etRunner::get().generateMouseUp(150, 150); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_green); // Expected focus res: // [Top] Red -> Green[focused] -> Blue [Bottom] @@ -837,7 +833,7 @@ TEST_F(etTestFocus, focus_touch_history2) // activate red win etRunner::get().setWinActivate(tw_red); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); // Expected focus res: // [Top] Red[focused] -> Blue -> Green [Bottom] @@ -855,7 +851,7 @@ TEST_F(etTestFocus, focus_touch_history2) // lower red win etRunner::get().setWinStack(tw_red, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_LOWER); // Expected focus res: // [Top] Blue -> Green[focused] -> ... -> Red [Bottom] @@ -882,7 +878,7 @@ TEST_F(etTestFocus, focus_skip_set) // set focus_skip on tw_blue etRunner::get().setFocusSkip(tw_blue, EINA_TRUE); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_green); // Expected focus res: // [Top] Blue -> Green[focused] -> Red [Bottom] @@ -911,7 +907,7 @@ TEST_F(etTestFocus, focus_skip_unset) // set focus_skip on tw_blue etRunner::get().setFocusSkip(tw_blue, EINA_TRUE); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_green); // Expected focus res: // [Top] Blue -> Green[focused] -> Red [Bottom] @@ -1012,8 +1008,8 @@ TEST_F(etTestFocus, focus_fullsize_lower) // make tw_blue lower res = etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED); ASSERT_TRUE(res); + ASSERT_FOCUS_IN(tw_green); // Expected focus res: // [Top] Green[focused] -> Red -> ... -> Blue [Bottom] @@ -1041,8 +1037,8 @@ TEST_F(etTestFocus, focus_fullsize_lower2) // make tw_green lower res = etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_STACK_LOWER); ASSERT_TRUE(res); + ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_LOWER); // Expected focus res: // [Top] Blue[focused] -> Red -> ... -> Green [Bottom] @@ -1070,8 +1066,8 @@ TEST_F(etTestFocus, focus_fullsize_raise) // make tw_red raise res = etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); ASSERT_TRUE(res); + ASSERT_FOCUS_IN(tw_red); // Expected focus res: // [Top] Red[focused] -> Blue -> Green [Bottom] @@ -1098,9 +1094,8 @@ TEST_F(etTestFocus, focus_fullsize_destroy) // delete tw_blue removeTCWin(tw_blue); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF); tw_blue = NULL; - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_green); // Expected focus res: // [Top] Green[focused] -> Red [Bottom] @@ -1128,8 +1123,8 @@ TEST_F(etTestFocus, focus_fullsize_activate) // Activate tw_red res = etRunner::get().setWinActivate(tw_red); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); ASSERT_TRUE(res); + ASSERT_FOCUS_IN(tw_red); // Expected focus res: // [Top] Red[focused] -> Blue -> Green [Bottom] @@ -1160,12 +1155,12 @@ TEST_F(etTestFocus, focus_fullsize_obscured_activate) EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT); EXPECT_TRUE(res); showTCWin(tw_blocker); - etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blocker); // Activate tw_red res = etRunner::get().setWinActivate(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); // Expected focus res: // [Top] Blocker[focused] -> ... -> Red -> Blue -> Green [Bottom] @@ -1196,7 +1191,7 @@ TEST_F(etTestFocus, focus_fullsize_obscured_activate_check_event) EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT); EXPECT_TRUE(res); showTCWin(tw_blocker); - etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blocker); // set event checkpoint etRunner::get().setEventCheckpoint(); @@ -1204,7 +1199,7 @@ TEST_F(etTestFocus, focus_fullsize_obscured_activate_check_event) // Activate tw_red res = etRunner::get().setWinActivate(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); // Expected focus res: // [Top] Blocker[focused] -> ... -> Red -> Blue -> Green [Bottom] @@ -1238,18 +1233,17 @@ TEST_F(etTestFocus, focus_fullsize_obscured_activate_destroy) EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT); EXPECT_TRUE(res); showTCWin(tw_blocker); - etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blocker); // Activate tw_red res = etRunner::get().setWinActivate(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE); // remove tw_blocker removeTCWin(tw_blocker); - etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_OFF); tw_blocker = NULL; - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_red); // Expected focus res: // [Top] Red[focused] -> Blue -> Green [Bottom] @@ -1278,12 +1272,12 @@ TEST_F(etTestFocus, focus_fullsize_show_activate_under_blocker) showTCWin(tw_blocker); etRunner::get().setWinNotiLevel(tw_blocker, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT); - etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blocker); // Activate tw_red res = showActivateTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); // Expected focus res: // [Top] Blocker[focused] -> ... -> Red [Bottom] @@ -1312,7 +1306,7 @@ TEST_F(etTestFocus, focus_fullsize_show_activate_under_blocker_check_event) showTCWin(tw_blocker); etRunner::get().setWinNotiLevel(tw_blocker, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT); - etRunner::get().waitEvent(tw_blocker, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blocker); // set event checkpoint etRunner::get().setEventCheckpoint(); @@ -1320,7 +1314,7 @@ TEST_F(etTestFocus, focus_fullsize_show_activate_under_blocker_check_event) // Activate tw_red res = showActivateTCWin(tw_red); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_RAISE); // Expected focus res: // [Top] Blocker[focused] -> ... -> Red [Bottom] @@ -1352,7 +1346,7 @@ TEST_F(etTestFocus, focus_fullsize_transient_for) // set transient_for Blue(parent) & Red(child) res = etRunner::get().setWinTransientFor(tw_red, tw_blue, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_red); // Expected focus res: // [Top] Red[focused] -> Blue -> Green [Bottom] @@ -1381,7 +1375,7 @@ TEST_F(etTestFocus, focus_fullsize_iconify) // set iconify Blue res = etRunner::get().setWinIconic(tw_blue, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_OFF); + ASSERT_VIS_OFF(tw_blue); // Expected focus res: // [Top] Blue(iconified) -> Green[focused] -> Red [Bottom] @@ -1410,12 +1404,12 @@ TEST_F(etTestFocus, focus_fullsize_uniconify) // set iconify Red res = etRunner::get().setWinIconic(tw_red, EINA_TRUE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_OFF); + etRunner::get().work(0.1); // wait for iconify done // set uniconify Red res = etRunner::get().setWinIconic(tw_red, EINA_FALSE); ASSERT_TRUE(res); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_red); // Expected focus res: // [Top] Red[focused] -> Blue -> Green [Bottom] @@ -1442,7 +1436,7 @@ TEST_F(etTestFocus, focus_fullsize_skip_set) // set focus_skip on tw_blue etRunner::get().setFocusSkip(tw_blue, EINA_TRUE); - etRunner::get().work(0.1); // waiting for adjust focus skip set + ASSERT_FOCUS_OUT(tw_blue); // Expected focus res: // [Top] Blue -> Green -> Red [Bottom] @@ -1468,12 +1462,11 @@ TEST_F(etTestFocus, focus_fullsize_skip_unset) // Expected focus res: // [Top] Blue -> Green -> Red [Bottom] etRunner::get().setFocusSkip(tw_blue, EINA_TRUE); - etRunner::get().work(0.1); // waiting for adjust focus skip set + ASSERT_FOCUS_OUT(tw_blue); // unset focus_skip on tw_blue etRunner::get().setFocusSkip(tw_blue, EINA_FALSE); - etRunner::get().work(0.1); // waiting for adjust focus skip set - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_FOCUS_IN(tw_blue); // Expected focus res: // [Top] Blue[focused] -> Green -> Red [Bottom] @@ -1504,7 +1497,7 @@ TEST_F(etTestFocus, focus_fullsize_below_skip_above_remove) // remove tw_blue removeTCWin(tw_blue); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_green); // Expected focus res: // [Top] Blue -> Green -> Red [Bottom] @@ -1533,9 +1526,9 @@ TEST_F(etTestFocus, focus_fullsize_show_after_skip_set) etRunner::get().setFocusSkipEcoreWl2(tw_blue, EINA_TRUE); etRunner::get().work(0.1); // waiting for adjust focus skip set - // remove tw_blue + // show tw_blue showTCWin(tw_blue); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // Expected focus res: // [Top] Blue -> Green -> Red [Bottom] @@ -1558,9 +1551,9 @@ TEST_F(etTestFocus, focus_fullsize_show_after_skip_set_and_transient_for) initTC(EINA_FALSE, EINA_FALSE); showTCWin(tw_red); - etRunner::get().waitEvent(tw_red, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_red); showTCWin(tw_green); - etRunner::get().waitEvent(tw_green, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_green); // set transient_for etRunner::get().setWinTransientFor(tw_green, tw_red, EINA_TRUE); @@ -1571,9 +1564,9 @@ TEST_F(etTestFocus, focus_fullsize_show_after_skip_set_and_transient_for) etRunner::get().setFocusSkipEcoreWl2(tw_blue, EINA_TRUE); etRunner::get().work(0.1); // waiting for adjust focus skip set - // remove tw_blue + // show tw_blue showTCWin(tw_blue); - etRunner::get().waitEvent(tw_blue, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_blue); // Expected focus res: // [Top] Blue -> Green[focused] -> Red [Bottom] diff --git a/src/testcase/0009_input.cpp b/src/testcase/0009_input.cpp index 5421694..5546531 100644 --- a/src/testcase/0009_input.cpp +++ b/src/testcase/0009_input.cpp @@ -17,6 +17,9 @@ public: key_name = NULL; }; + void test_gesture_edge_swipe(int fingers, efl_util_gesture_edge_e edge); + void test_gesture_edge_drag(int fingers, efl_util_gesture_edge_e edge); + protected: etWin *tw_shared = NULL; etWin *tw_topposition = NULL; @@ -29,14 +32,13 @@ protected: TEST_F(etTestInput, keygrab_nowin_shared) { - std::shared_ptr 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); - ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY); - ASSERT_TRUE(ei != NULL); + ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY); + ASSERT_NE(ev_result, nullptr); ret = ecore_wl2_window_keygrab_unset(NULL, "XF86Menu", 0, 0); ASSERT_TRUE(ret); @@ -44,15 +46,14 @@ TEST_F(etTestInput, keygrab_nowin_shared) TEST_F(etTestInput, keygrab_nowin_orexcl) { - std::shared_ptr 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); - ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY); - ASSERT_TRUE(ei != NULL); + ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY); + ASSERT_NE(ev_result, nullptr); ret = ecore_wl2_window_keygrab_unset(NULL, "XF86Menu", 0, 0); ASSERT_TRUE(ret); @@ -60,15 +61,14 @@ TEST_F(etTestInput, keygrab_nowin_orexcl) TEST_F(etTestInput, keygrab_nowin_excl) { - std::shared_ptr 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); - ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY); - ASSERT_TRUE(ei != NULL); + ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY); + ASSERT_NE(ev_result, nullptr); ret = ecore_wl2_window_keygrab_unset(NULL, "XF86Menu", 0, 0); ASSERT_TRUE(ret); @@ -76,14 +76,13 @@ TEST_F(etTestInput, keygrab_nowin_excl) TEST_F(etTestInput, keygrab_win_shared) { - std::shared_ptr ei = NULL; Eina_Bool ret = EINA_FALSE; tw_shared = initNormalWin("TCWin_SharedGrab", EINA_FALSE); ASSERT_TRUE(tw_shared != NULL) << "failed to initiation window"; showTCWin(tw_shared); - etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_shared); ret = elm_win_keygrab_set(tw_shared->elm_win, "XF86Menu", 0, 0, 0, ELM_WIN_KEYGRAB_SHARED); ASSERT_TRUE(ret); @@ -93,12 +92,11 @@ TEST_F(etTestInput, keygrab_win_shared) etRunner::get().ev.elm_win = tw_shared->elm_win; etRunner::get().ev.native_win = tw_shared->native_win; ret = etRunner::get().setWinStack(tw_shared, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_EVENT(tw_shared, E_TC_EVENT_TYPE_STACK_LOWER); ASSERT_TRUE(ret); etRunner::get().generateKeyEvent(key_name, 0.3); - ei = etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); - ASSERT_TRUE(ei != NULL); + ASSERT_EVENT(tw_shared, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); etRunner::get().ev.elm_win = NULL; etRunner::get().ev.native_win = 0; @@ -110,14 +108,13 @@ TEST_F(etTestInput, keygrab_win_shared) TEST_F(etTestInput, keygrab_win_orexcl) { - std::shared_ptr ei = NULL; Eina_Bool ret = EINA_FALSE; tw_orexcl = initNormalWin("TCWin_OrexclGrab", EINA_FALSE); ASSERT_TRUE(tw_orexcl != NULL) << "failed to initiation window"; showTCWin(tw_orexcl); - etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_orexcl); ret = elm_win_keygrab_set(tw_orexcl->elm_win, "XF86Menu", 0, 0, 0, ELM_WIN_KEYGRAB_OVERRIDE_EXCLUSIVE); ASSERT_TRUE(ret); @@ -127,12 +124,11 @@ TEST_F(etTestInput, keygrab_win_orexcl) etRunner::get().ev.elm_win = tw_orexcl->elm_win; etRunner::get().ev.native_win = tw_orexcl->native_win; ret = etRunner::get().setWinStack(tw_orexcl, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_FOCUS_CHANGED); ASSERT_TRUE(ret); + ASSERT_EVENT(tw_orexcl, E_TC_EVENT_TYPE_STACK_LOWER); etRunner::get().generateKeyEvent(key_name, 0.3); - ei = etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); - ASSERT_TRUE(ei); + ASSERT_EVENT(tw_orexcl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); etRunner::get().ev.elm_win = NULL; etRunner::get().ev.native_win = 0; @@ -144,14 +140,13 @@ TEST_F(etTestInput, keygrab_win_orexcl) TEST_F(etTestInput, keygrab_win_excl) { - std::shared_ptr ei = NULL; Eina_Bool ret = EINA_FALSE; tw_excl = initNormalWin("TCWin_ExclGrab", EINA_FALSE); ASSERT_TRUE(tw_excl != NULL) << "failed to initiation window"; showTCWin(tw_excl); - etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_excl); ret = elm_win_keygrab_set(tw_excl->elm_win, "XF86Menu", 0, 0, 0, ELM_WIN_KEYGRAB_EXCLUSIVE); ASSERT_TRUE(ret); @@ -161,12 +156,11 @@ TEST_F(etTestInput, keygrab_win_excl) etRunner::get().ev.elm_win = tw_excl->elm_win; etRunner::get().ev.native_win = tw_excl->native_win; ret = etRunner::get().setWinStack(tw_excl, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_FOCUS_CHANGED); + ASSERT_EVENT(tw_excl, E_TC_EVENT_TYPE_STACK_LOWER); ASSERT_TRUE(ret); etRunner::get().generateKeyEvent(key_name, 0.3); - ei = etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); - ASSERT_TRUE(ei); + ASSERT_EVENT(tw_excl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); etRunner::get().ev.elm_win = NULL; etRunner::get().ev.native_win = 0; @@ -178,14 +172,13 @@ TEST_F(etTestInput, keygrab_win_excl) TEST_F(etTestInput, keygrab_win_topposition) { - std::shared_ptr ei = NULL; Eina_Bool ret = EINA_FALSE; tw_topposition = initNormalWin("TCWin_ToppositionGrab", EINA_TRUE); ASSERT_TRUE(tw_topposition != NULL) << "failed to initiation window"; showTCWin(tw_topposition); - etRunner::get().waitEvent(tw_topposition, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_topposition); ecore_evas_focus_skip_set(ecore_evas_ecore_evas_get(evas_object_evas_get(tw_topposition->elm_win)), EINA_TRUE); @@ -198,8 +191,7 @@ TEST_F(etTestInput, keygrab_win_topposition) etRunner::get().ev.native_win = tw_topposition->native_win; etRunner::get().generateKeyEvent(key_name, 0.3); - ei = etRunner::get().waitEvent(tw_topposition, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); - ASSERT_TRUE(ei); + ASSERT_EVENT(tw_topposition, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); etRunner::get().ev.elm_win = NULL; etRunner::get().ev.native_win = 0; @@ -211,32 +203,31 @@ TEST_F(etTestInput, keygrab_win_topposition) TEST_F(etTestInput, keygrab_win) { - std::shared_ptr ei = NULL; Eina_Bool ret = EINA_FALSE; tw_shared = initNormalWin("TCWin_SharedGrab", EINA_FALSE); ASSERT_TRUE(tw_shared != NULL) << "failed to initiation window"; showTCWin(tw_shared); - etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_shared); tw_orexcl = initNormalWin("TCWin_OrexclGrab", EINA_FALSE); ASSERT_TRUE(tw_orexcl != NULL) << "failed to initiation window"; showTCWin(tw_orexcl); - etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_orexcl); tw_excl = initNormalWin("TCWin_ExclGrab", EINA_FALSE); ASSERT_TRUE(tw_excl != NULL) << "failed to initiation window"; showTCWin(tw_excl); - etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_excl); tw_topposition = initNormalWin("TCWin_ToppositionGrab", EINA_TRUE); ASSERT_TRUE(tw_topposition != NULL) << "failed to initiation window"; showTCWin(tw_topposition); - etRunner::get().waitEvent(tw_topposition, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw_topposition); ecore_evas_focus_skip_set(ecore_evas_ecore_evas_get(evas_object_evas_get(tw_topposition->elm_win)), EINA_TRUE); @@ -261,24 +252,23 @@ TEST_F(etTestInput, keygrab_win) ASSERT_TRUE(ret); ret = etRunner::get().setWinStack(tw_excl, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_FOCUS_CHANGED); ASSERT_TRUE(ret); + ASSERT_EVENT(tw_excl, E_TC_EVENT_TYPE_STACK_LOWER); ret = etRunner::get().setWinStack(tw_orexcl, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_FOCUS_CHANGED); ASSERT_TRUE(ret); + ASSERT_EVENT(tw_orexcl, E_TC_EVENT_TYPE_STACK_LOWER); ret = etRunner::get().setWinStack(tw_shared, NULL, EINA_FALSE); - etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_FOCUS_CHANGED); ASSERT_TRUE(ret); + ASSERT_EVENT(tw_shared, E_TC_EVENT_TYPE_STACK_LOWER); // test exclusive grab etRunner::get().ev.elm_win = tw_excl->elm_win; etRunner::get().ev.native_win = tw_excl->native_win; etRunner::get().generateKeyEvent(key_name, 0.3); - ei = etRunner::get().waitEvent(tw_excl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); - ASSERT_TRUE(ei != NULL); + ASSERT_EVENT(tw_excl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); evas_object_key_ungrab(tw_excl->elm_win, "XF86Menu", 0, 0); ret = elm_win_keygrab_unset(tw_excl->elm_win, "XF86Menu", 0, 0); @@ -289,8 +279,7 @@ TEST_F(etTestInput, keygrab_win) etRunner::get().ev.native_win = tw_orexcl->native_win; etRunner::get().generateKeyEvent(key_name, 0.3); - ei = etRunner::get().waitEvent(tw_orexcl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); - ASSERT_TRUE(ei != NULL); + ASSERT_EVENT(tw_orexcl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); evas_object_key_ungrab(tw_orexcl->elm_win, "XF86Menu", 0, 0); ret = elm_win_keygrab_unset(tw_orexcl->elm_win, "XF86Menu", 0, 0); @@ -301,8 +290,7 @@ TEST_F(etTestInput, keygrab_win) etRunner::get().ev.native_win = tw_topposition->native_win; etRunner::get().generateKeyEvent(key_name, 0.3); - ei = etRunner::get().waitEvent(tw_topposition, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); - ASSERT_TRUE(ei != NULL); + ASSERT_EVENT(tw_topposition, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); evas_object_key_ungrab(tw_topposition->elm_win, "XF86Menu", 0, 0); ret = elm_win_keygrab_unset(tw_topposition->elm_win, "XF86Menu", 0, 0); @@ -313,8 +301,7 @@ TEST_F(etTestInput, keygrab_win) etRunner::get().ev.native_win = tw_shared->native_win; etRunner::get().generateKeyEvent(key_name, 0.3); - ei = etRunner::get().waitEvent(tw_shared, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); - ASSERT_TRUE(ei != NULL); + ASSERT_EVENT(tw_shared, E_TC_EVENT_TYPE_INPUT_EVAS_KEY); evas_object_key_ungrab(tw_shared->elm_win, "XF86Menu", 0, 0); ret = elm_win_keygrab_unset(tw_shared->elm_win, "XF86Menu", 0, 0); @@ -326,7 +313,6 @@ TEST_F(etTestInput, keygrab_win) TEST_F(etTestInput, gesture_tap22) { - std::shared_ptr ei = NULL; int ret = EFL_UTIL_ERROR_NONE; efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler(); efl_util_gesture_data tap_d; @@ -342,8 +328,8 @@ TEST_F(etTestInput, gesture_tap22) etRunner::get().ev.gesture.tap.repeats = 2; etRunner::get().generateTapGesture(); - ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_TAP); - ASSERT_TRUE(ei != NULL); + ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_TAP); + ASSERT_NE(ev_result, nullptr); etRunner::get().ev.gesture.tap.fingers = 0; etRunner::get().ev.gesture.tap.repeats = 0; @@ -355,7 +341,6 @@ TEST_F(etTestInput, gesture_tap22) TEST_F(etTestInput, gesture_tap23) { - std::shared_ptr ei = NULL; int ret = EFL_UTIL_ERROR_NONE; efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler(); efl_util_gesture_data tap_d; @@ -371,8 +356,8 @@ TEST_F(etTestInput, gesture_tap23) etRunner::get().ev.gesture.tap.repeats = 3; etRunner::get().generateTapGesture(); - ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_TAP); - ASSERT_TRUE(ei != NULL); + ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_TAP); + ASSERT_NE(ev_result, nullptr); etRunner::get().ev.gesture.tap.fingers = 0; etRunner::get().ev.gesture.tap.repeats = 0; @@ -385,10 +370,9 @@ TEST_F(etTestInput, gesture_tap23) << EFL_UTIL_RETURN_TO_STRING(ret) << ")"; } -static void -_test_gesture_edge_swipe(int fingers, efl_util_gesture_edge_e edge) +void +etTestInput::test_gesture_edge_swipe(int fingers, efl_util_gesture_edge_e edge) { - std::shared_ptr ei = NULL; int ret = EFL_UTIL_ERROR_NONE; efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler(); efl_util_gesture_data edge_swipe_d; @@ -404,8 +388,8 @@ _test_gesture_edge_swipe(int fingers, efl_util_gesture_edge_e edge) etRunner::get().ev.gesture.edge.edge = edge; etRunner::get().generateEdgeSwipeGesture(); - ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE); - ASSERT_TRUE(ei != NULL); + ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE); + ASSERT_NE(ev_result, nullptr); etRunner::get().ev.gesture.edge.fingers = 0; etRunner::get().ev.gesture.edge.edge = EFL_UTIL_GESTURE_EDGE_NONE;; @@ -421,48 +405,47 @@ _test_gesture_edge_swipe(int fingers, efl_util_gesture_edge_e edge) TEST_F(etTestInput, gesture_edge_swipe11) { - _test_gesture_edge_swipe(1, EFL_UTIL_GESTURE_EDGE_TOP); + test_gesture_edge_swipe(1, EFL_UTIL_GESTURE_EDGE_TOP); } TEST_F(etTestInput, gesture_edge_swipe12) { - _test_gesture_edge_swipe(1, EFL_UTIL_GESTURE_EDGE_RIGHT); + test_gesture_edge_swipe(1, EFL_UTIL_GESTURE_EDGE_RIGHT); } TEST_F(etTestInput, gesture_edge_swipe13) { - _test_gesture_edge_swipe(1, EFL_UTIL_GESTURE_EDGE_BOTTOM); + test_gesture_edge_swipe(1, EFL_UTIL_GESTURE_EDGE_BOTTOM); } TEST_F(etTestInput, gesture_edge_swipe14) { - _test_gesture_edge_swipe(1, EFL_UTIL_GESTURE_EDGE_LEFT); + test_gesture_edge_swipe(1, EFL_UTIL_GESTURE_EDGE_LEFT); } TEST_F(etTestInput, gesture_edge_swipe21) { - _test_gesture_edge_swipe(2, EFL_UTIL_GESTURE_EDGE_TOP); + test_gesture_edge_swipe(2, EFL_UTIL_GESTURE_EDGE_TOP); } TEST_F(etTestInput, gesture_edge_swipe22) { - _test_gesture_edge_swipe(2, EFL_UTIL_GESTURE_EDGE_RIGHT); + test_gesture_edge_swipe(2, EFL_UTIL_GESTURE_EDGE_RIGHT); } TEST_F(etTestInput, gesture_edge_swipe23) { - _test_gesture_edge_swipe(2, EFL_UTIL_GESTURE_EDGE_BOTTOM); + test_gesture_edge_swipe(2, EFL_UTIL_GESTURE_EDGE_BOTTOM); } TEST_F(etTestInput, gesture_edge_swipe24) { - _test_gesture_edge_swipe(2, EFL_UTIL_GESTURE_EDGE_LEFT); + test_gesture_edge_swipe(2, EFL_UTIL_GESTURE_EDGE_LEFT); } -static void -_test_gesture_edge_drag(int fingers, efl_util_gesture_edge_e edge) +void +etTestInput::test_gesture_edge_drag(int fingers, efl_util_gesture_edge_e edge) { - std::shared_ptr ei = NULL; int ret = EFL_UTIL_ERROR_NONE; efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler(); efl_util_gesture_data edge_drag_d; @@ -478,8 +461,8 @@ _test_gesture_edge_drag(int fingers, efl_util_gesture_edge_e edge) etRunner::get().ev.gesture.edge.edge = edge; etRunner::get().generateEdgeDragGesture(); - ei = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG); - ASSERT_TRUE(ei != NULL); + ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG); + ASSERT_NE(ev_result, nullptr); etRunner::get().ev.gesture.edge.fingers = 0; etRunner::get().ev.gesture.edge.edge = EFL_UTIL_GESTURE_EDGE_NONE;; @@ -495,40 +478,40 @@ _test_gesture_edge_drag(int fingers, efl_util_gesture_edge_e edge) TEST_F(etTestInput, gesture_edge_drag11) { - _test_gesture_edge_drag(1, EFL_UTIL_GESTURE_EDGE_TOP); + test_gesture_edge_drag(1, EFL_UTIL_GESTURE_EDGE_TOP); } TEST_F(etTestInput, gesture_edge_drag12) { - _test_gesture_edge_drag(1, EFL_UTIL_GESTURE_EDGE_RIGHT); + test_gesture_edge_drag(1, EFL_UTIL_GESTURE_EDGE_RIGHT); } TEST_F(etTestInput, gesture_edge_drag13) { - _test_gesture_edge_drag(1, EFL_UTIL_GESTURE_EDGE_BOTTOM); + test_gesture_edge_drag(1, EFL_UTIL_GESTURE_EDGE_BOTTOM); } TEST_F(etTestInput, gesture_edge_drag14) { - _test_gesture_edge_drag(1, EFL_UTIL_GESTURE_EDGE_LEFT); + test_gesture_edge_drag(1, EFL_UTIL_GESTURE_EDGE_LEFT); } TEST_F(etTestInput, gesture_edge_drag21) { - _test_gesture_edge_drag(2, EFL_UTIL_GESTURE_EDGE_TOP); + test_gesture_edge_drag(2, EFL_UTIL_GESTURE_EDGE_TOP); } TEST_F(etTestInput, gesture_edge_drag22) { - _test_gesture_edge_drag(2, EFL_UTIL_GESTURE_EDGE_RIGHT); + test_gesture_edge_drag(2, EFL_UTIL_GESTURE_EDGE_RIGHT); } TEST_F(etTestInput, gesture_edge_drag23) { - _test_gesture_edge_drag(2, EFL_UTIL_GESTURE_EDGE_BOTTOM); + test_gesture_edge_drag(2, EFL_UTIL_GESTURE_EDGE_BOTTOM); } TEST_F(etTestInput, gesture_edge_drag24) { - _test_gesture_edge_drag(2, EFL_UTIL_GESTURE_EDGE_LEFT); + test_gesture_edge_drag(2, EFL_UTIL_GESTURE_EDGE_LEFT); } diff --git a/src/testcase/0010_splash.cpp b/src/testcase/0010_splash.cpp index 440c933..b2b7e56 100644 --- a/src/testcase/0010_splash.cpp +++ b/src/testcase/0010_splash.cpp @@ -39,7 +39,7 @@ TEST_F(etTestSplash, splash_edc) Eina_List *list = NULL, *l = NULL; initTC((char*)path_edc, SPLASH_TYPE_EDC); - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw); // find Launchscreen from toplv windows list = etRunner::get().getWinInfoList(); @@ -63,7 +63,7 @@ TEST_F(etTestSplash, splash_img) Eina_List *list = NULL, *l = NULL; initTC((char*)path_img, SPLASH_TYPE_IMG); - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw); // find Launchscreen from toplv windows list = etRunner::get().getWinInfoList(); @@ -88,7 +88,7 @@ TEST_F(etTestSplash, splash_disappear_after_real) initTC((char*)path_img, SPLASH_TYPE_IMG); showTCWin(tw); - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw); // Expected focus res: list = etRunner::get().getWinInfoList(); @@ -113,14 +113,12 @@ TEST_F(etTestSplash, splash_evas_callback_after_real) { etWin *tw2 = NULL; Eina_List *list = NULL, *l = NULL; - std::shared_ptr ei = NULL; initTC((char*)path_img, SPLASH_TYPE_IMG); etRunner::get().setSplashOwner(); showTCWin(tw); - ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT_EVAS_CB); - ASSERT_TRUE(ei != NULL); + ASSERT_EVENT(tw, E_TC_EVENT_TYPE_EFFECT_EVAS_CB); // Expected focus res: list = etRunner::get().getWinInfoList(); diff --git a/src/testcase/0011_effect.cpp b/src/testcase/0011_effect.cpp index 9745664..cc23911 100644 --- a/src/testcase/0011_effect.cpp +++ b/src/testcase/0011_effect.cpp @@ -26,7 +26,6 @@ etTestEffect::initTC() TEST_F(etTestEffect, effect_show) { - std::shared_ptr ei = NULL; Eina_Bool res = EINA_FALSE; initTC(); @@ -35,16 +34,13 @@ TEST_F(etTestEffect, effect_show) ASSERT_TRUE(res); showTCWin(tw); - - ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT); - ASSERT_TRUE(ei != NULL); + ASSERT_EVENT(tw, E_TC_EVENT_TYPE_EFFECT); return; } TEST_F(etTestEffect, effect_show_evas_callback) { - std::shared_ptr ei = NULL; Eina_Bool res = EINA_FALSE; initTC(); @@ -53,67 +49,62 @@ TEST_F(etTestEffect, effect_show_evas_callback) ASSERT_TRUE(res); showTCWin(tw); - - ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT_EVAS_CB); - ASSERT_TRUE(ei != NULL); + ASSERT_EVENT(tw, E_TC_EVENT_TYPE_EFFECT_EVAS_CB); return; } TEST_F(etTestEffect, effect_hide_bylower) { - std::shared_ptr ei = NULL; Eina_Bool res = EINA_FALSE; initTC(); showTCWin(tw); - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw); res = etRunner::get().setWinEffect(tw); ASSERT_TRUE(res); + elm_win_lower(tw->elm_win); - ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT); - ASSERT_TRUE(ei != NULL); + ASSERT_EVENT(tw, E_TC_EVENT_TYPE_EFFECT); return; } TEST_F(etTestEffect, effect_hide_byunmap) { - std::shared_ptr ei = NULL; Eina_Bool res = EINA_FALSE; initTC(); showTCWin(tw); - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw); res = etRunner::get().setWinEffect(tw); ASSERT_TRUE(res); + tw->hide(); - ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT); - ASSERT_TRUE(ei != NULL); + ASSERT_EVENT(tw, E_TC_EVENT_TYPE_EFFECT); return; } TEST_F(etTestEffect, effect_bg) { - std::shared_ptr ei = NULL; Eina_Bool res = EINA_FALSE; initTC(); showTCWin(tw); - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); + ASSERT_VIS_ON(tw); res = etRunner::get().setWinEffect(tw); ASSERT_TRUE(res); + //show upper window showTCWin(tw_green); - ei = etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_EFFECT); - ASSERT_TRUE(ei != NULL); + ASSERT_EVENT(tw, E_TC_EVENT_TYPE_EFFECT); return; } diff --git a/src/testcase/0012_aux_hint.cpp b/src/testcase/0012_aux_hint.cpp index 0160710..b7dfc84 100644 --- a/src/testcase/0012_aux_hint.cpp +++ b/src/testcase/0012_aux_hint.cpp @@ -15,6 +15,8 @@ class etTestAuxHint : public ::etTCBase etRunner::get().delSupportedAuxHint("win.test.auxhint"); }; + void compareHint(std::shared_ptr data, int id, const char *hint, const char *val); + protected: etWin *tw = NULL; @@ -22,69 +24,73 @@ class etTestAuxHint : public ::etTCBase }; void +etTestAuxHint::compareHint(std::shared_ptr data, + int id, + const char *hint, + const char *val) +{ + ASSERT_NE(data, nullptr); + if (id >= 0) + { + ASSERT_TRUE(data->isSameID(id)) << "Result mismatch, ID: " << data->getID() << " vs " << id; + } + if (hint) + { + ASSERT_TRUE(data->isSameHint(std::string(hint))) << "Result mismatch, hint: " << data->getHint() << " vs " << hint; + } + if (val) + { + ASSERT_TRUE(data->isSameVal(std::string(val))) << "Result mismatch, hint: " << data->getVal() << " vs " << val; + } +} + +void etTestAuxHint::initTC() { tw = initNormalWin("TCWin_Normal", EINA_TRUE); ASSERT_TRUE(tw != NULL) << "failed to initiation window"; ASSERT_TRUE(showTCWin(tw)) << "failed to show window"; + ASSERT_FOCUS_IN(tw); // for consume default aux hint event } TEST_F(etTestAuxHint, add_hint) { - std::shared_ptr data = NULL; Eina_Bool ret = EINA_FALSE; initTC(); - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); ret = etRunner::get().addAuxHint(tw, test_hint_id, "win.test.auxhint", "test"); ASSERT_TRUE(ret); - data = std::static_pointer_cast(etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_AUX_HINT_CHANGED)); - ASSERT_TRUE(data != NULL); - ASSERT_TRUE(data->isSameHint(std::string("win.test.auxhint"))) << "Err: " << data->getHint(); - ASSERT_TRUE(data->isSameVal(std::string("test"))) << "Err: " << data->getVal(); + ASSERT_HINT(tw, test_hint_id, "win.test.auxhint", "test"); } TEST_F(etTestAuxHint, change_hint) { - std::shared_ptr data = NULL; Eina_Bool ret = EINA_FALSE; initTC(); - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); ret = etRunner::get().addAuxHint(tw, test_hint_id, "win.test.auxhint", "test"); ASSERT_TRUE(ret); - data = std::static_pointer_cast(etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_AUX_HINT_CHANGED)); - ASSERT_TRUE(data != NULL); - ASSERT_TRUE(data->isSameHint(std::string("win.test.auxhint"))) << "Err: " << data->getHint(); - ASSERT_TRUE(data->isSameVal(std::string("test"))) << "Err: " << data->getVal(); + ASSERT_HINT(tw, test_hint_id, "win.test.auxhint", "test"); ret = etRunner::get().changeAuxHint(tw, test_hint_id, "test2"); ASSERT_TRUE(ret); - data = std::static_pointer_cast(etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_AUX_HINT_CHANGED)); - ASSERT_TRUE(data != NULL); - ASSERT_TRUE(data->isSameHint(std::string("win.test.auxhint"))) << "Err: " << data->getHint(); - ASSERT_TRUE(data->isSameVal(std::string("test2"))) << "Err: " << data->getVal(); + ASSERT_HINT(tw, test_hint_id, "win.test.auxhint", "test2"); } TEST_F(etTestAuxHint, del_hint) { - std::shared_ptr data = NULL; Eina_Bool ret = EINA_FALSE; initTC(); - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_VIS_ON); ret = etRunner::get().addAuxHint(tw, test_hint_id, "win.test.auxhint", "test"); ASSERT_TRUE(ret); - data = std::static_pointer_cast(etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_AUX_HINT_CHANGED)); - ASSERT_TRUE(data != NULL); - ASSERT_TRUE(data->isSameHint(std::string("win.test.auxhint"))) << "Err: " << data->getHint(); - ASSERT_TRUE(data->isSameVal(std::string("test"))) << "Err: " << data->getVal(); + ASSERT_HINT(tw, test_hint_id, "win.test.auxhint", "test"); ret = etRunner::get().delAuxHint(tw, test_hint_id); ASSERT_TRUE(ret); - etRunner::get().waitEvent(tw, E_TC_EVENT_TYPE_AUX_HINT_CHANGED); + ASSERT_HINT(tw, test_hint_id, "win.test.auxhint", "test"); } -- 2.7.4 From 2b8e609c833f841347cf6f73d4f1b94109bf8e37 Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Tue, 27 Apr 2021 22:08:53 +0900 Subject: [PATCH 13/16] 0004_transient_for: added test for restack as transient_for set Change-Id: I38a12c92c4aecb622ce2b222790a5624ae3ca30c --- src/testcase/0004_transient_for.cpp | 53 +++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/src/testcase/0004_transient_for.cpp b/src/testcase/0004_transient_for.cpp index ed44866..410ee63 100644 --- a/src/testcase/0004_transient_for.cpp +++ b/src/testcase/0004_transient_for.cpp @@ -92,6 +92,59 @@ TEST_F(etTestTransientFor, transient_for_basic) ASSERT_EQ(3, pass_count); } +TEST_F(etTestTransientFor, transient_for_basic2) +{ + etWin *tw = NULL; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l = NULL; + int pass_count = 0; + + // init TC window, show=true, geom=true + initTC(EINA_TRUE, EINA_TRUE); + + // raise tw_parent + etRunner::get().setWinStack(tw_parent, NULL, EINA_TRUE); + ASSERT_EVENT(tw_parent, E_TC_EVENT_TYPE_STACK_RAISE); + + // set transient_for + res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_TRUE); + ASSERT_TRUE(res); + ASSERT_EVENT(tw_child, E_TC_EVENT_TYPE_STACK_ABOVE); + + // Expected stack res: + // [Top] tw_child -> tw_parent -> tw_base [Bottom] + list = etRunner::get().getWinInfoList(); + ASSERT_TRUE(list != NULL); + + EINA_LIST_CAST_FOREACH(list, l, tw, etWin*) + { + if (tw->layer > 200) continue; + + if (pass_count == 0) + { + ASSERT_EQ(tw->native_win, tw_child->native_win); + pass_count++; + continue; + } + else if (pass_count == 1) + { + ASSERT_EQ(tw->native_win, tw_parent->native_win); + pass_count++; + continue; + } + else + { + ASSERT_EQ(tw->native_win, tw_base->native_win); + pass_count++; + } + + break; + } + etRunner::get().freeWinInfoList(list); + + ASSERT_EQ(3, pass_count); +} + TEST_F(etTestTransientFor, transient_for_raise) { etWin *tw = NULL; -- 2.7.4 From a7c227c8b1b92d0eb66abf2b7b9d7e7a0fa0b910 Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Tue, 27 Apr 2021 22:10:29 +0900 Subject: [PATCH 14/16] 0012_aux_hint: added test for aux hint Added test for aux hint. - add_hint2: test for change value using aux_hint_add - revert_hint_using_add: test revert hint using aux_hint_del Change-Id: I6f84cb00f7dded5d49ca023e952489f9f08c4d13 --- src/testcase/0012_aux_hint.cpp | 56 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/src/testcase/0012_aux_hint.cpp b/src/testcase/0012_aux_hint.cpp index b7dfc84..315dbae 100644 --- a/src/testcase/0012_aux_hint.cpp +++ b/src/testcase/0012_aux_hint.cpp @@ -64,6 +64,22 @@ TEST_F(etTestAuxHint, add_hint) ASSERT_HINT(tw, test_hint_id, "win.test.auxhint", "test"); } +TEST_F(etTestAuxHint, add_hint2) +{ + Eina_Bool ret = EINA_FALSE; + + initTC(); + + ret = etRunner::get().addAuxHint(tw, test_hint_id, "win.test.auxhint", "test"); + ASSERT_TRUE(ret); + ASSERT_HINT(tw, test_hint_id, "win.test.auxhint", "test"); + + // change value using add hint + ret = etRunner::get().addAuxHint(tw, test_hint_id, "win.test.auxhint", "test2"); + ASSERT_TRUE(ret); + ASSERT_HINT(tw, test_hint_id, "win.test.auxhint", "test2"); +} + TEST_F(etTestAuxHint, change_hint) { Eina_Bool ret = EINA_FALSE; @@ -94,3 +110,43 @@ TEST_F(etTestAuxHint, del_hint) ASSERT_HINT(tw, test_hint_id, "win.test.auxhint", "test"); } +TEST_F(etTestAuxHint, revert_hint_using_add) +{ + Eina_Bool ret = EINA_FALSE; + + initTC(); + + // add hint with id:486 + ret = etRunner::get().addAuxHint(tw, test_hint_id, "win.test.auxhint", "origin"); + ASSERT_TRUE(ret); + + // verify add aux hint - val:origin + ASSERT_HINT(tw, test_hint_id, "win.test.auxhint", "origin"); + + // verify server's aux hint of "win.test.auxhint" // "origin" + ev_result_hint = etRunner::get().getAuxHint(tw, "win.test.auxhint"); + compareHint(ev_result_hint, test_hint_id, "win.test.auxhint", "origin"); + + // add hint with id:487 + ret = etRunner::get().addAuxHint(tw, test_hint_id + 1, "win.test.auxhint", "temp"); + ASSERT_TRUE(ret); + + // verify add aux hint - val:temp + ASSERT_HINT(tw, test_hint_id + 1, "win.test.auxhint", "temp"); + + // verify server's aux hint of "win.test.auxhint" // "temp" + ev_result_hint = etRunner::get().getAuxHint(tw, "win.test.auxhint"); + compareHint(ev_result_hint, test_hint_id + 1, "win.test.auxhint", "temp"); + + // remove hint id:487 + ret = etRunner::get().delAuxHint(tw, test_hint_id + 1); + ASSERT_TRUE(ret); + + // verify del aux hint - val:temp + ASSERT_HINT(tw, test_hint_id + 1, "win.test.auxhint", "temp"); + + // verify server's aux hint of "win.test.auxhint" // "origin" + ev_result_hint = etRunner::get().getAuxHint(tw, "win.test.auxhint"); + compareHint(ev_result_hint, test_hint_id, "win.test.auxhint", "origin"); +} + -- 2.7.4 From a4b07664b04b80ae94f3ea57b00f9184f0ee36c1 Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Wed, 28 Apr 2021 13:38:05 +0900 Subject: [PATCH 15/16] Packaging: update version to 0.5.9 Change-Id: Ia40a9b08e858004c0745c4b2c3ebc35f31bfa5c0 --- packaging/e-tizen-unittests.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-tizen-unittests.spec b/packaging/e-tizen-unittests.spec index 8893a57..8613cde 100644 --- a/packaging/e-tizen-unittests.spec +++ b/packaging/e-tizen-unittests.spec @@ -1,7 +1,7 @@ %define USE_GCOV 0 Name: e-tizen-unittests -Version: 0.5.8 +Version: 0.5.9 Release: 1 Summary: The test case runner for enlightenment URL: http://www.enlightenment.org -- 2.7.4 From cc823d6dacfddf3547e4245ba08346dceacb21c8 Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Wed, 28 Apr 2021 19:52:58 +0900 Subject: [PATCH 16/16] e_test_base: Add verifyTC function Check the test result with the reference image by using screenshot. If pixel checking failed, make dump image to /tmp/etTestErr/'testmodule'/ directory. Change-Id: I8aef4425595647b26d4075e72bd5d9c732bd7a50 Signed-off-by: Junkyeong Kim --- configure.ac | 4 + packaging/e-tizen-unittests.spec | 4 + src/e_test_base.cpp | 411 +++++++++++++++++++++++++++++++++++++++ src/e_test_base.h | 5 + src/e_test_util.h | 6 + 5 files changed, 430 insertions(+) diff --git a/configure.ac b/configure.ac index d280684..e9db6ce 100644 --- a/configure.ac +++ b/configure.ac @@ -24,6 +24,8 @@ AC_PROG_CXX requirements="\ elementary \ + libtbm \ + libpng \ eldbus \ enlightenment \ capi-ui-efl-util \ @@ -33,6 +35,8 @@ requirements="\ tizen-launch-client \ tzsh-screensaver-manager-service \ tzsh-screensaver-service \ + cairo \ + pixman-1 \ " PKG_CHECK_MODULES(E_TEST_RUNNER, [${requirements}]) diff --git a/packaging/e-tizen-unittests.spec b/packaging/e-tizen-unittests.spec index 8613cde..168a7fe 100644 --- a/packaging/e-tizen-unittests.spec +++ b/packaging/e-tizen-unittests.spec @@ -10,6 +10,8 @@ Source0: %{name}-%{version}.tar.gz Source1001: e-tizen-unittests.manifest License: BSD-2-Clause BuildRequires: pkgconfig(enlightenment) +BuildRequires: pkgconfig(libtbm) +BuildRequires: pkgconfig(libpng) BuildRequires: pkgconfig(eldbus) BuildRequires: pkgconfig(capi-ui-efl-util) BuildRequires: pkgconfig(ecore-wl2) @@ -21,6 +23,8 @@ BuildRequires: pkgconfig(tzsh-screensaver-service) BuildRequires: gtest-devel BuildRequires: pkgconfig(edje) BuildRequires: edje-tools +BuildRequires: pkgconfig(cairo) +BuildRequires: pkgconfig(pixman-1) %description This package is a test case runner for enlightenment. diff --git a/src/e_test_base.cpp b/src/e_test_base.cpp index 3027967..78834d6 100644 --- a/src/e_test_base.cpp +++ b/src/e_test_base.cpp @@ -1,11 +1,47 @@ #include "e_test_base.h" +#include +#include +#include using ::testing::Test; +#ifndef ARRAY_LENGTH +#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0]) +#endif + +#define UT_WAIT(fmt, ...) \ + do { \ + char ch; \ + do { \ + printf(fmt" [n]):next ", ##__VA_ARGS__); \ + ch = tc_getchar(); \ + } while (ch != 'n'); \ + } while (0) + +char +tc_getchar(void) +{ + int c = getchar(); + int ch = c; + + if (ch == '\n' || ch == '\r') + ch = 'y'; + else if (ch < 'a') + ch += ('a' - 'A'); + + while (c != '\n' && c != EOF) + c = getchar(); + + return ch; +} + etTCBase::etTCBase() { etRunner::get().flushEventQueue(); etRunner::get().setTCStart(); + screenshot = efl_util_screenshot_initialize(CAPTURE_WIDTH, CAPTURE_HEIGHT); + if (screenshot == NULL) + ERR("efl_util_screenshot_initialize fail\n"); } etTCBase::~etTCBase() @@ -14,6 +50,12 @@ etTCBase::~etTCBase() numGeomTw = 0; numTw = 0; + if (screenshot) + { + efl_util_screenshot_deinitialize(screenshot); + screenshot = NULL; + } + etRunner::get().setTCEnd(); etRunner::get().flushEventQueue(); @@ -197,3 +239,372 @@ etTCBase::removeTCWin(etWin *tw) return EINA_TRUE; } + +void +_verifyTCGetBufferSize(tbm_surface_h buffer, int *buffer_w, int *buffer_h, int *stride) +{ + tbm_surface_info_s info; + int ret; + + EINA_SAFETY_ON_NULL_RETURN(buffer); + + ret = tbm_surface_get_info(buffer, &info); + if (ret != TBM_SURFACE_ERROR_NONE) + return; + + if (buffer_w) + *buffer_w = info.planes[0].stride >> 2; + + if (buffer_h) + *buffer_h = info.planes[0].size / info.planes[0].stride; + + if (stride) + *stride = info.planes[0].stride; +} + +static void +_verifyTCdumpPng(const char *file, const void *data, int width, int height, int stride) +{ + pixman_image_t *image; + cairo_surface_t *cairo_surface; + cairo_status_t status; + + image = pixman_image_create_bits_no_clear(PIXMAN_x8r8g8b8, width, height, (uint32_t *)data, stride); + if (image == (pixman_image_t *)NULL) + { + ERR("pixman_image_create_bits_no_clear failed"); + return; + } + + cairo_surface = cairo_image_surface_create_for_data((unsigned char *)pixman_image_get_data(image), + CAIRO_FORMAT_RGB24, pixman_image_get_width(image), pixman_image_get_height(image), + pixman_image_get_stride(image)); + if (cairo_surface_status(cairo_surface) != CAIRO_STATUS_SUCCESS) + { + ERR("cairo_image_surface_create_for_data failed"); + pixman_image_unref(image); + return; + } + + status = cairo_surface_write_to_png(cairo_surface, file); + if (status != CAIRO_STATUS_SUCCESS) + { + ERR("Failed to save image '%s': %s\n", file, cairo_status_to_string(status)); + pixman_image_unref(image); + return; + } + + cairo_surface_destroy(cairo_surface); + pixman_image_unref(image); +} + +std::string +_verifyTCMakeDumpPath(std::string basetype, std::string tcname) +{ + std::string path = "/tmp/etTestErr/"; + std::string format = ".png"; + int ret; + + ret = mkdir(path.c_str(), 0755); + if (ret < 0 && errno != EEXIST) + { + ERR("mkdir failed. (%s)\n", path.c_str()); + return "\0"; + } + + path = path + basetype + '/'; + ret = mkdir(path.c_str(), 0755); + if (ret < 0 && errno != EEXIST) + { + ERR("mkdir failed. (%s)\n", path.c_str()); + return "\0"; + } + + path = path + tcname + format; + ERR("path : %s", path.c_str()); + + return path; +} + +void +_verifyTCDumpBuffer(tbm_surface_h buffer, std::string basetype, std::string tcname) +{ + std::string dumppath; + tbm_surface_info_s info; + int ret; + int bo_cnt; + int bw, bh, stride; + + EINA_SAFETY_ON_NULL_RETURN(buffer); + + dumppath = _verifyTCMakeDumpPath(basetype, tcname); + if (dumppath.length() == 0) + { + ERR("getting dumppath failed"); + return; + } + + ret = tbm_surface_map(buffer, TBM_OPTION_READ, &info); + if (ret != TBM_SURFACE_ERROR_NONE) + { + ERR("tbm_surface_map failed"); + return; + } + + _verifyTCGetBufferSize(buffer, &bw, &bh, &stride); + + bo_cnt = tbm_surface_internal_get_num_bos(buffer); + DBG("buffer: bo_cnt(%d) %dx%d(%dx%d) %c%c%c%c, plane: (%p+%d, %d,%d) (%p+%d, %d,%d) (%p+%d, %d,%d)", + bo_cnt, bw, bh, info.width, info.height, FOURCC_STR(info.format), + info.planes[0].ptr, info.planes[0].offset, info.planes[0].stride, info.planes[0].size, + info.planes[1].ptr, info.planes[1].offset, info.planes[1].stride, info.planes[1].size, + info.planes[2].ptr, info.planes[2].offset, info.planes[2].stride, info.planes[2].size); + + if (info.format == TBM_FORMAT_ARGB8888 || info.format == TBM_FORMAT_XRGB8888) + _verifyTCdumpPng(dumppath.c_str(), info.planes[0].ptr, bw, bh, stride); + else + DBG("not supported dump format"); + + tbm_surface_unmap(buffer); +} + +std::string +_verifyTCMakeRefPath(std::string basetype, std::string tcname) +{ + std::string path = "/usr/share/e_tizen_unittests/data/"; + std::string format = ".png"; + + path = path + basetype + '/' + tcname + format; + + return path; +} + +pixman_format_code_t +_verifyTCCairo2Pixman(cairo_format_t fmt) +{ + if (fmt == CAIRO_FORMAT_ARGB32) + return PIXMAN_a8r8g8b8; + else if (fmt == CAIRO_FORMAT_RGB24) + return PIXMAN_x8r8g8b8; + else + return (pixman_format_code_t)0; +} + +static void +destroy_cairo_surface(pixman_image_t *image, void *data) +{ + cairo_surface_t *surface = (cairo_surface_t *)data; + + cairo_surface_destroy(surface); +} + +pixman_image_t * +_verifyTCConvertx8r8g8b8(pixman_image_t *image) +{ + pixman_image_t *ret; + int width; + int height; + + if (pixman_image_get_format(image) == PIXMAN_x8r8g8b8) + return pixman_image_ref(image); + + width = pixman_image_get_width(image); + height = pixman_image_get_height(image); + + ret = pixman_image_create_bits_no_clear(PIXMAN_x8r8g8b8, width, height, NULL, 0); + if (ret == NULL) + { + ERR("pixman_image_create_bits_no_clear failed"); + return NULL; + } + + pixman_image_composite32(PIXMAN_OP_SRC, image, NULL, ret, 0, 0, 0, 0, 0, 0, width, height); + + return ret; +} + +pixman_image_t * +_verifyTCLoadImage(const char *fname) +{ + pixman_image_t *image; + pixman_image_t *converted; + cairo_format_t cairo_fmt; + pixman_format_code_t pixman_fmt; + cairo_surface_t *reference_cairo_surface; + cairo_status_t status; + int width; + int height; + int stride; + void *data; + + reference_cairo_surface = cairo_image_surface_create_from_png(fname); + cairo_surface_flush(reference_cairo_surface); + status = cairo_surface_status(reference_cairo_surface); + if (status != CAIRO_STATUS_SUCCESS) + { + ERR("Could not open %s: %s\n", fname, cairo_status_to_string(status)); + cairo_surface_destroy(reference_cairo_surface); + return NULL; + } + + cairo_fmt = cairo_image_surface_get_format(reference_cairo_surface); + pixman_fmt = _verifyTCCairo2Pixman(cairo_fmt); + ERR("pixman format(PIXMAN_a8r8g8b8:%d,PIXMAN_x8r8g8b8:%d) : %d", PIXMAN_a8r8g8b8, PIXMAN_x8r8g8b8, pixman_fmt); + if (pixman_fmt == (pixman_format_code_t)0) + { + ERR("unknown format"); + cairo_surface_destroy(reference_cairo_surface); + return NULL; + } + + width = cairo_image_surface_get_width(reference_cairo_surface); + height = cairo_image_surface_get_height(reference_cairo_surface); + stride = cairo_image_surface_get_stride(reference_cairo_surface); + data = cairo_image_surface_get_data(reference_cairo_surface); + + image = pixman_image_create_bits_no_clear(pixman_fmt, width, height, (uint32_t *)data, stride); + if (image == (pixman_image_t *)NULL) + { + ERR("pixman_image_create_bits_no_clear failed"); + cairo_surface_destroy(reference_cairo_surface); + return NULL; + } + + pixman_image_set_destroy_function(image, destroy_cairo_surface, reference_cairo_surface); + + converted = _verifyTCConvertx8r8g8b8(image); + pixman_image_unref(image); + + return converted; +} + +Eina_Bool +_verifyTCCheckPixel(uint32_t pix_a, uint32_t pix_b, int w, int h) +{ + int i, shift; + int diffmin = -3; + int diffmax = 4; + + for (shift = 8, i = 1; i < 4; shift += 8, i++) + { + int val_a = (pix_a >> shift) & 0xFF; + int val_b = (pix_b >> shift) & 0xFF; + int diff = val_b - val_a; + + if (diff < diffmin || diff > diffmax) + return EINA_FALSE; + } + + return EINA_TRUE; +} + +Eina_Bool +_verifyTCCheckImage(pixman_image_t *surface, pixman_image_t *ref) +{ + Eina_Bool ret = EINA_TRUE; + int surface_width, surface_height, surface_stride; + uint32_t *surface_data; + int pixman_width; + uint32_t *pixman_data; + int w, h; + + surface_width = pixman_image_get_width(surface); + surface_height = pixman_image_get_height(surface); + surface_stride = pixman_image_get_stride(surface); + surface_data = pixman_image_get_data(surface); + + pixman_width = pixman_image_get_width(ref); + pixman_data = pixman_image_get_data(ref); + + for (h = 0; h < surface_height; h++ ) + { + uint32_t *current_surface_data = surface_data + h * surface_stride; + uint32_t *current_pixman_data = pixman_data + h * pixman_width; + + for (w = 0; w < surface_width; w++) + { + ret = _verifyTCCheckPixel(*current_surface_data, *current_pixman_data, w, h); + if (ret == EINA_FALSE) + return ret; + + current_surface_data++; + current_pixman_data++; + } + } + + return ret; +} + +Eina_Bool +_verifyTC(tbm_surface_h surface, std::string basetype, std::string tcname) +{ + std::string refpath; + pixman_image_t *shot; + pixman_image_t *ref; + Eina_Bool ret = EINA_FALSE; + tbm_surface_info_s info; + int error; + + refpath = _verifyTCMakeRefPath(basetype, tcname); + if (refpath.length() == 0) + { + ERR("getting dumppath failed"); + return EINA_FALSE; + } + + ref = _verifyTCLoadImage(refpath.c_str()); + if (ref == (pixman_image_t *)NULL) + { + ERR("LoadImage failed"); + return EINA_FALSE; + } + + error = tbm_surface_map(surface, TBM_OPTION_READ, &info); + if (error != TBM_SURFACE_ERROR_NONE) + { + ERR("tbm_surface_map failed"); + pixman_image_unref(ref); + return EINA_FALSE; + } + + shot = pixman_image_create_bits_no_clear(PIXMAN_x8r8g8b8, info.width, info.height, (uint32_t *)info.planes[0].ptr, info.planes[0].stride >> 2); + if (shot == (pixman_image_t *)NULL) + { + ERR("pixman_image_create_bits_no_clear failed"); + tbm_surface_unmap(surface); + pixman_image_unref(ref); + return EINA_FALSE; + } + + ret = _verifyTCCheckImage(shot, ref); + + pixman_image_unref(shot); + pixman_image_unref(ref); + + return ret; +} + +Eina_Bool +etTCBase::verifyTC(std::string basetype, std::string tcname) +{ + tbm_surface_h surface = NULL; + Eina_Bool ret = EINA_FALSE; + + surface = efl_util_screenshot_take_tbm_surface(screenshot); + if (surface == NULL) + { + ERR("screenshot failed"); + return EINA_FALSE; + } + + ret = _verifyTC(surface, basetype, tcname); + if (ret == EINA_FALSE) + { + ERR("verify failed"); + _verifyTCDumpBuffer(surface, basetype, tcname); + } + +// UT_WAIT("test"); + + return ret; +} diff --git a/src/e_test_base.h b/src/e_test_base.h index f3e1c37..f9e85d6 100644 --- a/src/e_test_base.h +++ b/src/e_test_base.h @@ -2,6 +2,9 @@ #define __ET_TESTCASE_BASE__ #include "e_test_event.h" +#include +#include +#include using ::testing::Test; @@ -23,6 +26,7 @@ class etTCBase : public ::testing::Test Eina_Bool showTCWin(etWin *tw); Eina_Bool showActivateTCWin(etWin *tw); Eina_Bool removeTCWin(etWin *tw); + Eina_Bool verifyTC(std::string basetype, std::string tcname); protected: std::shared_ptr ev_result; @@ -36,6 +40,7 @@ class etTCBase : public ::testing::Test int numTw = 0; // number of wins int numGeomTw = 0; // number of wins using usr_geom + efl_util_screenshot_h screenshot; etWin *createWindow(Elm_Win_Type type, const char *name, Eina_Bool usr_geom, int x, int y, int w, int h); }; diff --git a/src/e_test_util.h b/src/e_test_util.h index 15167de..740565d 100644 --- a/src/e_test_util.h +++ b/src/e_test_util.h @@ -264,6 +264,12 @@ typedef struct _Window_Info_List } \ } while (0) +#define CAPTURE_WIDTH 720 +#define CAPTURE_HEIGHT 1280 +#define PNG_DEPTH 8 +#define C(b, m) (((b) >> (m)) & 0xFF) +#define FOURCC_STR(id) C(id, 0), C(id, 8), C(id, 16), C(id, 24) + #ifdef __cplusplus } #endif -- 2.7.4