src/testcase/0013_iconic_state.cpp

   1 #include "e_test_event.h"
   2 #include "e_test_base.h"
   3
   4 class etTestIconicState : public ::etTCBase
   5 {
   6  public:
   7     etTestIconicState() { };
   8     ~etTestIconicState() { };
   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 etTestIconicState::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         ASSERT_ICONIFIED_BY_SERVER(tw_red);
  40      }
  41
  42    tw_blue = initNormalWin("TCWin_Normal_blue", usr_geom);
  43    ASSERT_TRUE(tw_blue != NULL) << "failed to initiation window";
  44    if (show_win)
  45      {
  46         showTCWin(tw_blue);
  47         ASSERT_VIS_ON(tw_blue);
  48         ASSERT_ICONIFIED_BY_SERVER(tw_green);
  49      }
  50
  51    testCaseName = test_info->test_case_name();
  52    testName = test_info->name();
  53 }
  54
  55 TEST_F(etTestIconicState, iconify_by_client_basic)
  56 {
  57    etWin *tw = NULL;
  58    Eina_Bool res = EINA_FALSE;
  59    Eina_List *list = NULL, *l = NULL;
  60    int pass_count = 0;
  61
  62    // init TC window, show=true, geom=false
  63    initTC(EINA_TRUE, EINA_FALSE);
  64
  65    // Iconify Blue
  66    res = etRunner::get().setWinIconic(tw_blue, EINA_TRUE);
  67    ASSERT_TRUE(res);
  68    ASSERT_ICONIFIED(tw_blue);
  69
  70    // Expected stack res:
  71    // [Top] Blue (iconified) -> Green -> Red [Bottom]
  72    list = etRunner::get().getWinInfoList();
  73    ASSERT_TRUE(list != NULL);
  74
  75    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
  76      {
  77         if (tw->layer > 200)
  78           continue;
  79
  80         if (pass_count == 0)
  81           {
  82              ASSERT_EQ(tw->native_win, tw_blue->native_win);
  83              ASSERT_FALSE(tw->Vis.obj);
  84              ASSERT_TRUE(tw->iconic.set);
  85              ASSERT_TRUE(tw->iconic.by_client);
  86              pass_count++;
  87              continue;
  88           }
  89         else if (pass_count == 1)
  90           {
  91              ASSERT_EQ(tw->native_win, tw_green->native_win);
  92              ASSERT_TRUE(tw->Vis.obj);
  93              ASSERT_FALSE(tw->iconic.set);
  94              pass_count++;
  95              continue;
  96           }
  97         else
  98           {
  99              ASSERT_EQ(tw->native_win, tw_red->native_win);
 100              ASSERT_TRUE(tw->iconic.set);
 101              pass_count++;
 102           }
 103
 104         break;
 105      }
 106    etRunner::get().freeWinInfoList(list);
 107
 108    ASSERT_EQ(3, pass_count);
 109
 110    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 111 }
 112
 113 TEST_F(etTestIconicState, iconify_by_client_basic2)
 114 {
 115    etWin *tw = NULL;
 116    Eina_Bool res = EINA_FALSE;
 117    Eina_List *list = NULL, *l = NULL;
 118    int pass_count = 0;
 119
 120    // init TC window, show=true, geom=false
 121    initTC(EINA_TRUE, EINA_FALSE);
 122
 123    // Iconify Green
 124    res = etRunner::get().setWinIconic(tw_green, EINA_TRUE);
 125    ASSERT_TRUE(res);
 126
 127    // Expected stack res:
 128    // [Top] Blue -> Green (iconified) -> Red [Bottom]
 129    list = etRunner::get().getWinInfoList();
 130    ASSERT_TRUE(list != NULL);
 131
 132    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 133      {
 134         if (tw->layer > 200)
 135           continue;
 136
 137         if (pass_count == 0)
 138           {
 139              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 140              ASSERT_TRUE(tw->Vis.obj);
 141              ASSERT_FALSE(tw->iconic.set);
 142              pass_count++;
 143              continue;
 144           }
 145         else if (pass_count == 1)
 146           {
 147              ASSERT_EQ(tw->native_win, tw_green->native_win);
 148              ASSERT_FALSE(tw->Vis.obj);
 149              ASSERT_TRUE(tw->iconic.set);
 150              ASSERT_TRUE(tw->iconic.by_client);
 151              pass_count++;
 152              continue;
 153           }
 154         else
 155           {
 156              ASSERT_EQ(tw->native_win, tw_red->native_win);
 157              ASSERT_TRUE(tw->iconic.set);
 158              pass_count++;
 159           }
 160
 161         break;
 162      }
 163    etRunner::get().freeWinInfoList(list);
 164
 165    ASSERT_EQ(3, pass_count);
 166
 167    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 168 }
 169
 170 TEST_F(etTestIconicState, iconify_by_client_basic3)
 171 {
 172    etWin *tw = NULL;
 173    Eina_Bool res = EINA_FALSE;
 174    Eina_List *list = NULL, *l = NULL;
 175    int pass_count = 0;
 176
 177    // init TC window, show=true, geom=false
 178    initTC(EINA_TRUE, EINA_FALSE);
 179
 180    // Iconify Green
 181    res = etRunner::get().setWinIconic(tw_green, EINA_TRUE);
 182    ASSERT_TRUE(res);
 183
 184    // hide Blue
 185    hideTCWin(tw_blue);
 186    ASSERT_VIS_OFF(tw_blue);
 187
 188    // Expected stack res:
 189    // [Top] Blue (hide) -> Green (iconified) -> Red [Bottom]
 190    list = etRunner::get().getWinInfoList();
 191    ASSERT_TRUE(list != NULL);
 192
 193    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 194      {
 195         if (tw->layer > 200)
 196           continue;
 197
 198         if (pass_count == 0)
 199           {
 200              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 201              ASSERT_FALSE(tw->Vis.obj);
 202              ASSERT_FALSE(tw->iconic.set);
 203              pass_count++;
 204              continue;
 205           }
 206         else if (pass_count == 1)
 207           {
 208              ASSERT_EQ(tw->native_win, tw_green->native_win);
 209              ASSERT_FALSE(tw->Vis.obj);
 210              ASSERT_TRUE(tw->iconic.set);
 211              ASSERT_TRUE(tw->iconic.by_client);
 212              pass_count++;
 213              continue;
 214           }
 215         else
 216           {
 217              ASSERT_EQ(tw->native_win, tw_red->native_win);
 218              ASSERT_FALSE(tw->iconic.set);
 219              pass_count++;
 220           }
 221
 222         break;
 223      }
 224    etRunner::get().freeWinInfoList(list);
 225
 226    ASSERT_EQ(3, pass_count);
 227
 228    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 229 }
 230
 231 TEST_F(etTestIconicState, iconify_by_client_uniconify)
 232 {
 233    etWin *tw = NULL;
 234    Eina_Bool res = EINA_FALSE;
 235    Eina_List *list = NULL, *l = NULL;
 236    int pass_count = 0;
 237
 238    // init TC window, show=true, geom=false
 239    initTC(EINA_TRUE, EINA_FALSE);
 240
 241    // Iconify Blue
 242    res = etRunner::get().setWinIconic(tw_blue, EINA_TRUE);
 243    ASSERT_TRUE(res);
 244    ASSERT_ICONIFIED(tw_blue);
 245
 246    // Uniconify Blue
 247    res = etRunner::get().setWinIconic(tw_blue, EINA_FALSE);
 248    ASSERT_TRUE(res);
 249    tw_blue->setColor(0, 0, 250); // for buffer commit
 250    ASSERT_UNICONIFIED(tw_blue);
 251
 252    // Expected stack res:
 253    // [Top] Blue -> Green -> Red [Bottom]
 254    list = etRunner::get().getWinInfoList();
 255    ASSERT_TRUE(list != NULL);
 256
 257    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 258      {
 259         if (tw->layer > 200)
 260           continue;
 261
 262         if (pass_count == 0)
 263           {
 264              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 265              ASSERT_TRUE(tw->Vis.obj);
 266              ASSERT_FALSE(tw->iconic.set);
 267              pass_count++;
 268              continue;
 269           }
 270         else if (pass_count == 1)
 271           {
 272              ASSERT_EQ(tw->native_win, tw_green->native_win);
 273              ASSERT_FALSE(tw->Vis.obj);
 274              ASSERT_TRUE(tw->iconic.set);
 275              pass_count++;
 276              continue;
 277           }
 278         else
 279           {
 280              ASSERT_EQ(tw->native_win, tw_red->native_win);
 281              ASSERT_TRUE(tw->iconic.set);
 282              pass_count++;
 283           }
 284
 285         break;
 286      }
 287    etRunner::get().freeWinInfoList(list);
 288
 289    ASSERT_EQ(3, pass_count);
 290
 291    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 292 }
 293
 294 TEST_F(etTestIconicState, iconify_by_client_uniconify2)
 295 {
 296    etWin *tw = NULL;
 297    Eina_Bool res = EINA_FALSE;
 298    Eina_List *list = NULL, *l = NULL;
 299    int pass_count = 0;
 300
 301    // init TC window, show=true, geom=false
 302    initTC(EINA_TRUE, EINA_FALSE);
 303
 304    // Iconify Green
 305    res = etRunner::get().setWinIconic(tw_green, EINA_TRUE);
 306    ASSERT_TRUE(res);
 307
 308    // Uniconify Green
 309    res = etRunner::get().setWinIconic(tw_green, EINA_FALSE);
 310    ASSERT_TRUE(res);
 311    tw_green->setColor(0, 250, 0); // for buffer commit
 312    ASSERT_UNICONIFIED(tw_green);
 313
 314    // Expected stack res:
 315    // [Top] Green -> Blue -> Red [Bottom]
 316    list = etRunner::get().getWinInfoList();
 317    ASSERT_TRUE(list != NULL);
 318
 319    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 320      {
 321         if (tw->layer > 200)
 322           continue;
 323
 324         if (pass_count == 0)
 325           {
 326              ASSERT_EQ(tw->native_win, tw_green->native_win);
 327              ASSERT_TRUE(tw->Vis.obj);
 328              ASSERT_FALSE(tw->iconic.set);
 329              pass_count++;
 330              continue;
 331           }
 332         else if (pass_count == 1)
 333           {
 334              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 335              ASSERT_FALSE(tw->Vis.obj);
 336              ASSERT_TRUE(tw->iconic.set);
 337              pass_count++;
 338              continue;
 339           }
 340         else
 341           {
 342              ASSERT_EQ(tw->native_win, tw_red->native_win);
 343              ASSERT_TRUE(tw->iconic.set);
 344              pass_count++;
 345           }
 346
 347         break;
 348      }
 349    etRunner::get().freeWinInfoList(list);
 350
 351    ASSERT_EQ(3, pass_count);
 352
 353    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 354 }
 355
 356 TEST_F(etTestIconicState, iconify_by_client_uniconify3)
 357 {
 358    etWin *tw = NULL;
 359    Eina_Bool res = EINA_FALSE;
 360    Eina_List *list = NULL, *l = NULL;
 361    int pass_count = 0;
 362
 363    // init TC window, show=true, geom=false
 364    initTC(EINA_TRUE, EINA_FALSE);
 365
 366    // Uniconify Green
 367    res = etRunner::get().setWinIconic(tw_green, EINA_FALSE);
 368    ASSERT_TRUE(res);
 369    tw_green->setColor(0, 250, 0); // for buffer commit
 370    ASSERT_UNICONIFIED(tw_green);
 371
 372    // Expected stack res:
 373    // [Top] Green -> Blue -> Red [Bottom]
 374    list = etRunner::get().getWinInfoList();
 375    ASSERT_TRUE(list != NULL);
 376
 377    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 378      {
 379         if (tw->layer > 200)
 380           continue;
 381
 382         if (pass_count == 0)
 383           {
 384              ASSERT_EQ(tw->native_win, tw_green->native_win);
 385              ASSERT_TRUE(tw->Vis.obj);
 386              ASSERT_FALSE(tw->iconic.set);
 387              pass_count++;
 388              continue;
 389           }
 390         else if (pass_count == 1)
 391           {
 392              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 393              ASSERT_FALSE(tw->Vis.obj);
 394              ASSERT_TRUE(tw->iconic.set);
 395              pass_count++;
 396              continue;
 397           }
 398         else
 399           {
 400              ASSERT_EQ(tw->native_win, tw_red->native_win);
 401              ASSERT_TRUE(tw->iconic.set);
 402              pass_count++;
 403           }
 404
 405         break;
 406      }
 407    etRunner::get().freeWinInfoList(list);
 408
 409    ASSERT_EQ(3, pass_count);
 410
 411    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 412 }
 413
 414 TEST_F(etTestIconicState, uniconify_by_above_alpha)
 415 {
 416    etWin *tw = NULL;
 417    Eina_Bool res = EINA_FALSE;
 418    Eina_List *list = NULL, *l = NULL;
 419    int pass_count = 0;
 420
 421    // init TC window, show=true, geom=false
 422    initTC(EINA_TRUE, EINA_FALSE);
 423
 424    etRunner::get().work(0.5);
 425
 426    // Expected stack res:
 427    // [Top] Blue -> Green (iconified) -> Red (iconified) [Bottom]
 428    list = etRunner::get().getWinInfoList();
 429    ASSERT_TRUE(list != NULL);
 430
 431    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 432      {
 433         if (tw->layer > 200)
 434           continue;
 435
 436         if (pass_count == 0)
 437           {
 438              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 439              ASSERT_TRUE(tw->Vis.obj);
 440              ASSERT_FALSE(tw->iconic.set);
 441              ASSERT_FALSE(tw->iconic.by_client);
 442              pass_count++;
 443              continue;
 444           }
 445         else if (pass_count == 1)
 446           {
 447              ASSERT_EQ(tw->native_win, tw_green->native_win);
 448              ASSERT_FALSE(tw->Vis.obj);
 449              ASSERT_TRUE(tw->iconic.set);
 450              ASSERT_FALSE(tw->iconic.by_client);
 451              pass_count++;
 452              continue;
 453           }
 454         else
 455           {
 456              ASSERT_EQ(tw->native_win, tw_red->native_win);
 457              ASSERT_FALSE(tw->Vis.obj);
 458              ASSERT_TRUE(tw->iconic.set);
 459              ASSERT_FALSE(tw->iconic.by_client);
 460              pass_count++;
 461           }
 462
 463         break;
 464      }
 465    etRunner::get().freeWinInfoList(list);
 466    ASSERT_EQ(3, pass_count);
 467
 468    // Change Blue's alpha
 469    elm_win_alpha_set(tw_blue->elm_win, EINA_TRUE);
 470    etRunner::get().work(0.5);
 471
 472    // Expected stack res:
 473    // [Top] Blue -> Green (uniconified) -> Red (iconified) [Bottom]
 474    list = etRunner::get().getWinInfoList();
 475    ASSERT_TRUE(list != NULL);
 476
 477    pass_count = 0;
 478    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 479      {
 480         if (tw->layer > 200)
 481           continue;
 482
 483         if (pass_count == 0)
 484           {
 485              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 486              ASSERT_TRUE(tw->Vis.obj);
 487              ASSERT_FALSE(tw->iconic.set);
 488              ASSERT_FALSE(tw->iconic.by_client);
 489              pass_count++;
 490              continue;
 491           }
 492         else if (pass_count == 1)
 493           {
 494              ASSERT_EQ(tw->native_win, tw_green->native_win);
 495              ASSERT_TRUE(tw->Vis.obj);
 496              ASSERT_FALSE(tw->iconic.set);
 497              ASSERT_FALSE(tw->iconic.by_client);
 498              pass_count++;
 499              continue;
 500           }
 501         else
 502           {
 503              ASSERT_EQ(tw->native_win, tw_red->native_win);
 504              ASSERT_FALSE(tw->Vis.obj);
 505              ASSERT_TRUE(tw->iconic.set);
 506              ASSERT_FALSE(tw->iconic.by_client);
 507              pass_count++;
 508           }
 509
 510         break;
 511      }
 512    etRunner::get().freeWinInfoList(list);
 513
 514    ASSERT_EQ(3, pass_count);
 515
 516    //ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 517 }
 518
 519 TEST_F(etTestIconicState, iconify_by_server_basic)
 520 {
 521    etWin *tw = NULL;
 522    Eina_Bool res = EINA_FALSE;
 523    Eina_List *list = NULL, *l = NULL;
 524    int pass_count = 0;
 525
 526    // init TC window, show=false, geom=false
 527    initTC(EINA_FALSE, EINA_FALSE);
 528
 529    // show tw_red
 530    res = showTCWin(tw_red);
 531    ASSERT_TRUE(res);
 532    ASSERT_VIS_ON(tw_red);
 533
 534    // show tw_green
 535    res = showTCWin(tw_green);
 536    ASSERT_TRUE(res);
 537    ASSERT_VIS_ON(tw_green);
 538
 539    // event check tw_red is iconified_by_server
 540    ASSERT_ICONIFIED_BY_SERVER(tw_red);
 541
 542    // Expected stack res:
 543    // [Top] Green -> Red (iconified by server) [Bottom]
 544    list = etRunner::get().getWinInfoList();
 545    ASSERT_TRUE(list != NULL);
 546
 547    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 548      {
 549         if (tw->layer > 200)
 550           continue;
 551
 552         if (pass_count == 0)
 553           {
 554              ASSERT_EQ(tw->native_win, tw_green->native_win);
 555              ASSERT_TRUE(tw->Vis.obj);
 556              ASSERT_FALSE(tw->iconic.set);
 557              pass_count++;
 558              continue;
 559           }
 560         else
 561           {
 562              ASSERT_EQ(tw->native_win, tw_red->native_win);
 563              ASSERT_FALSE(tw->Vis.obj);
 564              ASSERT_TRUE(tw->iconic.set);
 565              ASSERT_FALSE(tw->iconic.by_client);
 566              pass_count++;
 567           }
 568
 569         break;
 570      }
 571    etRunner::get().freeWinInfoList(list);
 572
 573    ASSERT_EQ(2, pass_count);
 574
 575    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 576 }
 577
 578 TEST_F(etTestIconicState, iconify_by_server_uniconify)
 579 {
 580    etWin *tw = NULL;
 581    Eina_Bool res = EINA_FALSE;
 582    Eina_List *list = NULL, *l = NULL;
 583    int pass_count = 0;
 584
 585    // init TC window, show=false, geom=false
 586    initTC(EINA_FALSE, EINA_FALSE);
 587
 588    // show tw_red
 589    res = showTCWin(tw_red);
 590    ASSERT_TRUE(res);
 591    ASSERT_VIS_ON(tw_red);
 592
 593    // show tw_green
 594    res = showTCWin(tw_green);
 595    ASSERT_TRUE(res);
 596    ASSERT_VIS_ON(tw_green);
 597
 598    // event check tw_red is iconified_by_server
 599    ASSERT_ICONIFIED_BY_SERVER(tw_red);
 600
 601    // change tw_green to 32bit colored window
 602    elm_win_alpha_set(tw_green->elm_win, EINA_TRUE);
 603
 604    // event check tw_red is uniconified
 605    tw_red->setColor(250, 0, 0); // for buffer commit
 606    ASSERT_UNICONIFIED(tw_red);
 607
 608    // Expected stack res:
 609    // [Top] Green (alpha) -> Red [Bottom]
 610    list = etRunner::get().getWinInfoList();
 611    ASSERT_TRUE(list != NULL);
 612
 613    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 614      {
 615         if (tw->layer > 200)
 616           continue;
 617
 618         if (pass_count == 0)
 619           {
 620              ASSERT_EQ(tw->native_win, tw_green->native_win);
 621              ASSERT_TRUE(tw->Vis.obj);
 622              ASSERT_FALSE(tw->iconic.set);
 623              pass_count++;
 624              continue;
 625           }
 626         else
 627           {
 628              ASSERT_EQ(tw->native_win, tw_red->native_win);
 629              ASSERT_TRUE(tw->Vis.obj);
 630              ASSERT_FALSE(tw->iconic.set);
 631              pass_count++;
 632           }
 633
 634         break;
 635      }
 636    etRunner::get().freeWinInfoList(list);
 637
 638    ASSERT_EQ(2, pass_count);
 639
 640    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 641 }
 642
 643 TEST_F(etTestIconicState, iconify_by_server_uniconify2)
 644 {
 645    etWin *tw = NULL;
 646    Eina_List *list = NULL, *l = NULL;
 647    int pass_count = 0;
 648
 649    // init TC window, show=true, geom=false
 650    initTC(EINA_TRUE, EINA_FALSE);
 651
 652    // change all window to 32bit colored window
 653    elm_win_alpha_set(tw_blue->elm_win, EINA_TRUE);
 654    elm_win_alpha_set(tw_green->elm_win, EINA_TRUE);
 655    elm_win_alpha_set(tw_red->elm_win, EINA_TRUE);
 656
 657    // event check tw_red is uniconified_by_server
 658    ASSERT_UNICONIFIED(tw_red);
 659
 660    // Expected stack res:
 661    // [Top] Blue -> Green -> Red [Bottom]
 662    list = etRunner::get().getWinInfoList();
 663    ASSERT_TRUE(list != NULL);
 664
 665    EINA_LIST_CAST_FOREACH(list, l, tw, etWin*)
 666      {
 667         if (tw->layer > 200)
 668           continue;
 669
 670         if (pass_count == 0)
 671           {
 672              ASSERT_EQ(tw->native_win, tw_blue->native_win);
 673              ASSERT_TRUE(tw->Vis.obj);
 674              ASSERT_FALSE(tw->iconic.set);
 675              pass_count++;
 676              continue;
 677           }
 678         else if (pass_count == 1)
 679           {
 680              ASSERT_EQ(tw->native_win, tw_green->native_win);
 681              ASSERT_TRUE(tw->Vis.obj);
 682              ASSERT_FALSE(tw->iconic.set);
 683              pass_count++;
 684              continue;
 685           }
 686         else
 687           {
 688              ASSERT_EQ(tw->native_win, tw_red->native_win);
 689              ASSERT_TRUE(tw->Vis.obj);
 690              ASSERT_FALSE(tw->iconic.set);
 691              pass_count++;
 692           }
 693
 694         break;
 695      }
 696    etRunner::get().freeWinInfoList(list);
 697
 698    ASSERT_EQ(3, pass_count);
 699
 700    ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
 701 }