e-tizen-testcase: Add fullsize window testcase corrspending to partial window testcase.

Change-Id: Ie07c7b503594ec55aaa1eeaae3660cbd7c369a8f

diff --git a/src/0150_base_operation_multi_wins.c b/src/0150_base_operation_multi_wins.c
index 73f5c7df4b69f8f420c57628500062d6365dd578..ee8a3e61f2bbf3280c21a9c3f66fb72a68a92f56 100644 (file)
--- a/src/0150_base_operation_multi_wins.c
+++ b/src/0150_base_operation_multi_wins.c
@@ -10,7 +10,7 @@ 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_multi_wins_pre_run(E_TC *tc, Eina_Bool alpha);
+static Eina_Bool _tc_multi_wins_pre_run(E_TC *tc, Eina_Bool alpha, Eina_Bool use_geom);
 static void      _tc_multi_wins_post_run(E_TC *tc);
 static void      _tc_multi_wins_shutdown(E_TC *tc);
 
@@ -51,14 +51,14 @@ _tc_win_unregister(E_TC *tc)
 
 
 static Eina_Bool
-_tc_multi_wins_pre_run(E_TC *tc, Eina_Bool show_win)
+_tc_multi_wins_pre_run(E_TC *tc, Eina_Bool show_win, Eina_Bool use_geom)
 {
    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,
+                                   0, 0, 400, 400, use_geom,
                                    200, E_TC_WIN_COLOR_RED);
    EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_red, cleanup);
 
@@ -70,7 +70,7 @@ _tc_multi_wins_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, 400, 400, EINA_TRUE,
+                                     150, 150, 400, 400, use_geom,
                                      200, E_TC_WIN_COLOR_GREEN);
    EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_green, cleanup);
 
@@ -82,7 +82,7 @@ _tc_multi_wins_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, 400, 400, EINA_TRUE,
+                                    20, 350, 400, 400, use_geom,
                                     200, E_TC_WIN_COLOR_BLUE);
    EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_blue, cleanup);
 
@@ -153,7 +153,7 @@ tc_0150_multi_all_wins_basic(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_TRUE);
+   res = _tc_multi_wins_pre_run(tc, EINA_TRUE, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;
@@ -213,7 +213,7 @@ tc_0151_multi_all_wins_show1(E_TC *tc)
    int pass_count;
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
-   res = _tc_multi_wins_pre_run(tc, EINA_FALSE);
+   res = _tc_multi_wins_pre_run(tc, EINA_FALSE, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;
@@ -286,7 +286,7 @@ tc_0152_multi_all_wins_show2(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_FALSE);
+   res = _tc_multi_wins_pre_run(tc, EINA_FALSE, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;
@@ -360,7 +360,7 @@ tc_0153_multi_all_wins_show3(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_FALSE);
+   res = _tc_multi_wins_pre_run(tc, EINA_FALSE, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;
@@ -433,7 +433,7 @@ tc_0154_multi_all_wins_raise1(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_TRUE);
+   res = _tc_multi_wins_pre_run(tc, EINA_TRUE, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;
@@ -501,7 +501,7 @@ tc_0155_multi_all_wins_raise2(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_TRUE);
+   res = _tc_multi_wins_pre_run(tc, EINA_TRUE, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;
@@ -569,7 +569,7 @@ tc_0156_multi_all_wins_stack_above1(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_TRUE);
+   res = _tc_multi_wins_pre_run(tc, EINA_TRUE, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;
@@ -638,7 +638,7 @@ tc_0157_multi_all_wins_stack_above2(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_TRUE);
+   res = _tc_multi_wins_pre_run(tc, EINA_TRUE, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;
@@ -706,7 +706,7 @@ tc_0158_multi_all_wins_stack_above3(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_TRUE);
+   res = _tc_multi_wins_pre_run(tc, EINA_TRUE, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;
@@ -774,7 +774,7 @@ tc_0159_multi_all_wins_lower1(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_TRUE);
+   res = _tc_multi_wins_pre_run(tc, EINA_TRUE, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;
@@ -861,7 +861,800 @@ tc_0160_multi_all_wins_lower2(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_TRUE);
+   res = _tc_multi_wins_pre_run(tc, EINA_TRUE, 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);
+   e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE);
+
+   // 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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+Eina_Bool
+tc_0161_multi_all_full_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_multi_wins_pre_run(tc, EINA_TRUE, 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;
+
+   // 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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+Eina_Bool
+tc_0162_multi_all_full_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_multi_wins_pre_run(tc, EINA_FALSE, 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
+   res = _tc_win_show(tc, tc->data->tw_red);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   // show green
+   res = _tc_win_show(tc, tc->data->tw_green);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   // show blue
+   res = _tc_win_show(tc, tc->data->tw_blue);
+   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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+Eina_Bool
+tc_0163_multi_all_full_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_multi_wins_pre_run(tc, EINA_FALSE, 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
+   res = _tc_win_show(tc, tc->data->tw_blue);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   // show red
+   res = _tc_win_show(tc, tc->data->tw_red);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   // show green
+   res = _tc_win_show(tc, tc->data->tw_green);
+   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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+
+Eina_Bool
+tc_0164_multi_all_full_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_multi_wins_pre_run(tc, EINA_FALSE, 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
+   res = _tc_win_show(tc, tc->data->tw_green);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   // show blue
+   res = _tc_win_show(tc, tc->data->tw_blue);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   // show red
+   res = _tc_win_show(tc, tc->data->tw_red);
+   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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+Eina_Bool
+tc_0165_multi_all_full_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_multi_wins_pre_run(tc, EINA_TRUE, 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;
+
+   // Expected stack result:
+   // [Top] Blue -> Green -> Red [Bottom]
+
+   // Raise Red
+   e_test_runner_req_win_stack_set(tc->runner, tw_red, NULL, EINA_TRUE);
+   e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE);
+
+   // 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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+Eina_Bool
+tc_0166_multi_all_full_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_multi_wins_pre_run(tc, EINA_TRUE, 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;
+
+   // Expected stack result:
+   // [Top] Blue -> Green -> Red [Bottom]
+
+   // Raise Green
+   e_test_runner_req_win_stack_set(tc->runner, tw_green, NULL, EINA_TRUE);
+   e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE);
+
+   // 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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+Eina_Bool
+tc_0167_multi_all_full_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_multi_wins_pre_run(tc, EINA_TRUE, 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;
+
+   // 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);
+   e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE);
+
+   // 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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+
+Eina_Bool
+tc_0168_multi_all_full_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_multi_wins_pre_run(tc, EINA_TRUE, 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;
+
+   // 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);
+   e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE);
+
+   // 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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+Eina_Bool
+tc_0169_multi_all_full_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_multi_wins_pre_run(tc, EINA_TRUE, 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;
+
+   // 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);
+   e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE);
+
+   // 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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+Eina_Bool
+tc_0170_multi_all_full_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_multi_wins_pre_run(tc, EINA_TRUE, 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;
+
+   // Expected stack result:
+   // [Top] Blue -> Green -> Red [Bottom]
+
+   // Lower Blue
+   e_test_runner_req_win_stack_set(tc->runner, tw_blue, NULL, EINA_FALSE);
+   e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_STACK_RAISE);
+
+   // 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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+
+Eina_Bool
+tc_0171_multi_all_full_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_multi_wins_pre_run(tc, EINA_TRUE, EINA_FALSE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;
@@ -947,7 +1740,7 @@ tc_0180_multi_2wins_show1(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_FALSE);
+   res = _tc_multi_wins_pre_run(tc, EINA_FALSE, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;
@@ -1017,7 +1810,7 @@ tc_0181_multi_2wins_show2(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_FALSE);
+   res = _tc_multi_wins_pre_run(tc, EINA_FALSE, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_green = tc->data->tw_green;
@@ -1087,7 +1880,216 @@ tc_0182_multi_2wins_show3(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_multi_wins_pre_run(tc, EINA_FALSE);
+   res = _tc_multi_wins_pre_run(tc, EINA_FALSE, EINA_TRUE);
+   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
+   e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON);
+
+   // 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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+Eina_Bool
+tc_0183_multi_full_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_multi_wins_pre_run(tc, EINA_FALSE, 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
+   e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON);
+
+   // 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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+
+Eina_Bool
+tc_0184_multi_full_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_multi_wins_pre_run(tc, EINA_FALSE, 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
+   e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON);
+
+   // 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_multi_wins_post_run(tc);
+   _tc_multi_wins_shutdown(tc);
+   E_FREE_LIST(list, e_tc_win_del);
+
+   return tc->passed;
+}
+
+
+Eina_Bool
+tc_0185_multi_full_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_multi_wins_pre_run(tc, EINA_FALSE, EINA_FALSE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
 
    tw_red = tc->data->tw_red;

diff --git a/src/0300_notification.c b/src/0300_notification.c
index a201d27b1ee10b50126cd207e73ae89a2ed5b225..64bda5f2776e28ad905cd6f4b8eede4405ca474b 100644 (file)
--- a/src/0300_notification.c
+++ b/src/0300_notification.c
@@ -38,7 +38,7 @@ _tc_post_run(E_TC *tc)
 }
 
 static Eina_Bool
-_tc_pre_run(E_TC *tc)
+_tc_pre_run(E_TC *tc, Eina_Bool usegeom)
 {
    Eina_Bool res;
    E_TC_Data *data = NULL;
@@ -49,19 +49,19 @@ _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, EINA_TRUE,
+                                  0, 0, TW_W, TW_H, usegeom,
                                   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, EINA_TRUE,
+                                 0, 0, TW_W, TW_H, usegeom,
                                  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, EINA_TRUE,
+                                 0, 0, TW_W, TW_H, usegeom,
                                  200, E_TC_WIN_COLOR_BLUE);
    EINA_SAFETY_ON_NULL_GOTO(data->tw_noti2, cleanup);
 
@@ -161,7 +161,7 @@ tc_0300_notification_level_default(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_pre_run(tc);
+   res = _tc_pre_run(tc, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
    data = tc->data;
 
@@ -189,7 +189,7 @@ tc_0301_notification_level_medium(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_pre_run(tc);
+   res = _tc_pre_run(tc, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
    data = tc->data;
 
@@ -217,7 +217,7 @@ tc_0302_notification_level_top(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_pre_run(tc);
+   res = _tc_pre_run(tc, EINA_TRUE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
    data = tc->data;
 
@@ -245,7 +245,125 @@ tc_0303_notification_level_change(E_TC *tc)
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
 
-   res = _tc_pre_run(tc);
+   res = _tc_pre_run(tc, EINA_TRUE);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+   data = tc->data;
+
+   res = _tc_noti_level_set(data->tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   res = _tc_noti_level_set(data->tw_noti2, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   res = _tc_check_stack(tc, data->tw_normal, data->tw_noti2, data->tw_noti1);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   res = _tc_noti_level_set(data->tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   res = _tc_check_stack(tc, data->tw_normal, data->tw_noti1, data->tw_noti2);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+cleanup:
+   _tc_post_run(tc);
+   _tc_shutdown(tc);
+
+   return res;
+}
+
+Eina_Bool
+tc_0304_notification_fullsize_level_default(E_TC *tc)
+{
+   Eina_Bool res = EINA_FALSE;
+   E_TC_Data *data;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
+
+   res = _tc_pre_run(tc, EINA_FALSE);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+   data = tc->data;
+
+   res = _tc_noti_level_set(data->tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   res = _tc_noti_level_check(data->tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   res = _tc_check_stack(tc, data->tw_normal, data->tw_noti2, data->tw_noti1);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+cleanup:
+   _tc_post_run(tc);
+   _tc_shutdown(tc);
+
+   return res;
+}
+
+Eina_Bool
+tc_0305_notification_fullsize_level_medium(E_TC *tc)
+{
+   Eina_Bool res = EINA_FALSE;
+   E_TC_Data *data;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
+
+   res = _tc_pre_run(tc, EINA_FALSE);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+   data = tc->data;
+
+   res = _tc_noti_level_set(data->tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   res = _tc_noti_level_check(data->tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   res = _tc_check_stack(tc, data->tw_normal, data->tw_noti2, data->tw_noti1);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+cleanup:
+   _tc_post_run(tc);
+   _tc_shutdown(tc);
+
+   return res;
+}
+
+Eina_Bool
+tc_0306_notification_fullsize_level_top(E_TC *tc)
+{
+   Eina_Bool res = EINA_FALSE;
+   E_TC_Data *data;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
+
+   res = _tc_pre_run(tc, EINA_FALSE);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+   data = tc->data;
+
+   res = _tc_noti_level_set(data->tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   res = _tc_noti_level_check(data->tw_noti1, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+   res = _tc_check_stack(tc, data->tw_normal, data->tw_noti2, data->tw_noti1);
+   EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
+
+cleanup:
+   _tc_post_run(tc);
+   _tc_shutdown(tc);
+
+   return res;
+}
+
+Eina_Bool
+tc_0307_notification_fullsize_level_change(E_TC *tc)
+{
+   Eina_Bool res = EINA_FALSE;
+   E_TC_Data *data;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
+
+   res = _tc_pre_run(tc, EINA_FALSE);
    EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
    data = tc->data;
 

diff --git a/src/e_test_runner.c b/src/e_test_runner.c
index 2b5747840d8f9eec71d87753ea23304e401cd405..899ea50dd689d00a8c75048b9bf575ce2293a3d0 100644 (file)
--- a/src/e_test_runner.c
+++ b/src/e_test_runner.c
@@ -1009,10 +1009,26 @@ _e_test_runner_init(E_Test_Runner *runner,
    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( 161, "Multi full window: Basic",          T_FUNC( 161, multi_all_full_wins_basic        ), 1);
+   TC_ADD( 162, "Multi full window: 3 Show1",        T_FUNC( 162, multi_all_full_wins_show1        ), 1);
+   TC_ADD( 163, "Multi full window: 3 Show2",        T_FUNC( 163, multi_all_full_wins_show2        ), 1);
+   TC_ADD( 164, "Multi full window: 3 Show3",        T_FUNC( 164, multi_all_full_wins_show3        ), 1);
+   TC_ADD( 165, "Multi full window: 3 Raise1",       T_FUNC( 165, multi_all_full_wins_raise1       ), 1);
+   TC_ADD( 166, "Multi full window: 3 Raise2",       T_FUNC( 166, multi_all_full_wins_raise2       ), 1);
+   TC_ADD( 167, "Multi full window: 3 Stack Above1", T_FUNC( 167, multi_all_full_wins_stack_above1 ), 1);
+   TC_ADD( 168, "Multi full window: 3 Stack Above2", T_FUNC( 168, multi_all_full_wins_stack_above2 ), 1);
+   TC_ADD( 169, "Multi full window: 3 Stack Above3", T_FUNC( 169, multi_all_full_wins_stack_above3 ), 1);
+   TC_ADD( 170, "Multi full window: 3 Lower1",       T_FUNC( 170, multi_all_full_wins_lower1       ), 1);
+   TC_ADD( 171, "Multi full window: 3 Lower2",       T_FUNC( 171, multi_all_full_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);
 
+   TC_ADD( 183, "Multi full window: 2 Show1",   T_FUNC( 183, multi_full_2wins_show1 ), 1);
+   TC_ADD( 184, "Multi full window: 2 Show2",   T_FUNC( 184, multi_full_2wins_show2 ), 1);
+   TC_ADD( 185, "Multi full window: 2 Show3",   T_FUNC( 185, multi_full_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);
@@ -1026,6 +1042,11 @@ _e_test_runner_init(E_Test_Runner *runner,
    TC_ADD( 302, "Noti Level top",               T_FUNC( 302, notification_level_top    ), 1);
    TC_ADD( 303, "Noti Level Change",            T_FUNC( 303, notification_level_change ), 1);
 
+   TC_ADD( 304, "Fullsize Noti Level default",  T_FUNC( 304, notification_fullsize_level_default), 1);
+   TC_ADD( 305, "Fullsize Noti Level medium",   T_FUNC( 305, notification_fullsize_level_medium ), 1);
+   TC_ADD( 306, "Fullsize Noti Level top",      T_FUNC( 306, notification_fullsize_level_top    ), 1);
+   TC_ADD( 307, "Fullsize Noti Level Change",   T_FUNC( 307, notification_fullsize_level_change ), 1);
+
    /* [0400 - 0499] tizen-ws-shell */
    TC_ADD( 400, "Screensaver: Basic",           T_FUNC( 400, scrsaver_basic            ), 1);
    TC_ADD( 401, "Screensaver Manager: Basic",   T_FUNC( 401, scrsaver_mng_basic        ), 1);

diff --git a/src/e_test_runner.h b/src/e_test_runner.h
index 796b79dad5fcc4bd0dd5c1756c925edfe87f0ef5..f021071a9b018076228114012664ada2b669f532 100644 (file)
--- a/src/e_test_runner.h
+++ b/src/e_test_runner.h
@@ -251,10 +251,26 @@ 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_0161_multi_all_full_wins_basic(E_TC *tc);
+Eina_Bool  tc_0162_multi_all_full_wins_show1(E_TC *tc);
+Eina_Bool  tc_0163_multi_all_full_wins_show2(E_TC *tc);
+Eina_Bool  tc_0164_multi_all_full_wins_show3(E_TC *tc);
+Eina_Bool  tc_0165_multi_all_full_wins_raise1(E_TC *tc);
+Eina_Bool  tc_0166_multi_all_full_wins_raise2(E_TC *tc);
+Eina_Bool  tc_0167_multi_all_full_wins_stack_above1(E_TC *tc);
+Eina_Bool  tc_0168_multi_all_full_wins_stack_above2(E_TC *tc);
+Eina_Bool  tc_0169_multi_all_full_wins_stack_above3(E_TC *tc);
+Eina_Bool  tc_0170_multi_all_full_wins_lower1(E_TC *tc);
+Eina_Bool  tc_0171_multi_all_full_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_0183_multi_full_2wins_show1(E_TC *tc);
+Eina_Bool  tc_0184_multi_full_2wins_show2(E_TC *tc);
+Eina_Bool  tc_0185_multi_full_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);
@@ -266,6 +282,10 @@ Eina_Bool  tc_0300_notification_level_default(E_TC *tc);
 Eina_Bool  tc_0301_notification_level_medium(E_TC *tc);
 Eina_Bool  tc_0302_notification_level_top(E_TC *tc);
 Eina_Bool  tc_0303_notification_level_change(E_TC *tc);
+Eina_Bool  tc_0304_notification_fullsize_level_default(E_TC *tc);
+Eina_Bool  tc_0305_notification_fullsize_level_medium(E_TC *tc);
+Eina_Bool  tc_0306_notification_fullsize_level_top(E_TC *tc);
+Eina_Bool  tc_0307_notification_fullsize_level_change(E_TC *tc);
 
 Eina_Bool  tc_0400_scrsaver_basic(E_TC *tc);
 Eina_Bool  tc_0401_scrsaver_mng_basic(E_TC *tc);