From 3676217cdb4c9bc21cc61be6877a52b120c66611 Mon Sep 17 00:00:00 2001 From: MinJeong Kim Date: Thu, 1 Oct 2015 15:33:59 +0900 Subject: [PATCH 01/16] Added step to process deferred job for windows Change-Id: I6ae86cdcb7b48eb51db814ad8c7e4cb469445a74 Signed-off-by: MinJeong Kim --- src/0100_base_operation.c | 2 ++ src/0200_transient_for.c | 2 ++ src/0300_notification.c | 2 ++ src/e_test_runner.c | 17 +++++++++++++++++ src/e_test_runner.h | 1 + 5 files changed, 24 insertions(+) diff --git a/src/0100_base_operation.c b/src/0100_base_operation.c index 41a62c4..cf2a98e 100644 --- a/src/0100_base_operation.c +++ b/src/0100_base_operation.c @@ -32,6 +32,8 @@ _tc_pre_run(E_TC *tc, Eina_Bool alpha) res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_work(); + return EINA_TRUE; cleanup: diff --git a/src/0200_transient_for.c b/src/0200_transient_for.c index 0a5b205..345d404 100644 --- a/src/0200_transient_for.c +++ b/src/0200_transient_for.c @@ -57,6 +57,8 @@ _tc_pre_run(E_TC *tc) EINA_TRUE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_work(); + return EINA_TRUE; cleanup: diff --git a/src/0300_notification.c b/src/0300_notification.c index fee6316..e1b3a57 100644 --- a/src/0300_notification.c +++ b/src/0300_notification.c @@ -79,6 +79,8 @@ _tc_pre_run(E_TC *tc) res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_CHANGED); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_work(); + return EINA_TRUE; cleanup: diff --git a/src/e_test_runner.c b/src/e_test_runner.c index 7c92f18..71cb10e 100644 --- a/src/e_test_runner.c +++ b/src/e_test_runner.c @@ -1,5 +1,7 @@ #include "e_test_runner.h" +#define E_TEST_RUNNER_WORK_TIME 0.3 + int _log_dom = -1; #if HAVE_WAYLAND @@ -247,6 +249,13 @@ finish: } static Eina_Bool +_cb_work_time_out(void *data EINA_UNUSED) +{ + elm_exit(); + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool _ev_wait_timeout(void *data) { E_Test_Runner *runner = data; @@ -410,6 +419,14 @@ finish: return res; } +void +e_test_runner_work(void) +{ + /* give a turn to deal with deferred job for E_TEST_RUNNER_WORK_TIME */ + ecore_timer_add(E_TEST_RUNNER_WORK_TIME, _cb_work_time_out, NULL); + elm_run(); +} + E_TC_Win * e_tc_win_add(E_TC_Win *parent, Elm_Win_Type type, diff --git a/src/e_test_runner.h b/src/e_test_runner.h index e897c6a..ef0d684 100644 --- a/src/e_test_runner.h +++ b/src/e_test_runner.h @@ -137,6 +137,7 @@ void e_tc_win_geom_update(E_TC_Win *tw); void e_tc_win_show(E_TC_Win *tw); void e_tc_win_hide(E_TC_Win *tw); Eina_Bool e_tc_win_transient_for_set(E_TC_Win *tw_parent, E_TC_Win *tw_child, Eina_Bool set); +void e_test_runner_work(void); /* test cases */ Eina_Bool tc_0000_base_pass(E_TC *tc); -- 2.7.4 From e27e3371e7b678b521fc3a9af51129535ef324e8 Mon Sep 17 00:00:00 2001 From: MinJeong Kim Date: Mon, 12 Oct 2015 17:18:27 +0900 Subject: [PATCH 02/16] Fixed null dereference and dead code Change-Id: I29bbce41ab4b891c6ef5adfa20bbc67c72ee1aea --- src/0000_easy.c | 9 ++++++++- src/e_test_runner.c | 9 ++++++++- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/src/0000_easy.c b/src/0000_easy.c index 1885017..07a2674 100644 --- a/src/0000_easy.c +++ b/src/0000_easy.c @@ -49,6 +49,12 @@ _cb_prop_registrant(void *data, Eina_Bool res; char *type; + if (!tc) + { + elm_exit(); + return; + } + tc->passed = EINA_FALSE; res = eldbus_message_error_get(msg, &name, &text); @@ -59,6 +65,7 @@ _cb_prop_registrant(void *data, EINA_SAFETY_ON_NULL_GOTO(variant, finish); type = eldbus_message_iter_signature_get(variant); + EINA_SAFETY_ON_NULL_GOTO(type, finish); EINA_SAFETY_ON_FALSE_GOTO((type[0] == 'u'), finish); res = eldbus_message_iter_arguments_get(variant, "u", &win); @@ -68,7 +75,7 @@ _cb_prop_registrant(void *data, tc->passed = EINA_TRUE; finish: - if ((tc) && (!tc->passed)) + if (!tc->passed) { ERR("errname:%s errmsg:%s\n", name, text); } diff --git a/src/e_test_runner.c b/src/e_test_runner.c index 71cb10e..1ea4c66 100644 --- a/src/e_test_runner.c +++ b/src/e_test_runner.c @@ -77,8 +77,9 @@ _e_test_runner_window_id_get(Evas_Object *elm_win) if (tizen_resource) tizen_resource_destroy(tizen_resource); return id; -#endif +#else return elm_win_window_id_get(elm_win); +#endif } static void @@ -592,6 +593,12 @@ _e_tc_add(unsigned int num, E_TC *tc; tc = E_NEW(E_TC, 1); + if (!tc) + { + ERR("Can't allocate E_TC %s", name); + return NULL; + } + tc->num = num; tc->name = name; -- 2.7.4 From 9ed0487f08362cf22010df2fe33126956da9ea3e Mon Sep 17 00:00:00 2001 From: Gwanglim Lee Date: Tue, 13 Oct 2015 18:58:38 +0900 Subject: [PATCH 03/16] Packaging: update version to 0.0.6 Change-Id: I743bfecb806b2d4b2f65f91a444861445b4ecd18 --- packaging/e-tizen-testcase.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-tizen-testcase.spec b/packaging/e-tizen-testcase.spec index 4b070be..d3b8df7 100644 --- a/packaging/e-tizen-testcase.spec +++ b/packaging/e-tizen-testcase.spec @@ -2,7 +2,7 @@ %bcond_with x Name: e-tizen-testcase -Version: 0.0.5 +Version: 0.0.6 Release: 1 Summary: The test case runner for enlightenment URL: http://www.enlightenment.org -- 2.7.4 From 5b57a3b2f979c4880005259f8e85aa556ba36182 Mon Sep 17 00:00:00 2001 From: Doyoun Kang Date: Fri, 11 Mar 2016 14:07:38 +0900 Subject: [PATCH 04/16] Apply directory macros Change-Id: Ib61f32c15b30033b565cd204d48e32e8d35078b6 --- packaging/e-tizen-testcase.spec | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/packaging/e-tizen-testcase.spec b/packaging/e-tizen-testcase.spec index d3b8df7..c5ff7ae 100644 --- a/packaging/e-tizen-testcase.spec +++ b/packaging/e-tizen-testcase.spec @@ -17,6 +17,7 @@ BuildRequires: gettext BuildRequires: pkgconfig(tizen-extension-client) %endif +%global TZ_SYS_RO_SHARE %{?TZ_SYS_RO_SHARE:%TZ_SYS_RO_SHARE}%{!?TZ_SYS_RO_SHARE:/usr/share} %description This package is a test case runner for enlightenment. @@ -44,13 +45,13 @@ make %{?_smp_mflags} rm -rf %{buildroot} # for license notification -mkdir -p %{buildroot}/usr/share/license -cp -a %{_builddir}/%{buildsubdir}/COPYING %{buildroot}/usr/share/license/%{name} +mkdir -p %{buildroot}/%{TZ_SYS_RO_SHARE}/license +cp -a %{_builddir}/%{buildsubdir}/COPYING %{buildroot}/%{TZ_SYS_RO_SHARE}/license/%{name} # install make install DESTDIR=%{buildroot} %files %defattr(-,root,root,-) -/usr/share/license/%{name} +%{TZ_SYS_RO_SHARE}/license/%{name} %{_bindir}/e_test_runner -- 2.7.4 From fbf01ba4e362ae6a3645c566e621fc1e55ee862e Mon Sep 17 00:00:00 2001 From: Gwanglim Lee Date: Thu, 17 Mar 2016 17:15:39 +0900 Subject: [PATCH 05/16] Packaging: update version to 0.0.7 Change-Id: Id3b8963dd273aff501a88b25ffc49ad78f64cf6e --- packaging/e-tizen-testcase.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-tizen-testcase.spec b/packaging/e-tizen-testcase.spec index c5ff7ae..7b7fb99 100644 --- a/packaging/e-tizen-testcase.spec +++ b/packaging/e-tizen-testcase.spec @@ -2,7 +2,7 @@ %bcond_with x Name: e-tizen-testcase -Version: 0.0.6 +Version: 0.0.7 Release: 1 Summary: The test case runner for enlightenment URL: http://www.enlightenment.org -- 2.7.4 From d0635695eb3d34da17c629778fd9584f35d17e52 Mon Sep 17 00:00:00 2001 From: Gwanglim Lee Date: Thu, 12 May 2016 15:24:55 +0900 Subject: [PATCH 06/16] removed checking of the window system because wayland is default. Change-Id: I7ab59a6999162d8a1f4e092a8dcccace025e211d --- configure.ac | 32 ++++---------------------------- packaging/e-tizen-testcase.spec | 13 +------------ src/e_test_runner.c | 16 ---------------- src/e_test_runner.h | 11 +++-------- 4 files changed, 8 insertions(+), 64 deletions(-) diff --git a/configure.ac b/configure.ac index 4390dd5..be1c478 100644 --- a/configure.ac +++ b/configure.ac @@ -20,38 +20,14 @@ AC_USE_SYSTEM_EXTENSIONS AM_PROG_CC_STDC AM_PROG_CC_C_O -## X11 -AC_ARG_WITH([x11], - AC_HELP_STRING([--with-x11], [use x11]), - [WITH_X="yes" - AC_SUBST([WITH_X])], [WITH_X="no"]) -if test "x${WITH_X}" = x"yes"; then - AC_DEFINE_UNQUOTED([HAVE_X],[1],[define HAVE_X]) -fi -AM_CONDITIONAL(HAVE_X, [test "${WITH_X}" = x"yes"]) - -## Wayland -AC_ARG_WITH([wayland], - AC_HELP_STRING([--with-wayland], [use wayland]), - [WITH_WAYLAND="yes" - AC_SUBST([WIHT_WAYLAND])], [WITH_WAYLAND="no"]) -if test "x${WITH_WAYLAND}" = x"yes"; then - AC_DEFINE_UNQUOTED([HAVE_WAYLAND],[1],[define HAVE_WAYLAND]) -fi -AM_CONDITIONAL(HAVE_WAYLAND, [test "${WITH_WAYLAND}" = x"yes"]) - requirements="\ elementary \ eldbus \ enlightenment \ - capi-ui-efl-util" - -if test "x$WITH_WAYLAND" = x"yes"; then -requirements="$requirements \ - wayland-client \ - ecore-wayland \ - tizen-extension-client" -fi + capi-ui-efl-util \ + wayland-client \ + ecore-wayland \ + tizen-extension-client" PKG_CHECK_MODULES(E_TEST_RUNNER, [${requirements}]) diff --git a/packaging/e-tizen-testcase.spec b/packaging/e-tizen-testcase.spec index 7b7fb99..50cedd2 100644 --- a/packaging/e-tizen-testcase.spec +++ b/packaging/e-tizen-testcase.spec @@ -1,6 +1,3 @@ -%bcond_with wayland -%bcond_with x - Name: e-tizen-testcase Version: 0.0.7 Release: 1 @@ -13,9 +10,7 @@ BuildRequires: pkgconfig(enlightenment) BuildRequires: pkgconfig(eldbus) BuildRequires: pkgconfig(capi-ui-efl-util) BuildRequires: gettext -%if %{with wayland} BuildRequires: pkgconfig(tizen-extension-client) -%endif %global TZ_SYS_RO_SHARE %{?TZ_SYS_RO_SHARE:%TZ_SYS_RO_SHARE}%{!?TZ_SYS_RO_SHARE:/usr/share} @@ -32,13 +27,7 @@ export CFLAGS+=" -Wall -g -fPIC -rdynamic ${GC_SECTIONS_FLAGS}" export LDFLAGS+=" -Wl,--hash-style=both -Wl,--as-needed -Wl,--rpath=/usr/lib" %autogen -%configure --prefix=/usr \ -%if %{with x} - --with-x11 -%endif -%if %{with wayland} - --with-wayland -%endif +%configure --prefix=/usr make %{?_smp_mflags} %install diff --git a/src/e_test_runner.c b/src/e_test_runner.c index 1ea4c66..537caa8 100644 --- a/src/e_test_runner.c +++ b/src/e_test_runner.c @@ -4,7 +4,6 @@ int _log_dom = -1; -#if HAVE_WAYLAND struct tizen_policy *tizen_policy = NULL; struct tizen_surface *tizen_surface = NULL; @@ -24,12 +23,10 @@ static const struct tizen_resource_listener _tizen_resource_listener = { _e_test_runner_cb_resource_id, }; -#endif static Ecore_Window _e_test_runner_window_id_get(Evas_Object *elm_win) { -#if HAVE_WAYLAND Ecore_Wl_Window *wlwin; struct wl_surface *surf; Ecore_Window id = 0; @@ -77,9 +74,6 @@ _e_test_runner_window_id_get(Evas_Object *elm_win) if (tizen_resource) tizen_resource_destroy(tizen_resource); return id; -#else - return elm_win_window_id_get(elm_win); -#endif } static void @@ -541,7 +535,6 @@ e_tc_win_hide(E_TC_Win *tw) Eina_Bool e_tc_win_transient_for_set(E_TC_Win *tw_child, E_TC_Win *tw_parent, Eina_Bool set) { -#if HAVE_WAYLAND Eina_Inlist *globals; Ecore_Wl_Global *global; struct wl_registry *registry; @@ -573,13 +566,6 @@ e_tc_win_transient_for_set(E_TC_Win *tw_child, E_TC_Win *tw_parent, Eina_Bool se else tizen_policy_unset_transient_for(tizen_policy, tw_child->native_win); -#else - if (set) - ecore_x_icccm_transient_for_set(tw_child->native_win, - tw_parent->native_win); - else - ecore_x_icccm_transient_for_unset(tw_child->native_win); -#endif return EINA_TRUE; } @@ -658,13 +644,11 @@ _e_test_runner_shutdown(E_Test_Runner *runner) E_FREE(tc); } -#if HAVE_WAYLAND if (tizen_surface) tizen_surface_destroy(tizen_surface); if (tizen_policy) tizen_policy_destroy(tizen_policy); tizen_surface = NULL; tizen_policy = NULL; -#endif } static void diff --git a/src/e_test_runner.h b/src/e_test_runner.h index ef0d684..c9b0c49 100644 --- a/src/e_test_runner.h +++ b/src/e_test_runner.h @@ -4,14 +4,9 @@ #include "config.h" #include #include - -#if HAVE_WAYLAND - #include - #include - #include -#else - #include -#endif +#include +#include +#include extern int _log_dom; -- 2.7.4 From 475bfdfb3771beea98d541a7fa7df4ee863deca3 Mon Sep 17 00:00:00 2001 From: Gwanglim Lee Date: Tue, 31 May 2016 19:48:02 +0900 Subject: [PATCH 07/16] Packaging: make all warnings into errors. Change-Id: Ic03a85823745cc5aaaf005151223e7c0bc9e89ce --- packaging/e-tizen-testcase.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-tizen-testcase.spec b/packaging/e-tizen-testcase.spec index 50cedd2..9f27102 100644 --- a/packaging/e-tizen-testcase.spec +++ b/packaging/e-tizen-testcase.spec @@ -23,7 +23,7 @@ This package is a test case runner for enlightenment. %build export GC_SECTIONS_FLAGS="-fdata-sections -ffunction-sections -Wl,--gc-sections" -export CFLAGS+=" -Wall -g -fPIC -rdynamic ${GC_SECTIONS_FLAGS}" +export CFLAGS+=" -Wall -g -fPIC -Werror -rdynamic ${GC_SECTIONS_FLAGS}" export LDFLAGS+=" -Wl,--hash-style=both -Wl,--as-needed -Wl,--rpath=/usr/lib" %autogen -- 2.7.4 From 7b7769b8f6499bceb9710ea6f61c2c6daf05a9ca Mon Sep 17 00:00:00 2001 From: Doyoun Kang Date: Thu, 26 May 2016 20:27:44 +0900 Subject: [PATCH 08/16] Added TCs and Modified some TCs Change-Id: I32fe738b0b958aaa3af33b27d55210760ffd7844 --- packaging/e-tizen-testcase.spec | 1 - src/0100_base_operation.c | 26 +- src/0150_base_operation_multi_wins.c | 1172 ++++++++++++++++++++++++++++++++++ src/0200_transient_for.c | 282 +++++--- src/0300_notification.c | 12 +- src/Makefile.am | 1 + src/e_test_runner.c | 111 +++- src/e_test_runner.h | 30 +- 8 files changed, 1492 insertions(+), 143 deletions(-) create mode 100644 src/0150_base_operation_multi_wins.c diff --git a/packaging/e-tizen-testcase.spec b/packaging/e-tizen-testcase.spec index 9f27102..a40a0aa 100644 --- a/packaging/e-tizen-testcase.spec +++ b/packaging/e-tizen-testcase.spec @@ -21,7 +21,6 @@ This package is a test case runner for enlightenment. %setup -q %build - export GC_SECTIONS_FLAGS="-fdata-sections -ffunction-sections -Wl,--gc-sections" export CFLAGS+=" -Wall -g -fPIC -Werror -rdynamic ${GC_SECTIONS_FLAGS}" export LDFLAGS+=" -Wl,--hash-style=both -Wl,--as-needed -Wl,--rpath=/usr/lib" diff --git a/src/0100_base_operation.c b/src/0100_base_operation.c index cf2a98e..9f3816e 100644 --- a/src/0100_base_operation.c +++ b/src/0100_base_operation.c @@ -6,7 +6,7 @@ struct _E_TC_Data }; static Eina_Bool _tc_pre_run(E_TC *tc, Eina_Bool alpha); -static Eina_Bool _tc_post_run(E_TC *tc); +static void _tc_post_run(E_TC *tc); static void _tc_shutdown(E_TC *tc); static Eina_Bool @@ -19,8 +19,8 @@ _tc_pre_run(E_TC *tc, Eina_Bool alpha) tc->data->tw = e_tc_win_add(NULL, ELM_WIN_BASIC, alpha, "tc", - 0, 0, 320, 320, - 200); + 0, 0, 320, 320, EINA_FALSE, + 200, E_TC_WIN_COLOR_GREEN); EINA_SAFETY_ON_NULL_GOTO(tc->data->tw, cleanup); res = e_test_runner_req_win_register(tc->runner, tc->data->tw); @@ -41,12 +41,10 @@ cleanup: return EINA_FALSE; } -static Eina_Bool +static void _tc_post_run(E_TC *tc) { e_tc_win_hide(tc->data->tw); - - return EINA_TRUE; } static void @@ -70,12 +68,10 @@ tc_0100_win_show(E_TC *tc) res = _tc_pre_run(tc, EINA_FALSE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - res = _tc_post_run(tc); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - tc->passed = EINA_TRUE; cleanup: + _tc_post_run(tc); _tc_shutdown(tc); return tc->passed; @@ -111,12 +107,10 @@ tc_0101_win_stack(E_TC *tc) EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - res = _tc_post_run(tc); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - tc->passed = EINA_TRUE; cleanup: + _tc_post_run(tc); _tc_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); @@ -133,12 +127,10 @@ tc_0110_alpha_win_show(E_TC *tc) res = _tc_pre_run(tc, EINA_TRUE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - res = _tc_post_run(tc); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - tc->passed = EINA_TRUE; cleanup: + _tc_post_run(tc); _tc_shutdown(tc); return tc->passed; @@ -174,12 +166,10 @@ tc_0111_alpha_win_stack(E_TC *tc) EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - res = _tc_post_run(tc); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - tc->passed = EINA_TRUE; cleanup: + _tc_post_run(tc); _tc_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); diff --git a/src/0150_base_operation_multi_wins.c b/src/0150_base_operation_multi_wins.c new file mode 100644 index 0000000..4acdc4c --- /dev/null +++ b/src/0150_base_operation_multi_wins.c @@ -0,0 +1,1172 @@ +#include "e_test_runner.h" + +struct _E_TC_Data +{ + E_TC_Win *tw_red; + E_TC_Win *tw_green; + E_TC_Win *tw_blue; + E_TC_Win *tw_register; +}; + +static Eina_Bool _tc_win_register(E_TC *tc, E_TC_Win *win); +static void _tc_win_unregister(E_TC *tc); +static Eina_Bool _tc_pre_run(E_TC *tc, Eina_Bool alpha); +static void _tc_post_run(E_TC *tc); +static void _tc_shutdown(E_TC *tc); + +static Eina_Bool +_tc_win_register(E_TC *tc, E_TC_Win *win) +{ + Eina_Bool res; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + EINA_SAFETY_ON_NULL_RETURN_VAL(tc->data, EINA_FALSE); + + EINA_SAFETY_ON_NULL_RETURN_VAL(win, EINA_FALSE); + + tc->data->tw_register = win; + + res = e_test_runner_req_win_register(tc->runner, tc->data->tw_register); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE); + + return EINA_TRUE; +} + +static void +_tc_win_unregister(E_TC *tc) +{ + EINA_SAFETY_ON_NULL_RETURN(tc); + EINA_SAFETY_ON_NULL_RETURN(tc->data); + EINA_SAFETY_ON_NULL_RETURN(tc->data->tw_register); + + e_test_runner_req_win_deregister(tc->runner, tc->data->tw_register); + tc->data->tw_register = NULL; +} + + +static Eina_Bool +_tc_pre_run(E_TC *tc, Eina_Bool show_win) +{ + Eina_Bool res; + + tc->data = E_NEW(E_TC_Data, 1); + EINA_SAFETY_ON_NULL_RETURN_VAL(tc->data, EINA_FALSE); + + tc->data->tw_red = e_tc_win_add(NULL, ELM_WIN_BASIC, + EINA_FALSE, "red", + 0, 0, 400, 400, EINA_TRUE, + 200, E_TC_WIN_COLOR_RED); + EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_red, cleanup); + + if (show_win) + { + e_tc_win_geom_update(tc->data->tw_red); + e_tc_win_show(tc->data->tw_red); + } + + tc->data->tw_green = e_tc_win_add(NULL, ELM_WIN_BASIC, + EINA_FALSE, "green", + 150, 150, 320, 320, EINA_TRUE, + 200, E_TC_WIN_COLOR_GREEN); + EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_green, cleanup); + + if (show_win) + { + e_tc_win_geom_update(tc->data->tw_green); + e_tc_win_show(tc->data->tw_green); + } + + tc->data->tw_blue = e_tc_win_add(NULL, ELM_WIN_BASIC, + EINA_FALSE, "blue", + 20, 350, 500, 500, EINA_TRUE, + 200, E_TC_WIN_COLOR_BLUE); + EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_blue, cleanup); + + if (show_win) + { + _tc_win_register(tc, tc->data->tw_blue); + + e_tc_win_geom_update(tc->data->tw_blue); + e_tc_win_show(tc->data->tw_blue); + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + } + + e_test_runner_work(); + + return EINA_TRUE; + +cleanup: + _tc_shutdown(tc); + return EINA_FALSE; +} + +static void +_tc_post_run(E_TC *tc) +{ + EINA_SAFETY_ON_NULL_RETURN(tc->data); + + e_tc_win_hide(tc->data->tw_red); + e_tc_win_hide(tc->data->tw_green); + e_tc_win_hide(tc->data->tw_blue); +} + +static void +_tc_shutdown(E_TC *tc) +{ + EINA_SAFETY_ON_NULL_RETURN(tc->data); + + _tc_win_unregister(tc); + e_tc_win_del(tc->data->tw_red); + e_tc_win_del(tc->data->tw_green); + e_tc_win_del(tc->data->tw_blue); + + E_FREE(tc->data); +} + +Eina_Bool +tc_0150_multi_all_wins_basic(E_TC *tc) +{ + E_TC_Win *tw; + E_TC_Win *tw_red, *tw_green, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_TRUE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_green = tc->data->tw_green; + tw_blue = tc->data->tw_blue; + + // Expected stack result: + // [Top] Blue -> Green -> Red [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_blue->native_win), cleanup); + pass_count++; + continue; + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_green->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + } + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + +Eina_Bool +tc_0151_multi_all_wins_show1(E_TC *tc) +{ + E_TC_Win *tw; + E_TC_Win *tw_red, *tw_green, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_FALSE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_green = tc->data->tw_green; + tw_blue = tc->data->tw_blue; + + // show red + e_tc_win_geom_update(tc->data->tw_red); + e_tc_win_show(tc->data->tw_red); + + // show green + e_tc_win_geom_update(tc->data->tw_green); + e_tc_win_show(tc->data->tw_green); + + // register blue + res = _tc_win_register(tc, tc->data->tw_blue); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // show blue + e_tc_win_geom_update(tc->data->tw_blue); + e_tc_win_show(tc->data->tw_blue); + + // wait for showing register_win + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Blue -> Green -> Red [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_blue->native_win), cleanup); + pass_count++; + continue; + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_green->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + } + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + +Eina_Bool +tc_0152_multi_all_wins_show2(E_TC *tc) +{ + E_TC_Win *tw; + E_TC_Win *tw_red, *tw_green, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_FALSE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_green = tc->data->tw_green; + tw_blue = tc->data->tw_blue; + + // show blue + e_tc_win_geom_update(tc->data->tw_blue); + e_tc_win_show(tc->data->tw_blue); + + // show red + e_tc_win_geom_update(tc->data->tw_red); + e_tc_win_show(tc->data->tw_red); + + // register green + res = _tc_win_register(tc, tc->data->tw_green); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // show green + e_tc_win_geom_update(tc->data->tw_green); + e_tc_win_show(tc->data->tw_green); + + // wait for showing register_win + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Green -> Red -> Blue [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_green->native_win), cleanup); + pass_count++; + continue; + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_blue->native_win), cleanup); + pass_count++; + } + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + + +Eina_Bool +tc_0153_multi_all_wins_show3(E_TC *tc) +{ + E_TC_Win *tw; + E_TC_Win *tw_red, *tw_green, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_FALSE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_green = tc->data->tw_green; + tw_blue = tc->data->tw_blue; + + // show green + e_tc_win_geom_update(tc->data->tw_green); + e_tc_win_show(tc->data->tw_green); + + // show blue + e_tc_win_geom_update(tc->data->tw_blue); + e_tc_win_show(tc->data->tw_blue); + + // register red + res = _tc_win_register(tc, tc->data->tw_red); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // show red + e_tc_win_geom_update(tc->data->tw_red); + e_tc_win_show(tc->data->tw_red); + + // wait for showing register_win + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Red -> Blue -> Green [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + continue; + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_blue->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_green->native_win), cleanup); + pass_count++; + } + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + +Eina_Bool +tc_0154_multi_all_wins_raise1(E_TC *tc) +{ + E_TC_Win *tw; + E_TC_Win *tw_red, *tw_green, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_TRUE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_green = tc->data->tw_green; + tw_blue = tc->data->tw_blue; + + // Expected stack result: + // [Top] Blue -> Green -> Red [Bottom] + + // Raise Red + e_test_runner_req_win_stack_set(tc->runner, tw_red, NULL, EINA_TRUE); + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Red -> Blue -> Green [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + continue; + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_blue->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_green->native_win), cleanup); + pass_count++; + } + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + +Eina_Bool +tc_0155_multi_all_wins_raise2(E_TC *tc) +{ + E_TC_Win *tw; + E_TC_Win *tw_red, *tw_green, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_TRUE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_green = tc->data->tw_green; + tw_blue = tc->data->tw_blue; + + // Expected stack result: + // [Top] Blue -> Green -> Red [Bottom] + + // Raise Green + e_test_runner_req_win_stack_set(tc->runner, tw_green, NULL, EINA_TRUE); + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Green -> Blue -> Red [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_green->native_win), cleanup); + pass_count++; + continue; + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_blue->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + } + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + +Eina_Bool +tc_0156_multi_all_wins_stack_above1(E_TC *tc) +{ + E_TC_Win *tw; + E_TC_Win *tw_red, *tw_green, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_TRUE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_green = tc->data->tw_green; + tw_blue = tc->data->tw_blue; + + // Expected stack result: + // [Top] Blue -> Green -> Red [Bottom] + + // Raise Red on the Green + e_test_runner_req_win_stack_set(tc->runner, tw_red, tw_green, EINA_TRUE); + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Blue -> Red -> Green [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_blue->native_win), cleanup); + pass_count++; + continue; + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_green->native_win), cleanup); + pass_count++; + } + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + + +Eina_Bool +tc_0157_multi_all_wins_stack_above2(E_TC *tc) +{ + E_TC_Win *tw; + E_TC_Win *tw_red, *tw_green, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_TRUE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_green = tc->data->tw_green; + tw_blue = tc->data->tw_blue; + + // Expected stack result: + // [Top] Blue -> Green -> Red [Bottom] + + // Raise Blue on the Red + e_test_runner_req_win_stack_set(tc->runner, tw_blue, tw_red, EINA_TRUE); + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Green -> Blue -> Red [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_green->native_win), cleanup); + pass_count++; + continue; + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_blue->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + } + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + +Eina_Bool +tc_0158_multi_all_wins_stack_above3(E_TC *tc) +{ + E_TC_Win *tw; + E_TC_Win *tw_red, *tw_green, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_TRUE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_green = tc->data->tw_green; + tw_blue = tc->data->tw_blue; + + // Expected stack result: + // [Top] Blue -> Green -> Red [Bottom] + + // Raise Red on the Blue + e_test_runner_req_win_stack_set(tc->runner, tw_red, tw_blue, EINA_TRUE); + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Red -> Blue -> Green [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + continue; + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_blue->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_green->native_win), cleanup); + pass_count++; + } + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + +Eina_Bool +tc_0159_multi_all_wins_lower1(E_TC *tc) +{ + E_TC_Win *tw, *tw_above = NULL; + E_TC_Win *tw_red, *tw_green, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_TRUE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_green = tc->data->tw_green; + tw_blue = tc->data->tw_blue; + + // Expected stack result: + // [Top] Blue -> Green -> Red [Bottom] + + // Lower Blue + e_test_runner_req_win_stack_set(tc->runner, tw_blue, NULL, EINA_FALSE); + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Green -> Red -> ... -> Blue [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_green->native_win), cleanup); + pass_count++; + tw_above = tw; + continue; + + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + tw_above = tw; + continue; + } + else + { + if (tw->layer < 200) + { + EINA_SAFETY_ON_FALSE_GOTO((tw_above->native_win == tw_blue->native_win), cleanup); + pass_count++; + } + else + { + tw_above = tw; + continue; + } + } + + break; + } + // check the tw_above when there is no window under 200 layer. + if (tw == NULL) + { + EINA_SAFETY_ON_NULL_GOTO(tw_above, cleanup); + EINA_SAFETY_ON_FALSE_GOTO((tw_above->native_win == tw_blue->native_win), cleanup); + pass_count++; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + + +Eina_Bool +tc_0160_multi_all_wins_lower2(E_TC *tc) +{ + E_TC_Win *tw, *tw_above = NULL; + E_TC_Win *tw_red, *tw_green, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_TRUE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_green = tc->data->tw_green; + tw_blue = tc->data->tw_blue; + + // Expected stack result: + // [Top] Blue -> Green -> Red [Bottom] + + // Lower Green + e_test_runner_req_win_stack_set(tc->runner, tw_green, NULL, EINA_FALSE); + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Blue -> Red -> ... -> Green [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_blue->native_win), cleanup); + pass_count++; + tw_above = tw; + continue; + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + tw_above = tw; + continue; + } + else + { + if (tw->layer < 200) + { + EINA_SAFETY_ON_FALSE_GOTO((tw_above->native_win == tw_green->native_win), cleanup); + pass_count++; + } + else + { + tw_above = tw; + continue; + } + } + + break; + } + // check the tw_above when there is no window under 200 layer. + if (tw == NULL) + { + EINA_SAFETY_ON_NULL_GOTO(tw_above, cleanup); + EINA_SAFETY_ON_FALSE_GOTO((tw_above->native_win == tw_green->native_win), cleanup); + pass_count++; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + + +Eina_Bool +tc_0180_multi_2wins_show1(E_TC *tc) +{ + E_TC_Win *tw; + E_TC_Win *tw_red, *tw_green; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_FALSE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_green = tc->data->tw_green; + + // show green + e_tc_win_geom_update(tc->data->tw_green); + e_tc_win_show(tc->data->tw_green); + + // register red + res = _tc_win_register(tc, tc->data->tw_red); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // show red + e_tc_win_geom_update(tc->data->tw_red); + e_tc_win_show(tc->data->tw_red); + + // wait for showing register_win + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Red -> Green [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_green->native_win), cleanup); + pass_count++; + } + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 2), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + + +Eina_Bool +tc_0181_multi_2wins_show2(E_TC *tc) +{ + E_TC_Win *tw; + E_TC_Win *tw_green, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_FALSE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_green = tc->data->tw_green; + tw_blue = tc->data->tw_blue; + + // show blue + e_tc_win_geom_update(tc->data->tw_blue); + e_tc_win_show(tc->data->tw_blue); + + // register green + res = _tc_win_register(tc, tc->data->tw_green); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // show green + e_tc_win_geom_update(tc->data->tw_green); + e_tc_win_show(tc->data->tw_green); + + // wait for showing register_win + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Green -> Blue [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_green->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_blue->native_win), cleanup); + pass_count++; + } + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 2), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + + +Eina_Bool +tc_0182_multi_2wins_show3(E_TC *tc) +{ + E_TC_Win *tw; + E_TC_Win *tw_red, *tw_blue; + Eina_Bool res = EINA_FALSE; + Eina_List *list = NULL, *l; + int pass_count; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_FALSE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw_red = tc->data->tw_red; + tw_blue = tc->data->tw_blue; + + // show red + e_tc_win_geom_update(tc->data->tw_red); + e_tc_win_show(tc->data->tw_red); + + // register blue + res = _tc_win_register(tc, tc->data->tw_blue); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // show blue + e_tc_win_geom_update(tc->data->tw_blue); + e_tc_win_show(tc->data->tw_blue); + + // wait for showing register_win + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] Blue -> Red [Bottom] + + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + pass_count = 0; + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_blue->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_red->native_win), cleanup); + pass_count++; + } + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 2), cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_post_run(tc); + _tc_shutdown(tc); + E_FREE_LIST(list, e_tc_win_del); + + return tc->passed; +} + diff --git a/src/0200_transient_for.c b/src/0200_transient_for.c index 345d404..b5fa13b 100644 --- a/src/0200_transient_for.c +++ b/src/0200_transient_for.c @@ -8,7 +8,7 @@ struct _E_TC_Data }; static Eina_Bool _tc_pre_run(E_TC *tc); -static Eina_Bool _tc_post_run(E_TC *tc); +static void _tc_post_run(E_TC *tc); static void _tc_shutdown(E_TC *tc); static Eina_Bool @@ -21,20 +21,20 @@ _tc_pre_run(E_TC *tc) tc->data->tw_parent = e_tc_win_add(NULL, ELM_WIN_BASIC, EINA_FALSE, "parent", - 0, 0, 400, 400, - 200); + 0, 0, 400, 400, EINA_FALSE, + 200, E_TC_WIN_COLOR_BLUE); EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_parent, cleanup); tc->data->tw_child = e_tc_win_add(tc->data->tw_parent, ELM_WIN_BASIC, EINA_FALSE, "child", - 0, 0, 320, 320, - 200); + 0, 0, 320, 320, EINA_FALSE, + 200, E_TC_WIN_COLOR_RED); EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_child, cleanup); tc->data->tw = e_tc_win_add(NULL, ELM_WIN_BASIC, EINA_FALSE, "tc", - 0, 0, 200, 200, - 200); + 200, 200, 500, 500, EINA_FALSE, + 200, E_TC_WIN_COLOR_GREEN); EINA_SAFETY_ON_NULL_GOTO(tc->data->tw, cleanup); res = e_test_runner_req_win_register(tc->runner, tc->data->tw); @@ -49,7 +49,7 @@ _tc_pre_run(E_TC *tc) e_tc_win_geom_update(tc->data->tw_child); e_tc_win_show(tc->data->tw_child); - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_CHANGED); + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); res = e_tc_win_transient_for_set(tc->data->tw_child, @@ -66,14 +66,14 @@ cleanup: return EINA_FALSE; } -static Eina_Bool +static void _tc_post_run(E_TC *tc) { + EINA_SAFETY_ON_NULL_RETURN(tc->data); + e_tc_win_hide(tc->data->tw_child); e_tc_win_hide(tc->data->tw); e_tc_win_hide(tc->data->tw_parent); - - return EINA_TRUE; } static void @@ -82,9 +82,9 @@ _tc_shutdown(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN(tc->data); e_test_runner_req_win_deregister(tc->runner, tc->data->tw); + e_tc_win_del(tc->data->tw_child); e_tc_win_del(tc->data->tw_parent); e_tc_win_del(tc->data->tw); - e_tc_win_del(tc->data->tw_child); E_FREE(tc->data); } @@ -92,47 +92,55 @@ _tc_shutdown(E_TC *tc) Eina_Bool tc_0200_transient_for_basic(E_TC *tc) { - E_TC_Win *tw, *tw2, *tw_parent, *tw_child; - E_TC_Win *tw_above = NULL; + E_TC_Win *tw, *tw_main, *tw_parent, *tw_child; Eina_Bool res = EINA_FALSE; Eina_List *list = NULL, *l; + int pass_count = 0; EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); res = _tc_pre_run(tc); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - list = e_test_runner_req_win_info_list_get(tc->runner); - EINA_SAFETY_ON_NULL_GOTO(list, cleanup); - - tw = tc->data->tw; + tw_main = tc->data->tw; tw_parent = tc->data->tw_parent; tw_child = tc->data->tw_child; - EINA_LIST_FOREACH(list, l, tw2) - { - if (tw2->layer > tw->layer) continue; - if (tw2->layer < tw->layer) break; + // Expected stack result: + // [Top] tw_main -> tw_child -> tw_parent [Bottom] - if (tw2->native_win == tw_parent->native_win) + list = e_test_runner_req_win_info_list_get(tc->runner); + EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + + EINA_LIST_FOREACH(list, l, tw) + { + if (tw->layer > 200) continue; + if (pass_count == 0) { - if ((tw_above) && - (tw_above->native_win == tw_child->native_win)) - res = EINA_TRUE; - break; + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_main->native_win), cleanup); + pass_count++; + continue; } - - tw_above = tw2; + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_child->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_parent->native_win), cleanup); + pass_count++; + } + break; } - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - - res = _tc_post_run(tc); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); tc->passed = EINA_TRUE; cleanup: + _tc_post_run(tc); _tc_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); @@ -142,20 +150,28 @@ cleanup: Eina_Bool tc_0201_transient_for_raise(E_TC *tc) { - E_TC_Win *tw_parent, *tw_child, *tw; + E_TC_Win *tw, *tw_main, *tw_parent, *tw_child; Eina_Bool res = EINA_FALSE; Eina_List *list = NULL, *l; + int pass_count = 0; EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); res = _tc_pre_run(tc); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + tw_main = tc->data->tw; tw_parent = tc->data->tw_parent; tw_child = tc->data->tw_child; + // Expected stack result: + // [Top] tw_main -> tw_child -> tw_parent [Bottom] + e_test_runner_req_win_stack_set(tc->runner, tw_parent, NULL, EINA_TRUE); + // Expected stack result: + // [Top] tw_child -> tw_parent -> tw_main [Bottom] + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); @@ -164,20 +180,33 @@ tc_0201_transient_for_raise(E_TC *tc) EINA_LIST_FOREACH(list, l, tw) { - if (tw->layer > tw_parent->layer) continue; - + if (tw->layer > 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_child->native_win), cleanup); + pass_count++; + continue; + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_parent->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_main->native_win), cleanup); + pass_count++; + } break; } - EINA_SAFETY_ON_NULL_GOTO(tw, cleanup); - EINA_SAFETY_ON_FALSE_GOTO(tw->native_win == tw_child->native_win, cleanup); - - res = _tc_post_run(tc); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); tc->passed = EINA_TRUE; cleanup: + _tc_post_run(tc); _tc_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); @@ -187,43 +216,84 @@ cleanup: Eina_Bool tc_0202_transient_for_lower(E_TC *tc) { - E_TC_Win *tw_parent, *tw_child, *tw; + E_TC_Win *tw, *tw_main, *tw_parent, *tw_child; + E_TC_Win *tw_below = NULL; Eina_Bool res = EINA_FALSE; Eina_List *list = NULL, *l; + int pass_count = 0; EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); res = _tc_pre_run(tc); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + tw_main = tc->data->tw; tw_parent = tc->data->tw_parent; tw_child = tc->data->tw_child; + // Expected stack result: + // [Top] tw_main -> tw_child -> tw_parent [Bottom] + + // lower tw_parent e_test_runner_req_win_stack_set(tc->runner, tw_parent, NULL, EINA_FALSE); res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_LOWER); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + // Expected stack result: + // [Top] tw_main -> ... -> tw_child -> tw_parent [Bottom] + list = e_test_runner_req_win_info_list_get(tc->runner); EINA_SAFETY_ON_NULL_GOTO(list, cleanup); + // bottom to top search EINA_LIST_REVERSE_FOREACH(list, l, tw) { - if (tw->layer < tw_parent->layer) continue; - if (tw->native_win == tw_parent->native_win) continue; - + if (tw->layer < 200) continue; + if (pass_count == 0) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_parent->native_win), cleanup); + tw_below = tw; + pass_count++; + continue; + } + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_child->native_win), cleanup); + tw_below = tw; + pass_count++; + continue; + } + else + { + if (tw->layer > 200) + { + EINA_SAFETY_ON_FALSE_GOTO((tw_below->native_win == tw_main->native_win), cleanup); + pass_count++; + } + else + { + tw_below = tw; + continue; + } + } break; } + // check the tw_below if there is no window over 200 layer. + if (tw == NULL) + { + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 2), cleanup); + EINA_SAFETY_ON_NULL_GOTO(tw_below, cleanup); + EINA_SAFETY_ON_FALSE_GOTO((tw_below->native_win == tw_main->native_win), cleanup); + pass_count++; + } - EINA_SAFETY_ON_NULL_GOTO(tw, cleanup); - EINA_SAFETY_ON_FALSE_GOTO(tw->native_win == tw_child->native_win, cleanup); - - res = _tc_post_run(tc); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); tc->passed = EINA_TRUE; cleanup: + _tc_post_run(tc); _tc_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); @@ -233,52 +303,63 @@ cleanup: Eina_Bool tc_0203_transient_for_stack_above(E_TC *tc) { - E_TC_Win *tw, *tw2, *tw_parent, *tw_child; - E_TC_Win *tw_above = NULL; + E_TC_Win *tw, *tw_main, *tw_parent, *tw_child; Eina_Bool res = EINA_FALSE; Eina_List *list = NULL, *l; + int pass_count = 0; EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); res = _tc_pre_run(tc); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - tw = tc->data->tw; + tw_main = tc->data->tw; tw_parent = tc->data->tw_parent; tw_child = tc->data->tw_child; - e_test_runner_req_win_stack_set(tc->runner, tw_parent, tw, EINA_TRUE); + // Expected stack result: + // [Top] tw_main -> tw_child -> tw_parent [Bottom] + + e_test_runner_req_win_stack_set(tc->runner, tw_parent, tw_main, EINA_TRUE); res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_ABOVE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + // Expected stack result: + // [Top] tw_child -> tw_parent -> tw_main [Bottom] + list = e_test_runner_req_win_info_list_get(tc->runner); EINA_SAFETY_ON_NULL_GOTO(list, cleanup); - EINA_LIST_FOREACH(list, l, tw2) + EINA_LIST_FOREACH(list, l, tw) { - if (tw2->layer > tw->layer) continue; - if (tw2->layer < tw->layer) break; - if (tw2->native_win == tw_parent->native_win) continue; - if (tw2->native_win == tw->native_win) + if (tw->layer > 200) continue; + if (pass_count == 0) { - if ((tw_above) && - (tw_above->native_win == tw_child->native_win)) - res = EINA_TRUE; - break; + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_child->native_win), cleanup); + pass_count++; + continue; } - - tw_above = tw2; + else if (pass_count == 1) + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_parent->native_win), cleanup); + pass_count++; + continue; + } + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_main->native_win), cleanup); + pass_count++; + } + break; } - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - - res = _tc_post_run(tc); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); tc->passed = EINA_TRUE; cleanup: + _tc_post_run(tc); _tc_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); @@ -288,60 +369,73 @@ cleanup: Eina_Bool tc_0204_transient_for_stack_below(E_TC *tc) { - E_TC_Win *tw, *tw2, *tw_parent, *tw_child; - E_TC_Win *tw_above = NULL; + E_TC_Win *tw, *tw_main, *tw_parent, *tw_child; Eina_Bool res = EINA_FALSE; Eina_List *list = NULL, *l; + int pass_count = 0; EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); res = _tc_pre_run(tc); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - tw = tc->data->tw; + tw_main = tc->data->tw; tw_parent = tc->data->tw_parent; tw_child = tc->data->tw_child; - e_test_runner_req_win_stack_set(tc->runner, tw_parent, tw, EINA_FALSE); + // Expected stack result: + // [Top] tw_main -> tw_child -> tw_parent [Bottom] + + // lower tw_main + e_test_runner_req_win_stack_set(tc->runner, tw_main, NULL, EINA_FALSE); + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_BELOW); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Expected stack result: + // [Top] tw_child -> tw_parent -> ... -> tw_main [Bottom] + + e_test_runner_req_win_stack_set(tc->runner, tw_parent, tw_main, EINA_FALSE); res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_BELOW); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + // Expected stack result: + // [Top] ... -> tw_main -> tw_child -> tw_parent [Bottom] + list = e_test_runner_req_win_info_list_get(tc->runner); EINA_SAFETY_ON_NULL_GOTO(list, cleanup); - EINA_LIST_FOREACH(list, l, tw2) + // bottom to top search + EINA_LIST_REVERSE_FOREACH(list, l, tw) { - if (tw2->layer > tw->layer) continue; - if (tw2->layer < tw->layer) break; - - if (tw2->native_win == tw_parent->native_win) + if (tw->layer < 200) continue; + if (pass_count == 0) { - if ((tw_above) && - (tw_above->native_win == tw_child->native_win)) - res = EINA_TRUE; - break; + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_parent->native_win), cleanup); + pass_count++; + continue; } - else if (tw2->native_win == tw_child->native_win) + else if (pass_count == 1) { - if ((!tw_above) || - (tw_above->native_win != tw->native_win)) - { - res = EINA_FALSE; - break; - } + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_child->native_win), cleanup); + pass_count++; + continue; } - - tw_above = tw2; + else + { + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_main->native_win), cleanup); + pass_count++; + } + break; } - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - res = _tc_post_run(tc); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + EINA_SAFETY_ON_FALSE_GOTO((pass_count == 3), cleanup); tc->passed = EINA_TRUE; cleanup: + _tc_post_run(tc); _tc_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); diff --git a/src/0300_notification.c b/src/0300_notification.c index e1b3a57..027e628 100644 --- a/src/0300_notification.c +++ b/src/0300_notification.c @@ -49,20 +49,20 @@ _tc_pre_run(E_TC *tc) data->tw_normal = e_tc_win_add(NULL, ELM_WIN_BASIC, EINA_FALSE, "tw_normal", - 0, 0, TW_W, TW_H, - 200); + 0, 0, TW_W, TW_H, EINA_TRUE, + 200, E_TC_WIN_COLOR_RED); EINA_SAFETY_ON_NULL_GOTO(data->tw_normal, cleanup); data->tw_noti1 = e_tc_win_add(NULL, ELM_WIN_NOTIFICATION, EINA_FALSE, "tw_noti1", - 0, 0, TW_W, TW_H, - 200); + 0, 0, TW_W, TW_H, EINA_TRUE, + 200, E_TC_WIN_COLOR_GREEN); EINA_SAFETY_ON_NULL_GOTO(data->tw_noti1, cleanup); data->tw_noti2 = e_tc_win_add(NULL, ELM_WIN_NOTIFICATION, EINA_FALSE, "tw_noti2", - 0, 0, TW_W, TW_H, - 200); + 0, 0, TW_W, TW_H, EINA_TRUE, + 200, E_TC_WIN_COLOR_BLUE); EINA_SAFETY_ON_NULL_GOTO(data->tw_noti2, cleanup); res = e_test_runner_req_win_register(tc->runner, data->tw_normal); diff --git a/src/Makefile.am b/src/Makefile.am index 6fba867..41c8885 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -12,6 +12,7 @@ e_test_runner.c \ e_test_runner.h \ 0000_easy.c \ 0100_base_operation.c \ +0150_base_operation_multi_wins.c \ 0200_transient_for.c \ 0300_notification.c diff --git a/src/e_test_runner.c b/src/e_test_runner.c index 537caa8..bce4fc3 100644 --- a/src/e_test_runner.c +++ b/src/e_test_runner.c @@ -429,11 +429,14 @@ e_tc_win_add(E_TC_Win *parent, const char *name, int x, int y, int w, int h, - int layer) + Eina_Bool usr_geom, + int layer, + E_TC_Win_Color color) { E_TC_Win *tw = NULL; Evas_Object *elm_win = NULL, *bg = NULL; Evas_Object *p_elm_win = NULL; + int sw, sh; if (parent) p_elm_win = parent->elm_win; @@ -444,23 +447,67 @@ e_tc_win_add(E_TC_Win *parent, elm_win_title_set(elm_win, name); elm_win_autodel_set(elm_win, EINA_FALSE); + elm_win_borderless_set(elm_win, EINA_TRUE); + if (usr_geom) + elm_win_aux_hint_add(elm_win, "wm.policy.win.user.geometry", "1"); bg = elm_bg_add(elm_win); evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); elm_win_resize_object_add(elm_win, bg); - elm_bg_color_set(bg, 0, 120, 100); + switch (color) + { + case E_TC_WIN_COLOR_BLACK: + elm_bg_color_set(bg, 0, 0, 0); + break; + case E_TC_WIN_COLOR_WHITE: + elm_bg_color_set(bg, 255, 255, 255); + break; + case E_TC_WIN_COLOR_RED: + elm_bg_color_set(bg, 255, 0, 0); + break; + case E_TC_WIN_COLOR_GREEN: + elm_bg_color_set(bg, 0, 255, 0); + break; + case E_TC_WIN_COLOR_BLUE: + elm_bg_color_set(bg, 0, 0, 255); + break; + case E_TC_WIN_COLOR_YELLOW: + elm_bg_color_set(bg, 255, 255, 0); + break; + case E_TC_WIN_COLOR_CYAN: + elm_bg_color_set(bg, 0, 255, 255); + break; + case E_TC_WIN_COLOR_PURPLE: + elm_bg_color_set(bg, 255, 0, 255); + break; + default: + elm_bg_color_set(bg, 255, 0, 0); + break; + } evas_object_show(bg); + elm_win_screen_size_get(elm_win, NULL, NULL, &sw, &sh); + tw = E_NEW(E_TC_Win, 1); EINA_SAFETY_ON_NULL_RETURN_VAL(tw, NULL); tw->elm_win = elm_win; tw->native_win = _e_test_runner_window_id_get(elm_win); tw->name = eina_stringshare_add(name); - tw->x = x; - tw->y = y; - tw->w = w; - tw->h = h; + if (usr_geom) + { + tw->x = x; + tw->y = y; + tw->w = w; + tw->h = h; + } + else + { + tw->x = 0; + tw->y = 0; + tw->w = sw; + tw->h = sh; + } tw->layer = layer; tw->alpha = alpha; @@ -606,30 +653,48 @@ _e_test_runner_init(E_Test_Runner *runner) #undef T_FUNC #define T_FUNC(num_, test_) tc_000##num_##_##test_ /* [0000 - 0099] test runner verification */ - TC_ADD( 0, "Base: Pass", T_FUNC( 0, base_pass ), 1); - TC_ADD( 1, "Base: Fail", T_FUNC( 1, base_fail ), 0); + TC_ADD( 0, "Base: Pass", T_FUNC( 0, base_pass ), 1); + TC_ADD( 1, "Base: Fail", T_FUNC( 1, base_fail ), 0); #undef T_FUNC #define T_FUNC(num_, test_) tc_00##num_##_##test_ - TC_ADD( 10, "DBus: Introspect", T_FUNC( 10, introspect ), 1); - TC_ADD( 11, "DBus: Window register", T_FUNC( 11, win_register ), 1); + TC_ADD( 10, "DBus: Introspect", T_FUNC( 10, introspect ), 1); + TC_ADD( 11, "DBus: Window register", T_FUNC( 11, win_register ), 1); #undef T_FUNC #define T_FUNC(num_, test_) tc_0##num_##_##test_ /* [0100 - 0199] window base operation */ - TC_ADD( 100, "Basic window: Show", T_FUNC( 100, win_show ), 1); - TC_ADD( 101, "Basic window: Stack", T_FUNC( 101, win_stack ), 1); - TC_ADD( 110, "Alpha window: Show", T_FUNC( 110, alpha_win_show ), 1); - TC_ADD( 111, "Alpha window: Stack", T_FUNC( 111, alpha_win_stack ), 1); + TC_ADD( 100, "Basic window: Show", T_FUNC( 100, win_show ), 1); + TC_ADD( 101, "Basic window: Stack", T_FUNC( 101, win_stack ), 1); + TC_ADD( 110, "Alpha window: Show", T_FUNC( 110, alpha_win_show ), 1); + TC_ADD( 111, "Alpha window: Stack", T_FUNC( 111, alpha_win_stack ), 1); + + TC_ADD( 150, "Multi window: Basic", T_FUNC( 150, multi_all_wins_basic ), 1); + TC_ADD( 151, "Multi window: 3 Show1", T_FUNC( 151, multi_all_wins_show1 ), 1); + TC_ADD( 152, "Multi window: 3 Show2", T_FUNC( 152, multi_all_wins_show2 ), 1); + TC_ADD( 153, "Multi window: 3 Show3", T_FUNC( 153, multi_all_wins_show3 ), 1); + TC_ADD( 154, "Multi window: 3 Raise1", T_FUNC( 154, multi_all_wins_raise1 ), 1); + TC_ADD( 155, "Multi window: 3 Raise2", T_FUNC( 155, multi_all_wins_raise2 ), 1); + TC_ADD( 156, "Multi window: 3 Stack Above1", T_FUNC( 156, multi_all_wins_stack_above1 ), 1); + TC_ADD( 157, "Multi window: 3 Stack Above2", T_FUNC( 157, multi_all_wins_stack_above2 ), 1); + TC_ADD( 158, "Multi window: 3 Stack Above3", T_FUNC( 158, multi_all_wins_stack_above3 ), 1); + TC_ADD( 159, "Multi window: 3 Lower1", T_FUNC( 159, multi_all_wins_lower1 ), 1); + TC_ADD( 160, "Multi window: 3 Lower2", T_FUNC( 160, multi_all_wins_lower2 ), 1); + + TC_ADD( 180, "Multi window: 2 Show1", T_FUNC( 180, multi_2wins_show1 ), 1); + TC_ADD( 181, "Multi window: 2 Show2", T_FUNC( 181, multi_2wins_show2 ), 1); + TC_ADD( 182, "Multi window: 2 Show3", T_FUNC( 182, multi_2wins_show3 ), 1); + /* [0200 - 0299] transient for */ - TC_ADD( 200, "Transient for: Basic", T_FUNC( 200, transient_for_basic ), 1); - TC_ADD( 201, "Transient for: Raise", T_FUNC( 201, transient_for_raise ), 1); - TC_ADD( 202, "Transient for: Lower", T_FUNC( 202, transient_for_lower ), 1); - TC_ADD( 203, "Transient for: Stack above", T_FUNC( 203, transient_for_stack_above), 1); - TC_ADD( 204, "Transient for: Stack below", T_FUNC( 204, transient_for_stack_below), 1); + TC_ADD( 200, "Transient for: Basic", T_FUNC( 200, transient_for_basic ), 1); + TC_ADD( 201, "Transient for: Raise", T_FUNC( 201, transient_for_raise ), 1); + TC_ADD( 202, "Transient for: Lower", T_FUNC( 202, transient_for_lower ), 1); + TC_ADD( 203, "Transient for: Stack above", T_FUNC( 203, transient_for_stack_above ), 1); + TC_ADD( 204, "Transient for: Stack below", T_FUNC( 204, transient_for_stack_below ), 1); + /* [0300 - 0399] notification */ - TC_ADD( 300, "Noti Level 1", T_FUNC( 300, notification_level_1 ), 1); - TC_ADD( 301, "Noti Level 2", T_FUNC( 301, notification_level_2 ), 1); - TC_ADD( 302, "Noti Level 3", T_FUNC( 302, notification_level_3 ), 1); - TC_ADD( 303, "Noti Level Change", T_FUNC( 303, notification_level_change), 1); + TC_ADD( 300, "Noti Level 1", T_FUNC( 300, notification_level_1 ), 1); + TC_ADD( 301, "Noti Level 2", T_FUNC( 301, notification_level_2 ), 1); + TC_ADD( 302, "Noti Level 3", T_FUNC( 302, notification_level_3 ), 1); + TC_ADD( 303, "Noti Level Change", T_FUNC( 303, notification_level_change ), 1); /* TODO */ #undef T_FUNC } diff --git a/src/e_test_runner.h b/src/e_test_runner.h index c9b0c49..64e6fff 100644 --- a/src/e_test_runner.h +++ b/src/e_test_runner.h @@ -73,6 +73,18 @@ typedef enum _E_TC_Event_Type E_TC_EVENT_TYPE_MAX } E_TC_Event_Type; +typedef enum _E_TC_Win_Color +{ + E_TC_WIN_COLOR_BLACK = 0, + E_TC_WIN_COLOR_WHITE, + E_TC_WIN_COLOR_RED, + E_TC_WIN_COLOR_GREEN, + E_TC_WIN_COLOR_BLUE, + E_TC_WIN_COLOR_YELLOW, + E_TC_WIN_COLOR_CYAN, + E_TC_WIN_COLOR_PURPLE, +} E_TC_Win_Color; + typedef struct _E_Test_Runner E_Test_Runner; typedef struct _E_TC_Win E_TC_Win; typedef struct _E_TC E_TC; @@ -125,7 +137,7 @@ Eina_List *e_test_runner_req_win_info_list_get(E_Test_Runner *runner); Eina_Bool e_test_runner_req_win_stack_set(E_Test_Runner *runner, E_TC_Win *tw, E_TC_Win *sibling, Eina_Bool above); Eina_Bool e_test_runner_ev_wait(E_Test_Runner *runner, E_TC_Event_Type ev); -E_TC_Win *e_tc_win_add(E_TC_Win *parent, Elm_Win_Type type, Eina_Bool alpha, const char *name, int x, int y, int w, int h, int layer); +E_TC_Win *e_tc_win_add(E_TC_Win *parent, Elm_Win_Type type, Eina_Bool alpha, const char *name, int x, int y, int w, int h, Eina_Bool usr_geom, int layer, E_TC_Win_Color color); E_TC_Win *e_tc_win_info_add(Ecore_Window native_win, Eina_Bool alpha, const char *name, int x, int y, int w, int h, int layer); void e_tc_win_del(E_TC_Win *tw); void e_tc_win_geom_update(E_TC_Win *tw); @@ -145,6 +157,22 @@ Eina_Bool tc_0101_win_stack(E_TC *tc); Eina_Bool tc_0110_alpha_win_show(E_TC *tc); Eina_Bool tc_0111_alpha_win_stack(E_TC *tc); +Eina_Bool tc_0150_multi_all_wins_basic(E_TC *tc); +Eina_Bool tc_0151_multi_all_wins_show1(E_TC *tc); +Eina_Bool tc_0152_multi_all_wins_show2(E_TC *tc); +Eina_Bool tc_0153_multi_all_wins_show3(E_TC *tc); +Eina_Bool tc_0154_multi_all_wins_raise1(E_TC *tc); +Eina_Bool tc_0155_multi_all_wins_raise2(E_TC *tc); +Eina_Bool tc_0156_multi_all_wins_stack_above1(E_TC *tc); +Eina_Bool tc_0157_multi_all_wins_stack_above2(E_TC *tc); +Eina_Bool tc_0158_multi_all_wins_stack_above3(E_TC *tc); +Eina_Bool tc_0159_multi_all_wins_lower1(E_TC *tc); +Eina_Bool tc_0160_multi_all_wins_lower2(E_TC *tc); + +Eina_Bool tc_0180_multi_2wins_show1(E_TC *tc); +Eina_Bool tc_0181_multi_2wins_show2(E_TC *tc); +Eina_Bool tc_0182_multi_2wins_show3(E_TC *tc); + Eina_Bool tc_0200_transient_for_basic(E_TC *tc); Eina_Bool tc_0201_transient_for_raise(E_TC *tc); Eina_Bool tc_0202_transient_for_lower(E_TC *tc); -- 2.7.4 From eb6ebe18d907d330f73e3707bdc89b918694a49f Mon Sep 17 00:00:00 2001 From: Gwanglim Lee Date: Thu, 2 Jun 2016 19:47:49 +0900 Subject: [PATCH 09/16] Packaging: update version to 0.0.8 Change-Id: If0a62e7048c4f365c72bd553e58e36fd75a7981f --- packaging/e-tizen-testcase.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-tizen-testcase.spec b/packaging/e-tizen-testcase.spec index a40a0aa..1d04aa0 100644 --- a/packaging/e-tizen-testcase.spec +++ b/packaging/e-tizen-testcase.spec @@ -1,5 +1,5 @@ Name: e-tizen-testcase -Version: 0.0.7 +Version: 0.0.8 Release: 1 Summary: The test case runner for enlightenment URL: http://www.enlightenment.org -- 2.7.4 From f55b1b61eebf71eec7e111969fb18a680e01e7df Mon Sep 17 00:00:00 2001 From: Doyoun Kang Date: Fri, 15 Jul 2016 16:19:49 +0900 Subject: [PATCH 10/16] modified some TCs Change-Id: I4c1a07b82871205ac4ac027062d591680d8a7042 --- src/0100_base_operation.c | 4 + src/0150_base_operation_multi_wins.c | 174 +++++++++++++++++------------------ src/0200_transient_for.c | 163 +++++++++++++++++++++++--------- 3 files changed, 211 insertions(+), 130 deletions(-) diff --git a/src/0100_base_operation.c b/src/0100_base_operation.c index 9f3816e..53d6ffb 100644 --- a/src/0100_base_operation.c +++ b/src/0100_base_operation.c @@ -44,12 +44,16 @@ cleanup: static void _tc_post_run(E_TC *tc) { + EINA_SAFETY_ON_NULL_RETURN(tc); + EINA_SAFETY_ON_NULL_RETURN(tc->data); + e_tc_win_hide(tc->data->tw); } static void _tc_shutdown(E_TC *tc) { + EINA_SAFETY_ON_NULL_RETURN(tc); EINA_SAFETY_ON_NULL_RETURN(tc->data); e_test_runner_req_win_deregister(tc->runner, tc->data->tw); diff --git a/src/0150_base_operation_multi_wins.c b/src/0150_base_operation_multi_wins.c index 4acdc4c..e1ce6a8 100644 --- a/src/0150_base_operation_multi_wins.c +++ b/src/0150_base_operation_multi_wins.c @@ -10,9 +10,9 @@ struct _E_TC_Data static Eina_Bool _tc_win_register(E_TC *tc, E_TC_Win *win); static void _tc_win_unregister(E_TC *tc); -static Eina_Bool _tc_pre_run(E_TC *tc, Eina_Bool alpha); -static void _tc_post_run(E_TC *tc); -static void _tc_shutdown(E_TC *tc); +static Eina_Bool _tc_multi_wins_pre_run(E_TC *tc, Eina_Bool alpha); +static void _tc_multi_wins_post_run(E_TC *tc); +static void _tc_multi_wins_shutdown(E_TC *tc); static Eina_Bool _tc_win_register(E_TC *tc, E_TC_Win *win) @@ -24,6 +24,12 @@ _tc_win_register(E_TC *tc, E_TC_Win *win) EINA_SAFETY_ON_NULL_RETURN_VAL(win, EINA_FALSE); + if (tc->data->tw_register) + { + e_test_runner_req_win_deregister(tc->runner, tc->data->tw_register); + tc->data->tw_register = NULL; + } + tc->data->tw_register = win; res = e_test_runner_req_win_register(tc->runner, tc->data->tw_register); @@ -45,7 +51,7 @@ _tc_win_unregister(E_TC *tc) static Eina_Bool -_tc_pre_run(E_TC *tc, Eina_Bool show_win) +_tc_multi_wins_pre_run(E_TC *tc, Eina_Bool show_win) { Eina_Bool res; @@ -66,7 +72,7 @@ _tc_pre_run(E_TC *tc, Eina_Bool show_win) tc->data->tw_green = e_tc_win_add(NULL, ELM_WIN_BASIC, EINA_FALSE, "green", - 150, 150, 320, 320, EINA_TRUE, + 150, 150, 400, 400, EINA_TRUE, 200, E_TC_WIN_COLOR_GREEN); EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_green, cleanup); @@ -78,7 +84,7 @@ _tc_pre_run(E_TC *tc, Eina_Bool show_win) tc->data->tw_blue = e_tc_win_add(NULL, ELM_WIN_BASIC, EINA_FALSE, "blue", - 20, 350, 500, 500, EINA_TRUE, + 20, 350, 400, 400, EINA_TRUE, 200, E_TC_WIN_COLOR_BLUE); EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_blue, cleanup); @@ -98,12 +104,12 @@ _tc_pre_run(E_TC *tc, Eina_Bool show_win) return EINA_TRUE; cleanup: - _tc_shutdown(tc); + _tc_multi_wins_shutdown(tc); return EINA_FALSE; } static void -_tc_post_run(E_TC *tc) +_tc_multi_wins_post_run(E_TC *tc) { EINA_SAFETY_ON_NULL_RETURN(tc->data); @@ -113,7 +119,7 @@ _tc_post_run(E_TC *tc) } static void -_tc_shutdown(E_TC *tc) +_tc_multi_wins_shutdown(E_TC *tc) { EINA_SAFETY_ON_NULL_RETURN(tc->data); @@ -125,6 +131,23 @@ _tc_shutdown(E_TC *tc) E_FREE(tc->data); } +static Eina_Bool +_tc_win_show(E_TC *tc, E_TC_Win *tw) +{ + Eina_Bool res = EINA_FALSE; + + res = _tc_win_register(tc, tw); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE); + + e_tc_win_geom_update(tw); + e_tc_win_show(tw); + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE); + + return EINA_TRUE; +} + Eina_Bool tc_0150_multi_all_wins_basic(E_TC *tc) { @@ -136,7 +159,7 @@ tc_0150_multi_all_wins_basic(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_TRUE); + res = _tc_multi_wins_pre_run(tc, EINA_TRUE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -179,8 +202,8 @@ tc_0150_multi_all_wins_basic(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -196,8 +219,7 @@ tc_0151_multi_all_wins_show1(E_TC *tc) int pass_count; EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - - res = _tc_pre_run(tc, EINA_FALSE); + res = _tc_multi_wins_pre_run(tc, EINA_FALSE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -205,23 +227,15 @@ tc_0151_multi_all_wins_show1(E_TC *tc) tw_blue = tc->data->tw_blue; // show red - e_tc_win_geom_update(tc->data->tw_red); - e_tc_win_show(tc->data->tw_red); + res = _tc_win_show(tc, tc->data->tw_red); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); // show green - e_tc_win_geom_update(tc->data->tw_green); - e_tc_win_show(tc->data->tw_green); - - // register blue - res = _tc_win_register(tc, tc->data->tw_blue); + res = _tc_win_show(tc, tc->data->tw_green); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); // show blue - e_tc_win_geom_update(tc->data->tw_blue); - e_tc_win_show(tc->data->tw_blue); - - // wait for showing register_win - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + res = _tc_win_show(tc, tc->data->tw_blue); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); // Expected stack result: @@ -260,8 +274,8 @@ tc_0151_multi_all_wins_show1(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -278,7 +292,7 @@ tc_0152_multi_all_wins_show2(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_FALSE); + res = _tc_multi_wins_pre_run(tc, EINA_FALSE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -286,23 +300,15 @@ tc_0152_multi_all_wins_show2(E_TC *tc) tw_blue = tc->data->tw_blue; // show blue - e_tc_win_geom_update(tc->data->tw_blue); - e_tc_win_show(tc->data->tw_blue); + res = _tc_win_show(tc, tc->data->tw_blue); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); // show red - e_tc_win_geom_update(tc->data->tw_red); - e_tc_win_show(tc->data->tw_red); - - // register green - res = _tc_win_register(tc, tc->data->tw_green); + res = _tc_win_show(tc, tc->data->tw_red); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); // show green - e_tc_win_geom_update(tc->data->tw_green); - e_tc_win_show(tc->data->tw_green); - - // wait for showing register_win - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + res = _tc_win_show(tc, tc->data->tw_green); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); // Expected stack result: @@ -341,8 +347,8 @@ tc_0152_multi_all_wins_show2(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -360,7 +366,7 @@ tc_0153_multi_all_wins_show3(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_FALSE); + res = _tc_multi_wins_pre_run(tc, EINA_FALSE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -368,23 +374,15 @@ tc_0153_multi_all_wins_show3(E_TC *tc) tw_blue = tc->data->tw_blue; // show green - e_tc_win_geom_update(tc->data->tw_green); - e_tc_win_show(tc->data->tw_green); + res = _tc_win_show(tc, tc->data->tw_green); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); // show blue - e_tc_win_geom_update(tc->data->tw_blue); - e_tc_win_show(tc->data->tw_blue); - - // register red - res = _tc_win_register(tc, tc->data->tw_red); + res = _tc_win_show(tc, tc->data->tw_blue); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); // show red - e_tc_win_geom_update(tc->data->tw_red); - e_tc_win_show(tc->data->tw_red); - - // wait for showing register_win - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + res = _tc_win_show(tc, tc->data->tw_red); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); // Expected stack result: @@ -423,8 +421,8 @@ tc_0153_multi_all_wins_show3(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -441,7 +439,7 @@ tc_0154_multi_all_wins_raise1(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_TRUE); + res = _tc_multi_wins_pre_run(tc, EINA_TRUE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -493,8 +491,8 @@ tc_0154_multi_all_wins_raise1(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -511,7 +509,7 @@ tc_0155_multi_all_wins_raise2(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_TRUE); + res = _tc_multi_wins_pre_run(tc, EINA_TRUE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -563,8 +561,8 @@ tc_0155_multi_all_wins_raise2(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -581,7 +579,7 @@ tc_0156_multi_all_wins_stack_above1(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_TRUE); + res = _tc_multi_wins_pre_run(tc, EINA_TRUE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -633,8 +631,8 @@ tc_0156_multi_all_wins_stack_above1(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -652,7 +650,7 @@ tc_0157_multi_all_wins_stack_above2(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_TRUE); + res = _tc_multi_wins_pre_run(tc, EINA_TRUE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -704,8 +702,8 @@ tc_0157_multi_all_wins_stack_above2(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -722,7 +720,7 @@ tc_0158_multi_all_wins_stack_above3(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_TRUE); + res = _tc_multi_wins_pre_run(tc, EINA_TRUE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -774,8 +772,8 @@ tc_0158_multi_all_wins_stack_above3(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -792,7 +790,7 @@ tc_0159_multi_all_wins_lower1(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_TRUE); + res = _tc_multi_wins_pre_run(tc, EINA_TRUE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -862,8 +860,8 @@ tc_0159_multi_all_wins_lower1(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -881,7 +879,7 @@ tc_0160_multi_all_wins_lower2(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_TRUE); + res = _tc_multi_wins_pre_run(tc, EINA_TRUE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -950,8 +948,8 @@ tc_0160_multi_all_wins_lower2(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -969,7 +967,7 @@ tc_0180_multi_2wins_show1(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_FALSE); + res = _tc_multi_wins_pre_run(tc, EINA_FALSE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -1021,8 +1019,8 @@ tc_0180_multi_2wins_show1(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -1040,7 +1038,7 @@ tc_0181_multi_2wins_show2(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_FALSE); + res = _tc_multi_wins_pre_run(tc, EINA_FALSE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_green = tc->data->tw_green; @@ -1092,8 +1090,8 @@ tc_0181_multi_2wins_show2(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -1111,7 +1109,7 @@ tc_0182_multi_2wins_show3(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc, EINA_FALSE); + res = _tc_multi_wins_pre_run(tc, EINA_FALSE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_red = tc->data->tw_red; @@ -1163,8 +1161,8 @@ tc_0182_multi_2wins_show3(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_multi_wins_post_run(tc); + _tc_multi_wins_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; diff --git a/src/0200_transient_for.c b/src/0200_transient_for.c index b5fa13b..a6a3639 100644 --- a/src/0200_transient_for.c +++ b/src/0200_transient_for.c @@ -5,14 +5,69 @@ struct _E_TC_Data E_TC_Win *tw; E_TC_Win *tw_parent; E_TC_Win *tw_child; + E_TC_Win *tw_register; }; -static Eina_Bool _tc_pre_run(E_TC *tc); -static void _tc_post_run(E_TC *tc); -static void _tc_shutdown(E_TC *tc); +static Eina_Bool _tc_transient_for_win_register(E_TC *tc, E_TC_Win *win); +static void _tc_transient_for_win_unregister(E_TC *tc); +static Eina_Bool _tc_transient_for_pre_run(E_TC *tc); +static void _tc_transient_for_post_run(E_TC *tc); +static void _tc_transient_for_shutdown(E_TC *tc); static Eina_Bool -_tc_pre_run(E_TC *tc) +_tc_transient_for_win_register(E_TC *tc, E_TC_Win *win) +{ + Eina_Bool res; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + EINA_SAFETY_ON_NULL_RETURN_VAL(tc->data, EINA_FALSE); + + EINA_SAFETY_ON_NULL_RETURN_VAL(win, EINA_FALSE); + + if (tc->data->tw_register) + { + e_test_runner_req_win_deregister(tc->runner, tc->data->tw_register); + tc->data->tw_register = NULL; + } + + tc->data->tw_register = win; + + res = e_test_runner_req_win_register(tc->runner, tc->data->tw_register); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE); + + return EINA_TRUE; +} + +static void +_tc_transient_for_win_unregister(E_TC *tc) +{ + EINA_SAFETY_ON_NULL_RETURN(tc); + EINA_SAFETY_ON_NULL_RETURN(tc->data); + EINA_SAFETY_ON_NULL_RETURN(tc->data->tw_register); + + e_test_runner_req_win_deregister(tc->runner, tc->data->tw_register); + tc->data->tw_register = NULL; +} + +static Eina_Bool +_tc_win_show(E_TC *tc, E_TC_Win *tw) +{ + Eina_Bool res = EINA_FALSE; + + res = _tc_transient_for_win_register(tc, tw); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE); + + e_tc_win_geom_update(tw); + e_tc_win_show(tw); + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE); + + return EINA_TRUE; +} + +static Eina_Bool +_tc_transient_for_pre_run(E_TC *tc) { Eina_Bool res; @@ -25,7 +80,7 @@ _tc_pre_run(E_TC *tc) 200, E_TC_WIN_COLOR_BLUE); EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_parent, cleanup); - tc->data->tw_child = e_tc_win_add(tc->data->tw_parent, ELM_WIN_BASIC, + tc->data->tw_child = e_tc_win_add(NULL, ELM_WIN_BASIC, EINA_FALSE, "child", 0, 0, 320, 320, EINA_FALSE, 200, E_TC_WIN_COLOR_RED); @@ -37,37 +92,40 @@ _tc_pre_run(E_TC *tc) 200, E_TC_WIN_COLOR_GREEN); EINA_SAFETY_ON_NULL_GOTO(tc->data->tw, cleanup); - res = e_test_runner_req_win_register(tc->runner, tc->data->tw); + // show tw_parent + res = _tc_win_show(tc, tc->data->tw_parent); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - e_tc_win_geom_update(tc->data->tw_parent); - e_tc_win_show(tc->data->tw_parent); - - e_tc_win_geom_update(tc->data->tw); - e_tc_win_show(tc->data->tw); + // show tw + res = _tc_win_show(tc, tc->data->tw); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - e_tc_win_geom_update(tc->data->tw_child); - e_tc_win_show(tc->data->tw_child); - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); + // show tw_child + res = _tc_win_show(tc, tc->data->tw_child); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // set transient_for res = e_tc_win_transient_for_set(tc->data->tw_child, tc->data->tw_parent, EINA_TRUE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_work(); return EINA_TRUE; cleanup: - _tc_shutdown(tc); + _tc_transient_for_shutdown(tc); return EINA_FALSE; } static void -_tc_post_run(E_TC *tc) +_tc_transient_for_post_run(E_TC *tc) { EINA_SAFETY_ON_NULL_RETURN(tc->data); @@ -77,11 +135,11 @@ _tc_post_run(E_TC *tc) } static void -_tc_shutdown(E_TC *tc) +_tc_transient_for_shutdown(E_TC *tc) { EINA_SAFETY_ON_NULL_RETURN(tc->data); - e_test_runner_req_win_deregister(tc->runner, tc->data->tw); + _tc_transient_for_win_unregister(tc); e_tc_win_del(tc->data->tw_child); e_tc_win_del(tc->data->tw_parent); e_tc_win_del(tc->data->tw); @@ -99,7 +157,7 @@ tc_0200_transient_for_basic(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc); + res = _tc_transient_for_pre_run(tc); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_main = tc->data->tw; @@ -140,8 +198,8 @@ tc_0200_transient_for_basic(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_transient_for_post_run(tc); + _tc_transient_for_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -157,7 +215,7 @@ tc_0201_transient_for_raise(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc); + res = _tc_transient_for_pre_run(tc); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_main = tc->data->tw; @@ -167,6 +225,9 @@ tc_0201_transient_for_raise(E_TC *tc) // Expected stack result: // [Top] tw_main -> tw_child -> tw_parent [Bottom] + res = _tc_transient_for_win_register(tc, tw_parent); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_req_win_stack_set(tc->runner, tw_parent, NULL, EINA_TRUE); // Expected stack result: @@ -206,8 +267,8 @@ tc_0201_transient_for_raise(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_transient_for_post_run(tc); + _tc_transient_for_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -224,7 +285,7 @@ tc_0202_transient_for_lower(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc); + res = _tc_transient_for_pre_run(tc); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_main = tc->data->tw; @@ -234,6 +295,18 @@ tc_0202_transient_for_lower(E_TC *tc) // Expected stack result: // [Top] tw_main -> tw_child -> tw_parent [Bottom] + res = _tc_transient_for_win_register(tc, tw_parent); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + // Raise Transient_for Parent window + e_test_runner_req_win_stack_set(tc->runner, tw_parent, NULL, EINA_TRUE); + + // Expected stack result: + // [Top] tw_child -> tw_parent -> tw_main [Bottom] + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + // lower tw_parent e_test_runner_req_win_stack_set(tc->runner, tw_parent, NULL, EINA_FALSE); @@ -293,8 +366,8 @@ tc_0202_transient_for_lower(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_transient_for_post_run(tc); + _tc_transient_for_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -310,7 +383,7 @@ tc_0203_transient_for_stack_above(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc); + res = _tc_transient_for_pre_run(tc); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_main = tc->data->tw; @@ -320,6 +393,9 @@ tc_0203_transient_for_stack_above(E_TC *tc) // Expected stack result: // [Top] tw_main -> tw_child -> tw_parent [Bottom] + res = _tc_transient_for_win_register(tc, tw_parent); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_req_win_stack_set(tc->runner, tw_parent, tw_main, EINA_TRUE); res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_ABOVE); @@ -359,8 +435,8 @@ tc_0203_transient_for_stack_above(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_transient_for_post_run(tc); + _tc_transient_for_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; @@ -376,7 +452,7 @@ tc_0204_transient_for_stack_below(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - res = _tc_pre_run(tc); + res = _tc_transient_for_pre_run(tc); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); tw_main = tc->data->tw; @@ -386,14 +462,17 @@ tc_0204_transient_for_stack_below(E_TC *tc) // Expected stack result: // [Top] tw_main -> tw_child -> tw_parent [Bottom] - // lower tw_main - e_test_runner_req_win_stack_set(tc->runner, tw_main, NULL, EINA_FALSE); + res = _tc_transient_for_win_register(tc, tw_parent); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_BELOW); + // raise tw_parent + e_test_runner_req_win_stack_set(tc->runner, tw_parent, NULL, EINA_TRUE); + + res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); // Expected stack result: - // [Top] tw_child -> tw_parent -> ... -> tw_main [Bottom] + // [Top] tw_child -> tw_parent -> tw_main [Bottom] e_test_runner_req_win_stack_set(tc->runner, tw_parent, tw_main, EINA_FALSE); @@ -401,18 +480,18 @@ tc_0204_transient_for_stack_below(E_TC *tc) EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); // Expected stack result: - // [Top] ... -> tw_main -> tw_child -> tw_parent [Bottom] + // [Top] tw_main -> tw_child -> tw_parent [Bottom] list = e_test_runner_req_win_info_list_get(tc->runner); EINA_SAFETY_ON_NULL_GOTO(list, cleanup); // bottom to top search - EINA_LIST_REVERSE_FOREACH(list, l, tw) + EINA_LIST_FOREACH(list, l, tw) { - if (tw->layer < 200) continue; + if (tw->layer > 200) continue; if (pass_count == 0) { - EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_parent->native_win), cleanup); + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_main->native_win), cleanup); pass_count++; continue; } @@ -424,7 +503,7 @@ tc_0204_transient_for_stack_below(E_TC *tc) } else { - EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_main->native_win), cleanup); + EINA_SAFETY_ON_FALSE_GOTO((tw->native_win == tw_parent->native_win), cleanup); pass_count++; } break; @@ -435,8 +514,8 @@ tc_0204_transient_for_stack_below(E_TC *tc) tc->passed = EINA_TRUE; cleanup: - _tc_post_run(tc); - _tc_shutdown(tc); + _tc_transient_for_post_run(tc); + _tc_transient_for_shutdown(tc); E_FREE_LIST(list, e_tc_win_del); return tc->passed; -- 2.7.4 From bc4eb037275700f0a49568cab46180129af5ede1 Mon Sep 17 00:00:00 2001 From: Doyoun Kang Date: Fri, 15 Jul 2016 16:49:44 +0900 Subject: [PATCH 11/16] modified code to run the TC when the timeout is occured Change-Id: Id3012855574344c7bbc5666e3a04422ff839f0ae --- src/0100_base_operation.c | 3 +-- src/0150_base_operation_multi_wins.c | 47 +++++++++--------------------------- src/0200_transient_for.c | 30 ++++++----------------- src/0300_notification.c | 3 +-- 4 files changed, 22 insertions(+), 61 deletions(-) diff --git a/src/0100_base_operation.c b/src/0100_base_operation.c index 53d6ffb..f80349b 100644 --- a/src/0100_base_operation.c +++ b/src/0100_base_operation.c @@ -29,8 +29,7 @@ _tc_pre_run(E_TC *tc, Eina_Bool alpha) e_tc_win_geom_update(tc->data->tw); e_tc_win_show(tc->data->tw); - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); e_test_runner_work(); diff --git a/src/0150_base_operation_multi_wins.c b/src/0150_base_operation_multi_wins.c index e1ce6a8..73f5c7d 100644 --- a/src/0150_base_operation_multi_wins.c +++ b/src/0150_base_operation_multi_wins.c @@ -53,8 +53,6 @@ _tc_win_unregister(E_TC *tc) static Eina_Bool _tc_multi_wins_pre_run(E_TC *tc, Eina_Bool show_win) { - Eina_Bool res; - tc->data = E_NEW(E_TC_Data, 1); EINA_SAFETY_ON_NULL_RETURN_VAL(tc->data, EINA_FALSE); @@ -94,9 +92,7 @@ _tc_multi_wins_pre_run(E_TC *tc, Eina_Bool show_win) e_tc_win_geom_update(tc->data->tw_blue); e_tc_win_show(tc->data->tw_blue); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); } e_test_runner_work(); @@ -141,9 +137,7 @@ _tc_win_show(E_TC *tc, E_TC_Win *tw) e_tc_win_geom_update(tw); e_tc_win_show(tw); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); - EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); return EINA_TRUE; } @@ -451,9 +445,7 @@ tc_0154_multi_all_wins_raise1(E_TC *tc) // Raise Red e_test_runner_req_win_stack_set(tc->runner, tw_red, NULL, EINA_TRUE); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack result: // [Top] Red -> Blue -> Green [Bottom] @@ -521,9 +513,7 @@ tc_0155_multi_all_wins_raise2(E_TC *tc) // Raise Green e_test_runner_req_win_stack_set(tc->runner, tw_green, NULL, EINA_TRUE); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack result: // [Top] Green -> Blue -> Red [Bottom] @@ -591,9 +581,7 @@ tc_0156_multi_all_wins_stack_above1(E_TC *tc) // Raise Red on the Green e_test_runner_req_win_stack_set(tc->runner, tw_red, tw_green, EINA_TRUE); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack result: // [Top] Blue -> Red -> Green [Bottom] @@ -662,9 +650,7 @@ tc_0157_multi_all_wins_stack_above2(E_TC *tc) // Raise Blue on the Red e_test_runner_req_win_stack_set(tc->runner, tw_blue, tw_red, EINA_TRUE); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack result: // [Top] Green -> Blue -> Red [Bottom] @@ -732,9 +718,7 @@ tc_0158_multi_all_wins_stack_above3(E_TC *tc) // Raise Red on the Blue e_test_runner_req_win_stack_set(tc->runner, tw_red, tw_blue, EINA_TRUE); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack result: // [Top] Red -> Blue -> Green [Bottom] @@ -802,9 +786,7 @@ tc_0159_multi_all_wins_lower1(E_TC *tc) // Lower Blue e_test_runner_req_win_stack_set(tc->runner, tw_blue, NULL, EINA_FALSE); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack result: // [Top] Green -> Red -> ... -> Blue [Bottom] @@ -891,9 +873,7 @@ tc_0160_multi_all_wins_lower2(E_TC *tc) // Lower Green e_test_runner_req_win_stack_set(tc->runner, tw_green, NULL, EINA_FALSE); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack result: // [Top] Blue -> Red -> ... -> Green [Bottom] @@ -986,8 +966,7 @@ tc_0180_multi_2wins_show1(E_TC *tc) e_tc_win_show(tc->data->tw_red); // wait for showing register_win - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); // Expected stack result: // [Top] Red -> Green [Bottom] @@ -1057,8 +1036,7 @@ tc_0181_multi_2wins_show2(E_TC *tc) e_tc_win_show(tc->data->tw_green); // wait for showing register_win - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); // Expected stack result: // [Top] Green -> Blue [Bottom] @@ -1128,8 +1106,7 @@ tc_0182_multi_2wins_show3(E_TC *tc) e_tc_win_show(tc->data->tw_blue); // wait for showing register_win - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); // Expected stack result: // [Top] Blue -> Red [Bottom] diff --git a/src/0200_transient_for.c b/src/0200_transient_for.c index a6a3639..5fdd926 100644 --- a/src/0200_transient_for.c +++ b/src/0200_transient_for.c @@ -59,9 +59,7 @@ _tc_win_show(E_TC *tc, E_TC_Win *tw) e_tc_win_geom_update(tw); e_tc_win_show(tw); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); - EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON); return EINA_TRUE; } @@ -112,8 +110,7 @@ _tc_transient_for_pre_run(E_TC *tc) EINA_TRUE); EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); e_test_runner_work(); @@ -229,13 +226,11 @@ tc_0201_transient_for_raise(E_TC *tc) EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); e_test_runner_req_win_stack_set(tc->runner, tw_parent, NULL, EINA_TRUE); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack result: // [Top] tw_child -> tw_parent -> tw_main [Bottom] - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); - list = e_test_runner_req_win_info_list_get(tc->runner); EINA_SAFETY_ON_NULL_GOTO(list, cleanup); @@ -300,18 +295,15 @@ tc_0202_transient_for_lower(E_TC *tc) // Raise Transient_for Parent window e_test_runner_req_win_stack_set(tc->runner, tw_parent, NULL, EINA_TRUE); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack result: // [Top] tw_child -> tw_parent -> tw_main [Bottom] - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); // lower tw_parent e_test_runner_req_win_stack_set(tc->runner, tw_parent, NULL, EINA_FALSE); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_LOWER); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_LOWER); // Expected stack result: // [Top] tw_main -> ... -> tw_child -> tw_parent [Bottom] @@ -397,9 +389,7 @@ tc_0203_transient_for_stack_above(E_TC *tc) EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); e_test_runner_req_win_stack_set(tc->runner, tw_parent, tw_main, EINA_TRUE); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_ABOVE); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_ABOVE); // Expected stack result: // [Top] tw_child -> tw_parent -> tw_main [Bottom] @@ -467,17 +457,13 @@ tc_0204_transient_for_stack_below(E_TC *tc) // raise tw_parent e_test_runner_req_win_stack_set(tc->runner, tw_parent, NULL, EINA_TRUE); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE); // Expected stack result: // [Top] tw_child -> tw_parent -> tw_main [Bottom] e_test_runner_req_win_stack_set(tc->runner, tw_parent, tw_main, EINA_FALSE); - - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_BELOW); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_BELOW); // Expected stack result: // [Top] tw_main -> tw_child -> tw_parent [Bottom] diff --git a/src/0300_notification.c b/src/0300_notification.c index 027e628..a7f9fcf 100644 --- a/src/0300_notification.c +++ b/src/0300_notification.c @@ -76,8 +76,7 @@ _tc_pre_run(E_TC *tc) e_tc_win_show(data->tw_noti1); e_tc_win_show(data->tw_noti2); - res = e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_CHANGED); - EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_CHANGED); e_test_runner_work(); -- 2.7.4 From 555abcba7561dd73e9461f75e4d0d51c741f00c3 Mon Sep 17 00:00:00 2001 From: Doyoun Kang Date: Fri, 15 Jul 2016 17:06:45 +0900 Subject: [PATCH 12/16] Packaging: update version to 0.1.0 Change-Id: Ie4431b662036429803ec2946d6944477940e2823 --- packaging/e-tizen-testcase.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-tizen-testcase.spec b/packaging/e-tizen-testcase.spec index 1d04aa0..96ff310 100644 --- a/packaging/e-tizen-testcase.spec +++ b/packaging/e-tizen-testcase.spec @@ -1,5 +1,5 @@ Name: e-tizen-testcase -Version: 0.0.8 +Version: 0.1.0 Release: 1 Summary: The test case runner for enlightenment URL: http://www.enlightenment.org -- 2.7.4 From 76a1420dfb914122361698e7bf195b212ca34271 Mon Sep 17 00:00:00 2001 From: MinJeong Kim Date: Wed, 3 Aug 2016 21:57:14 +0900 Subject: [PATCH 13/16] Wait for end of effect animation to get proper window list Change-Id: I0bac90e7a48de9287fbe21cb35431bab9ad27400 Signed-off-by: MinJeong Kim --- src/0000_easy.c | 2 +- src/e_test_runner.c | 77 +++++++++++++++++++++++++++++++++++++++-------------- src/e_test_runner.h | 3 ++- 3 files changed, 60 insertions(+), 22 deletions(-) diff --git a/src/0000_easy.c b/src/0000_easy.c index 07a2674..84538fb 100644 --- a/src/0000_easy.c +++ b/src/0000_easy.c @@ -129,7 +129,7 @@ tc_0011_win_register(E_TC *tc) EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - tw = e_tc_win_info_add(_WIN_ID, EINA_FALSE, "tc", 0, 0, 1, 1, 0); + tw = e_tc_win_info_add(_WIN_ID, EINA_FALSE, EINA_FALSE, "tc", 0, 0, 1, 1, 0); EINA_SAFETY_ON_NULL_GOTO(tw, finish); /* check RegisterWindow method */ diff --git a/src/e_test_runner.c b/src/e_test_runner.c index bce4fc3..07c58cb 100644 --- a/src/e_test_runner.c +++ b/src/e_test_runner.c @@ -7,6 +7,11 @@ int _log_dom = -1; struct tizen_policy *tizen_policy = NULL; struct tizen_surface *tizen_surface = NULL; +typedef struct { + Eina_List *list; + Eina_Bool retry; +} Window_Info_List; + static void _e_test_runner_cb_resource_id(void *data, struct tizen_resource *tizen_resource EINA_UNUSED, @@ -84,44 +89,56 @@ _cb_method_win_info_list_get(void *data, const char *name = NULL, *text = NULL; Eldbus_Message_Iter *array, *ec; Ecore_Window target_win = 0; - Eina_List *list = data; - Eina_Bool res; + Window_Info_List *info_list = data; + Eina_Bool res, animating = EINA_FALSE; + + if (!!!info_list) + goto finish; res = eldbus_message_error_get(msg, &name, &text); EINA_SAFETY_ON_TRUE_GOTO(res, finish); - res = eldbus_message_arguments_get(msg, "ua(usiiiiibb)", &target_win, &array); + res = eldbus_message_arguments_get(msg, "ua(usiiiiibbb)", &target_win, &array); EINA_SAFETY_ON_FALSE_GOTO(res, finish); while (eldbus_message_iter_get_and_next(array, 'r', &ec)) { const char *win_name; int x, y, w, h, layer; - Eina_Bool visible, alpha; + Eina_Bool visible, alpha, effect = EINA_FALSE; Ecore_Window native_win; E_TC_Win *tw = NULL; res = eldbus_message_iter_arguments_get(ec, - "usiiiiibb", - &native_win, + "usiiiiibbb", + &native_win, &win_name, &x, &y, &w, &h, &layer, + &effect, &visible, &alpha); + + if (effect) + animating = EINA_TRUE; + if (!res) { WRN("Failed to get win info\n"); continue; } - tw = e_tc_win_info_add(native_win, alpha, win_name, x, y, w, h, layer); - list = eina_list_append(list, tw); + tw = e_tc_win_info_add(native_win, alpha, effect, win_name, x, y, w, h, layer); + info_list->list = eina_list_append(info_list->list, tw); } + if (animating) + info_list->retry = EINA_TRUE; + + finish: if ((name) || (text)) { @@ -332,21 +349,39 @@ Eina_List * e_test_runner_req_win_info_list_get(E_Test_Runner *runner) { Eldbus_Pending *p; - Eina_List *list = NULL; - list = eina_list_append(list, NULL); + Window_Info_List *info_list = NULL; - p = eldbus_proxy_call(runner->dbus.proxy, - "GetWindowInfo", - _cb_method_win_info_list_get, - list, - -1, - ""); - EINA_SAFETY_ON_NULL_RETURN_VAL(p, NULL); + info_list = E_NEW(Window_Info_List, 1); - elm_run(); - list = eina_list_remove(list, NULL); + while (info_list) + { + p = eldbus_proxy_call(runner->dbus.proxy, + "GetWindowInfo", + _cb_method_win_info_list_get, + info_list, + -1, + ""); + EINA_SAFETY_ON_NULL_RETURN_VAL(p, NULL); + + elm_run(); + + if (info_list->retry) + { + E_TC_Win *tw; + info_list->retry = EINA_FALSE; + EINA_LIST_FREE(info_list->list, tw) + { + if (tw) + e_tc_win_del(tw); + } + + continue; + } + + break; + } - return list; + return info_list->list; } Eina_Bool @@ -523,6 +558,7 @@ err: E_TC_Win * e_tc_win_info_add(Ecore_Window native_win, Eina_Bool alpha, + Eina_Bool animating, const char *name, int x, int y, int w, int h, @@ -542,6 +578,7 @@ e_tc_win_info_add(Ecore_Window native_win, tw->h = h; tw->layer = layer; tw->alpha = alpha; + tw->animating = animating; return tw; } diff --git a/src/e_test_runner.h b/src/e_test_runner.h index 64e6fff..f646489 100644 --- a/src/e_test_runner.h +++ b/src/e_test_runner.h @@ -118,6 +118,7 @@ struct _E_TC_Win int layer; // value of E_Layer int vis; // visibility int alpha; // alpha window + Eina_Bool animating; }; struct _E_TC @@ -138,7 +139,7 @@ Eina_Bool e_test_runner_req_win_stack_set(E_Test_Runner *runner, E_TC_Win *tw, Eina_Bool e_test_runner_ev_wait(E_Test_Runner *runner, E_TC_Event_Type ev); E_TC_Win *e_tc_win_add(E_TC_Win *parent, Elm_Win_Type type, Eina_Bool alpha, const char *name, int x, int y, int w, int h, Eina_Bool usr_geom, int layer, E_TC_Win_Color color); -E_TC_Win *e_tc_win_info_add(Ecore_Window native_win, Eina_Bool alpha, const char *name, int x, int y, int w, int h, int layer); +E_TC_Win *e_tc_win_info_add(Ecore_Window native_win, Eina_Bool alpha, Eina_Bool animating, const char *name, int x, int y, int w, int h, int layer); void e_tc_win_del(E_TC_Win *tw); void e_tc_win_geom_update(E_TC_Win *tw); void e_tc_win_show(E_TC_Win *tw); -- 2.7.4 From 1a0f0717124bc85c38872ed4f2e119d407b126b9 Mon Sep 17 00:00:00 2001 From: Gwanglim Lee Date: Tue, 9 Aug 2016 15:20:26 +0900 Subject: [PATCH 14/16] Packaging: update version to 0.1.1 Change-Id: Id0ba79acf3331e8cb78b1a46f5cd7dd590b1fa5b --- packaging/e-tizen-testcase.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-tizen-testcase.spec b/packaging/e-tizen-testcase.spec index 96ff310..ba4eec1 100644 --- a/packaging/e-tizen-testcase.spec +++ b/packaging/e-tizen-testcase.spec @@ -1,5 +1,5 @@ Name: e-tizen-testcase -Version: 0.1.0 +Version: 0.1.1 Release: 1 Summary: The test case runner for enlightenment URL: http://www.enlightenment.org -- 2.7.4 From b76baba3e4ed5001c509c1fb582b9a983dc5eb36 Mon Sep 17 00:00:00 2001 From: Gwanglim Lee Date: Mon, 22 Aug 2016 13:21:02 +0900 Subject: [PATCH 15/16] e_test_runner: added missing free for info_list. Change-Id: Icfccb938cb8b50c5dd11a318a2b63a7f8858f05a --- src/e_test_runner.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/e_test_runner.c b/src/e_test_runner.c index 07c58cb..a77c1a0 100644 --- a/src/e_test_runner.c +++ b/src/e_test_runner.c @@ -350,8 +350,10 @@ e_test_runner_req_win_info_list_get(E_Test_Runner *runner) { Eldbus_Pending *p; Window_Info_List *info_list = NULL; + Eina_List *list = NULL; info_list = E_NEW(Window_Info_List, 1); + EINA_SAFETY_ON_NULL_RETURN_VAL(info_list, NULL); while (info_list) { @@ -381,7 +383,10 @@ e_test_runner_req_win_info_list_get(E_Test_Runner *runner) break; } - return info_list->list; + list = eina_list_clone(info_list->list); + E_FREE(info_list); + + return list; } Eina_Bool -- 2.7.4 From d17339c5a903159014260aa48b4bed7fab78ec51 Mon Sep 17 00:00:00 2001 From: Gwanglim Lee Date: Mon, 22 Aug 2016 13:38:10 +0900 Subject: [PATCH 16/16] Packaging: update version to 0.1.2 Change-Id: I0cfbebd0ffd2c58b8612eb9bcd6e4ae7c3dc8481 --- packaging/e-tizen-testcase.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/e-tizen-testcase.spec b/packaging/e-tizen-testcase.spec index ba4eec1..6fa202a 100644 --- a/packaging/e-tizen-testcase.spec +++ b/packaging/e-tizen-testcase.spec @@ -1,5 +1,5 @@ Name: e-tizen-testcase -Version: 0.1.1 +Version: 0.1.2 Release: 1 Summary: The test case runner for enlightenment URL: http://www.enlightenment.org -- 2.7.4