src/testcase/0014_transient_for_below.cpp

   1 #include "e_test_event.h"
   2 #include "e_test_base.h"
   3
   4 class etTestTransientForBelow : public ::etTCBase
   5 {
   6  public:
   7     etTestTransientForBelow() { };
   8     ~etTestTransientForBelow() { };
   9
  10  protected:
  11     etWin *tw_parent = NULL;
  12     etWin *tw_base = NULL;
  13     std::string testCaseName;
  14     std::string testName;
  15
  16     void initTC(Eina_Bool show_win, Eina_Bool partial = EINA_TRUE);
  17     void makeTransientBelowChild(etWin **win, etWin *parent, int x, int y, int w, int h, E_TC_Win_Color color, const char *name, Eina_Bool partial = EINA_TRUE);
  18 };
  19
  20 void
  21 etTestTransientForBelow::initTC(Eina_Bool show_win, Eina_Bool partial)
  22 {
  23    const ::testing::TestInfo *const test_info = ::testing::UnitTest::GetInstance()->current_test_info();
  24
  25    if (partial)
  26      tw_base = initNormalWin("TCWin_Normal_normal", 0, 0, 480, 800, E_TC_WIN_COLOR_BLACK);
  27    else
  28      tw_base = initNormalWin("TCWin_Normal_normal", EINA_FALSE, E_TC_WIN_COLOR_BLACK);
  29    if (show_win)
  30      {
  31         showTCWin(tw_base);
  32         ASSERT_VIS_ON(tw_base);
  33      }
  34    ASSERT_TRUE(tw_base != NULL) << "failed to initiation window";
  35
  36    if (partial)
  37      tw_parent = initNormalWin("TCWin_Normal_parent", 50, 50, 300, 300, E_TC_WIN_COLOR_RED);
  38    else
  39      tw_parent = initNormalWin("TCWin_Normal_parent", EINA_FALSE, E_TC_WIN_COLOR_RED);
  40    if (show_win)
  41      {
  42         showTCWin(tw_parent);
  43         ASSERT_VIS_ON(tw_parent);
  44      }
  45    ASSERT_TRUE(tw_parent != NULL) << "failed to initiation window";
  46
  47    testCaseName = test_info->test_case_name();
  48    testName = test_info->name();
  49 }
  50
  51 void
  52 etTestTransientForBelow::makeTransientBelowChild(etWin **win, etWin *parent, int x, int y, int w, int h, E_TC_Win_Color color, const char *name, Eina_Bool partial)
  53 {
  54    Eina_Bool res;
  55    etWin *temp_win = NULL;
  56
  57    if (partial)
  58      temp_win = initNormalWin(name, x, y, w, h, color);
  59    else
  60      temp_win = initNormalWin(name, EINA_FALSE, color);
  61    ASSERT_TRUE(temp_win != NULL) << "failed to create window";
  62
  63    res = etRunner::get().setWinTransientForBelow(temp_win, parent, EINA_TRUE);
  64    ASSERT_TRUE(res);
  65    etRunner::get().work(0.1); // wait for activate done. It does not change stack.
  66
  67    showTCWin(temp_win);
  68    if (partial)
  69      ASSERT_VIS_ON(temp_win);
  70
  71    *win = temp_win;
  72 }
  73
  74 TEST_F(etTestTransientForBelow, transient_for_below_basic)
  75 {
  76    etWin *tw = NULL;
  77    etWin *tw_child = NULL;
  78    Eina_List *list = NULL, *l = NULL;
  79    int pass_count = 0;
  80
  81    // init TC window, show=true, geom=true
  82    initTC(EINA_TRUE);
  83
  84    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
  85
  86    // Expected stack res:
  87    // [Top] tw_parent -> tw_child -> tw_base [Bottom]
  88    list = etRunner::get().getWinInfoList();
  89    ASSERT_TRUE(list != NULL);
  90
  91    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
  92      {
  93         if (tw->layer > 200) continue;
  94
  95         if (pass_count == 0)
  96           {
  97              ASSERT_EQ(tw->native_win, tw_parent->native_win);
  98              pass_count++;
  99              continue;
 100           }
 101         else if (pass_count == 1)
 102           {
 103              ASSERT_EQ(tw->native_win, tw_child->native_win);
 104              pass_count++;
 105              continue;
 106           }
 107         else
 108           {
 109              ASSERT_EQ(tw->native_win, tw_base->native_win);
 110              pass_count++;
 111           }
 112
 113         break;
 114      }
 115    etRunner::get().freeWinInfoList(list);
 116
 117    ASSERT_EQ(3, pass_count);
 118    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 119 }
 120
 121 TEST_F(etTestTransientForBelow, transient_for_below_unset)
 122 {
 123    etWin *tw = NULL;
 124    etWin *tw_child = NULL;
 125    Eina_List *list = NULL, *l = NULL;
 126    int pass_count = 0;
 127
 128    // init TC window, show=true, geom=true
 129    initTC(EINA_TRUE);
 130
 131    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
 132
 133    // unset tansient_for below - using tizen_policy_set_transient_for_below(child, NULL);
 134    Eina_Bool res = etRunner::get().setWinTransientForBelow(tw_child, tw_parent, EINA_FALSE);
 135    ASSERT_TRUE(res);
 136
 137    // Expected stack res:
 138    // [Top] tw_parent -> tw_child -> tw_base [Bottom]
 139    list = etRunner::get().getWinInfoList();
 140    ASSERT_TRUE(list != NULL);
 141
 142    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 143      {
 144         if (tw->layer > 200) continue;
 145
 146         if (pass_count == 0)
 147           {
 148              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 149              pass_count++;
 150              continue;
 151           }
 152         else if (pass_count == 1)
 153           {
 154              ASSERT_EQ(tw->native_win, tw_child->native_win);
 155              pass_count++;
 156              continue;
 157           }
 158         else
 159           {
 160              ASSERT_EQ(tw->native_win, tw_base->native_win);
 161              pass_count++;
 162           }
 163
 164         break;
 165      }
 166    etRunner::get().freeWinInfoList(list);
 167    ASSERT_EQ(3, pass_count);
 168
 169
 170    // Raise tw_child
 171    etRunner::get().setWinStack(tw_child, NULL, EINA_TRUE);
 172    ASSERT_EVENT(tw_child, E_TC_EVENT_TYPE_STACK_RAISE);
 173
 174    // Expected stack res:
 175    // [Top] tw_child -> tw_parent -> tw_base [Bottom]
 176    list = etRunner::get().getWinInfoList();
 177    ASSERT_TRUE(list != NULL);
 178
 179    pass_count = 0;
 180    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 181      {
 182         if (tw->layer > 200) continue;
 183
 184         if (pass_count == 0)
 185           {
 186              ASSERT_EQ(tw->native_win, tw_child->native_win);
 187              pass_count++;
 188              continue;
 189           }
 190         else if (pass_count == 1)
 191           {
 192              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 193              pass_count++;
 194              continue;
 195           }
 196         else
 197           {
 198              ASSERT_EQ(tw->native_win, tw_base->native_win);
 199              pass_count++;
 200           }
 201
 202         break;
 203      }
 204    etRunner::get().freeWinInfoList(list);
 205
 206    ASSERT_EQ(3, pass_count);
 207    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 208 }
 209
 210 TEST_F(etTestTransientForBelow, transient_for_below_unset2)
 211 {
 212    etWin *tw = NULL;
 213    etWin *tw_child = NULL;
 214    Eina_List *list = NULL, *l = NULL;
 215    int pass_count = 0;
 216
 217    // init TC window, show=true, geom=true
 218    initTC(EINA_TRUE);
 219
 220    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
 221
 222    // unset tansient_for below - using tizen_policy_unset_transient_for
 223    Eina_Bool res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_FALSE);
 224    ASSERT_TRUE(res);
 225
 226    // Expected stack res:
 227    // [Top] tw_parent -> tw_child -> tw_base [Bottom]
 228    list = etRunner::get().getWinInfoList();
 229    ASSERT_TRUE(list != NULL);
 230
 231    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 232      {
 233         if (tw->layer > 200) continue;
 234
 235         if (pass_count == 0)
 236           {
 237              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 238              pass_count++;
 239              continue;
 240           }
 241         else if (pass_count == 1)
 242           {
 243              ASSERT_EQ(tw->native_win, tw_child->native_win);
 244              pass_count++;
 245              continue;
 246           }
 247         else
 248           {
 249              ASSERT_EQ(tw->native_win, tw_base->native_win);
 250              pass_count++;
 251           }
 252
 253         break;
 254      }
 255    etRunner::get().freeWinInfoList(list);
 256    ASSERT_EQ(3, pass_count);
 257
 258
 259    // Raise tw_child
 260    etRunner::get().setWinStack(tw_child, NULL, EINA_TRUE);
 261    ASSERT_EVENT(tw_child, E_TC_EVENT_TYPE_STACK_RAISE);
 262
 263    // Expected stack res:
 264    // [Top] tw_child -> tw_parent -> tw_base [Bottom]
 265    list = etRunner::get().getWinInfoList();
 266    ASSERT_TRUE(list != NULL);
 267
 268    pass_count = 0;
 269    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 270      {
 271         if (tw->layer > 200) continue;
 272
 273         if (pass_count == 0)
 274           {
 275              ASSERT_EQ(tw->native_win, tw_child->native_win);
 276              pass_count++;
 277              continue;
 278           }
 279         else if (pass_count == 1)
 280           {
 281              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 282              pass_count++;
 283              continue;
 284           }
 285         else
 286           {
 287              ASSERT_EQ(tw->native_win, tw_base->native_win);
 288              pass_count++;
 289           }
 290
 291         break;
 292      }
 293    etRunner::get().freeWinInfoList(list);
 294
 295    ASSERT_EQ(3, pass_count);
 296    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 297 }
 298
 299 TEST_F(etTestTransientForBelow, transient_for_below_basic2)
 300 {
 301    etWin *tw = NULL;
 302    etWin *tw_child = NULL;
 303    etWin *tw_child2 = NULL;
 304    Eina_List *list = NULL, *l = NULL;
 305    int pass_count = 0;
 306
 307    // init TC window, show=true, geom=true
 308    initTC(EINA_TRUE);
 309
 310    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
 311    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2");
 312
 313    // Expected stack res:
 314    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_base [Bottom]
 315    list = etRunner::get().getWinInfoList();
 316    ASSERT_TRUE(list != NULL);
 317
 318    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 319      {
 320         if (tw->layer > 200) continue;
 321
 322         if (pass_count == 0)
 323           {
 324              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 325              pass_count++;
 326              continue;
 327           }
 328         else if (pass_count == 1)
 329           {
 330              ASSERT_EQ(tw->native_win, tw_child->native_win);
 331              pass_count++;
 332              continue;
 333           }
 334         else if (pass_count == 2)
 335           {
 336              ASSERT_EQ(tw->native_win, tw_child2->native_win);
 337              pass_count++;
 338              continue;
 339           }
 340         else
 341           {
 342              ASSERT_EQ(tw->native_win, tw_base->native_win);
 343              pass_count++;
 344           }
 345
 346         break;
 347      }
 348    etRunner::get().freeWinInfoList(list);
 349
 350    ASSERT_EQ(4, pass_count);
 351    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 352 }
 353
 354 TEST_F(etTestTransientForBelow, transient_for_below_raise)
 355 {
 356    etWin *tw = NULL;
 357    etWin *tw_child = NULL;
 358    etWin *tw_child2 = NULL;
 359    Eina_List *list = NULL, *l = NULL;
 360    int pass_count = 0;
 361
 362    // init TC window, show=true, geom=true
 363    initTC(EINA_TRUE);
 364
 365    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
 366    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2");
 367
 368    // Expected stack res:
 369    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_base [Bottom]
 370
 371    // Raise tw_child2
 372    etRunner::get().setWinStack(tw_child2, NULL, EINA_TRUE);
 373    ASSERT_EVENT(tw_child2, E_TC_EVENT_TYPE_STACK_RAISE);
 374
 375    // Expected stack res:
 376    // [Top] tw_parent -> tw_child2 -> tw_child -> tw_base [Bottom]
 377    list = etRunner::get().getWinInfoList();
 378    ASSERT_TRUE(list != NULL);
 379
 380    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 381      {
 382         if (tw->layer > 200) continue;
 383
 384         if (pass_count == 0)
 385           {
 386              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 387              pass_count++;
 388              continue;
 389           }
 390         else if (pass_count == 1)
 391           {
 392              ASSERT_EQ(tw->native_win, tw_child2->native_win);
 393              pass_count++;
 394              continue;
 395           }
 396         else if (pass_count == 2)
 397           {
 398              ASSERT_EQ(tw->native_win, tw_child->native_win);
 399              pass_count++;
 400              continue;
 401           }
 402         else
 403           {
 404              ASSERT_EQ(tw->native_win, tw_base->native_win);
 405              pass_count++;
 406           }
 407
 408         break;
 409      }
 410    etRunner::get().freeWinInfoList(list);
 411
 412    ASSERT_EQ(4, pass_count);
 413    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 414 }
 415
 416 TEST_F(etTestTransientForBelow, transient_for_below_lower)
 417 {
 418    etWin *tw = NULL;
 419    etWin *tw_child = NULL;
 420    etWin *tw_child2 = NULL;
 421    Eina_List *list = NULL, *l = NULL;
 422    int pass_count = 0;
 423
 424    // init TC window, show=true, geom=true
 425    initTC(EINA_TRUE);
 426
 427    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
 428    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2");
 429
 430    // Expected stack res:
 431    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_base [Bottom]
 432
 433    // Lower tw_child2
 434    etRunner::get().setWinStack(tw_child2, NULL, EINA_FALSE);
 435
 436    // Expected stack res:
 437    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_base [Bottom]
 438    list = etRunner::get().getWinInfoList();
 439    ASSERT_TRUE(list != NULL);
 440
 441    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 442      {
 443         if (tw->layer > 200) continue;
 444
 445         if (pass_count == 0)
 446           {
 447              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 448              pass_count++;
 449              continue;
 450           }
 451         else if (pass_count == 1)
 452           {
 453              ASSERT_EQ(tw->native_win, tw_child->native_win);
 454              pass_count++;
 455              continue;
 456           }
 457         else if (pass_count == 2)
 458           {
 459              ASSERT_EQ(tw->native_win, tw_child2->native_win);
 460              pass_count++;
 461              continue;
 462           }
 463         else
 464           {
 465              ASSERT_EQ(tw->native_win, tw_base->native_win);
 466              pass_count++;
 467           }
 468
 469         break;
 470      }
 471    etRunner::get().freeWinInfoList(list);
 472
 473    ASSERT_EQ(4, pass_count);
 474    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 475 }
 476
 477 TEST_F(etTestTransientForBelow, transient_for_below_lower2)
 478 {
 479    etWin *tw = NULL;
 480    etWin *tw_child = NULL;
 481    etWin *tw_child2 = NULL;
 482    Eina_List *list = NULL, *l = NULL;
 483    int pass_count = 0;
 484
 485    // init TC window, show=true, geom=true
 486    initTC(EINA_TRUE);
 487
 488    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
 489    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2");
 490
 491    // Expected stack res:
 492    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_base [Bottom]
 493
 494    // Lower tw_child
 495    etRunner::get().setWinStack(tw_child, NULL, EINA_FALSE);
 496    ASSERT_EVENT(tw_child, E_TC_EVENT_TYPE_STACK_BELOW);
 497
 498    // Expected stack res:
 499    // [Top] tw_parent -> tw_child2 -> tw_child -> tw_base [Bottom]
 500    list = etRunner::get().getWinInfoList();
 501    ASSERT_TRUE(list != NULL);
 502
 503    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 504      {
 505         if (tw->layer > 200) continue;
 506
 507         if (pass_count == 0)
 508           {
 509              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 510              pass_count++;
 511              continue;
 512           }
 513         else if (pass_count == 1)
 514           {
 515              ASSERT_EQ(tw->native_win, tw_child2->native_win);
 516              pass_count++;
 517              continue;
 518           }
 519         else if (pass_count == 2)
 520           {
 521              ASSERT_EQ(tw->native_win, tw_child->native_win);
 522              pass_count++;
 523              continue;
 524           }
 525         else
 526           {
 527              ASSERT_EQ(tw->native_win, tw_base->native_win);
 528              pass_count++;
 529           }
 530
 531         break;
 532      }
 533    etRunner::get().freeWinInfoList(list);
 534
 535    ASSERT_EQ(4, pass_count);
 536    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 537 }
 538
 539 TEST_F(etTestTransientForBelow, transient_for_below_parent_change_alpha)
 540 {
 541    etWin *tw = NULL;
 542    etWin *tw_child = NULL;
 543    etWin *tw_child2 = NULL;
 544    Eina_List *list = NULL, *l = NULL;
 545    int pass_count = 0;
 546
 547    // init TC window, show=true, geom=false
 548    initTC(EINA_TRUE, EINA_FALSE);
 549
 550    // make below child : user_geo=false
 551    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child", EINA_FALSE);
 552    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2", EINA_FALSE);
 553
 554    // Expected stack res:
 555    // [Top] tw_parent -> tw_child (iconified) -> tw_child2 (iconified) -> tw_base [Bottom]
 556    list = etRunner::get().getWinInfoList();
 557    ASSERT_TRUE(list != NULL);
 558
 559    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 560      {
 561         if (tw->layer > 200) continue;
 562
 563         if (pass_count == 0)
 564           {
 565              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 566              ASSERT_TRUE(tw->Vis.obj);
 567              ASSERT_FALSE(tw->iconic.set);
 568              ASSERT_FALSE(tw->iconic.by_client);
 569              pass_count++;
 570              continue;
 571           }
 572         else if (pass_count == 1)
 573           {
 574              ASSERT_EQ(tw->native_win, tw_child->native_win);
 575              ASSERT_FALSE(tw->Vis.obj);
 576              ASSERT_TRUE(tw->iconic.set);
 577              ASSERT_FALSE(tw->iconic.by_client);
 578              pass_count++;
 579              continue;
 580           }
 581         else if (pass_count == 2)
 582           {
 583              ASSERT_EQ(tw->native_win, tw_child2->native_win);
 584              ASSERT_FALSE(tw->Vis.obj);
 585              ASSERT_TRUE(tw->iconic.set);
 586              ASSERT_FALSE(tw->iconic.by_client);
 587              pass_count++;
 588              continue;
 589           }
 590         else
 591           {
 592              ASSERT_EQ(tw->native_win, tw_base->native_win);
 593              pass_count++;
 594           }
 595
 596         break;
 597      }
 598    etRunner::get().freeWinInfoList(list);
 599
 600    ASSERT_EQ(4, pass_count);
 601
 602
 603    // change parent's alpha
 604    elm_win_alpha_set(tw_parent->elm_win, EINA_TRUE);
 605    etRunner::get().work(0.5);
 606
 607    // Expected stack res:
 608    // [Top] tw_parent -> tw_child (uniconified) -> tw_child2 (iconified) -> tw_base [Bottom]
 609    list = etRunner::get().getWinInfoList();
 610    ASSERT_TRUE(list != NULL);
 611
 612    pass_count = 0;
 613    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 614      {
 615         if (tw->layer > 200) continue;
 616
 617         if (pass_count == 0)
 618           {
 619              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 620              ASSERT_TRUE(tw->Vis.obj);
 621              ASSERT_FALSE(tw->iconic.set);
 622              ASSERT_FALSE(tw->iconic.by_client);
 623              pass_count++;
 624              continue;
 625           }
 626         else if (pass_count == 1)
 627           {
 628              ASSERT_EQ(tw->native_win, tw_child->native_win);
 629              ASSERT_TRUE(tw->Vis.obj);
 630              ASSERT_FALSE(tw->iconic.set);
 631              ASSERT_FALSE(tw->iconic.by_client);
 632              pass_count++;
 633              continue;
 634           }
 635         else if (pass_count == 2)
 636           {
 637              ASSERT_EQ(tw->native_win, tw_child2->native_win);
 638              ASSERT_FALSE(tw->Vis.obj);
 639              ASSERT_TRUE(tw->iconic.set);
 640              ASSERT_FALSE(tw->iconic.by_client);
 641              pass_count++;
 642              continue;
 643           }
 644         else
 645           {
 646              ASSERT_EQ(tw->native_win, tw_base->native_win);
 647              pass_count++;
 648           }
 649
 650         break;
 651      }
 652    etRunner::get().freeWinInfoList(list);
 653
 654    ASSERT_EQ(4, pass_count);
 655    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 656 }
 657
 658 TEST_F(etTestTransientForBelow, transient_for_below_parent_change_alpha2)
 659 {
 660    etWin *tw = NULL;
 661    etWin *tw_child = NULL;
 662    etWin *tw_child2 = NULL;
 663    Eina_List *list = NULL, *l = NULL;
 664    int pass_count = 0;
 665
 666    // init TC window, show=true, geom=false
 667    initTC(EINA_TRUE, EINA_FALSE);
 668
 669    // make below child : user_geo=false
 670    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child", EINA_FALSE);
 671    elm_win_alpha_set(tw_child->elm_win, EINA_TRUE);
 672    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2", EINA_FALSE);
 673
 674    // Expected stack res:
 675    // [Top] tw_parent -> tw_child (iconified) -> tw_child2 (iconified) -> tw_base [Bottom]
 676    list = etRunner::get().getWinInfoList();
 677    ASSERT_TRUE(list != NULL);
 678
 679    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 680      {
 681         if (tw->layer > 200) continue;
 682
 683         if (pass_count == 0)
 684           {
 685              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 686              ASSERT_TRUE(tw->Vis.obj);
 687              ASSERT_FALSE(tw->iconic.set);
 688              ASSERT_FALSE(tw->iconic.by_client);
 689              pass_count++;
 690              continue;
 691           }
 692         else if (pass_count == 1)
 693           {
 694              ASSERT_EQ(tw->native_win, tw_child->native_win);
 695              ASSERT_FALSE(tw->Vis.obj);
 696              ASSERT_TRUE(tw->iconic.set);
 697              ASSERT_FALSE(tw->iconic.by_client);
 698              pass_count++;
 699              continue;
 700           }
 701         else if (pass_count == 2)
 702           {
 703              ASSERT_EQ(tw->native_win, tw_child2->native_win);
 704              ASSERT_FALSE(tw->Vis.obj);
 705              ASSERT_TRUE(tw->iconic.set);
 706              ASSERT_FALSE(tw->iconic.by_client);
 707              pass_count++;
 708              continue;
 709           }
 710         else
 711           {
 712              ASSERT_EQ(tw->native_win, tw_base->native_win);
 713              pass_count++;
 714           }
 715
 716         break;
 717      }
 718    etRunner::get().freeWinInfoList(list);
 719
 720    ASSERT_EQ(4, pass_count);
 721
 722
 723    // change parent's alpha
 724    elm_win_alpha_set(tw_parent->elm_win, EINA_TRUE);
 725    etRunner::get().work(0.5);
 726
 727    // Expected stack res:
 728    // [Top] tw_parent -> tw_child (uniconified) -> tw_child2 (iconified) -> tw_base [Bottom]
 729    list = etRunner::get().getWinInfoList();
 730    ASSERT_TRUE(list != NULL);
 731
 732    pass_count = 0;
 733    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 734      {
 735         if (tw->layer > 200) continue;
 736
 737         if (pass_count == 0)
 738           {
 739              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 740              ASSERT_TRUE(tw->Vis.obj);
 741              ASSERT_FALSE(tw->iconic.set);
 742              ASSERT_FALSE(tw->iconic.by_client);
 743              pass_count++;
 744              continue;
 745           }
 746         else if (pass_count == 1)
 747           {
 748              ASSERT_EQ(tw->native_win, tw_child->native_win);
 749              ASSERT_TRUE(tw->Vis.obj);
 750              ASSERT_FALSE(tw->iconic.set);
 751              ASSERT_FALSE(tw->iconic.by_client);
 752              pass_count++;
 753              continue;
 754           }
 755         else if (pass_count == 2)
 756           {
 757              ASSERT_EQ(tw->native_win, tw_child2->native_win);
 758              ASSERT_TRUE(tw->Vis.obj);
 759              ASSERT_FALSE(tw->iconic.set);
 760              ASSERT_FALSE(tw->iconic.by_client);
 761              pass_count++;
 762              continue;
 763           }
 764         else
 765           {
 766              ASSERT_EQ(tw->native_win, tw_base->native_win);
 767              pass_count++;
 768           }
 769
 770         break;
 771      }
 772    etRunner::get().freeWinInfoList(list);
 773
 774    ASSERT_EQ(4, pass_count);
 775    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 776 }
 777
 778 TEST_F(etTestTransientForBelow, transient_for_below_parent_lower)
 779 {
 780    etWin *tw = NULL;
 781    etWin *tw_child = NULL;
 782    etWin *tw_child2 = NULL;
 783    etWin *tw_above = NULL;
 784    Eina_List *list = NULL, *l = NULL;
 785    int pass_count = 0;
 786
 787    // init TC window, show=true, geom=true
 788    initTC(EINA_TRUE);
 789
 790    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
 791    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2");
 792
 793    // Expected stack res:
 794    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_base [Bottom]
 795
 796
 797    //////////////////////////////////////////////////
 798    // Lower tw_parent
 799    //////////////////////////////////////////////////
 800    etRunner::get().setWinStack(tw_parent, NULL, EINA_FALSE);
 801    ASSERT_EVENT(tw_parent, E_TC_EVENT_TYPE_STACK_LOWER);
 802
 803    list = etRunner::get().getWinInfoList();
 804    ASSERT_TRUE(list != NULL);
 805
 806    // Expected stack res:
 807    // [Top] tw_base -> ... -> tw_parent -> tw_child -> tw_child2 [Bottom]
 808
 809    // In this case,
 810    // To check validation of stack order, we have to check the stack from bottom to top
 811    // [Bottom] tw_child2 <- tw_child <- tw_parent <- ...  <- tw_base [Top]
 812
 813    EINA_LIST_CAST_REVERSE_FOREACH(list, l, tw, etWin*)
 814      {
 815         if (tw->layer < 200) continue;
 816
 817         if (pass_count == 0)
 818           {
 819              ASSERT_EQ(tw->native_win, tw_child2->native_win);
 820              pass_count++;
 821              continue;
 822           }
 823         else if (pass_count == 1)
 824           {
 825              ASSERT_EQ(tw->native_win, tw_child->native_win);
 826              pass_count++;
 827              continue;
 828           }
 829         else if (pass_count == 2)
 830           {
 831              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 832              pass_count++;
 833              continue;
 834           }
 835         else
 836           {
 837              if (tw->layer > 200)
 838                {
 839                   ASSERT_EQ(tw_above->native_win, tw_base->native_win);
 840                   pass_count++;
 841                   break;
 842                }
 843              else
 844                tw_above = tw;
 845           }
 846      }
 847    etRunner::get().freeWinInfoList(list);
 848
 849    ASSERT_EQ(4, pass_count);
 850    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 851 }
 852
 853 TEST_F(etTestTransientForBelow, transient_for_below_multi_parent)
 854 {
 855    etWin *tw = NULL;
 856    etWin *tw_child = NULL;
 857    etWin *tw_child2 = NULL;
 858    etWin *tw_child3 = NULL;
 859
 860    etWin *tw_parent2 = NULL;
 861    etWin *tw_parent2_child = NULL;
 862    etWin *tw_parent2_child2 = NULL;
 863    Eina_List *list = NULL, *l = NULL;
 864    int pass_count = 0;
 865
 866    // init TC window, show=true, geom=true
 867    initTC(EINA_TRUE);
 868
 869    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
 870    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2");
 871    makeTransientBelowChild(&tw_child3, tw_parent, 130, 130, 300, 300, E_TC_WIN_COLOR_YELLOW, "TCWin_Normal_child3");
 872
 873    // Expected stack res:
 874    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base [Bottom]
 875
 876    tw_parent2 = initNormalWin("TCWin_Normal_parent2", 0, 300, 400, 400, E_TC_WIN_COLOR_ORANGE);
 877    ASSERT_TRUE(tw_parent2 != NULL) << "failed to initiation window";
 878    showTCWin(tw_parent2);
 879    ASSERT_VIS_ON(tw_parent2);
 880
 881    makeTransientBelowChild(&tw_parent2_child, tw_parent2, 20, 320, 400, 400, E_TC_WIN_COLOR_CYAN, "TCWin_Normal_child");
 882    makeTransientBelowChild(&tw_parent2_child2, tw_parent2, 40, 340, 400, 400, E_TC_WIN_COLOR_INDIGO, "TCWin_Normal_child2");
 883
 884    // Expected stack res:
 885    // [Top] tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base [Bottom]
 886
 887    list = etRunner::get().getWinInfoList();
 888    ASSERT_TRUE(list != NULL);
 889
 890    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 891      {
 892         if (tw->layer > 200) continue;
 893
 894         if (pass_count == 0)
 895           {
 896              ASSERT_EQ(tw->native_win, tw_parent2->native_win);
 897              pass_count++;
 898              continue;
 899           }
 900         else if (pass_count == 1)
 901           {
 902              ASSERT_EQ(tw->native_win, tw_parent2_child->native_win);
 903              pass_count++;
 904              continue;
 905           }
 906         else if (pass_count == 2)
 907           {
 908              ASSERT_EQ(tw->native_win, tw_parent2_child2->native_win);
 909              pass_count++;
 910              continue;
 911           }
 912         else if (pass_count == 3)
 913           {
 914              ASSERT_EQ(tw->native_win, tw_parent->native_win);
 915              pass_count++;
 916              continue;
 917           }
 918         else if (pass_count == 4)
 919           {
 920              ASSERT_EQ(tw->native_win, tw_child->native_win);
 921              pass_count++;
 922              continue;
 923           }
 924         else if (pass_count == 5)
 925           {
 926              ASSERT_EQ(tw->native_win, tw_child2->native_win);
 927              pass_count++;
 928              continue;
 929           }
 930         else if (pass_count == 6)
 931           {
 932              ASSERT_EQ(tw->native_win, tw_child3->native_win);
 933              pass_count++;
 934              continue;
 935           }
 936         else
 937           {
 938              ASSERT_EQ(tw->native_win, tw_base->native_win);
 939              pass_count++;
 940           }
 941
 942         break;
 943      }
 944    etRunner::get().freeWinInfoList(list);
 945
 946    ASSERT_EQ(8, pass_count);
 947    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 948 }
 949
 950 TEST_F(etTestTransientForBelow, transient_for_below_multi_parent_raise_parent)
 951 {
 952    etWin *tw = NULL;
 953    etWin *tw_child = NULL;
 954    etWin *tw_child2 = NULL;
 955    etWin *tw_child3 = NULL;
 956
 957    etWin *tw_parent2 = NULL;
 958    etWin *tw_parent2_child = NULL;
 959    etWin *tw_parent2_child2 = NULL;
 960    Eina_List *list = NULL, *l = NULL;
 961    int pass_count = 0;
 962
 963    // init TC window, show=true, geom=true
 964    initTC(EINA_TRUE);
 965
 966    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
 967    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2");
 968    makeTransientBelowChild(&tw_child3, tw_parent, 130, 130, 300, 300, E_TC_WIN_COLOR_YELLOW, "TCWin_Normal_child3");
 969
 970    // Expected stack res:
 971    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base [Bottom]
 972
 973
 974    tw_parent2 = initNormalWin("TCWin_Normal_parent2", 0, 300, 400, 400, E_TC_WIN_COLOR_ORANGE);
 975    ASSERT_TRUE(tw_parent2 != NULL) << "failed to initiation window";
 976    showTCWin(tw_parent2);
 977    ASSERT_VIS_ON(tw_parent2);
 978
 979    makeTransientBelowChild(&tw_parent2_child, tw_parent2, 20, 320, 400, 400, E_TC_WIN_COLOR_CYAN, "TCWin_Normal_child");
 980    makeTransientBelowChild(&tw_parent2_child2, tw_parent2, 40, 340, 400, 400, E_TC_WIN_COLOR_INDIGO, "TCWin_Normal_child2");
 981
 982    // Expected stack res:
 983    // [Top] tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base [Bottom]
 984
 985
 986    //////////////////////////////////////////////////
 987    // Raise tw_parent
 988    //////////////////////////////////////////////////
 989    etRunner::get().setWinStack(tw_parent, NULL, EINA_TRUE);
 990    ASSERT_EVENT(tw_parent, E_TC_EVENT_TYPE_STACK_RAISE);
 991
 992    // Expected stack res:
 993    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_base [Bottom]
 994
 995    list = etRunner::get().getWinInfoList();
 996    ASSERT_TRUE(list != NULL);
 997
 998    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 999      {
1000         if (tw->layer > 200) continue;
1001
1002         if (pass_count == 0)
1003           {
1004              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1005              pass_count++;
1006              continue;
1007           }
1008         else if (pass_count == 1)
1009           {
1010              ASSERT_EQ(tw->native_win, tw_child->native_win);
1011              pass_count++;
1012              continue;
1013           }
1014         else if (pass_count == 2)
1015           {
1016              ASSERT_EQ(tw->native_win, tw_child2->native_win);
1017              pass_count++;
1018              continue;
1019           }
1020         else if (pass_count == 3)
1021           {
1022              ASSERT_EQ(tw->native_win, tw_child3->native_win);
1023              pass_count++;
1024              continue;
1025           }
1026         else if (pass_count == 4)
1027           {
1028              ASSERT_EQ(tw->native_win, tw_parent2->native_win);
1029              pass_count++;
1030              continue;
1031           }
1032         else if (pass_count == 5)
1033           {
1034              ASSERT_EQ(tw->native_win, tw_parent2_child->native_win);
1035              pass_count++;
1036              continue;
1037           }
1038         else if (pass_count == 6)
1039           {
1040              ASSERT_EQ(tw->native_win, tw_parent2_child2->native_win);
1041              pass_count++;
1042              continue;
1043           }
1044         else
1045           {
1046              ASSERT_EQ(tw->native_win, tw_base->native_win);
1047              pass_count++;
1048           }
1049
1050         break;
1051      }
1052    etRunner::get().freeWinInfoList(list);
1053
1054    ASSERT_EQ(8, pass_count);
1055    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1056 }
1057
1058 TEST_F(etTestTransientForBelow, transient_for_below_multi_parent_lower_parent)
1059 {
1060    etWin *tw = NULL;
1061    etWin *tw_child = NULL;
1062    etWin *tw_child2 = NULL;
1063    etWin *tw_child3 = NULL;
1064
1065    etWin *tw_parent2 = NULL;
1066    etWin *tw_parent2_child = NULL;
1067    etWin *tw_parent2_child2 = NULL;
1068    Eina_List *list = NULL, *l = NULL;
1069    int pass_count = 0;
1070
1071    // init TC window, show=true, geom=true
1072    initTC(EINA_TRUE);
1073
1074    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
1075    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2");
1076    makeTransientBelowChild(&tw_child3, tw_parent, 130, 130, 300, 300, E_TC_WIN_COLOR_YELLOW, "TCWin_Normal_child3");
1077
1078    // Expected stack res:
1079    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base [Bottom]
1080
1081
1082    tw_parent2 = initNormalWin("TCWin_Normal_parent2", 0, 300, 400, 400, E_TC_WIN_COLOR_ORANGE);
1083    ASSERT_TRUE(tw_parent2 != NULL) << "failed to initiation window";
1084    showTCWin(tw_parent2);
1085    ASSERT_VIS_ON(tw_parent2);
1086
1087    makeTransientBelowChild(&tw_parent2_child, tw_parent2, 20, 320, 400, 400, E_TC_WIN_COLOR_CYAN, "TCWin_Normal_child");
1088    makeTransientBelowChild(&tw_parent2_child2, tw_parent2, 40, 340, 400, 400, E_TC_WIN_COLOR_INDIGO, "TCWin_Normal_child2");
1089
1090    // Expected stack res:
1091    // [Top] tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base [Bottom]
1092
1093
1094    //////////////////////////////////////////////////
1095    // Lower tw_parent2
1096    //////////////////////////////////////////////////
1097    etRunner::get().setWinStack(tw_parent2, NULL, EINA_FALSE);
1098    ASSERT_EVENT(tw_parent2, E_TC_EVENT_TYPE_STACK_LOWER);
1099
1100    // Expected stack res:
1101    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base -> ... -> tw_parent2 -> tw_parent2_child -> tw_parent2_child2 [Bottom]
1102
1103    // In this case,
1104    // To check validation of stack order, we have to check 2 steps.
1105    // First, check window from top to bottom until meet tw_base.
1106    // Second, check window from bottom to top until tw_parent2.
1107
1108    list = etRunner::get().getWinInfoList();
1109    ASSERT_TRUE(list != NULL);
1110    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1111      {
1112         if (tw->layer > 200) continue;
1113
1114         if (pass_count == 0)
1115           {
1116              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1117              pass_count++;
1118              continue;
1119           }
1120         else if (pass_count == 1)
1121           {
1122              ASSERT_EQ(tw->native_win, tw_child->native_win);
1123              pass_count++;
1124              continue;
1125           }
1126         else if (pass_count == 2)
1127           {
1128              ASSERT_EQ(tw->native_win, tw_child2->native_win);
1129              pass_count++;
1130              continue;
1131           }
1132         else if (pass_count == 3)
1133           {
1134              ASSERT_EQ(tw->native_win, tw_child3->native_win);
1135              pass_count++;
1136              continue;
1137           }
1138         else
1139           {
1140              ASSERT_EQ(tw->native_win, tw_base->native_win);
1141              pass_count++;
1142           }
1143
1144         break;
1145      }
1146    etRunner::get().freeWinInfoList(list);
1147
1148    // [Bottom] tw_parent2_child2 <- tw_parent2_child <- tw_parent2 <- ... <- tw_base <- tw_child3 <- tw_child2 <- tw_child <- tw_parent [Top]
1149    list = etRunner::get().getWinInfoList();
1150    ASSERT_TRUE(list != NULL);
1151    EINA_LIST_CAST_REVERSE_FOREACH(list, l, tw, etWin*)
1152      {
1153         if (tw->layer < 200) continue;
1154
1155         if (pass_count == 5)
1156           {
1157              ASSERT_EQ(tw->native_win, tw_parent2_child2->native_win);
1158              pass_count++;
1159              continue;
1160           }
1161         else if (pass_count == 6)
1162           {
1163              ASSERT_EQ(tw->native_win, tw_parent2_child->native_win);
1164              pass_count++;
1165              continue;
1166           }
1167         else if (pass_count == 7)
1168           {
1169              ASSERT_EQ(tw->native_win, tw_parent2->native_win);
1170              pass_count++;
1171              break;
1172           }
1173      }
1174    etRunner::get().freeWinInfoList(list);
1175
1176    ASSERT_EQ(8, pass_count);
1177    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1178 }
1179
1180 TEST_F(etTestTransientForBelow, transient_for_below_multi_parent_raise_child)
1181 {
1182    etWin *tw = NULL;
1183    etWin *tw_child = NULL;
1184    etWin *tw_child2 = NULL;
1185    etWin *tw_child3 = NULL;
1186
1187    etWin *tw_parent2 = NULL;
1188    etWin *tw_parent2_child = NULL;
1189    etWin *tw_parent2_child2 = NULL;
1190    Eina_List *list = NULL, *l = NULL;
1191    int pass_count = 0;
1192
1193    // init TC window, show=true, geom=true
1194    initTC(EINA_TRUE);
1195
1196    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
1197    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2");
1198    makeTransientBelowChild(&tw_child3, tw_parent, 130, 130, 300, 300, E_TC_WIN_COLOR_YELLOW, "TCWin_Normal_child3");
1199
1200    tw_parent2 = initNormalWin("TCWin_Normal_parent2", 0, 300, 400, 400, E_TC_WIN_COLOR_ORANGE);
1201    ASSERT_TRUE(tw_parent2 != NULL) << "failed to initiation window";
1202    showTCWin(tw_parent2);
1203    ASSERT_VIS_ON(tw_parent2);
1204
1205    makeTransientBelowChild(&tw_parent2_child, tw_parent2, 20, 320, 400, 400, E_TC_WIN_COLOR_CYAN, "TCWin_Normal_child");
1206    makeTransientBelowChild(&tw_parent2_child2, tw_parent2, 40, 340, 400, 400, E_TC_WIN_COLOR_INDIGO, "TCWin_Normal_child2");
1207
1208    // Expected stack res:
1209    // [Top] tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base [Bottom]
1210
1211
1212    //////////////////////////////////////////////////
1213    // Raise tw_child3
1214    //////////////////////////////////////////////////
1215    etRunner::get().setWinStack(tw_child3, NULL, EINA_TRUE);
1216    ASSERT_EVENT(tw_child3, E_TC_EVENT_TYPE_STACK_RAISE);
1217
1218    // Expected stack res:
1219    // [Top] tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_parent -> tw_child3 -> tw_child -> tw_child2 -> tw_base [Bottom]
1220
1221    list = etRunner::get().getWinInfoList();
1222    ASSERT_TRUE(list != NULL);
1223
1224    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1225      {
1226         if (tw->layer > 200) continue;
1227
1228         if (pass_count == 0)
1229           {
1230              ASSERT_EQ(tw->native_win, tw_parent2->native_win);
1231              pass_count++;
1232              continue;
1233           }
1234         else if (pass_count == 1)
1235           {
1236              ASSERT_EQ(tw->native_win, tw_parent2_child->native_win);
1237              pass_count++;
1238              continue;
1239           }
1240         else if (pass_count == 2)
1241           {
1242              ASSERT_EQ(tw->native_win, tw_parent2_child2->native_win);
1243              pass_count++;
1244              continue;
1245           }
1246         else if (pass_count == 3)
1247           {
1248              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1249              pass_count++;
1250              continue;
1251           }
1252         else if (pass_count == 4)
1253           {
1254              ASSERT_EQ(tw->native_win, tw_child3->native_win);
1255              pass_count++;
1256              continue;
1257           }
1258         else if (pass_count == 5)
1259           {
1260              ASSERT_EQ(tw->native_win, tw_child->native_win);
1261              pass_count++;
1262              continue;
1263           }
1264         else if (pass_count == 6)
1265           {
1266              ASSERT_EQ(tw->native_win, tw_child2->native_win);
1267              pass_count++;
1268              continue;
1269           }
1270         else
1271           {
1272              ASSERT_EQ(tw->native_win, tw_base->native_win);
1273              pass_count++;
1274           }
1275
1276         break;
1277      }
1278    etRunner::get().freeWinInfoList(list);
1279
1280    ASSERT_EQ(8, pass_count);
1281
1282    //////////////////////////////////////////////////
1283    // Raise tw_child3 again
1284    //////////////////////////////////////////////////
1285    etRunner::get().setWinStack(tw_child3, NULL, EINA_TRUE);
1286
1287    // Expected stack res:
1288    // [Top] tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_parent -> tw_child3 -> tw_child -> tw_child2 -> tw_base [Bottom]
1289
1290    list = etRunner::get().getWinInfoList();
1291    ASSERT_TRUE(list != NULL);
1292
1293    pass_count = 0;
1294    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1295      {
1296         if (tw->layer > 200) continue;
1297
1298         if (pass_count == 0)
1299           {
1300              ASSERT_EQ(tw->native_win, tw_parent2->native_win);
1301              pass_count++;
1302              continue;
1303           }
1304         else if (pass_count == 1)
1305           {
1306              ASSERT_EQ(tw->native_win, tw_parent2_child->native_win);
1307              pass_count++;
1308              continue;
1309           }
1310         else if (pass_count == 2)
1311           {
1312              ASSERT_EQ(tw->native_win, tw_parent2_child2->native_win);
1313              pass_count++;
1314              continue;
1315           }
1316         else if (pass_count == 3)
1317           {
1318              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1319              pass_count++;
1320              continue;
1321           }
1322         else if (pass_count == 4)
1323           {
1324              ASSERT_EQ(tw->native_win, tw_child3->native_win);
1325              pass_count++;
1326              continue;
1327           }
1328         else if (pass_count == 5)
1329           {
1330              ASSERT_EQ(tw->native_win, tw_child->native_win);
1331              pass_count++;
1332              continue;
1333           }
1334         else if (pass_count == 6)
1335           {
1336              ASSERT_EQ(tw->native_win, tw_child2->native_win);
1337              pass_count++;
1338              continue;
1339           }
1340         else
1341           {
1342              ASSERT_EQ(tw->native_win, tw_base->native_win);
1343              pass_count++;
1344           }
1345
1346         break;
1347      }
1348    etRunner::get().freeWinInfoList(list);
1349
1350    ASSERT_EQ(8, pass_count);
1351
1352
1353    //////////////////////////////////////////////////
1354    // Raise tw_child
1355    //////////////////////////////////////////////////
1356    etRunner::get().setWinStack(tw_child, NULL, EINA_TRUE);
1357    ASSERT_EVENT(tw_child, E_TC_EVENT_TYPE_STACK_RAISE);
1358
1359    // Expected stack res:
1360    // [Top] tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_parent -> tw_child -> tw_child3 -> tw_child2 -> tw_base [Bottom]
1361
1362    list = etRunner::get().getWinInfoList();
1363    ASSERT_TRUE(list != NULL);
1364
1365    pass_count = 0;
1366    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1367      {
1368         if (tw->layer > 200) continue;
1369
1370         if (pass_count == 0)
1371           {
1372              ASSERT_EQ(tw->native_win, tw_parent2->native_win);
1373              pass_count++;
1374              continue;
1375           }
1376         else if (pass_count == 1)
1377           {
1378              ASSERT_EQ(tw->native_win, tw_parent2_child->native_win);
1379              pass_count++;
1380              continue;
1381           }
1382         else if (pass_count == 2)
1383           {
1384              ASSERT_EQ(tw->native_win, tw_parent2_child2->native_win);
1385              pass_count++;
1386              continue;
1387           }
1388         else if (pass_count == 3)
1389           {
1390              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1391              pass_count++;
1392              continue;
1393           }
1394         else if (pass_count == 4)
1395           {
1396              ASSERT_EQ(tw->native_win, tw_child->native_win);
1397              pass_count++;
1398              continue;
1399           }
1400         else if (pass_count == 5)
1401           {
1402              ASSERT_EQ(tw->native_win, tw_child3->native_win);
1403              pass_count++;
1404              continue;
1405           }
1406         else if (pass_count == 6)
1407           {
1408              ASSERT_EQ(tw->native_win, tw_child2->native_win);
1409              pass_count++;
1410              continue;
1411           }
1412         else
1413           {
1414              ASSERT_EQ(tw->native_win, tw_base->native_win);
1415              pass_count++;
1416           }
1417
1418         break;
1419      }
1420    etRunner::get().freeWinInfoList(list);
1421
1422    ASSERT_EQ(8, pass_count);
1423
1424
1425    //////////////////////////////////////////////////
1426    // Raise tw_parent2_child2
1427    //////////////////////////////////////////////////
1428    etRunner::get().setWinStack(tw_parent2_child2, NULL, EINA_TRUE);
1429    ASSERT_EVENT(tw_parent2_child2, E_TC_EVENT_TYPE_STACK_RAISE);
1430
1431    // Expected stack res:
1432    // [Top] tw_parent2 -> tw_parent2_child2 -> tw_parent2_child -> tw_parent -> tw_child -> tw_child3 -> tw_child2 -> tw_base [Bottom]
1433
1434    list = etRunner::get().getWinInfoList();
1435    ASSERT_TRUE(list != NULL);
1436
1437    pass_count = 0;
1438    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1439      {
1440         if (tw->layer > 200) continue;
1441
1442         if (pass_count == 0)
1443           {
1444              ASSERT_EQ(tw->native_win, tw_parent2->native_win);
1445              pass_count++;
1446              continue;
1447           }
1448         else if (pass_count == 1)
1449           {
1450              ASSERT_EQ(tw->native_win, tw_parent2_child2->native_win);
1451              pass_count++;
1452              continue;
1453           }
1454         else if (pass_count == 2)
1455           {
1456              ASSERT_EQ(tw->native_win, tw_parent2_child->native_win);
1457              pass_count++;
1458              continue;
1459           }
1460         else if (pass_count == 3)
1461           {
1462              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1463              pass_count++;
1464              continue;
1465           }
1466         else if (pass_count == 4)
1467           {
1468              ASSERT_EQ(tw->native_win, tw_child->native_win);
1469              pass_count++;
1470              continue;
1471           }
1472         else if (pass_count == 5)
1473           {
1474              ASSERT_EQ(tw->native_win, tw_child3->native_win);
1475              pass_count++;
1476              continue;
1477           }
1478         else if (pass_count == 6)
1479           {
1480              ASSERT_EQ(tw->native_win, tw_child2->native_win);
1481              pass_count++;
1482              continue;
1483           }
1484         else
1485           {
1486              ASSERT_EQ(tw->native_win, tw_base->native_win);
1487              pass_count++;
1488           }
1489
1490         break;
1491      }
1492    etRunner::get().freeWinInfoList(list);
1493
1494    ASSERT_EQ(8, pass_count);
1495    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1496 }
1497
1498 TEST_F(etTestTransientForBelow, transient_for_below_multi_parent_raise_child_and_parent)
1499 {
1500    etWin *tw = NULL;
1501    etWin *tw_child = NULL;
1502    etWin *tw_child2 = NULL;
1503    etWin *tw_child3 = NULL;
1504
1505    etWin *tw_parent2 = NULL;
1506    etWin *tw_parent2_child = NULL;
1507    etWin *tw_parent2_child2 = NULL;
1508    Eina_List *list = NULL, *l = NULL;
1509    int pass_count = 0;
1510
1511    // init TC window, show=true, geom=true
1512    initTC(EINA_TRUE);
1513
1514    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
1515    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2");
1516    makeTransientBelowChild(&tw_child3, tw_parent, 130, 130, 300, 300, E_TC_WIN_COLOR_YELLOW, "TCWin_Normal_child3");
1517
1518    tw_parent2 = initNormalWin("TCWin_Normal_parent2", 0, 300, 400, 400, E_TC_WIN_COLOR_ORANGE);
1519    ASSERT_TRUE(tw_parent2 != NULL) << "failed to initiation window";
1520    showTCWin(tw_parent2);
1521    ASSERT_VIS_ON(tw_parent2);
1522
1523    makeTransientBelowChild(&tw_parent2_child, tw_parent2, 20, 320, 400, 400, E_TC_WIN_COLOR_CYAN, "TCWin_Normal_child");
1524    makeTransientBelowChild(&tw_parent2_child2, tw_parent2, 40, 340, 400, 400, E_TC_WIN_COLOR_INDIGO, "TCWin_Normal_child2");
1525
1526    // Expected stack res:
1527    // [Top] tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base [Bottom]
1528
1529
1530    //////////////////////////////////////////////////
1531    // Raise tw_child3
1532    //////////////////////////////////////////////////
1533    etRunner::get().setWinStack(tw_child3, NULL, EINA_TRUE);
1534    ASSERT_EVENT(tw_child3, E_TC_EVENT_TYPE_STACK_RAISE);
1535
1536    // Expected stack res:
1537    // [Top] tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_parent -> tw_child3 -> tw_child -> tw_child2 -> tw_base [Bottom]
1538
1539    list = etRunner::get().getWinInfoList();
1540    ASSERT_TRUE(list != NULL);
1541
1542    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1543      {
1544         if (tw->layer > 200) continue;
1545
1546         if (pass_count == 0)
1547           {
1548              ASSERT_EQ(tw->native_win, tw_parent2->native_win);
1549              pass_count++;
1550              continue;
1551           }
1552         else if (pass_count == 1)
1553           {
1554              ASSERT_EQ(tw->native_win, tw_parent2_child->native_win);
1555              pass_count++;
1556              continue;
1557           }
1558         else if (pass_count == 2)
1559           {
1560              ASSERT_EQ(tw->native_win, tw_parent2_child2->native_win);
1561              pass_count++;
1562              continue;
1563           }
1564         else if (pass_count == 3)
1565           {
1566              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1567              pass_count++;
1568              continue;
1569           }
1570         else if (pass_count == 4)
1571           {
1572              ASSERT_EQ(tw->native_win, tw_child3->native_win);
1573              pass_count++;
1574              continue;
1575           }
1576         else if (pass_count == 5)
1577           {
1578              ASSERT_EQ(tw->native_win, tw_child->native_win);
1579              pass_count++;
1580              continue;
1581           }
1582         else if (pass_count == 6)
1583           {
1584              ASSERT_EQ(tw->native_win, tw_child2->native_win);
1585              pass_count++;
1586              continue;
1587           }
1588         else
1589           {
1590              ASSERT_EQ(tw->native_win, tw_base->native_win);
1591              pass_count++;
1592           }
1593
1594         break;
1595      }
1596    etRunner::get().freeWinInfoList(list);
1597
1598    ASSERT_EQ(8, pass_count);
1599
1600
1601    //////////////////////////////////////////////////
1602    // Raise tw_parent
1603    //////////////////////////////////////////////////
1604    etRunner::get().setWinStack(tw_parent, NULL, EINA_TRUE);
1605    ASSERT_EVENT(tw_parent, E_TC_EVENT_TYPE_STACK_RAISE);
1606
1607    // Expected stack res:
1608    // [Top] tw_parent -> tw_child3 -> tw_child -> tw_child2 -> tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_base [Bottom]
1609
1610    pass_count = 0;
1611    list = etRunner::get().getWinInfoList();
1612    ASSERT_TRUE(list != NULL);
1613    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1614      {
1615         if (tw->layer > 200) continue;
1616
1617         if (pass_count == 0)
1618           {
1619              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1620              pass_count++;
1621              continue;
1622           }
1623         else if (pass_count == 1)
1624           {
1625              ASSERT_EQ(tw->native_win, tw_child3->native_win);
1626              pass_count++;
1627              continue;
1628           }
1629         else if (pass_count == 2)
1630           {
1631              ASSERT_EQ(tw->native_win, tw_child->native_win);
1632              pass_count++;
1633              continue;
1634           }
1635         else if (pass_count == 3)
1636           {
1637              ASSERT_EQ(tw->native_win, tw_child2->native_win);
1638              pass_count++;
1639              continue;
1640           }
1641         else if (pass_count == 4)
1642           {
1643              ASSERT_EQ(tw->native_win, tw_parent2->native_win);
1644              pass_count++;
1645              continue;
1646           }
1647         else if (pass_count == 5)
1648           {
1649              ASSERT_EQ(tw->native_win, tw_parent2_child->native_win);
1650              pass_count++;
1651              continue;
1652           }
1653         else if (pass_count == 6)
1654           {
1655              ASSERT_EQ(tw->native_win, tw_parent2_child2->native_win);
1656              pass_count++;
1657              continue;
1658           }
1659         else
1660           {
1661              ASSERT_EQ(tw->native_win, tw_base->native_win);
1662              pass_count++;
1663           }
1664         break;
1665      }
1666    etRunner::get().freeWinInfoList(list);
1667
1668    ASSERT_EQ(8, pass_count);
1669    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1670 }
1671
1672 TEST_F(etTestTransientForBelow, transient_for_below_above_set)
1673 {
1674    etWin *tw = NULL;
1675    etWin *tw_child = NULL;
1676    Eina_List *list = NULL, *l = NULL;
1677    int pass_count = 0;
1678
1679    // init TC window, show=true, geom=true
1680    initTC(EINA_TRUE);
1681
1682    ///////////////////////////
1683    // SET transient BELOW
1684    ///////////////////////////
1685    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
1686
1687    etRunner::get().work(0.5);
1688
1689    ///////////////////////////
1690    // UNSET transient BELOW - using tizen_policy_set_transient_for_below(child, NULL)
1691    ///////////////////////////
1692    Eina_Bool res = etRunner::get().setWinTransientForBelow(tw_child, tw_parent, EINA_FALSE);
1693    ASSERT_TRUE(res);
1694
1695    // Expected stack res:
1696    // [Top] tw_parent -> tw_child -> tw_base [Bottom]
1697    list = etRunner::get().getWinInfoList();
1698    ASSERT_TRUE(list != NULL);
1699
1700    pass_count = 0;
1701    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1702      {
1703         if (tw->layer > 200) continue;
1704
1705         if (pass_count == 0)
1706           {
1707              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1708              pass_count++;
1709              continue;
1710           }
1711         else if (pass_count == 1)
1712           {
1713              ASSERT_EQ(tw->native_win, tw_child->native_win);
1714              pass_count++;
1715              continue;
1716           }
1717         else
1718           {
1719              ASSERT_EQ(tw->native_win, tw_base->native_win);
1720              pass_count++;
1721           }
1722
1723         break;
1724      }
1725    etRunner::get().freeWinInfoList(list);
1726    ASSERT_EQ(3, pass_count);
1727
1728    etRunner::get().work(0.5);
1729
1730    ///////////////////////////
1731    // SET transient ABOVE
1732    ///////////////////////////
1733    res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_TRUE);
1734    ASSERT_TRUE(res);
1735
1736    // Expected stack res:
1737    // [Top] tw_child -> tw_parent -> tw_base [Bottom]
1738    list = etRunner::get().getWinInfoList();
1739    ASSERT_TRUE(list != NULL);
1740
1741    pass_count = 0;
1742    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1743      {
1744         if (tw->layer > 200) continue;
1745
1746         if (pass_count == 0)
1747           {
1748              ASSERT_EQ(tw->native_win, tw_child->native_win);
1749              pass_count++;
1750              continue;
1751           }
1752         else if (pass_count == 1)
1753           {
1754              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1755              pass_count++;
1756              continue;
1757           }
1758         else
1759           {
1760              ASSERT_EQ(tw->native_win, tw_base->native_win);
1761              pass_count++;
1762           }
1763
1764         break;
1765      }
1766    etRunner::get().freeWinInfoList(list);
1767    ASSERT_EQ(3, pass_count);
1768
1769    ///////////////////////////
1770    // UNSET transient ABOVE
1771    ///////////////////////////
1772    res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_FALSE);
1773    ASSERT_TRUE(res);
1774
1775    // Expected stack res:
1776    // [Top] tw_child -> tw_parent -> tw_base [Bottom]
1777    list = etRunner::get().getWinInfoList();
1778    ASSERT_TRUE(list != NULL);
1779
1780    pass_count = 0;
1781    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1782      {
1783         if (tw->layer > 200) continue;
1784
1785         if (pass_count == 0)
1786           {
1787              ASSERT_EQ(tw->native_win, tw_child->native_win);
1788              pass_count++;
1789              continue;
1790           }
1791         else if (pass_count == 1)
1792           {
1793              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1794              pass_count++;
1795              continue;
1796           }
1797         else
1798           {
1799              ASSERT_EQ(tw->native_win, tw_base->native_win);
1800              pass_count++;
1801           }
1802
1803         break;
1804      }
1805    etRunner::get().freeWinInfoList(list);
1806    ASSERT_EQ(3, pass_count);
1807
1808    etRunner::get().work(0.5);
1809
1810    ///////////////////////////
1811    // SET transient BELOW
1812    ///////////////////////////
1813    res = etRunner::get().setWinTransientForBelow(tw_child, tw_parent, EINA_TRUE);
1814    ASSERT_TRUE(res);
1815
1816    // Expected stack res:
1817    // [Top] tw_parent -> tw_child -> tw_base [Bottom]
1818    list = etRunner::get().getWinInfoList();
1819    ASSERT_TRUE(list != NULL);
1820
1821    pass_count = 0;
1822    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1823      {
1824         if (tw->layer > 200) continue;
1825
1826         if (pass_count == 0)
1827           {
1828              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1829              pass_count++;
1830              continue;
1831           }
1832         else if (pass_count == 1)
1833           {
1834              ASSERT_EQ(tw->native_win, tw_child->native_win);
1835              pass_count++;
1836              continue;
1837           }
1838         else
1839           {
1840              ASSERT_EQ(tw->native_win, tw_base->native_win);
1841              pass_count++;
1842           }
1843
1844         break;
1845      }
1846    etRunner::get().freeWinInfoList(list);
1847    ASSERT_EQ(3, pass_count);
1848
1849    etRunner::get().work(0.5);
1850
1851
1852    ///////////////////////////
1853    // UNSET transient BELOW - using tizen_policy_unset_transient_for(child, NULL)
1854    ///////////////////////////
1855    res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_FALSE);
1856    ASSERT_TRUE(res);
1857
1858    // Expected stack res:
1859    // [Top] tw_parent -> tw_child -> tw_base [Bottom]
1860    list = etRunner::get().getWinInfoList();
1861    ASSERT_TRUE(list != NULL);
1862
1863    pass_count = 0;
1864    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1865      {
1866         if (tw->layer > 200) continue;
1867
1868         if (pass_count == 0)
1869           {
1870              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1871              pass_count++;
1872              continue;
1873           }
1874         else if (pass_count == 1)
1875           {
1876              ASSERT_EQ(tw->native_win, tw_child->native_win);
1877              pass_count++;
1878              continue;
1879           }
1880         else
1881           {
1882              ASSERT_EQ(tw->native_win, tw_base->native_win);
1883              pass_count++;
1884           }
1885
1886         break;
1887      }
1888    etRunner::get().freeWinInfoList(list);
1889    ASSERT_EQ(3, pass_count);
1890
1891    etRunner::get().work(0.5);
1892
1893    ///////////////////////////
1894    // SET transient ABOVE
1895    ///////////////////////////
1896    res = etRunner::get().setWinTransientFor(tw_child, tw_parent, EINA_TRUE);
1897    ASSERT_TRUE(res);
1898
1899    // Expected stack res:
1900    // [Top] tw_child -> tw_parent -> tw_base [Bottom]
1901    list = etRunner::get().getWinInfoList();
1902    ASSERT_TRUE(list != NULL);
1903
1904    pass_count = 0;
1905    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1906      {
1907         if (tw->layer > 200) continue;
1908
1909         if (pass_count == 0)
1910           {
1911              ASSERT_EQ(tw->native_win, tw_child->native_win);
1912              pass_count++;
1913              continue;
1914           }
1915         else if (pass_count == 1)
1916           {
1917              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1918              pass_count++;
1919              continue;
1920           }
1921         else
1922           {
1923              ASSERT_EQ(tw->native_win, tw_base->native_win);
1924              pass_count++;
1925           }
1926
1927         break;
1928      }
1929    etRunner::get().freeWinInfoList(list);
1930    ASSERT_EQ(3, pass_count);
1931
1932    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1933 }
1934
1935 TEST_F(etTestTransientForBelow, transient_for_below_activate_below_basic)
1936 {
1937    etWin *tw = NULL;
1938    etWin *tw_child = NULL;
1939    Eina_List *list = NULL, *l = NULL;
1940    int pass_count = 0;
1941
1942    // init TC window, show=true, geom=true
1943    initTC(EINA_TRUE);
1944
1945    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
1946
1947    // Expected stack res:
1948    // [Top] tw_parent -> tw_child -> tw_base [Bottom]
1949
1950
1951    //////////////////////////////////////////////////
1952    // tw_child Activate Below tw_parent
1953    //////////////////////////////////////////////////
1954    etRunner::get().setWinActivateBelow(tw_child, tw_parent);
1955    etRunner::get().work(1.0);
1956
1957    // Expected stack res:
1958    // [Top] tw_parent -> tw_child -> tw_base [Bottom]
1959
1960    list = etRunner::get().getWinInfoList();
1961    ASSERT_TRUE(list != NULL);
1962
1963    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1964      {
1965         if (tw->layer > 200) continue;
1966
1967         if (pass_count == 0)
1968           {
1969              ASSERT_EQ(tw->native_win, tw_parent->native_win);
1970              pass_count++;
1971              continue;
1972           }
1973         else if (pass_count == 1)
1974           {
1975              ASSERT_EQ(tw->native_win, tw_child->native_win);
1976              pass_count++;
1977              continue;
1978           }
1979         else
1980           {
1981              ASSERT_EQ(tw->native_win, tw_base->native_win);
1982              pass_count++;
1983           }
1984
1985         break;
1986      }
1987    etRunner::get().freeWinInfoList(list);
1988
1989    ASSERT_EQ(3, pass_count);
1990    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1991 }
1992
1993 TEST_F(etTestTransientForBelow, transient_for_below_activate_above_basic)
1994 {
1995    etWin *tw = NULL;
1996    etWin *tw_child = NULL;
1997    Eina_List *list = NULL, *l = NULL;
1998    int pass_count = 0;
1999
2000    // init TC window, show=true, geom=true
2001    initTC(EINA_TRUE);
2002
2003    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
2004
2005    // Expected stack res:
2006    // [Top] tw_parent -> tw_child -> tw_base [Bottom]
2007
2008
2009    //////////////////////////////////////////////////
2010    // tw_child Activate Above tw_parent
2011    //////////////////////////////////////////////////
2012    etRunner::get().setWinActivateAbove(tw_child, tw_parent);
2013    etRunner::get().work(1.0);
2014
2015    // Expected stack res:
2016    // [Top] tw_parent -> tw_child -> tw_base [Bottom]
2017
2018    list = etRunner::get().getWinInfoList();
2019    ASSERT_TRUE(list != NULL);
2020
2021    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
2022      {
2023         if (tw->layer > 200) continue;
2024
2025         if (pass_count == 0)
2026           {
2027              ASSERT_EQ(tw->native_win, tw_parent->native_win);
2028              pass_count++;
2029              continue;
2030           }
2031         else if (pass_count == 1)
2032           {
2033              ASSERT_EQ(tw->native_win, tw_child->native_win);
2034              pass_count++;
2035              continue;
2036           }
2037         else
2038           {
2039              ASSERT_EQ(tw->native_win, tw_base->native_win);
2040              pass_count++;
2041           }
2042
2043         break;
2044      }
2045    etRunner::get().freeWinInfoList(list);
2046
2047    ASSERT_EQ(3, pass_count);
2048    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
2049 }
2050
2051 TEST_F(etTestTransientForBelow, transient_for_below_activate_above_parent)
2052 {
2053    etWin *tw = NULL;
2054    etWin *tw_child = NULL;
2055    etWin *tw_child2 = NULL;
2056    etWin *tw_child3 = NULL;
2057
2058    etWin *tw_parent2 = NULL;
2059    Eina_List *list = NULL, *l = NULL;
2060    int pass_count = 0;
2061
2062    // init TC window, show=true, geom=true
2063    initTC(EINA_TRUE);
2064
2065    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
2066    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2");
2067    makeTransientBelowChild(&tw_child3, tw_parent, 130, 130, 300, 300, E_TC_WIN_COLOR_YELLOW, "TCWin_Normal_child3");
2068
2069    // Expected stack res:
2070    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base [Bottom]
2071
2072
2073    tw_parent2 = initNormalWin("TCWin_Normal_parent2", 0, 300, 400, 400, E_TC_WIN_COLOR_ORANGE);
2074    ASSERT_TRUE(tw_parent2 != NULL) << "failed to initiation window";
2075    showTCWin(tw_parent2);
2076    ASSERT_VIS_ON(tw_parent2);
2077
2078    // Expected stack res:
2079    // [Top] tw_parent2 -> tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base [Bottom]
2080
2081
2082    //////////////////////////////////////////////////
2083    // activate above tw_parent
2084    //////////////////////////////////////////////////
2085    etRunner::get().setWinActivateAbove(tw_parent, tw_parent2);
2086    ASSERT_EVENT(tw_parent, E_TC_EVENT_TYPE_STACK_RAISE);
2087
2088    // Expected stack res:
2089    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_parent2 -> tw_base [Bottom]
2090
2091    list = etRunner::get().getWinInfoList();
2092    ASSERT_TRUE(list != NULL);
2093
2094    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
2095      {
2096         if (tw->layer > 200) continue;
2097
2098         if (pass_count == 0)
2099           {
2100              ASSERT_EQ(tw->native_win, tw_parent->native_win);
2101              pass_count++;
2102              continue;
2103           }
2104         else if (pass_count == 1)
2105           {
2106              ASSERT_EQ(tw->native_win, tw_child->native_win);
2107              pass_count++;
2108              continue;
2109           }
2110         else if (pass_count == 2)
2111           {
2112              ASSERT_EQ(tw->native_win, tw_child2->native_win);
2113              pass_count++;
2114              continue;
2115           }
2116         else if (pass_count == 3)
2117           {
2118              ASSERT_EQ(tw->native_win, tw_child3->native_win);
2119              pass_count++;
2120              continue;
2121           }
2122         else if (pass_count == 4)
2123           {
2124              ASSERT_EQ(tw->native_win, tw_parent2->native_win);
2125              pass_count++;
2126              continue;
2127           }
2128         else
2129           {
2130              ASSERT_EQ(tw->native_win, tw_base->native_win);
2131              pass_count++;
2132           }
2133
2134         break;
2135      }
2136    etRunner::get().freeWinInfoList(list);
2137
2138    ASSERT_EQ(6, pass_count);
2139    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
2140 }
2141
2142 TEST_F(etTestTransientForBelow, transient_for_below_activate_above_parent2)
2143 {
2144    etWin *tw = NULL;
2145    etWin *tw_child = NULL;
2146    etWin *tw_child2 = NULL;
2147    etWin *tw_child3 = NULL;
2148
2149    etWin *tw_parent2 = NULL;
2150    etWin *tw_parent2_child = NULL;
2151    etWin *tw_parent2_child2 = NULL;
2152    Eina_List *list = NULL, *l = NULL;
2153    int pass_count = 0;
2154
2155    // init TC window, show=true, geom=true
2156    initTC(EINA_TRUE);
2157
2158    makeTransientBelowChild(&tw_child, tw_parent, 80, 80, 300, 300, E_TC_WIN_COLOR_BLUE, "TCWin_Normal_child");
2159    makeTransientBelowChild(&tw_child2, tw_parent, 110, 110, 300, 300, E_TC_WIN_COLOR_GREEN, "TCWin_Normal_child2");
2160    makeTransientBelowChild(&tw_child3, tw_parent, 130, 130, 300, 300, E_TC_WIN_COLOR_YELLOW, "TCWin_Normal_child3");
2161
2162    // Expected stack res:
2163    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base [Bottom]
2164
2165
2166    tw_parent2 = initNormalWin("TCWin_Normal_parent2", 0, 300, 400, 400, E_TC_WIN_COLOR_ORANGE);
2167    ASSERT_TRUE(tw_parent2 != NULL) << "failed to initiation window";
2168    showTCWin(tw_parent2);
2169    ASSERT_VIS_ON(tw_parent2);
2170
2171    makeTransientBelowChild(&tw_parent2_child, tw_parent2, 20, 320, 400, 400, E_TC_WIN_COLOR_CYAN, "TCWin_Normal_child");
2172    makeTransientBelowChild(&tw_parent2_child2, tw_parent2, 40, 340, 400, 400, E_TC_WIN_COLOR_INDIGO, "TCWin_Normal_child2");
2173
2174    // Expected stack res:
2175    // [Top] tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_base [Bottom]
2176
2177
2178    //////////////////////////////////////////////////
2179    // Activate above tw_parent
2180    //////////////////////////////////////////////////
2181    etRunner::get().setWinActivateAbove(tw_parent, tw_parent2);
2182    ASSERT_EVENT(tw_parent, E_TC_EVENT_TYPE_STACK_RAISE);
2183
2184    // Expected stack res:
2185    // [Top] tw_parent -> tw_child -> tw_child2 -> tw_child3 -> tw_parent2 -> tw_parent2_child -> tw_parent2_child2 -> tw_base [Bottom]
2186
2187    list = etRunner::get().getWinInfoList();
2188    ASSERT_TRUE(list != NULL);
2189
2190    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
2191      {
2192         if (tw->layer > 200) continue;
2193
2194         if (pass_count == 0)
2195           {
2196              ASSERT_EQ(tw->native_win, tw_parent->native_win);
2197              pass_count++;
2198              continue;
2199           }
2200         else if (pass_count == 1)
2201           {
2202              ASSERT_EQ(tw->native_win, tw_child->native_win);
2203              pass_count++;
2204              continue;
2205           }
2206         else if (pass_count == 2)
2207           {
2208              ASSERT_EQ(tw->native_win, tw_child2->native_win);
2209              pass_count++;
2210              continue;
2211           }
2212         else if (pass_count == 3)
2213           {
2214              ASSERT_EQ(tw->native_win, tw_child3->native_win);
2215              pass_count++;
2216              continue;
2217           }
2218         else if (pass_count == 4)
2219           {
2220              ASSERT_EQ(tw->native_win, tw_parent2->native_win);
2221              pass_count++;
2222              continue;
2223           }
2224         else if (pass_count == 5)
2225           {
2226              ASSERT_EQ(tw->native_win, tw_parent2_child->native_win);
2227              pass_count++;
2228              continue;
2229           }
2230         else if (pass_count == 6)
2231           {
2232              ASSERT_EQ(tw->native_win, tw_parent2_child2->native_win);
2233              pass_count++;
2234              continue;
2235           }
2236         else
2237           {
2238              ASSERT_EQ(tw->native_win, tw_base->native_win);
2239              pass_count++;
2240           }
2241
2242         break;
2243      }
2244    etRunner::get().freeWinInfoList(list);
2245
2246    ASSERT_EQ(8, pass_count);
2247    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
2248 }