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_full_wins_basic)
 668 {
 669    etWin *tw = NULL;
 670    Eina_List *list = NULL, *l = NULL;
 671    int pass_count = 0;
 672
 673    // init TC window, show=true, geom=false
 674    initTC(EINA_TRUE, EINA_FALSE);
 675
 676    // Expected stack res:
 677    // [Top] Blue -> Green -> Red [Bottom]
 678    list = etRunner::get().getWinInfoList();
 679    ASSERT_TRUE(list != NULL);
 680
 681    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 682      {
 683         if (tw->layer > 200)
 684           continue;
 685
 686         if (pass_count == 0)
 687           {
 688              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 689              pass_count++;
 690              continue;
 691           }
 692         else if (pass_count == 1)
 693           {
 694              ASSERT_EQ(tw->native_win, tw_green->native_win);
 695              pass_count++;
 696              continue;
 697           }
 698         else
 699           {
 700              ASSERT_EQ(tw->native_win, tw_red->native_win);
 701              pass_count++;
 702           }
 703
 704         break;
 705      }
 706    etRunner::get().freeWinInfoList(list);
 707
 708    ASSERT_EQ(3, pass_count);
 709
 710    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 711 }
 712
 713 TEST_F(etTestBaseMulti, multi_all_full_wins_show1)
 714 {
 715    etWin *tw = NULL;
 716    Eina_Bool res = EINA_FALSE;
 717    Eina_List *list = NULL, *l = NULL;
 718    int pass_count = 0;
 719
 720    // init TC window, show=false, geom=false
 721    initTC(EINA_FALSE, EINA_FALSE);
 722
 723    // show red
 724    res = showTCWin(tw_red);
 725    ASSERT_TRUE(res);
 726    ASSERT_VIS_ON(tw_red);
 727
 728    // show blue
 729    res = showTCWin(tw_blue);
 730    ASSERT_TRUE(res);
 731    ASSERT_VIS_ON(tw_blue);
 732
 733    // show green
 734    res = showTCWin(tw_green);
 735    ASSERT_TRUE(res);
 736    ASSERT_VIS_ON(tw_green);
 737
 738    // Expected stack res:
 739    // [Top] Green -> Blue -> Red [Bottom]
 740    list = etRunner::get().getWinInfoList();
 741    ASSERT_TRUE(list != NULL);
 742
 743    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 744      {
 745         if (tw->layer > 200)
 746           continue;
 747
 748         if (pass_count == 0)
 749           {
 750              ASSERT_EQ(tw->native_win, tw_green->native_win);
 751              pass_count++;
 752              continue;
 753           }
 754         else if (pass_count == 1)
 755           {
 756              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 757              pass_count++;
 758              continue;
 759           }
 760         else
 761           {
 762              ASSERT_EQ(tw->native_win, tw_red->native_win);
 763              pass_count++;
 764           }
 765
 766         break;
 767      }
 768    etRunner::get().freeWinInfoList(list);
 769
 770    ASSERT_EQ(3, pass_count);
 771
 772    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 773 }
 774
 775 TEST_F(etTestBaseMulti, multi_all_full_wins_show2)
 776 {
 777    etWin *tw = NULL;
 778    Eina_Bool res = EINA_FALSE;
 779    Eina_List *list = NULL, *l = NULL;
 780    int pass_count = 0;
 781
 782    // init TC window, show=false, geom=false
 783    initTC(EINA_FALSE, EINA_FALSE);
 784
 785    // show blue
 786    res = showTCWin(tw_blue);
 787    ASSERT_TRUE(res);
 788    ASSERT_VIS_ON(tw_blue);
 789
 790    // show red
 791    res = showTCWin(tw_red);
 792    ASSERT_TRUE(res);
 793    ASSERT_VIS_ON(tw_red);
 794
 795    // show green
 796    res = showTCWin(tw_green);
 797    ASSERT_TRUE(res);
 798    ASSERT_VIS_ON(tw_green);
 799
 800    // Expected stack res:
 801    // [Top] Green -> Red -> Blue [Bottom]
 802    list = etRunner::get().getWinInfoList();
 803    ASSERT_TRUE(list != NULL);
 804
 805    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 806      {
 807         if (tw->layer > 200)
 808           continue;
 809
 810         if (pass_count == 0)
 811           {
 812              ASSERT_EQ(tw->native_win, tw_green->native_win);
 813              pass_count++;
 814              continue;
 815           }
 816         else if (pass_count == 1)
 817           {
 818              ASSERT_EQ(tw->native_win, tw_red->native_win);
 819              pass_count++;
 820              continue;
 821           }
 822         else
 823           {
 824              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 825              pass_count++;
 826           }
 827
 828         break;
 829      }
 830    etRunner::get().freeWinInfoList(list);
 831
 832    ASSERT_EQ(3, pass_count);
 833
 834    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 835 }
 836
 837 TEST_F(etTestBaseMulti, multi_all_full_wins_show3)
 838 {
 839    etWin *tw = NULL;
 840    Eina_Bool res = EINA_FALSE;
 841    Eina_List *list = NULL, *l = NULL;
 842    int pass_count = 0;
 843
 844    // init TC window, show=false, geom=false
 845    initTC(EINA_FALSE, EINA_FALSE);
 846
 847    // show green
 848    res = showTCWin(tw_green);
 849    ASSERT_TRUE(res);
 850    ASSERT_VIS_ON(tw_green);
 851
 852    // show blue
 853    res = showTCWin(tw_blue);
 854    ASSERT_TRUE(res);
 855    ASSERT_VIS_ON(tw_blue);
 856
 857    // show red
 858    res = showTCWin(tw_red);
 859    ASSERT_TRUE(res);
 860    ASSERT_VIS_ON(tw_red);
 861
 862    // Expected stack res:
 863    // [Top] Red -> Blue -> Green [Bottom]
 864    list = etRunner::get().getWinInfoList();
 865    ASSERT_TRUE(list != NULL);
 866
 867    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 868      {
 869         if (tw->layer > 200)
 870           continue;
 871
 872         if (pass_count == 0)
 873           {
 874              ASSERT_EQ(tw->native_win, tw_red->native_win);
 875              pass_count++;
 876              continue;
 877           }
 878         else if (pass_count == 1)
 879           {
 880              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 881              pass_count++;
 882              continue;
 883           }
 884         else
 885           {
 886              ASSERT_EQ(tw->native_win, tw_green->native_win);
 887              pass_count++;
 888           }
 889
 890         break;
 891      }
 892    etRunner::get().freeWinInfoList(list);
 893
 894    ASSERT_EQ(3, pass_count);
 895
 896    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 897 }
 898
 899 TEST_F(etTestBaseMulti, multi_all_full_wins_raise1)
 900 {
 901    etWin *tw = NULL;
 902    Eina_List *list = NULL, *l = NULL;
 903    int pass_count = 0;
 904
 905    // init TC window, show=true, geom=false
 906    initTC(EINA_TRUE, EINA_FALSE);
 907
 908    // Raise Red
 909    etRunner::get().setWinStack(tw_red, NULL, EINA_TRUE);
 910    ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_RAISE);
 911
 912    // Expected stack res:
 913    // [Top] Red -> Blue -> Green [Bottom]
 914    list = etRunner::get().getWinInfoList();
 915    ASSERT_TRUE(list != NULL);
 916
 917    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 918      {
 919         if (tw->layer > 200)
 920           continue;
 921
 922         if (pass_count == 0)
 923           {
 924              ASSERT_EQ(tw->native_win, tw_red->native_win);
 925              pass_count++;
 926              continue;
 927           }
 928         else if (pass_count == 1)
 929           {
 930              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 931              pass_count++;
 932              continue;
 933           }
 934         else
 935           {
 936              ASSERT_EQ(tw->native_win, tw_green->native_win);
 937              pass_count++;
 938           }
 939
 940         break;
 941      }
 942    etRunner::get().freeWinInfoList(list);
 943
 944    ASSERT_EQ(3, pass_count);
 945
 946    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 947 }
 948
 949 TEST_F(etTestBaseMulti, multi_all_full_wins_raise2)
 950 {
 951    etWin *tw = NULL;
 952    Eina_List *list = NULL, *l = NULL;
 953    int pass_count = 0;
 954
 955    // init TC window, show=true, geom=false
 956    initTC(EINA_TRUE, EINA_FALSE);
 957
 958    // Raise Green
 959    etRunner::get().setWinStack(tw_green, NULL, EINA_TRUE);
 960    ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_RAISE);
 961
 962    // Expected stack res:
 963    // [Top] Green-> Blue -> Red [Bottom]
 964    list = etRunner::get().getWinInfoList();
 965    ASSERT_TRUE(list != NULL);
 966
 967    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 968      {
 969         if (tw->layer > 200)
 970           continue;
 971
 972         if (pass_count == 0)
 973           {
 974              ASSERT_EQ(tw->native_win, tw_green->native_win);
 975              pass_count++;
 976              continue;
 977           }
 978         else if (pass_count == 1)
 979           {
 980              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 981              pass_count++;
 982              continue;
 983           }
 984         else
 985           {
 986              ASSERT_EQ(tw->native_win, tw_red->native_win);
 987              pass_count++;
 988           }
 989
 990         break;
 991      }
 992    etRunner::get().freeWinInfoList(list);
 993
 994    ASSERT_EQ(3, pass_count);
 995
 996    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 997 }
 998
 999 TEST_F(etTestBaseMulti, multi_all_full_wins_stack_above1)
1000 {
1001    etWin *tw = NULL;
1002    Eina_List *list = NULL, *l = NULL;
1003    int pass_count = 0;
1004
1005    // init TC window, show=true, geom=false
1006    initTC(EINA_TRUE, EINA_FALSE);
1007
1008    // Raise Red on the Green
1009    etRunner::get().setWinStack(tw_red, tw_green, EINA_TRUE);
1010    ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
1011
1012    // Expected stack res:
1013    // [Top] Blue -> Red -> Green [Bottom]
1014    list = etRunner::get().getWinInfoList();
1015    ASSERT_TRUE(list != NULL);
1016
1017    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1018      {
1019         if (tw->layer > 200)
1020           continue;
1021
1022         if (pass_count == 0)
1023           {
1024              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1025              pass_count++;
1026              continue;
1027           }
1028         else if (pass_count == 1)
1029           {
1030              ASSERT_EQ(tw->native_win, tw_red->native_win);
1031              pass_count++;
1032              continue;
1033           }
1034         else
1035           {
1036              ASSERT_EQ(tw->native_win, tw_green->native_win);
1037              pass_count++;
1038           }
1039
1040         break;
1041      }
1042    etRunner::get().freeWinInfoList(list);
1043
1044    ASSERT_EQ(3, pass_count);
1045
1046    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1047 }
1048
1049 TEST_F(etTestBaseMulti, multi_all_full_wins_stack_above2)
1050 {
1051    etWin *tw = NULL;
1052    Eina_List *list = NULL, *l = NULL;
1053    int pass_count = 0;
1054
1055    // init TC window, show=true, geom=false
1056    initTC(EINA_TRUE, EINA_FALSE);
1057
1058    // Raise Blue on the Red
1059    etRunner::get().setWinStack(tw_blue, tw_red, EINA_TRUE);
1060    ASSERT_EVENT(tw_blue, E_TC_EVENT_TYPE_STACK_ABOVE);
1061
1062    // Expected stack res:
1063    // [Top] Green-> Blue -> Red [Bottom]
1064    list = etRunner::get().getWinInfoList();
1065    ASSERT_TRUE(list != NULL);
1066
1067    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1068      {
1069         if (tw->layer > 200)
1070           continue;
1071
1072         if (pass_count == 0)
1073           {
1074              ASSERT_EQ(tw->native_win, tw_green->native_win);
1075              pass_count++;
1076              continue;
1077           }
1078         else if (pass_count == 1)
1079           {
1080              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1081              pass_count++;
1082              continue;
1083           }
1084         else
1085           {
1086              ASSERT_EQ(tw->native_win, tw_red->native_win);
1087              pass_count++;
1088           }
1089
1090         break;
1091      }
1092    etRunner::get().freeWinInfoList(list);
1093
1094    ASSERT_EQ(3, pass_count);
1095
1096    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1097 }
1098
1099 TEST_F(etTestBaseMulti, multi_all_full_wins_stack_above3)
1100 {
1101    etWin *tw = NULL;
1102    Eina_List *list = NULL, *l = NULL;
1103    int pass_count = 0;
1104
1105    // init TC window, show=true, geom=false
1106    initTC(EINA_TRUE, EINA_FALSE);
1107
1108    // Raise Red on the Blue
1109    etRunner::get().setWinStack(tw_red, tw_blue, EINA_TRUE);
1110    ASSERT_EVENT(tw_red, E_TC_EVENT_TYPE_STACK_ABOVE);
1111
1112    // Expected stack res:
1113    // [Top] Green-> Blue -> Red [Bottom]
1114    list = etRunner::get().getWinInfoList();
1115    ASSERT_TRUE(list != NULL);
1116
1117    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1118      {
1119         if (tw->layer > 200)
1120           continue;
1121
1122         if (pass_count == 0)
1123           {
1124              ASSERT_EQ(tw->native_win, tw_red->native_win);
1125              pass_count++;
1126              continue;
1127           }
1128         else if (pass_count == 1)
1129           {
1130              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1131              pass_count++;
1132              continue;
1133           }
1134         else
1135           {
1136              ASSERT_EQ(tw->native_win, tw_green->native_win);
1137              pass_count++;
1138           }
1139
1140         break;
1141      }
1142    etRunner::get().freeWinInfoList(list);
1143
1144    ASSERT_EQ(3, pass_count);
1145
1146    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1147 }
1148
1149 TEST_F(etTestBaseMulti, multi_all_full_wins_lower1)
1150 {
1151    etWin *tw = NULL, *tw_above = NULL;
1152    Eina_List *list = NULL, *l = NULL;
1153    int pass_count = 0;
1154
1155    // init TC window, show=true, geom=false
1156    initTC(EINA_TRUE, EINA_FALSE);
1157
1158    // Lower Blue
1159    etRunner::get().setWinStack(tw_blue, NULL, EINA_FALSE);
1160    ASSERT_EVENT(tw_blue, E_TC_EVENT_TYPE_STACK_LOWER);
1161
1162    // Expected stack res:
1163    // [Top] Green -> Red -> ... -> Blue [Bottom]
1164    list = etRunner::get().getWinInfoList();
1165    ASSERT_TRUE(list != NULL);
1166
1167    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1168      {
1169         if (tw->layer > 200)
1170           continue;
1171
1172         if (pass_count == 0)
1173           {
1174              ASSERT_EQ(tw->native_win, tw_green->native_win);
1175              pass_count++;
1176              continue;
1177           }
1178         else if (pass_count == 1)
1179           {
1180              ASSERT_EQ(tw->native_win, tw_red->native_win);
1181              pass_count++;
1182              continue;
1183           }
1184         else
1185           {
1186              if (tw->layer < 200)
1187                {
1188                   ASSERT_EQ(tw->native_win, tw_blue->native_win);
1189                   pass_count++;
1190                }
1191              else
1192                {
1193                   tw_above = tw;
1194                   continue;
1195                }
1196           }
1197
1198         break;
1199      }
1200
1201    // check the tw_above when there is no window under 200 layer
1202    if (tw == NULL)
1203      {
1204         ASSERT_TRUE(tw_above != NULL);
1205         ASSERT_EQ(tw_above->native_win, tw_blue->native_win);
1206         pass_count++;
1207      }
1208    etRunner::get().freeWinInfoList(list);
1209
1210    ASSERT_EQ(3, pass_count);
1211
1212    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1213 }
1214
1215 TEST_F(etTestBaseMulti, multi_all_full_wins_lower2)
1216 {
1217    etWin *tw = NULL, *tw_above = NULL;
1218    Eina_List *list = NULL, *l = NULL;
1219    int pass_count = 0;
1220
1221    // init TC window, show=true, geom=false
1222    initTC(EINA_TRUE, EINA_FALSE);
1223
1224    // Lower Green
1225    etRunner::get().setWinStack(tw_green, NULL, EINA_FALSE);
1226    ASSERT_EVENT(tw_green, E_TC_EVENT_TYPE_STACK_LOWER);
1227
1228    // Expected stack res:
1229    // [Top] Blue -> Red -> ... -> Green [Bottom]
1230    list = etRunner::get().getWinInfoList();
1231    ASSERT_TRUE(list != NULL);
1232
1233    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1234      {
1235         if (tw->layer > 200)
1236           continue;
1237
1238         if (pass_count == 0)
1239           {
1240              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1241              pass_count++;
1242              continue;
1243           }
1244         else if (pass_count == 1)
1245           {
1246              ASSERT_EQ(tw->native_win, tw_red->native_win);
1247              pass_count++;
1248              continue;
1249           }
1250         else
1251           {
1252              if (tw->layer < 200)
1253                {
1254                   ASSERT_EQ(tw->native_win, tw_green->native_win);
1255                   pass_count++;
1256                }
1257              else
1258                {
1259                   tw_above = tw;
1260                   continue;
1261                }
1262           }
1263
1264         break;
1265      }
1266
1267    // check the tw_above when there is no window under 200 layer
1268    if (tw == NULL)
1269      {
1270         ASSERT_TRUE(tw_above != NULL);
1271         ASSERT_EQ(tw_above->native_win, tw_green->native_win);
1272         pass_count++;
1273      }
1274    etRunner::get().freeWinInfoList(list);
1275
1276    ASSERT_EQ(3, pass_count);
1277
1278    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1279 }
1280
1281 TEST_F(etTestBaseMulti, multi_all_full_wins_lower_activate)
1282 {
1283    etWin *tw = NULL;
1284    Eina_List *list = NULL, *l = NULL;
1285    int pass_count = 0;
1286
1287    // init TC window, show=true, geom=false
1288    initTC(EINA_TRUE, EINA_FALSE);
1289
1290    // Lower Blue
1291    evas_object_lower(tw_blue->elm_win);
1292    // Activate Blue immediately
1293    etRunner::get().setWinActivate(tw_blue);
1294    etRunner::get().work(0.1); // wait for activate done. It does not change stack.
1295
1296    // Expected stack res:
1297    // [Top] Blue -> Green -> Red [Bottom]
1298    list = etRunner::get().getWinInfoList();
1299    ASSERT_TRUE(list != NULL);
1300
1301    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1302      {
1303         if (tw->layer > 200)
1304           continue;
1305
1306         if (pass_count == 0)
1307           {
1308              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1309              pass_count++;
1310              continue;
1311           }
1312         else if (pass_count == 1)
1313           {
1314              ASSERT_EQ(tw->native_win, tw_green->native_win);
1315              pass_count++;
1316              continue;
1317           }
1318         else
1319           {
1320              ASSERT_EQ(tw->native_win, tw_red->native_win);
1321              pass_count++;
1322           }
1323
1324         break;
1325      }
1326    etRunner::get().freeWinInfoList(list);
1327
1328    ASSERT_EQ(3, pass_count);
1329
1330    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1331 }
1332
1333 TEST_F(etTestBaseMulti, multi_2wins_show1)
1334 {
1335    etWin *tw = NULL;
1336    Eina_Bool res = EINA_FALSE;
1337    Eina_List *list = NULL, *l = NULL;
1338    int pass_count = 0;
1339
1340    // init TC window, show=false, geom=true
1341    initTC(EINA_FALSE, EINA_TRUE);
1342
1343    // show green
1344    res = showTCWin(tw_green);
1345    ASSERT_TRUE(res);
1346    ASSERT_VIS_ON(tw_green);
1347
1348    // show red
1349    res = showTCWin(tw_red);
1350    ASSERT_TRUE(res);
1351    ASSERT_VIS_ON(tw_red);
1352
1353    // Expected stack res:
1354    // [Top] Red -> Green [Bottom]
1355    list = etRunner::get().getWinInfoList();
1356    ASSERT_TRUE(list != NULL);
1357
1358    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1359      {
1360         if (tw->layer > 200)
1361           continue;
1362
1363         if (pass_count == 0)
1364           {
1365              ASSERT_EQ(tw->native_win, tw_red->native_win);
1366              pass_count++;
1367              continue;
1368           }
1369         else
1370           {
1371              ASSERT_EQ(tw->native_win, tw_green->native_win);
1372              pass_count++;
1373           }
1374
1375         break;
1376      }
1377    etRunner::get().freeWinInfoList(list);
1378
1379    ASSERT_EQ(2, pass_count);
1380
1381    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1382 }
1383
1384 TEST_F(etTestBaseMulti, multi_2wins_show2)
1385 {
1386    etWin *tw = NULL;
1387    Eina_Bool res = EINA_FALSE;
1388    Eina_List *list = NULL, *l = NULL;
1389    int pass_count = 0;
1390
1391    // init TC window, show=false, geom=true
1392    initTC(EINA_FALSE, EINA_TRUE);
1393
1394    // show blue
1395    res = showTCWin(tw_blue);
1396    ASSERT_TRUE(res);
1397    ASSERT_VIS_ON(tw_blue);
1398
1399    // show green
1400    res = showTCWin(tw_green);
1401    ASSERT_TRUE(res);
1402    ASSERT_VIS_ON(tw_green);
1403
1404    // Expected stack res:
1405    // [Top] Green -> Blue [Bottom]
1406    list = etRunner::get().getWinInfoList();
1407    ASSERT_TRUE(list != NULL);
1408
1409    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1410      {
1411         if (tw->layer > 200)
1412           continue;
1413
1414         if (pass_count == 0)
1415           {
1416              ASSERT_EQ(tw->native_win, tw_green->native_win);
1417              pass_count++;
1418              continue;
1419           }
1420         else
1421           {
1422              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1423              pass_count++;
1424           }
1425
1426         break;
1427      }
1428    etRunner::get().freeWinInfoList(list);
1429
1430    ASSERT_EQ(2, pass_count);
1431
1432    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1433 }
1434
1435 TEST_F(etTestBaseMulti, multi_2wins_show3)
1436 {
1437    etWin *tw = NULL;
1438    Eina_Bool res = EINA_FALSE;
1439    Eina_List *list = NULL, *l = NULL;
1440    int pass_count = 0;
1441
1442    // init TC window, show=false, geom=true
1443    initTC(EINA_FALSE, EINA_TRUE);
1444
1445    // show red
1446    res = showTCWin(tw_red);
1447    ASSERT_TRUE(res);
1448    ASSERT_VIS_ON(tw_red);
1449
1450    // show blue
1451    res = showTCWin(tw_blue);
1452    ASSERT_TRUE(res);
1453    ASSERT_VIS_ON(tw_blue);
1454
1455    // Expected stack res:
1456    // [Top] Blue -> Red [Bottom]
1457    list = etRunner::get().getWinInfoList();
1458    ASSERT_TRUE(list != NULL);
1459
1460    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1461      {
1462         if (tw->layer > 200)
1463           continue;
1464
1465         if (pass_count == 0)
1466           {
1467              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1468              pass_count++;
1469              continue;
1470           }
1471         else
1472           {
1473              ASSERT_EQ(tw->native_win, tw_red->native_win);
1474              pass_count++;
1475           }
1476
1477         break;
1478      }
1479    etRunner::get().freeWinInfoList(list);
1480
1481    ASSERT_EQ(2, pass_count);
1482
1483    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1484 }
1485
1486 TEST_F(etTestBaseMulti, multi_full_2wins_show1)
1487 {
1488    etWin *tw = NULL;
1489    Eina_Bool res = EINA_FALSE;
1490    Eina_List *list = NULL, *l = NULL;
1491    int pass_count = 0;
1492
1493    // init TC window, show=false, geom=false
1494    initTC(EINA_FALSE, EINA_FALSE);
1495
1496    // show green
1497    res = showTCWin(tw_green);
1498    ASSERT_TRUE(res);
1499    ASSERT_VIS_ON(tw_green);
1500
1501    // show red
1502    res = showTCWin(tw_red);
1503    ASSERT_TRUE(res);
1504    ASSERT_VIS_ON(tw_red);
1505
1506    // Expected stack res:
1507    // [Top] Red -> Green [Bottom]
1508    list = etRunner::get().getWinInfoList();
1509    ASSERT_TRUE(list != NULL);
1510
1511    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1512      {
1513         if (tw->layer > 200)
1514           continue;
1515
1516         if (pass_count == 0)
1517           {
1518              ASSERT_EQ(tw->native_win, tw_red->native_win);
1519              pass_count++;
1520              continue;
1521           }
1522         else
1523           {
1524              ASSERT_EQ(tw->native_win, tw_green->native_win);
1525              pass_count++;
1526           }
1527
1528         break;
1529      }
1530    etRunner::get().freeWinInfoList(list);
1531
1532    ASSERT_EQ(2, pass_count);
1533
1534    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1535 }
1536
1537 TEST_F(etTestBaseMulti, multi_full_2wins_show2)
1538 {
1539    etWin *tw = NULL;
1540    Eina_Bool res = EINA_FALSE;
1541    Eina_List *list = NULL, *l = NULL;
1542    int pass_count = 0;
1543
1544    // init TC window, show=false, geom=false
1545    initTC(EINA_FALSE, EINA_FALSE);
1546
1547    // show blue
1548    res = showTCWin(tw_blue);
1549    ASSERT_TRUE(res);
1550    ASSERT_VIS_ON(tw_blue);
1551
1552    // show green
1553    res = showTCWin(tw_green);
1554    ASSERT_TRUE(res);
1555    ASSERT_VIS_ON(tw_green);
1556
1557    // Expected stack res:
1558    // [Top] Green -> Blue [Bottom]
1559    list = etRunner::get().getWinInfoList();
1560    ASSERT_TRUE(list != NULL);
1561
1562    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1563      {
1564         if (tw->layer > 200)
1565           continue;
1566
1567         if (pass_count == 0)
1568           {
1569              ASSERT_EQ(tw->native_win, tw_green->native_win);
1570              pass_count++;
1571              continue;
1572           }
1573         else
1574           {
1575              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1576              pass_count++;
1577           }
1578
1579         break;
1580      }
1581    etRunner::get().freeWinInfoList(list);
1582
1583    ASSERT_EQ(2, pass_count);
1584
1585    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1586 }
1587
1588 TEST_F(etTestBaseMulti, multi_full_2wins_show3)
1589 {
1590    etWin *tw = NULL;
1591    Eina_Bool res = EINA_FALSE;
1592    Eina_List *list = NULL, *l = NULL;
1593    int pass_count = 0;
1594
1595    // init TC window, show=false, geom=false
1596    initTC(EINA_FALSE, EINA_FALSE);
1597
1598    // show red
1599    res = showTCWin(tw_red);
1600    ASSERT_TRUE(res);
1601    ASSERT_VIS_ON(tw_red);
1602
1603    // show blue
1604    res = showTCWin(tw_blue);
1605    ASSERT_TRUE(res);
1606    ASSERT_VIS_ON(tw_blue);
1607
1608    // Expected stack res:
1609    // [Top] Blue -> Red [Bottom]
1610    list = etRunner::get().getWinInfoList();
1611    ASSERT_TRUE(list != NULL);
1612
1613    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
1614      {
1615         if (tw->layer > 200)
1616           continue;
1617
1618         if (pass_count == 0)
1619           {
1620              ASSERT_EQ(tw->native_win, tw_blue->native_win);
1621              pass_count++;
1622              continue;
1623           }
1624         else
1625           {
1626              ASSERT_EQ(tw->native_win, tw_red->native_win);
1627              pass_count++;
1628           }
1629
1630         break;
1631      }
1632    etRunner::get().freeWinInfoList(list);
1633
1634    ASSERT_EQ(2, pass_count);
1635
1636    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
1637 }