src/testcase/0003_base_operation_multi_wins.cpp

   1 #include "e_test_event.h"
   2 #include "e_test_base.h"
   3
   4 class etTestBaseMulti : public ::etTCBase
   5 {
   6  public:
   7     etTestBaseMulti() { };
   8     ~etTestBaseMulti() { };
   9
  10  protected:
  11     etWin *tw_red = NULL;
  12     etWin *tw_green = NULL;
  13     etWin *tw_blue = NULL;
  14     std::string testCaseName;
  15     std::string testName;
  16
  17     void initTC(Eina_Bool show_win, Eina_Bool usr_geom);
  18 };
  19
  20 void
  21 etTestBaseMulti::initTC(Eina_Bool show_win, Eina_Bool usr_geom)
  22 {
  23    const ::testing::TestInfo *const test_info = ::testing::UnitTest::GetInstance()->current_test_info();
  24
  25    tw_red = initNormalWin("TCWin_Normal_red", usr_geom);
  26    ASSERT_TRUE(tw_red != NULL) << "failed to initiation window";
  27    if (show_win)
  28      {
  29         showTCWin(tw_red);
  30         ASSERT_VIS_ON(tw_red);
  31      }
  32
  33    tw_green = initNormalWin("TCWin_Normal_green", usr_geom);
  34    ASSERT_TRUE(tw_green != NULL) << "failed to initiation window";
  35    if (show_win)
  36      {
  37         showTCWin(tw_green);
  38         ASSERT_VIS_ON(tw_green);
  39      }
  40
  41    tw_blue = initNormalWin("TCWin_Normal_blue", usr_geom);
  42    ASSERT_TRUE(tw_blue != NULL) << "failed to initiation window";
  43    if (show_win)
  44      {
  45         showTCWin(tw_blue);
  46         ASSERT_VIS_ON(tw_blue);
  47      }
  48
  49    testCaseName = test_info->test_case_name();
  50    testName = test_info->name();
  51 }
  52
  53 TEST_F(etTestBaseMulti, multi_all_wins_basic)
  54 {
  55    etWin *tw = NULL;
  56    Eina_List *list = NULL, *l = NULL;
  57    int pass_count = 0;
  58
  59    // init TC window, show=true, geom=true
  60    initTC(EINA_TRUE, EINA_TRUE);
  61
  62    // Expected stack res:
  63    // [Top] Blue -> Green -> Red [Bottom]
  64    list = etRunner::get().getWinInfoList();
  65    ASSERT_TRUE(list != NULL);
  66
  67    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
  68      {
  69         if (tw->layer > 200)
  70           continue;
  71
  72         if (pass_count == 0)
  73           {
  74              ASSERT_EQ(tw->native_win, tw_blue->native_win);
  75              pass_count++;
  76              continue;
  77           }
  78         else if (pass_count == 1)
  79           {
  80              ASSERT_EQ(tw->native_win, tw_green->native_win);
  81              pass_count++;
  82              continue;
  83           }
  84         else
  85           {
  86              ASSERT_EQ(tw->native_win, tw_red->native_win);
  87              pass_count++;
  88           }
  89
  90         break;
  91      }
  92    etRunner::get().freeWinInfoList(list);
  93
  94    ASSERT_EQ(3, pass_count);
  95
  96    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
  97 }
  98
  99 TEST_F(etTestBaseMulti, multi_all_wins_show1)
 100 {
 101    etWin *tw = NULL;
 102    Eina_Bool res = EINA_FALSE;
 103    Eina_List *list = NULL, *l = NULL;
 104    int pass_count = 0;
 105
 106    // init TC window, show=false, geom=true
 107    initTC(EINA_FALSE, EINA_TRUE);
 108
 109    // show red
 110    res = showTCWin(tw_red);
 111    ASSERT_TRUE(res);
 112    ASSERT_VIS_ON(tw_red);
 113
 114    // show blue
 115    res = showTCWin(tw_blue);
 116    ASSERT_TRUE(res);
 117    ASSERT_VIS_ON(tw_blue);
 118
 119    // show green
 120    res = showTCWin(tw_green);
 121    ASSERT_TRUE(res);
 122    ASSERT_VIS_ON(tw_green);
 123
 124    // Expected stack res:
 125    // [Top] Green -> Blue -> Red [Bottom]
 126    list = etRunner::get().getWinInfoList();
 127    ASSERT_TRUE(list != NULL);
 128
 129    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 130      {
 131         if (tw->layer > 200)
 132           continue;
 133
 134         if (pass_count == 0)
 135           {
 136              ASSERT_EQ(tw->native_win, tw_green->native_win);
 137              pass_count++;
 138              continue;
 139           }
 140         else if (pass_count == 1)
 141           {
 142              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 143              pass_count++;
 144              continue;
 145           }
 146         else
 147           {
 148              ASSERT_EQ(tw->native_win, tw_red->native_win);
 149              pass_count++;
 150           }
 151
 152         break;
 153      }
 154    etRunner::get().freeWinInfoList(list);
 155
 156    ASSERT_EQ(3, pass_count);
 157
 158    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 159 }
 160
 161 TEST_F(etTestBaseMulti, multi_all_wins_show2)
 162 {
 163    etWin *tw = NULL;
 164    Eina_Bool res = EINA_FALSE;
 165    Eina_List *list = NULL, *l = NULL;
 166    int pass_count = 0;
 167
 168    // init TC window, show=false, geom=true
 169    initTC(EINA_FALSE, EINA_TRUE);
 170
 171    // show blue
 172    res = showTCWin(tw_blue);
 173    ASSERT_TRUE(res);
 174    ASSERT_VIS_ON(tw_blue);
 175
 176    // show red
 177    res = showTCWin(tw_red);
 178    ASSERT_TRUE(res);
 179    ASSERT_VIS_ON(tw_red);
 180
 181    // show green
 182    res = showTCWin(tw_green);
 183    ASSERT_TRUE(res);
 184    ASSERT_VIS_ON(tw_green);
 185
 186    // Expected stack res:
 187    // [Top] Green -> Red -> Blue [Bottom]
 188    list = etRunner::get().getWinInfoList();
 189    ASSERT_TRUE(list != NULL);
 190
 191    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 192      {
 193         if (tw->layer > 200)
 194           continue;
 195
 196         if (pass_count == 0)
 197           {
 198              ASSERT_EQ(tw->native_win, tw_green->native_win);
 199              pass_count++;
 200              continue;
 201           }
 202         else if (pass_count == 1)
 203           {
 204              ASSERT_EQ(tw->native_win, tw_red->native_win);
 205              pass_count++;
 206              continue;
 207           }
 208         else
 209           {
 210              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 211              pass_count++;
 212           }
 213
 214         break;
 215      }
 216    etRunner::get().freeWinInfoList(list);
 217
 218    ASSERT_EQ(3, pass_count);
 219
 220    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 221 }
 222
 223 TEST_F(etTestBaseMulti, multi_all_wins_show3)
 224 {
 225    etWin *tw = NULL;
 226    Eina_Bool res = EINA_FALSE;
 227    Eina_List *list = NULL, *l = NULL;
 228    int pass_count = 0;
 229
 230    // init TC window, show=false, geom=true
 231    initTC(EINA_FALSE, EINA_TRUE);
 232
 233    // show green
 234    res = showTCWin(tw_green);
 235    ASSERT_TRUE(res);
 236    ASSERT_VIS_ON(tw_green);
 237
 238    // show blue
 239    res = showTCWin(tw_blue);
 240    ASSERT_TRUE(res);
 241    ASSERT_VIS_ON(tw_blue);
 242
 243    // show red
 244    res = showTCWin(tw_red);
 245    ASSERT_TRUE(res);
 246    ASSERT_VIS_ON(tw_red);
 247
 248    // Expected stack res:
 249    // [Top] Red -> Blue -> Green [Bottom]
 250    list = etRunner::get().getWinInfoList();
 251    ASSERT_TRUE(list != NULL);
 252
 253    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 254      {
 255         if (tw->layer > 200)
 256           continue;
 257
 258         if (pass_count == 0)
 259           {
 260              ASSERT_EQ(tw->native_win, tw_red->native_win);
 261              pass_count++;
 262              continue;
 263           }
 264         else if (pass_count == 1)
 265           {
 266              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 267              pass_count++;
 268              continue;
 269           }
 270         else
 271           {
 272              ASSERT_EQ(tw->native_win, tw_green->native_win);
 273              pass_count++;
 274           }
 275
 276         break;
 277      }
 278    etRunner::get().freeWinInfoList(list);
 279
 280    ASSERT_EQ(3, pass_count);
 281
 282    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 283 }
 284
 285 TEST_F(etTestBaseMulti, multi_all_wins_raise1)
 286 {
 287    etWin *tw = NULL;
 288    Eina_List *list = NULL, *l = NULL;
 289    int pass_count = 0;
 290
 291    // init TC window, show=true, geom=true
 292    initTC(EINA_TRUE, EINA_TRUE);
 293
 294    // Raise Red
 295    etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE);
 296    ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_RAISE);
 297
 298    // Expected stack res:
 299    // [Top] Red -> Blue -> Green [Bottom]
 300    list = etRunner::get().getWinInfoList();
 301    ASSERT_TRUE(list != NULL);
 302
 303    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 304      {
 305         if (tw->layer > 200)
 306           continue;
 307
 308         if (pass_count == 0)
 309           {
 310              ASSERT_EQ(tw->native_win, tw_red->native_win);
 311              pass_count++;
 312              continue;
 313           }
 314         else if (pass_count == 1)
 315           {
 316              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 317              pass_count++;
 318              continue;
 319           }
 320         else
 321           {
 322              ASSERT_EQ(tw->native_win, tw_green->native_win);
 323              pass_count++;
 324           }
 325
 326         break;
 327      }
 328    etRunner::get().freeWinInfoList(list);
 329
 330    ASSERT_EQ(3, pass_count);
 331
 332    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 333 }
 334
 335 TEST_F(etTestBaseMulti, multi_all_wins_raise2)
 336 {
 337    etWin *tw = NULL;
 338    Eina_List *list = NULL, *l = NULL;
 339    int pass_count = 0;
 340
 341    // init TC window, show=true, geom=true
 342    initTC(EINA_TRUE, EINA_TRUE);
 343
 344    // Raise Green
 345    etRunner::get().setWinStack(tw_green, NULL, EINA_TRUE);
 346    ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_RAISE);
 347
 348    // Expected stack res:
 349    // [Top] Green-> Blue -> Red [Bottom]
 350    list = etRunner::get().getWinInfoList();
 351    ASSERT_TRUE(list != NULL);
 352
 353    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 354      {
 355         if (tw->layer > 200)
 356           continue;
 357
 358         if (pass_count == 0)
 359           {
 360              ASSERT_EQ(tw->native_win, tw_green->native_win);
 361              pass_count++;
 362              continue;
 363           }
 364         else if (pass_count == 1)
 365           {
 366              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 367              pass_count++;
 368              continue;
 369           }
 370         else
 371           {
 372              ASSERT_EQ(tw->native_win, tw_red->native_win);
 373              pass_count++;
 374           }
 375
 376         break;
 377      }
 378    etRunner::get().freeWinInfoList(list);
 379
 380    ASSERT_EQ(3, pass_count);
 381
 382    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 383 }
 384
 385 TEST_F(etTestBaseMulti, multi_all_wins_stack_above1)
 386 {
 387    etWin *tw = NULL;
 388    Eina_List *list = NULL, *l = NULL;
 389    int pass_count = 0;
 390
 391    // init TC window, show=true, geom=true
 392    initTC(EINA_TRUE, EINA_TRUE);
 393
 394    // Raise Red on the Green
 395    etRunner::get().setWinStack(tw_red, tw_green, EINA_TRUE);
 396    ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
 397
 398    // Expected stack res:
 399    // [Top] Blue -> Red -> Green [Bottom]
 400    list = etRunner::get().getWinInfoList();
 401    ASSERT_TRUE(list != NULL);
 402
 403    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 404      {
 405         if (tw->layer > 200)
 406           continue;
 407
 408         if (pass_count == 0)
 409           {
 410              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 411              pass_count++;
 412              continue;
 413           }
 414         else if (pass_count == 1)
 415           {
 416              ASSERT_EQ(tw->native_win, tw_red->native_win);
 417              pass_count++;
 418              continue;
 419           }
 420         else
 421           {
 422              ASSERT_EQ(tw->native_win, tw_green->native_win);
 423              pass_count++;
 424           }
 425
 426         break;
 427      }
 428    etRunner::get().freeWinInfoList(list);
 429
 430    ASSERT_EQ(3, pass_count);
 431
 432    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 433 }
 434
 435 TEST_F(etTestBaseMulti, multi_all_wins_stack_above2)
 436 {
 437    etWin *tw = NULL;
 438    Eina_List *list = NULL, *l = NULL;
 439    int pass_count = 0;
 440
 441    // init TC window, show=true, geom=true
 442    initTC(EINA_TRUE, EINA_TRUE);
 443
 444    // Raise Blue on the Red
 445    etRunner::get().setWinStack(tw_blue, tw_red, EINA_TRUE);
 446    ASSERT_EVENT(tw_blue, E_TC_EVENT_TYPE_STACK_ABOVE);
 447
 448    // Expected stack res:
 449    // [Top] Green-> Blue -> Red [Bottom]
 450    list = etRunner::get().getWinInfoList();
 451    ASSERT_TRUE(list != NULL);
 452
 453    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 454      {
 455         if (tw->layer > 200)
 456           continue;
 457
 458         if (pass_count == 0)
 459           {
 460              ASSERT_EQ(tw->native_win, tw_green->native_win);
 461              pass_count++;
 462              continue;
 463           }
 464         else if (pass_count == 1)
 465           {
 466              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 467              pass_count++;
 468              continue;
 469           }
 470         else
 471           {
 472              ASSERT_EQ(tw->native_win, tw_red->native_win);
 473              pass_count++;
 474           }
 475
 476         break;
 477      }
 478    etRunner::get().freeWinInfoList(list);
 479
 480    ASSERT_EQ(3, pass_count);
 481
 482    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 483 }
 484
 485 TEST_F(etTestBaseMulti, multi_all_wins_stack_above3)
 486 {
 487    etWin *tw = NULL;
 488    Eina_List *list = NULL, *l = NULL;
 489    int pass_count = 0;
 490
 491    // init TC window, show=true, geom=true
 492    initTC(EINA_TRUE, EINA_TRUE);
 493
 494    // Raise Red on the Blue
 495    etRunner::get().setWinStack(tw_red, tw_blue, EINA_TRUE);
 496    ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
 497
 498    // Expected stack res:
 499    // [Top] Green-> Blue -> Red [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)
 506           continue;
 507
 508         if (pass_count == 0)
 509           {
 510              ASSERT_EQ(tw->native_win, tw_red->native_win);
 511              pass_count++;
 512              continue;
 513           }
 514         else if (pass_count == 1)
 515           {
 516              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 517              pass_count++;
 518              continue;
 519           }
 520         else
 521           {
 522              ASSERT_EQ(tw->native_win, tw_green->native_win);
 523              pass_count++;
 524           }
 525
 526         break;
 527      }
 528    etRunner::get().freeWinInfoList(list);
 529
 530    ASSERT_EQ(3, pass_count);
 531
 532    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 533 }
 534
 535 TEST_F(etTestBaseMulti, multi_all_wins_lower1)
 536 {
 537    etWin *tw = NULL, *tw_above = NULL;
 538    Eina_List *list = NULL, *l = NULL;
 539    int pass_count = 0;
 540
 541    // init TC window, show=true, geom=true
 542    initTC(EINA_TRUE, EINA_TRUE);
 543
 544    // Lower Blue
 545    etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE);
 546    ASSERT_EVENT(tw_blue, E_TC_EVENT_TYPE_STACK_LOWER);
 547
 548    // Expected stack res:
 549    // [Top] Green -> Red -> ... -> Blue [Bottom]
 550    list = etRunner::get().getWinInfoList();
 551    ASSERT_TRUE(list != NULL);
 552
 553    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 554      {
 555         if (tw->layer > 200)
 556           continue;
 557
 558         if (pass_count == 0)
 559           {
 560              ASSERT_EQ(tw->native_win, tw_green->native_win);
 561              pass_count++;
 562              continue;
 563           }
 564         else if (pass_count == 1)
 565           {
 566              ASSERT_EQ(tw->native_win, tw_red->native_win);
 567              pass_count++;
 568              continue;
 569           }
 570         else
 571           {
 572              if (tw->layer < 200)
 573                {
 574                   ASSERT_EQ(tw->native_win, tw_blue->native_win);
 575                   pass_count++;
 576                }
 577              else
 578                {
 579                   tw_above = tw;
 580                   continue;
 581                }
 582           }
 583
 584         break;
 585      }
 586
 587    // check the tw_above when there is no window under 200 layer
 588    if (tw == NULL)
 589      {
 590         ASSERT_TRUE(tw_above != NULL);
 591         ASSERT_EQ(tw_above->native_win, tw_blue->native_win);
 592         pass_count++;
 593      }
 594    etRunner::get().freeWinInfoList(list);
 595
 596    ASSERT_EQ(3, pass_count);
 597
 598    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 599 }
 600
 601 TEST_F(etTestBaseMulti, multi_all_wins_lower2)
 602 {
 603    etWin *tw = NULL, *tw_above = NULL;
 604    Eina_List *list = NULL, *l = NULL;
 605    int pass_count = 0;
 606
 607    // init TC window, show=true, geom=true
 608    initTC(EINA_TRUE, EINA_TRUE);
 609
 610    // Lower Green
 611    etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE);
 612    ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_LOWER);
 613
 614    // Expected stack res:
 615    // [Top] Blue -> Red -> ... -> Green [Bottom]
 616    list = etRunner::get().getWinInfoList();
 617    ASSERT_TRUE(list != NULL);
 618
 619    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 620      {
 621         if (tw->layer > 200)
 622           continue;
 623
 624         if (pass_count == 0)
 625           {
 626              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 627              pass_count++;
 628              continue;
 629           }
 630         else if (pass_count == 1)
 631           {
 632              ASSERT_EQ(tw->native_win, tw_red->native_win);
 633              pass_count++;
 634              continue;
 635           }
 636         else
 637           {
 638              if (tw->layer < 200)
 639                {
 640                   ASSERT_EQ(tw->native_win, tw_green->native_win);
 641                   pass_count++;
 642                }
 643              else
 644                {
 645                   tw_above = tw;
 646                   continue;
 647                }
 648           }
 649
 650         break;
 651      }
 652
 653    // check the tw_above when there is no window under 200 layer
 654    if (tw == NULL)
 655      {
 656         ASSERT_TRUE(tw_above != NULL);
 657         ASSERT_EQ(tw_above->native_win, tw_green->native_win);
 658         pass_count++;
 659      }
 660    etRunner::get().freeWinInfoList(list);
 661
 662    ASSERT_EQ(3, pass_count);
 663
 664    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 665 }
 666
 667 TEST_F(etTestBaseMulti, multi_all_wins_iconify)
 668 {
 669    etWin *tw = NULL;
 670    Eina_Bool res = EINA_FALSE;
 671    Eina_List *list = NULL, *l = NULL;
 672    int pass_count = 0;
 673
 674    // init TC window, show=true, geom=true
 675    initTC(EINA_TRUE, EINA_TRUE);
 676
 677    // Iconify Blue
 678    res = etRunner::get().setWinIconic(tw_blue, EINA_TRUE);
 679    ASSERT_TRUE(res);
 680    ASSERT_ICONIFIED(tw_blue);
 681
 682    // Expected stack res:
 683    // [Top] Blue -> Green -> Red [Bottom]
 684    list = etRunner::get().getWinInfoList();
 685    ASSERT_TRUE(list != NULL);
 686
 687    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 688      {
 689         if (tw->layer > 200)
 690           continue;
 691
 692         if (pass_count == 0)
 693           {
 694              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 695              ASSERT_FALSE(tw->Vis.obj);
 696              pass_count++;
 697              continue;
 698           }
 699         else if (pass_count == 1)
 700           {
 701              ASSERT_EQ(tw->native_win, tw_green->native_win);
 702              ASSERT_TRUE(tw->Vis.obj);
 703              pass_count++;
 704              continue;
 705           }
 706         else
 707           {
 708              ASSERT_EQ(tw->native_win, tw_red->native_win);
 709              ASSERT_TRUE(tw->Vis.obj);
 710              pass_count++;
 711           }
 712
 713         break;
 714      }
 715    etRunner::get().freeWinInfoList(list);
 716
 717    ASSERT_EQ(3, pass_count);
 718
 719    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 720 }
 721
 722 TEST_F(etTestBaseMulti, multi_all_wins_uniconify)
 723 {
 724    etWin *tw = NULL;
 725    Eina_Bool res = EINA_FALSE;
 726    Eina_List *list = NULL, *l = NULL;
 727    int pass_count = 0;
 728
 729    // init TC window, show=true, geom=true
 730    initTC(EINA_TRUE, EINA_TRUE);
 731
 732    // set tw_blue bg color change
 733    tw_blue->startBGColor(0.5);
 734
 735    // Iconify Blue
 736    res = etRunner::get().setWinIconic(tw_blue, EINA_TRUE);
 737    ASSERT_TRUE(res);
 738    ASSERT_ICONIFIED(tw_blue);
 739
 740    // Unconify Blue
 741    res = etRunner::get().setWinIconic(tw_blue, EINA_FALSE);
 742    ASSERT_TRUE(res);
 743    ASSERT_UNICONIFIED(tw_blue);
 744
 745    // unset tw_blue bg color change
 746    tw_blue->stopBGColor();
 747
 748    // Expected stack res:
 749    // [Top] Blue -> Green -> Red [Bottom]
 750    list = etRunner::get().getWinInfoList();
 751    ASSERT_TRUE(list != NULL);
 752
 753    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 754      {
 755         if (tw->layer > 200)
 756           continue;
 757
 758         if (pass_count == 0)
 759           {
 760              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 761              ASSERT_TRUE(tw->Vis.obj);
 762              pass_count++;
 763              continue;
 764           }
 765         else if (pass_count == 1)
 766           {
 767              ASSERT_EQ(tw->native_win, tw_green->native_win);
 768              ASSERT_TRUE(tw->Vis.obj);
 769              pass_count++;
 770              continue;
 771           }
 772         else
 773           {
 774              ASSERT_EQ(tw->native_win, tw_red->native_win);
 775              ASSERT_TRUE(tw->Vis.obj);
 776              pass_count++;
 777           }
 778
 779         break;
 780      }
 781    etRunner::get().freeWinInfoList(list);
 782
 783    ASSERT_EQ(3, pass_count);
 784
 785    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 786 }
 787
 788 TEST_F(etTestBaseMulti, multi_all_full_wins_basic)
 789 {
 790    etWin *tw = NULL;
 791    Eina_List *list = NULL, *l = NULL;
 792    int pass_count = 0;
 793
 794    // init TC window, show=true, geom=false
 795    initTC(EINA_TRUE, EINA_FALSE);
 796
 797    // Expected stack res:
 798    // [Top] Blue -> Green -> Red [Bottom]
 799    list = etRunner::get().getWinInfoList();
 800    ASSERT_TRUE(list != NULL);
 801
 802    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 803      {
 804         if (tw->layer > 200)
 805           continue;
 806
 807         if (pass_count == 0)
 808           {
 809              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 810              pass_count++;
 811              continue;
 812           }
 813         else if (pass_count == 1)
 814           {
 815              ASSERT_EQ(tw->native_win, tw_green->native_win);
 816              pass_count++;
 817              continue;
 818           }
 819         else
 820           {
 821              ASSERT_EQ(tw->native_win, tw_red->native_win);
 822              pass_count++;
 823           }
 824
 825         break;
 826      }
 827    etRunner::get().freeWinInfoList(list);
 828
 829    ASSERT_EQ(3, pass_count);
 830
 831    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 832 }
 833
 834 TEST_F(etTestBaseMulti, multi_all_full_wins_show1)
 835 {
 836    etWin *tw = NULL;
 837    Eina_Bool res = EINA_FALSE;
 838    Eina_List *list = NULL, *l = NULL;
 839    int pass_count = 0;
 840
 841    // init TC window, show=false, geom=false
 842    initTC(EINA_FALSE, EINA_FALSE);
 843
 844    // show red
 845    res = showTCWin(tw_red);
 846    ASSERT_TRUE(res);
 847    ASSERT_VIS_ON(tw_red);
 848
 849    // show blue
 850    res = showTCWin(tw_blue);
 851    ASSERT_TRUE(res);
 852    ASSERT_VIS_ON(tw_blue);
 853
 854    // show green
 855    res = showTCWin(tw_green);
 856    ASSERT_TRUE(res);
 857    ASSERT_VIS_ON(tw_green);
 858
 859    // Expected stack res:
 860    // [Top] Green -> Blue -> Red [Bottom]
 861    list = etRunner::get().getWinInfoList();
 862    ASSERT_TRUE(list != NULL);
 863
 864    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 865      {
 866         if (tw->layer > 200)
 867           continue;
 868
 869         if (pass_count == 0)
 870           {
 871              ASSERT_EQ(tw->native_win, tw_green->native_win);
 872              pass_count++;
 873              continue;
 874           }
 875         else if (pass_count == 1)
 876           {
 877              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 878              pass_count++;
 879              continue;
 880           }
 881         else
 882           {
 883              ASSERT_EQ(tw->native_win, tw_red->native_win);
 884              pass_count++;
 885           }
 886
 887         break;
 888      }
 889    etRunner::get().freeWinInfoList(list);
 890
 891    ASSERT_EQ(3, pass_count);
 892
 893    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 894 }
 895
 896 TEST_F(etTestBaseMulti, multi_all_full_wins_show2)
 897 {
 898    etWin *tw = NULL;
 899    Eina_Bool res = EINA_FALSE;
 900    Eina_List *list = NULL, *l = NULL;
 901    int pass_count = 0;
 902
 903    // init TC window, show=false, geom=false
 904    initTC(EINA_FALSE, EINA_FALSE);
 905
 906    // show blue
 907    res = showTCWin(tw_blue);
 908    ASSERT_TRUE(res);
 909    ASSERT_VIS_ON(tw_blue);
 910
 911    // show red
 912    res = showTCWin(tw_red);
 913    ASSERT_TRUE(res);
 914    ASSERT_VIS_ON(tw_red);
 915
 916    // show green
 917    res = showTCWin(tw_green);
 918    ASSERT_TRUE(res);
 919    ASSERT_VIS_ON(tw_green);
 920
 921    // Expected stack res:
 922    // [Top] Green -> Red -> Blue [Bottom]
 923    list = etRunner::get().getWinInfoList();
 924    ASSERT_TRUE(list != NULL);
 925
 926    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 927      {
 928         if (tw->layer > 200)
 929           continue;
 930
 931         if (pass_count == 0)
 932           {
 933              ASSERT_EQ(tw->native_win, tw_green->native_win);
 934              pass_count++;
 935              continue;
 936           }
 937         else if (pass_count == 1)
 938           {
 939              ASSERT_EQ(tw->native_win, tw_red->native_win);
 940              pass_count++;
 941              continue;
 942           }
 943         else
 944           {
 945              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 946              pass_count++;
 947           }
 948
 949         break;
 950      }
 951    etRunner::get().freeWinInfoList(list);
 952
 953    ASSERT_EQ(3, pass_count);
 954
 955    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 956 }
 957
 958 TEST_F(etTestBaseMulti, multi_all_full_wins_show3)
 959 {
 960    etWin *tw = NULL;
 961    Eina_Bool res = EINA_FALSE;
 962    Eina_List *list = NULL, *l = NULL;
 963    int pass_count = 0;
 964
 965    // init TC window, show=false, geom=false
 966    initTC(EINA_FALSE, EINA_FALSE);
 967
 968    // show green
 969    res = showTCWin(tw_green);
 970    ASSERT_TRUE(res);
 971    ASSERT_VIS_ON(tw_green);
 972
 973    // show blue
 974    res = showTCWin(tw_blue);
 975    ASSERT_TRUE(res);
 976    ASSERT_VIS_ON(tw_blue);
 977
 978    // show red
 979    res = showTCWin(tw_red);
 980    ASSERT_TRUE(res);
 981    ASSERT_VIS_ON(tw_red);
 982
 983    // Expected stack res:
 984    // [Top] Red -> Blue -> Green [Bottom]
 985    list = etRunner::get().getWinInfoList();
 986    ASSERT_TRUE(list != NULL);
 987
 988    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 989      {
 990         if (tw->layer > 200)
 991           continue;
 992
 993         if (pass_count == 0)
 994           {
 995              ASSERT_EQ(tw->native_win, tw_red->native_win);
 996              pass_count++;
 997              continue;
 998           }
 999         else if (pass_count == 1)
1000           {
1001              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1002              pass_count++;
1003              continue;
1004           }
1005         else
1006           {
1007              ASSERT_EQ(tw->native_win, tw_green->native_win);
1008              pass_count++;
1009           }
1010
1011         break;
1012      }
1013    etRunner::get().freeWinInfoList(list);
1014
1015    ASSERT_EQ(3, pass_count);
1016
1017    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1018 }
1019
1020 TEST_F(etTestBaseMulti, multi_all_full_wins_raise1)
1021 {
1022    etWin *tw = NULL;
1023    Eina_List *list = NULL, *l = NULL;
1024    int pass_count = 0;
1025
1026    // init TC window, show=true, geom=false
1027    initTC(EINA_TRUE, EINA_FALSE);
1028
1029    // Raise Red
1030    etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE);
1031    ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_RAISE);
1032
1033    // Expected stack res:
1034    // [Top] Red -> Blue -> Green [Bottom]
1035    list = etRunner::get().getWinInfoList();
1036    ASSERT_TRUE(list != NULL);
1037
1038    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1039      {
1040         if (tw->layer > 200)
1041           continue;
1042
1043         if (pass_count == 0)
1044           {
1045              ASSERT_EQ(tw->native_win, tw_red->native_win);
1046              pass_count++;
1047              continue;
1048           }
1049         else if (pass_count == 1)
1050           {
1051              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1052              pass_count++;
1053              continue;
1054           }
1055         else
1056           {
1057              ASSERT_EQ(tw->native_win, tw_green->native_win);
1058              pass_count++;
1059           }
1060
1061         break;
1062      }
1063    etRunner::get().freeWinInfoList(list);
1064
1065    ASSERT_EQ(3, pass_count);
1066
1067    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1068 }
1069
1070 TEST_F(etTestBaseMulti, multi_all_full_wins_raise2)
1071 {
1072    etWin *tw = NULL;
1073    Eina_List *list = NULL, *l = NULL;
1074    int pass_count = 0;
1075
1076    // init TC window, show=true, geom=false
1077    initTC(EINA_TRUE, EINA_FALSE);
1078
1079    // Raise Green
1080    etRunner::get().setWinStack(tw_green, NULL, EINA_TRUE);
1081    ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_RAISE);
1082
1083    // Expected stack res:
1084    // [Top] Green-> Blue -> Red [Bottom]
1085    list = etRunner::get().getWinInfoList();
1086    ASSERT_TRUE(list != NULL);
1087
1088    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1089      {
1090         if (tw->layer > 200)
1091           continue;
1092
1093         if (pass_count == 0)
1094           {
1095              ASSERT_EQ(tw->native_win, tw_green->native_win);
1096              pass_count++;
1097              continue;
1098           }
1099         else if (pass_count == 1)
1100           {
1101              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1102              pass_count++;
1103              continue;
1104           }
1105         else
1106           {
1107              ASSERT_EQ(tw->native_win, tw_red->native_win);
1108              pass_count++;
1109           }
1110
1111         break;
1112      }
1113    etRunner::get().freeWinInfoList(list);
1114
1115    ASSERT_EQ(3, pass_count);
1116
1117    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1118 }
1119
1120 TEST_F(etTestBaseMulti, multi_all_full_wins_stack_above1)
1121 {
1122    etWin *tw = NULL;
1123    Eina_List *list = NULL, *l = NULL;
1124    int pass_count = 0;
1125
1126    // init TC window, show=true, geom=false
1127    initTC(EINA_TRUE, EINA_FALSE);
1128
1129    // Raise Red on the Green
1130    etRunner::get().setWinStack(tw_red, tw_green, EINA_TRUE);
1131    ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
1132
1133    // Expected stack res:
1134    // [Top] Blue -> Red -> Green [Bottom]
1135    list = etRunner::get().getWinInfoList();
1136    ASSERT_TRUE(list != NULL);
1137
1138    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1139      {
1140         if (tw->layer > 200)
1141           continue;
1142
1143         if (pass_count == 0)
1144           {
1145              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1146              pass_count++;
1147              continue;
1148           }
1149         else if (pass_count == 1)
1150           {
1151              ASSERT_EQ(tw->native_win, tw_red->native_win);
1152              pass_count++;
1153              continue;
1154           }
1155         else
1156           {
1157              ASSERT_EQ(tw->native_win, tw_green->native_win);
1158              pass_count++;
1159           }
1160
1161         break;
1162      }
1163    etRunner::get().freeWinInfoList(list);
1164
1165    ASSERT_EQ(3, pass_count);
1166
1167    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1168 }
1169
1170 TEST_F(etTestBaseMulti, multi_all_full_wins_stack_above2)
1171 {
1172    etWin *tw = NULL;
1173    Eina_List *list = NULL, *l = NULL;
1174    int pass_count = 0;
1175
1176    // init TC window, show=true, geom=false
1177    initTC(EINA_TRUE, EINA_FALSE);
1178
1179    // Raise Blue on the Red
1180    etRunner::get().setWinStack(tw_blue, tw_red, EINA_TRUE);
1181    ASSERT_EVENT(tw_blue, E_TC_EVENT_TYPE_STACK_ABOVE);
1182
1183    // Expected stack res:
1184    // [Top] Green-> Blue -> Red [Bottom]
1185    list = etRunner::get().getWinInfoList();
1186    ASSERT_TRUE(list != NULL);
1187
1188    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1189      {
1190         if (tw->layer > 200)
1191           continue;
1192
1193         if (pass_count == 0)
1194           {
1195              ASSERT_EQ(tw->native_win, tw_green->native_win);
1196              pass_count++;
1197              continue;
1198           }
1199         else if (pass_count == 1)
1200           {
1201              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1202              pass_count++;
1203              continue;
1204           }
1205         else
1206           {
1207              ASSERT_EQ(tw->native_win, tw_red->native_win);
1208              pass_count++;
1209           }
1210
1211         break;
1212      }
1213    etRunner::get().freeWinInfoList(list);
1214
1215    ASSERT_EQ(3, pass_count);
1216
1217    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1218 }
1219
1220 TEST_F(etTestBaseMulti, multi_all_full_wins_stack_above3)
1221 {
1222    etWin *tw = NULL;
1223    Eina_List *list = NULL, *l = NULL;
1224    int pass_count = 0;
1225
1226    // init TC window, show=true, geom=false
1227    initTC(EINA_TRUE, EINA_FALSE);
1228
1229    // Raise Red on the Blue
1230    etRunner::get().setWinStack(tw_red, tw_blue, EINA_TRUE);
1231    ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
1232
1233    // Expected stack res:
1234    // [Top] Green-> Blue -> Red [Bottom]
1235    list = etRunner::get().getWinInfoList();
1236    ASSERT_TRUE(list != NULL);
1237
1238    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1239      {
1240         if (tw->layer > 200)
1241           continue;
1242
1243         if (pass_count == 0)
1244           {
1245              ASSERT_EQ(tw->native_win, tw_red->native_win);
1246              pass_count++;
1247              continue;
1248           }
1249         else if (pass_count == 1)
1250           {
1251              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1252              pass_count++;
1253              continue;
1254           }
1255         else
1256           {
1257              ASSERT_EQ(tw->native_win, tw_green->native_win);
1258              pass_count++;
1259           }
1260
1261         break;
1262      }
1263    etRunner::get().freeWinInfoList(list);
1264
1265    ASSERT_EQ(3, pass_count);
1266
1267    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1268 }
1269
1270 TEST_F(etTestBaseMulti, multi_all_full_wins_lower1)
1271 {
1272    etWin *tw = NULL, *tw_above = NULL;
1273    Eina_List *list = NULL, *l = NULL;
1274    int pass_count = 0;
1275
1276    // init TC window, show=true, geom=false
1277    initTC(EINA_TRUE, EINA_FALSE);
1278
1279    // Lower Blue
1280    etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE);
1281    ASSERT_EVENT(tw_blue, E_TC_EVENT_TYPE_STACK_LOWER);
1282
1283    // Expected stack res:
1284    // [Top] Green -> Red -> ... -> Blue [Bottom]
1285    list = etRunner::get().getWinInfoList();
1286    ASSERT_TRUE(list != NULL);
1287
1288    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1289      {
1290         if (tw->layer > 200)
1291           continue;
1292
1293         if (pass_count == 0)
1294           {
1295              ASSERT_EQ(tw->native_win, tw_green->native_win);
1296              pass_count++;
1297              continue;
1298           }
1299         else if (pass_count == 1)
1300           {
1301              ASSERT_EQ(tw->native_win, tw_red->native_win);
1302              pass_count++;
1303              continue;
1304           }
1305         else
1306           {
1307              if (tw->layer < 200)
1308                {
1309                   ASSERT_EQ(tw->native_win, tw_blue->native_win);
1310                   pass_count++;
1311                }
1312              else
1313                {
1314                   tw_above = tw;
1315                   continue;
1316                }
1317           }
1318
1319         break;
1320      }
1321
1322    // check the tw_above when there is no window under 200 layer
1323    if (tw == NULL)
1324      {
1325         ASSERT_TRUE(tw_above != NULL);
1326         ASSERT_EQ(tw_above->native_win, tw_blue->native_win);
1327         pass_count++;
1328      }
1329    etRunner::get().freeWinInfoList(list);
1330
1331    ASSERT_EQ(3, pass_count);
1332
1333    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1334 }
1335
1336 TEST_F(etTestBaseMulti, multi_all_full_wins_lower2)
1337 {
1338    etWin *tw = NULL, *tw_above = NULL;
1339    Eina_List *list = NULL, *l = NULL;
1340    int pass_count = 0;
1341
1342    // init TC window, show=true, geom=false
1343    initTC(EINA_TRUE, EINA_FALSE);
1344
1345    // Lower Green
1346    etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE);
1347    ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_LOWER);
1348
1349    // Expected stack res:
1350    // [Top] Blue -> Red -> ... -> Green [Bottom]
1351    list = etRunner::get().getWinInfoList();
1352    ASSERT_TRUE(list != NULL);
1353
1354    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1355      {
1356         if (tw->layer > 200)
1357           continue;
1358
1359         if (pass_count == 0)
1360           {
1361              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1362              pass_count++;
1363              continue;
1364           }
1365         else if (pass_count == 1)
1366           {
1367              ASSERT_EQ(tw->native_win, tw_red->native_win);
1368              pass_count++;
1369              continue;
1370           }
1371         else
1372           {
1373              if (tw->layer < 200)
1374                {
1375                   ASSERT_EQ(tw->native_win, tw_green->native_win);
1376                   pass_count++;
1377                }
1378              else
1379                {
1380                   tw_above = tw;
1381                   continue;
1382                }
1383           }
1384
1385         break;
1386      }
1387
1388    // check the tw_above when there is no window under 200 layer
1389    if (tw == NULL)
1390      {
1391         ASSERT_TRUE(tw_above != NULL);
1392         ASSERT_EQ(tw_above->native_win, tw_green->native_win);
1393         pass_count++;
1394      }
1395    etRunner::get().freeWinInfoList(list);
1396
1397    ASSERT_EQ(3, pass_count);
1398
1399    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1400 }
1401
1402 TEST_F(etTestBaseMulti, multi_all_full_wins_lower_activate)
1403 {
1404    etWin *tw = NULL;
1405    Eina_List *list = NULL, *l = NULL;
1406    int pass_count = 0;
1407
1408    // init TC window, show=true, geom=false
1409    initTC(EINA_TRUE, EINA_FALSE);
1410
1411    // Lower Blue
1412    evas_object_lower(tw_blue->elm_win);
1413    // Activate Blue immediately
1414    etRunner::get().setWinActivate(tw_blue);
1415    etRunner::get().work(0.1); // wait for activate done. It does not change stack.
1416
1417    // Expected stack res:
1418    // [Top] Blue -> Green -> Red [Bottom]
1419    list = etRunner::get().getWinInfoList();
1420    ASSERT_TRUE(list != NULL);
1421
1422    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1423      {
1424         if (tw->layer > 200)
1425           continue;
1426
1427         if (pass_count == 0)
1428           {
1429              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1430              pass_count++;
1431              continue;
1432           }
1433         else if (pass_count == 1)
1434           {
1435              ASSERT_EQ(tw->native_win, tw_green->native_win);
1436              pass_count++;
1437              continue;
1438           }
1439         else
1440           {
1441              ASSERT_EQ(tw->native_win, tw_red->native_win);
1442              pass_count++;
1443           }
1444
1445         break;
1446      }
1447    etRunner::get().freeWinInfoList(list);
1448
1449    ASSERT_EQ(3, pass_count);
1450
1451    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1452 }
1453
1454 TEST_F(etTestBaseMulti, multi_all_full_wins_iconify)
1455 {
1456    etWin *tw = NULL;
1457    Eina_Bool res = EINA_FALSE;
1458    Eina_List *list = NULL, *l = NULL;
1459    int pass_count = 0;
1460
1461    // init TC window, show=true, geom=false
1462    initTC(EINA_TRUE, EINA_FALSE);
1463
1464    // Iconify Blue
1465    res = etRunner::get().setWinIconic(tw_blue, EINA_TRUE);
1466    ASSERT_TRUE(res);
1467    ASSERT_ICONIFIED(tw_blue);
1468
1469    // Expected stack res:
1470    // [Top] Blue -> Green -> Red [Bottom]
1471    list = etRunner::get().getWinInfoList();
1472    ASSERT_TRUE(list != NULL);
1473
1474    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1475      {
1476         if (tw->layer > 200)
1477           continue;
1478
1479         if (pass_count == 0)
1480           {
1481              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1482              ASSERT_FALSE(tw->Vis.obj);
1483              pass_count++;
1484              continue;
1485           }
1486         else if (pass_count == 1)
1487           {
1488              ASSERT_EQ(tw->native_win, tw_green->native_win);
1489              ASSERT_TRUE(tw->Vis.obj);
1490              pass_count++;
1491              continue;
1492           }
1493         else
1494           {
1495              ASSERT_EQ(tw->native_win, tw_red->native_win);
1496              ASSERT_FALSE(tw->Vis.obj);
1497              pass_count++;
1498           }
1499
1500         break;
1501      }
1502    etRunner::get().freeWinInfoList(list);
1503
1504    ASSERT_EQ(3, pass_count);
1505
1506    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1507 }
1508
1509 TEST_F(etTestBaseMulti, multi_all_full_wins_uniconify)
1510 {
1511    etWin *tw = NULL;
1512    Eina_Bool res = EINA_FALSE;
1513    Eina_List *list = NULL, *l = NULL;
1514    int pass_count = 0;
1515
1516    // init TC window, show=true, geom=false
1517    initTC(EINA_TRUE, EINA_FALSE);
1518
1519    // set tw_blue bg color change
1520    tw_blue->startBGColor(0.5);
1521
1522    // Iconify Blue
1523    res = etRunner::get().setWinIconic(tw_blue, EINA_TRUE);
1524    ASSERT_TRUE(res);
1525    ASSERT_ICONIFIED(tw_blue);
1526
1527    // Unconify Blue
1528    res = etRunner::get().setWinIconic(tw_blue, EINA_FALSE);
1529    ASSERT_TRUE(res);
1530    ASSERT_UNICONIFIED(tw_blue);
1531
1532    // unset tw_blue bg color change
1533    tw_blue->stopBGColor();
1534
1535    // Expected stack res:
1536    // [Top] Blue -> Green -> Red [Bottom]
1537    list = etRunner::get().getWinInfoList();
1538    ASSERT_TRUE(list != NULL);
1539
1540    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1541      {
1542         if (tw->layer > 200)
1543           continue;
1544
1545         if (pass_count == 0)
1546           {
1547              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1548              ASSERT_TRUE(tw->Vis.obj);
1549              pass_count++;
1550              continue;
1551           }
1552         else if (pass_count == 1)
1553           {
1554              ASSERT_EQ(tw->native_win, tw_green->native_win);
1555              ASSERT_FALSE(tw->Vis.obj);
1556              pass_count++;
1557              continue;
1558           }
1559         else
1560           {
1561              ASSERT_EQ(tw->native_win, tw_red->native_win);
1562              ASSERT_FALSE(tw->Vis.obj);
1563              pass_count++;
1564           }
1565
1566         break;
1567      }
1568    etRunner::get().freeWinInfoList(list);
1569
1570    ASSERT_EQ(3, pass_count);
1571
1572    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1573 }
1574
1575 TEST_F(etTestBaseMulti, multi_2wins_show1)
1576 {
1577    etWin *tw = NULL;
1578    Eina_Bool res = EINA_FALSE;
1579    Eina_List *list = NULL, *l = NULL;
1580    int pass_count = 0;
1581
1582    // init TC window, show=false, geom=true
1583    initTC(EINA_FALSE, EINA_TRUE);
1584
1585    // show green
1586    res = showTCWin(tw_green);
1587    ASSERT_TRUE(res);
1588    ASSERT_VIS_ON(tw_green);
1589
1590    // show red
1591    res = showTCWin(tw_red);
1592    ASSERT_TRUE(res);
1593    ASSERT_VIS_ON(tw_red);
1594
1595    // Expected stack res:
1596    // [Top] Red -> Green [Bottom]
1597    list = etRunner::get().getWinInfoList();
1598    ASSERT_TRUE(list != NULL);
1599
1600    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1601      {
1602         if (tw->layer > 200)
1603           continue;
1604
1605         if (pass_count == 0)
1606           {
1607              ASSERT_EQ(tw->native_win, tw_red->native_win);
1608              pass_count++;
1609              continue;
1610           }
1611         else
1612           {
1613              ASSERT_EQ(tw->native_win, tw_green->native_win);
1614              pass_count++;
1615           }
1616
1617         break;
1618      }
1619    etRunner::get().freeWinInfoList(list);
1620
1621    ASSERT_EQ(2, pass_count);
1622
1623    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1624 }
1625
1626 TEST_F(etTestBaseMulti, multi_2wins_show2)
1627 {
1628    etWin *tw = NULL;
1629    Eina_Bool res = EINA_FALSE;
1630    Eina_List *list = NULL, *l = NULL;
1631    int pass_count = 0;
1632
1633    // init TC window, show=false, geom=true
1634    initTC(EINA_FALSE, EINA_TRUE);
1635
1636    // show blue
1637    res = showTCWin(tw_blue);
1638    ASSERT_TRUE(res);
1639    ASSERT_VIS_ON(tw_blue);
1640
1641    // show green
1642    res = showTCWin(tw_green);
1643    ASSERT_TRUE(res);
1644    ASSERT_VIS_ON(tw_green);
1645
1646    // Expected stack res:
1647    // [Top] Green -> Blue [Bottom]
1648    list = etRunner::get().getWinInfoList();
1649    ASSERT_TRUE(list != NULL);
1650
1651    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1652      {
1653         if (tw->layer > 200)
1654           continue;
1655
1656         if (pass_count == 0)
1657           {
1658              ASSERT_EQ(tw->native_win, tw_green->native_win);
1659              pass_count++;
1660              continue;
1661           }
1662         else
1663           {
1664              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1665              pass_count++;
1666           }
1667
1668         break;
1669      }
1670    etRunner::get().freeWinInfoList(list);
1671
1672    ASSERT_EQ(2, pass_count);
1673
1674    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1675 }
1676
1677 TEST_F(etTestBaseMulti, multi_2wins_show3)
1678 {
1679    etWin *tw = NULL;
1680    Eina_Bool res = EINA_FALSE;
1681    Eina_List *list = NULL, *l = NULL;
1682    int pass_count = 0;
1683
1684    // init TC window, show=false, geom=true
1685    initTC(EINA_FALSE, EINA_TRUE);
1686
1687    // show red
1688    res = showTCWin(tw_red);
1689    ASSERT_TRUE(res);
1690    ASSERT_VIS_ON(tw_red);
1691
1692    // show blue
1693    res = showTCWin(tw_blue);
1694    ASSERT_TRUE(res);
1695    ASSERT_VIS_ON(tw_blue);
1696
1697    // Expected stack res:
1698    // [Top] Blue -> Red [Bottom]
1699    list = etRunner::get().getWinInfoList();
1700    ASSERT_TRUE(list != NULL);
1701
1702    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1703      {
1704         if (tw->layer > 200)
1705           continue;
1706
1707         if (pass_count == 0)
1708           {
1709              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1710              pass_count++;
1711              continue;
1712           }
1713         else
1714           {
1715              ASSERT_EQ(tw->native_win, tw_red->native_win);
1716              pass_count++;
1717           }
1718
1719         break;
1720      }
1721    etRunner::get().freeWinInfoList(list);
1722
1723    ASSERT_EQ(2, pass_count);
1724
1725    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1726 }
1727
1728 TEST_F(etTestBaseMulti, multi_full_2wins_show1)
1729 {
1730    etWin *tw = NULL;
1731    Eina_Bool res = EINA_FALSE;
1732    Eina_List *list = NULL, *l = NULL;
1733    int pass_count = 0;
1734
1735    // init TC window, show=false, geom=false
1736    initTC(EINA_FALSE, EINA_FALSE);
1737
1738    // show green
1739    res = showTCWin(tw_green);
1740    ASSERT_TRUE(res);
1741    ASSERT_VIS_ON(tw_green);
1742
1743    // show red
1744    res = showTCWin(tw_red);
1745    ASSERT_TRUE(res);
1746    ASSERT_VIS_ON(tw_red);
1747
1748    // Expected stack res:
1749    // [Top] Red -> Green [Bottom]
1750    list = etRunner::get().getWinInfoList();
1751    ASSERT_TRUE(list != NULL);
1752
1753    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1754      {
1755         if (tw->layer > 200)
1756           continue;
1757
1758         if (pass_count == 0)
1759           {
1760              ASSERT_EQ(tw->native_win, tw_red->native_win);
1761              pass_count++;
1762              continue;
1763           }
1764         else
1765           {
1766              ASSERT_EQ(tw->native_win, tw_green->native_win);
1767              pass_count++;
1768           }
1769
1770         break;
1771      }
1772    etRunner::get().freeWinInfoList(list);
1773
1774    ASSERT_EQ(2, pass_count);
1775
1776    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1777 }
1778
1779 TEST_F(etTestBaseMulti, multi_full_2wins_show2)
1780 {
1781    etWin *tw = NULL;
1782    Eina_Bool res = EINA_FALSE;
1783    Eina_List *list = NULL, *l = NULL;
1784    int pass_count = 0;
1785
1786    // init TC window, show=false, geom=false
1787    initTC(EINA_FALSE, EINA_FALSE);
1788
1789    // show blue
1790    res = showTCWin(tw_blue);
1791    ASSERT_TRUE(res);
1792    ASSERT_VIS_ON(tw_blue);
1793
1794    // show green
1795    res = showTCWin(tw_green);
1796    ASSERT_TRUE(res);
1797    ASSERT_VIS_ON(tw_green);
1798
1799    // Expected stack res:
1800    // [Top] Green -> Blue [Bottom]
1801    list = etRunner::get().getWinInfoList();
1802    ASSERT_TRUE(list != NULL);
1803
1804    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1805      {
1806         if (tw->layer > 200)
1807           continue;
1808
1809         if (pass_count == 0)
1810           {
1811              ASSERT_EQ(tw->native_win, tw_green->native_win);
1812              pass_count++;
1813              continue;
1814           }
1815         else
1816           {
1817              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1818              pass_count++;
1819           }
1820
1821         break;
1822      }
1823    etRunner::get().freeWinInfoList(list);
1824
1825    ASSERT_EQ(2, pass_count);
1826
1827    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1828 }
1829
1830 TEST_F(etTestBaseMulti, multi_full_2wins_show3)
1831 {
1832    etWin *tw = NULL;
1833    Eina_Bool res = EINA_FALSE;
1834    Eina_List *list = NULL, *l = NULL;
1835    int pass_count = 0;
1836
1837    // init TC window, show=false, geom=false
1838    initTC(EINA_FALSE, EINA_FALSE);
1839
1840    // show red
1841    res = showTCWin(tw_red);
1842    ASSERT_TRUE(res);
1843    ASSERT_VIS_ON(tw_red);
1844
1845    // show blue
1846    res = showTCWin(tw_blue);
1847    ASSERT_TRUE(res);
1848    ASSERT_VIS_ON(tw_blue);
1849
1850    // Expected stack res:
1851    // [Top] Blue -> Red [Bottom]
1852    list = etRunner::get().getWinInfoList();
1853    ASSERT_TRUE(list != NULL);
1854
1855    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1856      {
1857         if (tw->layer > 200)
1858           continue;
1859
1860         if (pass_count == 0)
1861           {
1862              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1863              pass_count++;
1864              continue;
1865           }
1866         else
1867           {
1868              ASSERT_EQ(tw->native_win, tw_red->native_win);
1869              pass_count++;
1870           }
1871
1872         break;
1873      }
1874    etRunner::get().freeWinInfoList(list);
1875
1876    ASSERT_EQ(2, pass_count);
1877
1878    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1879 }