--- /dev/null
+#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;
+}
+
};
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
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);
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,
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
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);
}
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);
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);
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);
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);
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);
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);
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;
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;
#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
}
projects / platform / core / uifw / e-tizen-testcase.git / commitdiff