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