test/tc-efl-util.cpp

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "tc-efl-util.h"
  18
  19
  20 EFLUtil::EFLUtil()
  21 {
  22 }
  23
  24 void EFLUtil::SetUp(void)
  25 {
  26    elm_init(0, NULL);
  27 }
  28
  29 void EFLUtil::TearDown(void)
  30 {
  31    elm_shutdown();
  32 }
  33
  34 static void
  35 _win_del(void *data, Evas_Object *obj, void *event)
  36 {
  37    elm_exit();
  38 }
  39
  40 static Evas_Object *
  41 _create_normal_win(const char *name)
  42 {
  43    Evas_Object *eo = NULL;
  44
  45    eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
  46    if (eo)
  47      {
  48         elm_win_title_set(eo, name);
  49         elm_win_borderless_set(eo, EINA_TRUE);
  50         evas_object_smart_callback_add(eo, "delete,request", _win_del, NULL);
  51         elm_win_indicator_mode_set(eo, ELM_WIN_INDICATOR_SHOW);
  52      }
  53
  54    return eo;
  55 }
  56
  57 static Evas_Object *
  58 _create_notification_win(const char *name)
  59 {
  60    Evas_Object *eo = NULL;
  61
  62    eo = elm_win_add(NULL, name, ELM_WIN_NOTIFICATION);
  63    if (eo)
  64      {
  65         elm_win_title_set(eo, name);
  66         elm_win_borderless_set(eo, EINA_TRUE);
  67         evas_object_smart_callback_add(eo, "delete,request", _win_del, NULL);
  68         elm_win_indicator_mode_set(eo, ELM_WIN_INDICATOR_SHOW);
  69      }
  70
  71    return eo;
  72 }
  73
  74 static Evas_Object *
  75 _create_normal_alpha_win(const char *name)
  76 {
  77    Evas_Object *eo = NULL;
  78
  79    eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
  80    if (eo)
  81      {
  82         elm_win_alpha_set(eo, EINA_TRUE);
  83         elm_win_title_set(eo, name);
  84         elm_win_borderless_set(eo, EINA_TRUE);
  85         evas_object_smart_callback_add(eo, "delete,request", _win_del, NULL);
  86         elm_win_indicator_mode_set(eo, ELM_WIN_INDICATOR_SHOW);
  87      }
  88
  89    return eo;
  90 }
  91
  92 TEST_F(EFLUtil, set_notification_window_level_n1)
  93 {
  94    int ret = 0;
  95
  96    ret = efl_util_set_notification_window_level(NULL,  EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
  97
  98    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
  99 }
 100
 101 TEST_F(EFLUtil, set_notification_window_level_n2)
 102 {
 103    Evas_Object *win = NULL;
 104    int ret = 0;
 105
 106    win = _create_normal_win("Normal window");
 107    EXPECT_NE(win, nullptr);
 108
 109    ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
 110    EXPECT_EQ(ret, EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
 111 }
 112
 113 TEST_F(EFLUtil, set_notification_window_level_n3)
 114 {
 115    Evas_Object *win = NULL;
 116    int ret = 0;
 117
 118    win = _create_notification_win("Notification Type Window");
 119    EXPECT_NE(win, nullptr);
 120
 121    ret = efl_util_set_notification_window_level(win, (efl_util_notification_level_e)100);
 122    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 123 }
 124
 125 TEST_F(EFLUtil, get_notification_window_level_n1)
 126 {
 127    int ret = 0;
 128    efl_util_notification_level_e level = (efl_util_notification_level_e)0;
 129
 130    ret = efl_util_get_notification_window_level(NULL, &level);
 131    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 132 }
 133
 134 TEST_F(EFLUtil, get_notification_window_level_n2)
 135 {
 136    Evas_Object *win = NULL;
 137    int ret = 0;
 138    efl_util_notification_level_e level = (efl_util_notification_level_e)0;
 139
 140    win = _create_normal_win("Normal Type Window");
 141    EXPECT_NE(win, nullptr);
 142
 143    ret = efl_util_get_notification_window_level(win, &level);
 144    EXPECT_EQ(ret, EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE);
 145 }
 146
 147 TEST_F(EFLUtil, set_notification_window_level_p1)
 148 {
 149    Evas_Object *win = NULL;
 150    int ret = -1;
 151
 152    win = _create_notification_win("Notification Type Window");
 153    EXPECT_NE(win, nullptr);
 154
 155    ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
 156    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 157 }
 158
 159 TEST_F(EFLUtil, set_notification_window_level_p2)
 160 {
 161    Evas_Object *win = NULL;
 162    int ret = -1;
 163
 164    win = _create_notification_win("Notification Type Window");
 165    EXPECT_NE(win, nullptr);
 166
 167    ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
 168    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 169    ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
 170    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 171 }
 172
 173 TEST_F(EFLUtil, set_notification_window_level_p3)
 174 {
 175    Evas_Object *win = NULL;
 176    int ret = -1;
 177
 178    win = _create_notification_win("Notification Type Window");
 179    EXPECT_NE(win, nullptr);
 180
 181    ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
 182    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 183 }
 184
 185 TEST_F(EFLUtil, set_notification_window_level_p4)
 186 {
 187    Evas_Object *win = NULL;
 188    int ret = -1;
 189
 190    win = _create_notification_win("Notification Type Window");
 191    EXPECT_NE(win, nullptr);
 192
 193    ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 194    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 195 }
 196
 197 TEST_F(EFLUtil, set_notification_window_level_p5)
 198 {
 199    Evas_Object *win = NULL;
 200    int ret = -1;
 201
 202    win = _create_notification_win("Notification Type Window");
 203    EXPECT_NE(win, nullptr);
 204
 205
 206    ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
 207    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 208 }
 209
 210 TEST_F(EFLUtil, set_notification_window_level_p6)
 211 {
 212    Evas_Object *win = NULL;
 213    int ret = -1;
 214
 215    win = _create_notification_win("Notification Type Window");
 216    EXPECT_NE(win, nullptr);
 217
 218    ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
 219    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 220 }
 221
 222 TEST_F(EFLUtil, set_notification_window_level_p7)
 223 {
 224    Evas_Object *win = NULL;
 225    int ret = -1;
 226
 227    win = _create_notification_win("Notification Type Window");
 228    EXPECT_NE(win, nullptr);
 229
 230    ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
 231    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 232 }
 233
 234 TEST_F(EFLUtil, set_notification_window_level_p8)
 235 {
 236    Evas_Object *win = NULL;
 237    int ret = -1;
 238
 239    win = _create_notification_win("Notification Type Window");
 240    EXPECT_NE(win, nullptr);
 241
 242    ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
 243    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 244 }
 245
 246 TEST_F(EFLUtil, get_notification_window_level_p1)
 247 {
 248    Evas_Object *win = NULL;
 249    int ret = -1;
 250    efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
 251
 252    win = _create_notification_win("Notification Type Window");
 253    EXPECT_NE(win, nullptr);
 254
 255    efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
 256    evas_object_show(win);
 257    ret = efl_util_get_notification_window_level(win, &level);
 258
 259    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 260    EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
 261 }
 262
 263 TEST_F(EFLUtil, get_notification_window_level_p2)
 264 {
 265    Evas_Object *win = NULL;
 266    int ret = -1;
 267    efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
 268
 269    win = _create_notification_win("Notification Type Window");
 270    EXPECT_NE(win, nullptr);
 271
 272    efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
 273    evas_object_show(win);
 274    ret = efl_util_get_notification_window_level(win, &level);
 275    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 276    EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
 277
 278    efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
 279    ret = efl_util_get_notification_window_level(win, &level);
 280    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 281    EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
 282 }
 283
 284 TEST_F(EFLUtil, get_notification_window_level_p3)
 285 {
 286    Evas_Object *win = NULL;
 287    int ret = -1;
 288    efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
 289
 290    win = _create_notification_win("Notification Type Window");
 291    EXPECT_NE(win, nullptr);
 292
 293    efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
 294    evas_object_show(win);
 295    ret = efl_util_get_notification_window_level(win, &level);
 296
 297    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 298    EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
 299 }
 300
 301 TEST_F(EFLUtil, get_notification_window_level_p4)
 302 {
 303    Evas_Object *win = NULL;
 304    int ret = -1;
 305    efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
 306
 307    win = _create_notification_win("Notification Type Window");
 308    EXPECT_NE(win, nullptr);
 309
 310    efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 311    evas_object_show(win);
 312    ret = efl_util_get_notification_window_level(win, &level);
 313
 314    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 315    EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 316 }
 317
 318 TEST_F(EFLUtil, get_notification_window_level_p5)
 319 {
 320    Evas_Object *win = NULL;
 321    int ret = -1;
 322    efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
 323
 324    win = _create_notification_win("Notification Type Window");
 325    EXPECT_NE(win, nullptr);
 326
 327    efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
 328    evas_object_show(win);
 329    ret = efl_util_get_notification_window_level(win, &level);
 330
 331    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 332    EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
 333 }
 334
 335 TEST_F(EFLUtil, get_notification_window_level_p6)
 336 {
 337    Evas_Object *win = NULL;
 338    int ret = -1;
 339    efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
 340
 341    win = _create_notification_win("Notification Type Window");
 342    EXPECT_NE(win, nullptr);
 343
 344    efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
 345    evas_object_show(win);
 346    ret = efl_util_get_notification_window_level(win, &level);
 347
 348    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 349    EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_MEDIUM);
 350 }
 351
 352 TEST_F(EFLUtil, get_notification_window_level_p7)
 353 {
 354    Evas_Object *win = NULL;
 355    int ret = -1;
 356    efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
 357
 358    win = _create_notification_win("Notification Type Window");
 359    EXPECT_NE(win, nullptr);
 360
 361    efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
 362    evas_object_show(win);
 363    ret = efl_util_get_notification_window_level(win, &level);
 364
 365    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 366    EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_HIGH);
 367 }
 368
 369 TEST_F(EFLUtil, get_notification_window_level_p8)
 370 {
 371    Evas_Object *win = NULL;
 372    int ret = -1;
 373    efl_util_notification_level_e level = (efl_util_notification_level_e)-1;
 374
 375    win = _create_notification_win("Notification Type Window");
 376    EXPECT_NE(win, nullptr);
 377
 378    efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
 379    evas_object_show(win);
 380    ret = efl_util_get_notification_window_level(win, &level);
 381
 382    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 383    EXPECT_EQ(level, EFL_UTIL_NOTIFICATION_LEVEL_TOP);
 384 }
 385
 386 TEST_F(EFLUtil, set_window_opaque_state_p1)
 387 {
 388    Evas_Object *win = NULL;
 389    int ret = -1;
 390
 391    win = _create_normal_alpha_win("Normal Alpha Window");
 392    EXPECT_NE(win, nullptr);
 393
 394    ret = efl_util_set_window_opaque_state(win, 0);
 395    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 396 }
 397
 398 TEST_F(EFLUtil, set_window_opaque_state_p2)
 399 {
 400    Evas_Object *win = NULL;
 401    int ret = -1;
 402
 403    win = _create_normal_alpha_win("Normal Alpha Window");
 404    EXPECT_NE(win, nullptr);
 405
 406    ret = efl_util_set_window_opaque_state(win, 1);
 407    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 408 }
 409
 410 TEST_F(EFLUtil, set_window_opaque_state_n1)
 411 {
 412    int ret = -1;
 413
 414    ret = efl_util_set_window_opaque_state(NULL, 1);
 415    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 416 }
 417
 418 TEST_F(EFLUtil, set_window_opaque_state_n2)
 419 {
 420    Evas_Object *win = NULL;
 421    int ret = -1;
 422
 423    win = _create_normal_alpha_win("Normal Alpha Window");
 424    EXPECT_NE(win, nullptr);
 425
 426    ret = efl_util_set_window_opaque_state(win, -1);
 427    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 428 }
 429
 430 TEST_F(EFLUtil, set_window_screen_mode_p1)
 431 {
 432    Evas_Object *win = NULL;
 433    int ret = -1;
 434
 435    win = _create_normal_win("Screen mode test");
 436    EXPECT_NE(win, nullptr);
 437
 438    ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_DEFAULT);
 439    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 440 }
 441
 442 TEST_F(EFLUtil, set_window_screen_mode_p2)
 443 {
 444    Evas_Object *win = NULL;
 445    int ret = -1;
 446
 447    win = _create_normal_win("Screen mode test");
 448    EXPECT_NE(win, nullptr);
 449
 450    ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_ALWAYS_ON);
 451    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 452 }
 453
 454 TEST_F(EFLUtil, set_window_screen_mode_p3)
 455 {
 456    Evas_Object *win = NULL;
 457    int ret = -1;
 458    efl_util_screen_mode_e mode;
 459
 460    win = _create_normal_win("Screen mode test");
 461    EXPECT_NE(win, nullptr);
 462
 463    ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_ALWAYS_ON);
 464    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 465
 466    ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_DEFAULT);
 467    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 468
 469    ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_ALWAYS_ON);
 470    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 471
 472    ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_DEFAULT);
 473    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 474
 475    ret = efl_util_get_window_screen_mode(win, &mode);
 476    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 477    EXPECT_EQ(mode, EFL_UTIL_SCREEN_MODE_DEFAULT);
 478 }
 479
 480 TEST_F(EFLUtil, set_window_screen_mode_n1)
 481 {
 482    Evas_Object *win = NULL;
 483    int ret = -1;
 484
 485    ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_ALWAYS_ON);
 486    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 487 }
 488
 489 TEST_F(EFLUtil, set_window_screen_mode_n2)
 490 {
 491    Evas_Object *win = NULL;
 492    int ret = -1;
 493
 494    win = _create_normal_win("Screen mode test");
 495    EXPECT_NE(win, nullptr);
 496
 497    ret = efl_util_set_window_screen_mode(win, (efl_util_screen_mode_e)3);
 498    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 499 }
 500
 501 TEST_F(EFLUtil, get_window_screen_mode_p1)
 502 {
 503    Evas_Object *win = NULL;
 504    int ret = -1;
 505    efl_util_screen_mode_e mode;
 506
 507    win = _create_normal_win("Screen mode test");
 508    EXPECT_NE(win, nullptr);
 509
 510    ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_DEFAULT);
 511    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 512
 513    ret = efl_util_get_window_screen_mode(win, &mode);
 514    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 515    EXPECT_EQ(mode, EFL_UTIL_SCREEN_MODE_DEFAULT);
 516 }
 517
 518 TEST_F(EFLUtil, get_window_screen_mode_p2)
 519 {
 520    Evas_Object *win = NULL;
 521    int ret = -1;
 522    efl_util_screen_mode_e mode;
 523
 524    win = _create_normal_win("Screen mode test");
 525    EXPECT_NE(win, nullptr);
 526
 527    ret = efl_util_set_window_screen_mode(win, EFL_UTIL_SCREEN_MODE_ALWAYS_ON);
 528    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 529
 530    ret = efl_util_get_window_screen_mode(win, &mode);
 531    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 532    EXPECT_EQ(mode, EFL_UTIL_SCREEN_MODE_ALWAYS_ON);
 533 }
 534
 535 TEST_F(EFLUtil, get_window_screen_mode_n1)
 536 {
 537    Evas_Object *win = NULL;
 538    int ret = -1;
 539    efl_util_screen_mode_e mode;
 540
 541    ret = efl_util_get_window_screen_mode(win, &mode);
 542    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 543 }
 544
 545 TEST_F(EFLUtil, get_window_screen_mode_n2)
 546 {
 547    Evas_Object *win = NULL;
 548    int ret = -1;
 549    efl_util_screen_mode_e mode;
 550
 551    win = _create_normal_win("Screen mode test");
 552    EXPECT_NE(win, nullptr);
 553
 554    ret = efl_util_get_window_screen_mode(win, &mode);
 555    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 556 }
 557
 558 TEST_F(EFLUtil, set_window_brightness_p1)
 559 {
 560    Evas_Object *win = NULL;
 561    int ret = -1;
 562
 563    win = _create_normal_win("Brightness test");
 564    EXPECT_NE(win, nullptr);
 565
 566    ret = efl_util_set_window_brightness(win, 50);
 567    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 568 }
 569
 570 TEST_F(EFLUtil, set_window_brightness_p2)
 571 {
 572    Evas_Object *win = NULL;
 573    int ret = -1;
 574
 575    win = _create_normal_win("Brightness test");
 576    EXPECT_NE(win, nullptr);
 577
 578    ret = efl_util_set_window_brightness(win, -1);
 579    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 580 }
 581
 582 TEST_F(EFLUtil, set_window_brightness_n1)
 583 {
 584    Evas_Object *win = NULL;
 585    int ret = -1;
 586
 587    ret = efl_util_set_window_brightness(win, 60);
 588    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 589 }
 590
 591 TEST_F(EFLUtil, set_window_brightness_n2)
 592 {
 593    Evas_Object *win = NULL;
 594    int ret = -1;
 595
 596    win = _create_normal_win("Brightness test");
 597    EXPECT_NE(win, nullptr);
 598
 599    ret = efl_util_set_window_brightness(win, 1000);
 600    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 601 }
 602
 603 TEST_F(EFLUtil, get_window_brightness_p1)
 604 {
 605    Evas_Object *win = NULL;
 606    int ret = -1;
 607    int brightness = -1;
 608
 609    win = _create_normal_win("Brightness test");
 610    EXPECT_NE(win, nullptr);
 611
 612    ret = efl_util_set_window_brightness(win, 70);
 613    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 614
 615    ret = efl_util_get_window_brightness(win, &brightness);
 616    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 617    EXPECT_EQ(brightness, 70);
 618 }
 619
 620 TEST_F(EFLUtil, get_window_brightness_p2)
 621 {
 622    Evas_Object *win = NULL;
 623    int ret = -1;
 624    int brightness = -1;
 625
 626    win = _create_normal_win("Brightness test");
 627    EXPECT_NE(win, nullptr);
 628
 629    ret = efl_util_set_window_brightness(win, -1);
 630    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 631
 632    ret = efl_util_get_window_brightness(win, &brightness);
 633    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 634    EXPECT_EQ(brightness, -1);
 635 }
 636
 637 TEST_F(EFLUtil, get_window_brightness_p3)
 638 {
 639    Evas_Object *win = NULL;
 640    int ret = -1;
 641    int brightness = -1;
 642
 643    win = _create_normal_win("Brightness test");
 644    EXPECT_NE(win, nullptr);
 645
 646    ret = efl_util_get_window_brightness(win, &brightness);
 647    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 648    EXPECT_EQ(brightness, -1);
 649 }
 650
 651 TEST_F(EFLUtil, get_window_brightness_n1)
 652 {
 653    Evas_Object *win = NULL;
 654    int ret = -1;
 655    int brightness = -1;
 656
 657    ret = efl_util_get_window_brightness(win, &brightness);
 658    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 659 }
 660
 661 TEST_F(EFLUtil, get_window_brightness_n2)
 662 {
 663    Evas_Object *win = NULL;
 664    int ret = -1;
 665
 666    win = _create_normal_win("Brightness test");
 667    EXPECT_NE(win, nullptr);
 668
 669    ret = efl_util_get_window_brightness(win, NULL);
 670    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 671 }
 672
 673 TEST_F(EFLUtil, gesture_initialize_p)
 674 {
 675    int ret = EFL_UTIL_ERROR_NONE;
 676    efl_util_gesture_h h_gesture = NULL;
 677
 678    h_gesture = efl_util_gesture_initialize();
 679    ret = get_last_result();
 680    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 681    EXPECT_NE(h_gesture, nullptr);
 682
 683    ret = efl_util_gesture_deinitialize(h_gesture);
 684    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 685 }
 686
 687 TEST_F(EFLUtil, gesture_deinitialize_p)
 688 {
 689    int ret = EFL_UTIL_ERROR_NONE;
 690    efl_util_gesture_h h_gesture = NULL;
 691
 692    h_gesture = efl_util_gesture_initialize();
 693    ret = get_last_result();
 694    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 695    EXPECT_NE(h_gesture, nullptr);
 696
 697    ret = efl_util_gesture_deinitialize(h_gesture);
 698    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 699 }
 700
 701
 702 TEST_F(EFLUtil, gesture_deinitialize_n)
 703 {
 704    int ret = EFL_UTIL_ERROR_NONE;
 705    efl_util_gesture_h h_gesture = NULL;
 706
 707    ret = efl_util_gesture_deinitialize(h_gesture);
 708    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 709 }
 710
 711 TEST_F(EFLUtil, gesture_edge_swipe_new_p1)
 712 {
 713    int ret = EFL_UTIL_ERROR_NONE;
 714    efl_util_gesture_h h_gesture = NULL;
 715    efl_util_gesture_data d_edge_swipe = NULL;
 716
 717    h_gesture = efl_util_gesture_initialize();
 718    ret = get_last_result();
 719    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 720    EXPECT_NE(h_gesture, nullptr);
 721
 722    d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
 723    ret = get_last_result();
 724    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 725    EXPECT_NE(d_edge_swipe, nullptr);
 726
 727    ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
 728    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 729
 730    ret = efl_util_gesture_deinitialize(h_gesture);
 731    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 732 }
 733
 734 TEST_F(EFLUtil, gesture_edge_swipe_new_p2)
 735 {
 736    int ret = EFL_UTIL_ERROR_NONE;
 737    efl_util_gesture_h h_gesture = NULL;
 738    efl_util_gesture_data d_edge_swipe = NULL;
 739
 740    h_gesture = efl_util_gesture_initialize();
 741    ret = get_last_result();
 742    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 743    EXPECT_NE(h_gesture, nullptr);
 744
 745    d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 2, EFL_UTIL_GESTURE_EDGE_TOP);
 746    ret = get_last_result();
 747    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 748    EXPECT_NE(d_edge_swipe, nullptr);
 749
 750    ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
 751    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 752
 753    ret = efl_util_gesture_deinitialize(h_gesture);
 754    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 755 }
 756
 757 TEST_F(EFLUtil, gesture_edge_swipe_new_p3)
 758 {
 759    int ret = EFL_UTIL_ERROR_NONE;
 760    efl_util_gesture_h h_gesture = NULL;
 761    efl_util_gesture_data d_edge_swipe = NULL;
 762
 763    h_gesture = efl_util_gesture_initialize();
 764    ret = get_last_result();
 765    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 766    EXPECT_NE(h_gesture, nullptr);
 767
 768    d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_BOTTOM);
 769    ret = get_last_result();
 770    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 771    EXPECT_NE(d_edge_swipe, nullptr);
 772
 773    ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
 774    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 775
 776    ret = efl_util_gesture_deinitialize(h_gesture);
 777    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 778 }
 779
 780 TEST_F(EFLUtil, gesture_edge_swipe_new_p4)
 781 {
 782    int ret = EFL_UTIL_ERROR_NONE;
 783    efl_util_gesture_h h_gesture = NULL;
 784    efl_util_gesture_data d_edge_swipe = NULL;
 785
 786    h_gesture = efl_util_gesture_initialize();
 787    ret = get_last_result();
 788    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 789    EXPECT_NE(h_gesture, nullptr);
 790
 791    d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_LEFT);
 792    ret = get_last_result();
 793    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 794    EXPECT_NE(d_edge_swipe, nullptr);
 795
 796    ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
 797    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 798
 799    ret = efl_util_gesture_deinitialize(h_gesture);
 800    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 801 }
 802
 803 TEST_F(EFLUtil, gesture_edge_swipe_new_p5)
 804 {
 805    int ret = EFL_UTIL_ERROR_NONE;
 806    efl_util_gesture_h h_gesture = NULL;
 807    efl_util_gesture_data d_edge_swipe = NULL;
 808
 809    h_gesture = efl_util_gesture_initialize();
 810    ret = get_last_result();
 811    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 812    EXPECT_NE(h_gesture, nullptr);
 813
 814    d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_RIGHT);
 815    ret = get_last_result();
 816    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 817    EXPECT_NE(d_edge_swipe, nullptr);
 818
 819    ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
 820    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 821
 822    ret = efl_util_gesture_deinitialize(h_gesture);
 823    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 824 }
 825
 826 TEST_F(EFLUtil, gesture_edge_swipe_new_n1)
 827 {
 828    int ret = EFL_UTIL_ERROR_NONE;
 829    efl_util_gesture_h h_gesture = NULL;
 830
 831    efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
 832    ret = get_last_result();
 833    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 834 }
 835
 836 TEST_F(EFLUtil, gesture_edge_swipe_new_n2)
 837 {
 838    int ret = EFL_UTIL_ERROR_NONE;
 839    efl_util_gesture_h h_gesture = NULL;
 840
 841    h_gesture = efl_util_gesture_initialize();
 842    ret = get_last_result();
 843    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 844    EXPECT_NE(h_gesture, nullptr);
 845
 846    efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_NONE);
 847    ret = get_last_result();
 848    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 849
 850    ret = efl_util_gesture_deinitialize(h_gesture);
 851    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 852 }
 853
 854 TEST_F(EFLUtil, gesture_edge_swipe_new_n3)
 855 {
 856    int ret = EFL_UTIL_ERROR_NONE;
 857    efl_util_gesture_h h_gesture = NULL;
 858
 859    h_gesture = efl_util_gesture_initialize();
 860    ret = get_last_result();
 861    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 862    EXPECT_NE(h_gesture, nullptr);
 863
 864    efl_util_gesture_edge_swipe_new(h_gesture, 1, (efl_util_gesture_edge_e)(EFL_UTIL_GESTURE_EDGE_LEFT + 1));
 865    ret = get_last_result();
 866    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 867
 868    ret = efl_util_gesture_deinitialize(h_gesture);
 869    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 870 }
 871
 872 TEST_F(EFLUtil, gesture_edge_swipe_size_set_p1)
 873 {
 874    int ret = EFL_UTIL_ERROR_NONE;
 875    efl_util_gesture_h h_gesture = NULL;
 876    efl_util_gesture_data d_edge_swipe = NULL;
 877
 878    h_gesture = efl_util_gesture_initialize();
 879    ret = get_last_result();
 880    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 881    EXPECT_NE(h_gesture, nullptr);
 882
 883    d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
 884    ret = get_last_result();
 885    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 886    EXPECT_NE(d_edge_swipe, nullptr);
 887
 888    ret = efl_util_gesture_edge_swipe_size_set(d_edge_swipe, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 0, 359);
 889    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 890
 891    ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
 892    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 893
 894    ret = efl_util_gesture_deinitialize(h_gesture);
 895    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 896 }
 897
 898 TEST_F(EFLUtil, gesture_edge_swipe_size_set_n1)
 899 {
 900    int ret = EFL_UTIL_ERROR_NONE;
 901    efl_util_gesture_data d_edge_swipe = NULL;
 902
 903    ret = efl_util_gesture_edge_swipe_size_set(d_edge_swipe, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 0, 1);
 904    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 905 }
 906
 907 TEST_F(EFLUtil, gesture_edge_swipe_size_set_n2)
 908 {
 909    int ret = EFL_UTIL_ERROR_NONE;
 910    efl_util_gesture_h h_gesture = NULL;
 911    efl_util_gesture_data d_edge_drag = NULL;
 912
 913    h_gesture = efl_util_gesture_initialize();
 914    ret = get_last_result();
 915    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 916    EXPECT_NE(h_gesture, nullptr);
 917
 918    d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
 919    ret = get_last_result();
 920    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 921    EXPECT_NE(d_edge_drag, nullptr);
 922
 923    ret = efl_util_gesture_edge_swipe_size_set(d_edge_drag, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 0, 100);
 924    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 925
 926    ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
 927    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 928
 929    ret = efl_util_gesture_deinitialize(h_gesture);
 930    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 931 }
 932
 933 TEST_F(EFLUtil, gesture_edge_swipe_size_set_n3)
 934 {
 935    int ret = EFL_UTIL_ERROR_NONE;
 936    efl_util_gesture_h h_gesture = NULL;
 937    efl_util_gesture_data d_edge_swipe = NULL;
 938
 939    h_gesture = efl_util_gesture_initialize();
 940    ret = get_last_result();
 941    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 942    EXPECT_NE(h_gesture, nullptr);
 943
 944    d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
 945    ret = get_last_result();
 946    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 947    EXPECT_NE(d_edge_swipe, nullptr);
 948
 949    ret = efl_util_gesture_edge_swipe_size_set(d_edge_swipe, EFL_UTIL_GESTURE_EDGE_SIZE_FULL, 0, 1);
 950    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 951
 952    ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
 953    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 954
 955    ret = efl_util_gesture_deinitialize(h_gesture);
 956    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 957 }
 958
 959 TEST_F(EFLUtil, gesture_edge_swipe_size_set_n4)
 960 {
 961    int ret = EFL_UTIL_ERROR_NONE;
 962    efl_util_gesture_h h_gesture = NULL;
 963    efl_util_gesture_data d_edge_swipe = NULL;
 964
 965    h_gesture = efl_util_gesture_initialize();
 966    ret = get_last_result();
 967    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 968    EXPECT_NE(h_gesture, nullptr);
 969
 970    d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
 971    ret = get_last_result();
 972    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 973    EXPECT_NE(d_edge_swipe, nullptr);
 974
 975    ret = efl_util_gesture_edge_swipe_size_set(d_edge_swipe, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 5, 1);
 976    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
 977
 978    ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
 979    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 980
 981    ret = efl_util_gesture_deinitialize(h_gesture);
 982    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 983 }
 984
 985 TEST_F(EFLUtil, gesture_edge_swipe_free_p1)
 986 {
 987    int ret = EFL_UTIL_ERROR_NONE;
 988    efl_util_gesture_h h_gesture = NULL;
 989    efl_util_gesture_data d_edge_swipe = NULL;
 990
 991    h_gesture = efl_util_gesture_initialize();
 992    ret = get_last_result();
 993    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 994    EXPECT_NE(h_gesture, nullptr);
 995
 996    d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
 997    ret = get_last_result();
 998    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
 999    EXPECT_NE(d_edge_swipe, nullptr);
1000
1001    ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
1002    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1003
1004    ret = efl_util_gesture_deinitialize(h_gesture);
1005    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1006 }
1007
1008 TEST_F(EFLUtil, gesture_edge_swipe_free_n1)
1009 {
1010    int ret = EFL_UTIL_ERROR_NONE;
1011    efl_util_gesture_h h_gesture = NULL;
1012
1013    h_gesture = efl_util_gesture_initialize();
1014    ret = get_last_result();
1015    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1016    EXPECT_NE(h_gesture, nullptr);
1017
1018    ret = efl_util_gesture_edge_swipe_free(h_gesture, NULL);
1019    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1020
1021    ret = efl_util_gesture_deinitialize(h_gesture);
1022    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1023 }
1024
1025 TEST_F(EFLUtil, gesture_edge_swipe_free_n2)
1026 {
1027    int ret = EFL_UTIL_ERROR_NONE;
1028    efl_util_gesture_h h_gesture = NULL;
1029
1030    ret = efl_util_gesture_edge_swipe_free(h_gesture, NULL);
1031    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1032 }
1033
1034 TEST_F(EFLUtil, gesture_edge_drag_new_p1)
1035 {
1036    int ret = EFL_UTIL_ERROR_NONE;
1037    efl_util_gesture_h h_gesture = NULL;
1038    efl_util_gesture_data d_edge_drag = NULL;
1039
1040    h_gesture = efl_util_gesture_initialize();
1041    ret = get_last_result();
1042    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1043    EXPECT_NE(h_gesture, nullptr);
1044
1045    d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
1046    ret = get_last_result();
1047    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1048
1049    ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
1050    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1051    EXPECT_NE(d_edge_drag, nullptr);
1052
1053    ret = efl_util_gesture_deinitialize(h_gesture);
1054    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1055 }
1056
1057 TEST_F(EFLUtil, gesture_edge_drag_new_p2)
1058 {
1059    int ret = EFL_UTIL_ERROR_NONE;
1060    efl_util_gesture_h h_gesture = NULL;
1061    efl_util_gesture_data d_edge_drag = NULL;
1062
1063    h_gesture = efl_util_gesture_initialize();
1064    ret = get_last_result();
1065    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1066    EXPECT_NE(h_gesture, nullptr);
1067
1068    d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 2, EFL_UTIL_GESTURE_EDGE_TOP);
1069    ret = get_last_result();
1070    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1071    EXPECT_NE(d_edge_drag, nullptr);
1072
1073    ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
1074    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1075
1076    ret = efl_util_gesture_deinitialize(h_gesture);
1077    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1078 }
1079
1080 TEST_F(EFLUtil, gesture_edge_drag_new_p3)
1081 {
1082    int ret = EFL_UTIL_ERROR_NONE;
1083    efl_util_gesture_h h_gesture = NULL;
1084    efl_util_gesture_data d_edge_drag = NULL;
1085
1086    h_gesture = efl_util_gesture_initialize();
1087    ret = get_last_result();
1088    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1089    EXPECT_NE(h_gesture, nullptr);
1090
1091    d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_BOTTOM);
1092    ret = get_last_result();
1093    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1094    EXPECT_NE(d_edge_drag, nullptr);
1095
1096    ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
1097    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1098
1099    ret = efl_util_gesture_deinitialize(h_gesture);
1100    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1101 }
1102
1103 TEST_F(EFLUtil, gesture_edge_drag_new_p4)
1104 {
1105    int ret = EFL_UTIL_ERROR_NONE;
1106    efl_util_gesture_h h_gesture = NULL;
1107    efl_util_gesture_data d_edge_drag = NULL;
1108
1109    h_gesture = efl_util_gesture_initialize();
1110    ret = get_last_result();
1111    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1112    EXPECT_NE(h_gesture, nullptr);
1113
1114    d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_LEFT);
1115    ret = get_last_result();
1116    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1117    EXPECT_NE(d_edge_drag, nullptr);
1118
1119    ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
1120    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1121
1122    ret = efl_util_gesture_deinitialize(h_gesture);
1123    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1124 }
1125
1126 TEST_F(EFLUtil, gesture_edge_drag_new_p5)
1127 {
1128    int ret = EFL_UTIL_ERROR_NONE;
1129    efl_util_gesture_h h_gesture = NULL;
1130    efl_util_gesture_data d_edge_drag = NULL;
1131
1132    h_gesture = efl_util_gesture_initialize();
1133    ret = get_last_result();
1134    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1135    EXPECT_NE(h_gesture, nullptr);
1136
1137    d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_RIGHT);
1138    ret = get_last_result();
1139    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1140    EXPECT_NE(d_edge_drag, nullptr);
1141
1142    ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
1143    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1144
1145    ret = efl_util_gesture_deinitialize(h_gesture);
1146    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1147 }
1148
1149 TEST_F(EFLUtil, gesture_edge_drag_new_n1)
1150 {
1151    int ret = EFL_UTIL_ERROR_NONE;
1152    efl_util_gesture_h h_gesture = NULL;
1153
1154    efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
1155    ret = get_last_result();
1156    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1157 }
1158
1159 TEST_F(EFLUtil, gesture_edge_drag_new_n2)
1160 {
1161    int ret = EFL_UTIL_ERROR_NONE;
1162    efl_util_gesture_h h_gesture = NULL;
1163
1164    h_gesture = efl_util_gesture_initialize();
1165    ret = get_last_result();
1166    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1167    EXPECT_NE(h_gesture, nullptr);
1168
1169    efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_NONE);
1170    ret = get_last_result();
1171    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1172
1173    ret = efl_util_gesture_deinitialize(h_gesture);
1174    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1175 }
1176
1177 TEST_F(EFLUtil, gesture_edge_drag_new_n3)
1178 {
1179    int ret = EFL_UTIL_ERROR_NONE;
1180    efl_util_gesture_h h_gesture = NULL;
1181
1182    h_gesture = efl_util_gesture_initialize();
1183    ret = get_last_result();
1184    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1185    EXPECT_NE(h_gesture, nullptr);
1186
1187    efl_util_gesture_edge_drag_new(h_gesture, 1, (efl_util_gesture_edge_e)((int)EFL_UTIL_GESTURE_EDGE_NONE - 1));
1188    ret = get_last_result();
1189    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1190
1191    ret = efl_util_gesture_deinitialize(h_gesture);
1192    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1193 }
1194
1195 TEST_F(EFLUtil, gesture_edge_drag_new_n4)
1196 {
1197    int ret = EFL_UTIL_ERROR_NONE;
1198    efl_util_gesture_h h_gesture = NULL;
1199
1200    h_gesture = efl_util_gesture_initialize();
1201    ret = get_last_result();
1202    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1203    EXPECT_NE(h_gesture, nullptr);
1204
1205    efl_util_gesture_edge_drag_new(h_gesture, 1, (efl_util_gesture_edge_e)((int)EFL_UTIL_GESTURE_EDGE_LEFT + 1));
1206    ret = get_last_result();
1207    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1208
1209    ret = efl_util_gesture_deinitialize(h_gesture);
1210    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1211 }
1212
1213 TEST_F(EFLUtil, gesture_edge_drag_size_set_p1)
1214 {
1215    int ret = EFL_UTIL_ERROR_NONE;
1216    efl_util_gesture_h h_gesture = NULL;
1217    efl_util_gesture_data d_edge_drag = NULL;
1218
1219    h_gesture = efl_util_gesture_initialize();
1220    ret = get_last_result();
1221    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1222    EXPECT_NE(h_gesture, nullptr);
1223
1224    d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
1225    ret = get_last_result();
1226    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1227    EXPECT_NE(d_edge_drag, nullptr);
1228
1229    ret = efl_util_gesture_edge_drag_size_set(d_edge_drag, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 0, 359);
1230    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1231
1232    ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
1233    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1234
1235    ret = efl_util_gesture_deinitialize(h_gesture);
1236    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1237 }
1238
1239 TEST_F(EFLUtil, gesture_edge_drag_size_set_n1)
1240 {
1241    int ret = EFL_UTIL_ERROR_NONE;
1242    efl_util_gesture_data d_edge_drag = NULL;
1243
1244    ret = efl_util_gesture_edge_drag_size_set(d_edge_drag, EFL_UTIL_GESTURE_EDGE_SIZE_FULL, 0, 1);
1245    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1246 }
1247
1248 TEST_F(EFLUtil, gesture_edge_drag_size_set_n2)
1249 {
1250    int ret = EFL_UTIL_ERROR_NONE;
1251    efl_util_gesture_h h_gesture = NULL;
1252    efl_util_gesture_data d_edge_swipe = NULL;
1253
1254    h_gesture = efl_util_gesture_initialize();
1255    ret = get_last_result();
1256    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1257    EXPECT_NE(h_gesture, nullptr);
1258
1259    d_edge_swipe = efl_util_gesture_edge_swipe_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
1260    ret = get_last_result();
1261    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1262    EXPECT_NE(d_edge_swipe, nullptr);
1263
1264    ret = efl_util_gesture_edge_drag_size_set(d_edge_swipe, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 0, 100);
1265    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1266
1267    ret = efl_util_gesture_edge_swipe_free(h_gesture, d_edge_swipe);
1268    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1269
1270    ret = efl_util_gesture_deinitialize(h_gesture);
1271    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1272 }
1273
1274 TEST_F(EFLUtil, gesture_edge_drag_size_set_n3)
1275 {
1276    int ret = EFL_UTIL_ERROR_NONE;
1277    efl_util_gesture_h h_gesture = NULL;
1278    efl_util_gesture_data d_edge_drag = NULL;
1279
1280    h_gesture = efl_util_gesture_initialize();
1281    ret = get_last_result();
1282    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1283    EXPECT_NE(h_gesture, nullptr);
1284
1285    d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
1286    ret = get_last_result();
1287    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1288    EXPECT_NE(d_edge_drag, nullptr);
1289
1290    ret = efl_util_gesture_edge_drag_size_set(d_edge_drag, EFL_UTIL_GESTURE_EDGE_SIZE_FULL, 0, 1);
1291    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1292
1293    ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
1294    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1295
1296    ret = efl_util_gesture_deinitialize(h_gesture);
1297    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1298 }
1299
1300 TEST_F(EFLUtil, gesture_edge_drag_size_set_n4)
1301 {
1302    int ret = EFL_UTIL_ERROR_NONE;
1303    efl_util_gesture_h h_gesture = NULL;
1304    efl_util_gesture_data d_edge_drag = NULL;
1305
1306    h_gesture = efl_util_gesture_initialize();
1307    ret = get_last_result();
1308    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1309    EXPECT_NE(h_gesture, nullptr);
1310
1311    d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
1312    ret = get_last_result();
1313    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1314    EXPECT_NE(d_edge_drag, nullptr);
1315
1316    ret = efl_util_gesture_edge_drag_size_set(d_edge_drag, EFL_UTIL_GESTURE_EDGE_SIZE_PARTIAL, 5, 1);
1317    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1318
1319    ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
1320    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1321
1322    ret = efl_util_gesture_deinitialize(h_gesture);
1323    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1324 }
1325
1326 TEST_F(EFLUtil, gesture_edge_drag_free_p1)
1327 {
1328    int ret = EFL_UTIL_ERROR_NONE;
1329    efl_util_gesture_h h_gesture = NULL;
1330    efl_util_gesture_data d_edge_drag = NULL;
1331
1332    h_gesture = efl_util_gesture_initialize();
1333    ret = get_last_result();
1334    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1335    EXPECT_NE(h_gesture, nullptr);
1336
1337    d_edge_drag = efl_util_gesture_edge_drag_new(h_gesture, 1, EFL_UTIL_GESTURE_EDGE_TOP);
1338    ret = get_last_result();
1339    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1340    EXPECT_NE(d_edge_drag, nullptr);
1341
1342    ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
1343    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1344
1345    ret = efl_util_gesture_deinitialize(h_gesture);
1346    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1347 }
1348
1349 TEST_F(EFLUtil, gesture_edge_drag_free_n1)
1350 {
1351    int ret = EFL_UTIL_ERROR_NONE;
1352    efl_util_gesture_h h_gesture = NULL;
1353    efl_util_gesture_data d_edge_drag = NULL;
1354
1355    h_gesture = efl_util_gesture_initialize();
1356    ret = get_last_result();
1357    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1358    EXPECT_NE(h_gesture, nullptr);
1359
1360    ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
1361    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1362
1363    ret = efl_util_gesture_deinitialize(h_gesture);
1364    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1365 }
1366
1367 TEST_F(EFLUtil, gesture_edge_drag_free_n2)
1368 {
1369    int ret = EFL_UTIL_ERROR_NONE;
1370    efl_util_gesture_h h_gesture = NULL;
1371    efl_util_gesture_data d_edge_drag = NULL;
1372
1373    ret = efl_util_gesture_edge_drag_free(h_gesture, d_edge_drag);
1374    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1375 }
1376
1377 TEST_F(EFLUtil, gesture_tap_new_p)
1378 {
1379    int ret = EFL_UTIL_ERROR_NONE;
1380    efl_util_gesture_h h_gesture = NULL;
1381    efl_util_gesture_data d_tap = NULL;
1382
1383    h_gesture = efl_util_gesture_initialize();
1384    ret = get_last_result();
1385    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1386    EXPECT_NE(h_gesture, nullptr);
1387
1388    d_tap = efl_util_gesture_tap_new(h_gesture, 2, 2);
1389    ret = get_last_result();
1390    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1391    EXPECT_NE(d_tap, nullptr);
1392
1393    ret = efl_util_gesture_tap_free(h_gesture, d_tap);
1394    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1395
1396    ret = efl_util_gesture_deinitialize(h_gesture);
1397    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1398 }
1399
1400 TEST_F(EFLUtil, gesture_tap_new_n1)
1401 {
1402    int ret = EFL_UTIL_ERROR_NONE;
1403    efl_util_gesture_h h_gesture = NULL;
1404
1405    efl_util_gesture_tap_new(h_gesture, 2, 2);
1406    ret = get_last_result();
1407    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1408 }
1409
1410 TEST_F(EFLUtil, gesture_tap_new_n2)
1411 {
1412    int ret = EFL_UTIL_ERROR_NONE;
1413    efl_util_gesture_h h_gesture = NULL;
1414
1415    h_gesture = efl_util_gesture_initialize();
1416    ret = get_last_result();
1417    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1418    EXPECT_NE(h_gesture, nullptr);
1419
1420    efl_util_gesture_tap_new(h_gesture, 0, 2);
1421    ret = get_last_result();
1422    EXPECT_EQ(ret, EFL_UTIL_ERROR_NOT_SUPPORTED);
1423
1424    ret = efl_util_gesture_deinitialize(h_gesture);
1425    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1426 }
1427
1428 TEST_F(EFLUtil, gesture_tap_new_n3)
1429 {
1430    int ret = EFL_UTIL_ERROR_NONE;
1431    efl_util_gesture_h h_gesture = NULL;
1432
1433    h_gesture = efl_util_gesture_initialize();
1434    ret = get_last_result();
1435    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1436    EXPECT_NE(h_gesture, nullptr);
1437
1438    efl_util_gesture_tap_new(h_gesture, 2, 1);
1439    ret = get_last_result();
1440    EXPECT_EQ(ret, EFL_UTIL_ERROR_NOT_SUPPORTED);
1441
1442    ret = efl_util_gesture_deinitialize(h_gesture);
1443    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1444 }
1445
1446 TEST_F(EFLUtil, gesture_tap_free_p1)
1447 {
1448    int ret = EFL_UTIL_ERROR_NONE;
1449    efl_util_gesture_h h_gesture = NULL;
1450    efl_util_gesture_data d_tap = NULL;
1451
1452    h_gesture = efl_util_gesture_initialize();
1453    ret = get_last_result();
1454    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1455    EXPECT_NE(h_gesture, nullptr);
1456
1457    d_tap = efl_util_gesture_tap_new(h_gesture, 2, 2);
1458    ret = get_last_result();
1459    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1460    EXPECT_NE(d_tap, nullptr);
1461
1462    ret = efl_util_gesture_tap_free(h_gesture, d_tap);
1463    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1464
1465    ret = efl_util_gesture_deinitialize(h_gesture);
1466    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1467 }
1468
1469 TEST_F(EFLUtil, gesture_tap_free_n1)
1470 {
1471    int ret = EFL_UTIL_ERROR_NONE;
1472    efl_util_gesture_h h_gesture = NULL;
1473    efl_util_gesture_data d_tap = NULL;
1474
1475    h_gesture = efl_util_gesture_initialize();
1476    ret = get_last_result();
1477    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1478    EXPECT_NE(h_gesture, nullptr);
1479
1480    ret = efl_util_gesture_tap_free(h_gesture, d_tap);
1481    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1482
1483    ret = efl_util_gesture_deinitialize(h_gesture);
1484    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1485 }
1486
1487 TEST_F(EFLUtil, gesture_tap_free_n2)
1488 {
1489    int ret = EFL_UTIL_ERROR_NONE;
1490    efl_util_gesture_h h_gesture = NULL;
1491    efl_util_gesture_data d_tap = NULL;
1492
1493    ret = efl_util_gesture_tap_free(h_gesture, d_tap);
1494    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1495 }
1496
1497 TEST_F(EFLUtil, gesture_palm_cover_new_p)
1498 {
1499    int ret = EFL_UTIL_ERROR_NONE;
1500    efl_util_gesture_h h_gesture = NULL;
1501    efl_util_gesture_data d_palm_cover = NULL;
1502
1503    h_gesture = efl_util_gesture_initialize();
1504    ret = get_last_result();
1505    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1506    EXPECT_NE(h_gesture, nullptr);
1507
1508    d_palm_cover = efl_util_gesture_palm_cover_new(h_gesture);
1509    ret = get_last_result();
1510    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1511    EXPECT_NE(d_palm_cover, nullptr);
1512
1513    ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
1514    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1515
1516    ret = efl_util_gesture_deinitialize(h_gesture);
1517    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1518 }
1519
1520 TEST_F(EFLUtil, gesture_palm_cover_new_n)
1521 {
1522    int ret = EFL_UTIL_ERROR_NONE;
1523    efl_util_gesture_h h_gesture = NULL;
1524
1525    efl_util_gesture_palm_cover_new(h_gesture);
1526    ret = get_last_result();
1527    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1528 }
1529
1530 TEST_F(EFLUtil, gesture_palm_cover_free_p1)
1531 {
1532    int ret = EFL_UTIL_ERROR_NONE;
1533    efl_util_gesture_h h_gesture = NULL;
1534    efl_util_gesture_data d_palm_cover = NULL;
1535
1536    h_gesture = efl_util_gesture_initialize();
1537    ret = get_last_result();
1538    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1539    EXPECT_NE(h_gesture, nullptr);
1540
1541    d_palm_cover = efl_util_gesture_palm_cover_new(h_gesture);
1542    ret = get_last_result();
1543    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1544    EXPECT_NE(d_palm_cover, nullptr);
1545
1546    ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
1547    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1548
1549    ret = efl_util_gesture_deinitialize(h_gesture);
1550    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1551 }
1552
1553 TEST_F(EFLUtil, gesture_palm_cover_free_n1)
1554 {
1555    int ret = EFL_UTIL_ERROR_NONE;
1556    efl_util_gesture_h h_gesture = NULL;
1557    efl_util_gesture_data d_palm_cover = NULL;
1558
1559    h_gesture = efl_util_gesture_initialize();
1560    ret = get_last_result();
1561    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1562    EXPECT_NE(h_gesture, nullptr);
1563
1564    ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
1565    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1566
1567    ret = efl_util_gesture_deinitialize(h_gesture);
1568    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1569 }
1570
1571 TEST_F(EFLUtil, gesture_palm_cover_free_n2)
1572 {
1573    int ret = EFL_UTIL_ERROR_NONE;
1574    efl_util_gesture_h h_gesture = NULL;
1575    efl_util_gesture_data d_palm_cover = NULL;
1576
1577    ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
1578    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1579 }
1580
1581 TEST_F(EFLUtil, gesture_select_p)
1582 {
1583    int ret = EFL_UTIL_ERROR_NONE;
1584    efl_util_gesture_h h_gesture = NULL;
1585    efl_util_gesture_data d_palm_cover = NULL;
1586    Evas_Object *win = NULL;
1587
1588    win = _create_normal_win("Gesture Window");
1589    EXPECT_NE(win, nullptr);
1590
1591    h_gesture = efl_util_gesture_initialize();
1592    ret = get_last_result();
1593    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1594    EXPECT_NE(h_gesture, nullptr);
1595
1596    d_palm_cover = efl_util_gesture_palm_cover_new(h_gesture);
1597    ret = get_last_result();
1598    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1599    EXPECT_NE(d_palm_cover, nullptr);
1600
1601    ret = efl_util_gesture_select(h_gesture, win, d_palm_cover);
1602    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1603
1604    ret = efl_util_gesture_deselect(h_gesture, win, d_palm_cover);
1605    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1606
1607    ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
1608    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1609
1610    evas_object_del(win);
1611
1612    ret = efl_util_gesture_deinitialize(h_gesture);
1613    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1614 }
1615
1616 TEST_F(EFLUtil, gesture_select_n1)
1617 {
1618    int ret = EFL_UTIL_ERROR_NONE;
1619    efl_util_gesture_h h_gesture = NULL;
1620    efl_util_gesture_data d_palm_cover = NULL;
1621    Evas_Object *win = NULL;
1622
1623    ret = efl_util_gesture_select(h_gesture, win, d_palm_cover);
1624    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1625 }
1626
1627 TEST_F(EFLUtil, gesture_select_n2)
1628 {
1629    int ret = EFL_UTIL_ERROR_NONE;
1630    efl_util_gesture_h h_gesture = NULL;
1631    efl_util_gesture_data d_palm_cover = NULL;
1632    Evas_Object *win = NULL;
1633
1634    h_gesture = efl_util_gesture_initialize();
1635    ret = get_last_result();
1636    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1637    EXPECT_NE(h_gesture, nullptr);
1638
1639    d_palm_cover = efl_util_gesture_palm_cover_new(h_gesture);
1640    ret = get_last_result();
1641    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1642    EXPECT_NE(d_palm_cover, nullptr);
1643
1644    ret = efl_util_gesture_select(h_gesture, win, d_palm_cover);
1645    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1646
1647    ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
1648    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1649
1650    ret = efl_util_gesture_deinitialize(h_gesture);
1651    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1652 }
1653
1654 TEST_F(EFLUtil, gesture_select_n3)
1655 {
1656    int ret = EFL_UTIL_ERROR_NONE;
1657    efl_util_gesture_h h_gesture = NULL;
1658    efl_util_gesture_data d_palm_cover = NULL;
1659    Evas_Object *win = NULL;
1660
1661    win = _create_normal_win("Gesture Window");
1662    EXPECT_NE(win, nullptr);
1663
1664    h_gesture = efl_util_gesture_initialize();
1665    ret = get_last_result();
1666    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1667    EXPECT_NE(h_gesture, nullptr);
1668
1669    ret = efl_util_gesture_select(h_gesture, win, d_palm_cover);
1670    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1671
1672    evas_object_del(win);
1673
1674    ret = efl_util_gesture_deinitialize(h_gesture);
1675    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1676 }
1677
1678 TEST_F(EFLUtil, gesture_select_n4)
1679 {
1680    int ret = EFL_UTIL_ERROR_NONE;
1681    efl_util_gesture_h h_gesture = NULL;
1682    efl_util_gesture_data d_tap = NULL;
1683    Evas_Object *win = NULL;
1684
1685    win = _create_normal_win("Gesture Window");
1686    EXPECT_NE(win, nullptr);
1687
1688    h_gesture = efl_util_gesture_initialize();
1689    ret = get_last_result();
1690    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1691    EXPECT_NE(h_gesture, nullptr);
1692
1693    d_tap = efl_util_gesture_tap_new(h_gesture, 2, 2);
1694    ret = get_last_result();
1695    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1696    EXPECT_NE(d_tap, nullptr);
1697
1698    ret = efl_util_gesture_select(h_gesture, win, d_tap);
1699    EXPECT_EQ(ret, EFL_UTIL_ERROR_NOT_SUPPORTED);
1700
1701    ret = efl_util_gesture_tap_free(h_gesture, d_tap);
1702    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1703
1704    evas_object_del(win);
1705
1706    ret = efl_util_gesture_deinitialize(h_gesture);
1707    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1708 }
1709
1710 TEST_F(EFLUtil, gesture_deselect_p)
1711 {
1712    int ret = EFL_UTIL_ERROR_NONE;
1713    efl_util_gesture_h h_gesture = NULL;
1714    efl_util_gesture_data d_palm_cover = NULL;
1715    Evas_Object *win = NULL;
1716
1717    win = _create_normal_win("Gesture Window");
1718    EXPECT_NE(win, nullptr);
1719
1720    h_gesture = efl_util_gesture_initialize();
1721    ret = get_last_result();
1722    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1723    EXPECT_NE(h_gesture, nullptr);
1724
1725    d_palm_cover = efl_util_gesture_palm_cover_new(h_gesture);
1726    ret = get_last_result();
1727    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1728    EXPECT_NE(d_palm_cover, nullptr);
1729
1730    ret = efl_util_gesture_select(h_gesture, win, d_palm_cover);
1731    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1732
1733    ret = efl_util_gesture_deselect(h_gesture, win, d_palm_cover);
1734    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1735
1736    ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
1737    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1738
1739    evas_object_del(win);
1740
1741    ret = efl_util_gesture_deinitialize(h_gesture);
1742    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1743 }
1744
1745 TEST_F(EFLUtil, gesture_deselect_n1)
1746 {
1747    int ret = EFL_UTIL_ERROR_NONE;
1748    efl_util_gesture_h h_gesture = NULL;
1749    efl_util_gesture_data d_palm_cover = NULL;
1750    Evas_Object *win = NULL;
1751
1752    ret = efl_util_gesture_deselect(h_gesture, win, d_palm_cover);
1753    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1754 }
1755
1756 TEST_F(EFLUtil, gesture_deselect_n2)
1757 {
1758    int ret = EFL_UTIL_ERROR_NONE;
1759    efl_util_gesture_h h_gesture = NULL;
1760    efl_util_gesture_data d_palm_cover = NULL;
1761    Evas_Object *win = NULL;
1762
1763    h_gesture = efl_util_gesture_initialize();
1764    ret = get_last_result();
1765    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1766    EXPECT_NE(h_gesture, nullptr);
1767
1768    d_palm_cover = efl_util_gesture_palm_cover_new(h_gesture);
1769    ret = get_last_result();
1770    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1771    EXPECT_NE(d_palm_cover, nullptr);
1772
1773    ret = efl_util_gesture_deselect(h_gesture, win, d_palm_cover);
1774    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1775
1776    ret = efl_util_gesture_palm_cover_free(h_gesture, d_palm_cover);
1777    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1778
1779    ret = efl_util_gesture_deinitialize(h_gesture);
1780    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1781 }
1782
1783 TEST_F(EFLUtil, gesture_deselect_n3)
1784 {
1785    int ret = EFL_UTIL_ERROR_NONE;
1786    efl_util_gesture_h h_gesture = NULL;
1787    efl_util_gesture_data d_palm_cover = NULL;
1788    Evas_Object *win = NULL;
1789
1790    win = _create_normal_win("Gesture Window");
1791    EXPECT_NE(win, nullptr);
1792
1793    h_gesture = efl_util_gesture_initialize();
1794    ret = get_last_result();
1795    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1796    EXPECT_NE(h_gesture, nullptr);
1797
1798    ret = efl_util_gesture_deselect(h_gesture, win, d_palm_cover);
1799    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1800
1801    evas_object_del(win);
1802
1803    ret = efl_util_gesture_deinitialize(h_gesture);
1804    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1805 }
1806
1807 TEST_F(EFLUtil, gesture_deselect_n4)
1808 {
1809    int ret = EFL_UTIL_ERROR_NONE;
1810    efl_util_gesture_h h_gesture = NULL;
1811    efl_util_gesture_data d_tap = NULL;
1812    Evas_Object *win = NULL;
1813
1814    win = _create_normal_win("Gesture Window");
1815    EXPECT_NE(win, nullptr);
1816
1817    h_gesture = efl_util_gesture_initialize();
1818    ret = get_last_result();
1819    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1820    EXPECT_NE(h_gesture, nullptr);
1821
1822    d_tap = efl_util_gesture_tap_new(h_gesture, 2, 2);
1823    ret = get_last_result();
1824    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1825    EXPECT_NE(d_tap, nullptr);
1826
1827    ret = efl_util_gesture_deselect(h_gesture, win, d_tap);
1828    EXPECT_EQ(ret, EFL_UTIL_ERROR_NOT_SUPPORTED);
1829
1830    ret = efl_util_gesture_tap_free(h_gesture, d_tap);
1831    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1832
1833    evas_object_del(win);
1834
1835    ret = efl_util_gesture_deinitialize(h_gesture);
1836    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1837 }
1838
1839 TEST_F(EFLUtil, gesture_activate_set_on_window_p1)
1840 {
1841    int ret = EFL_UTIL_ERROR_NONE;
1842    efl_util_gesture_h h_gesture = NULL;
1843    Evas_Object *win = NULL;
1844    unsigned int type;
1845
1846    win = _create_normal_win("Gesture Window");
1847    EXPECT_NE(win, nullptr);
1848
1849    h_gesture = efl_util_gesture_initialize();
1850    ret = get_last_result();
1851    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1852    EXPECT_NE(h_gesture, nullptr);
1853
1854    type = EFL_UTIL_GESTURE_TYPE_EDGE_SWIPE;
1855    ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
1856    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1857
1858    evas_object_del(win);
1859
1860    ret = efl_util_gesture_deinitialize(h_gesture);
1861    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1862 }
1863
1864 TEST_F(EFLUtil, gesture_activate_set_on_window_p2)
1865 {
1866    int ret = EFL_UTIL_ERROR_NONE;
1867    efl_util_gesture_h h_gesture = NULL;
1868    Evas_Object *win = NULL;
1869    unsigned int type;
1870
1871    win = _create_normal_win("Gesture Window");
1872    EXPECT_NE(win, nullptr);
1873
1874    h_gesture = efl_util_gesture_initialize();
1875    ret = get_last_result();
1876    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1877    EXPECT_NE(h_gesture, nullptr);
1878
1879    type = EFL_UTIL_GESTURE_TYPE_EDGE_SWIPE;
1880    ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_FALSE);
1881    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1882
1883    evas_object_del(win);
1884
1885    ret = efl_util_gesture_deinitialize(h_gesture);
1886    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1887 }
1888
1889 TEST_F(EFLUtil, gesture_activate_set_on_window_p3)
1890 {
1891    int ret = EFL_UTIL_ERROR_NONE;
1892    efl_util_gesture_h h_gesture = NULL;
1893    Evas_Object *win = NULL;
1894    unsigned int type;
1895
1896    win = _create_normal_win("Gesture Window");
1897    EXPECT_NE(win, nullptr);
1898
1899    h_gesture = efl_util_gesture_initialize();
1900    ret = get_last_result();
1901    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1902    EXPECT_NE(h_gesture, nullptr);
1903
1904    type = EFL_UTIL_GESTURE_TYPE_EDGE_DRAG;
1905    ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
1906    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1907
1908    evas_object_del(win);
1909
1910    ret = efl_util_gesture_deinitialize(h_gesture);
1911    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1912 }
1913
1914 TEST_F(EFLUtil, gesture_activate_set_on_window_p4)
1915 {
1916    int ret = EFL_UTIL_ERROR_NONE;
1917    efl_util_gesture_h h_gesture = NULL;
1918    Evas_Object *win = NULL;
1919    unsigned int type;
1920
1921    win = _create_normal_win("Gesture Window");
1922    EXPECT_NE(win, nullptr);
1923
1924    h_gesture = efl_util_gesture_initialize();
1925    ret = get_last_result();
1926    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1927    EXPECT_NE(h_gesture, nullptr);
1928
1929    type = EFL_UTIL_GESTURE_TYPE_PALM_COVER;
1930    ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
1931    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1932
1933    evas_object_del(win);
1934
1935    ret = efl_util_gesture_deinitialize(h_gesture);
1936    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1937 }
1938
1939 TEST_F(EFLUtil, gesture_activate_set_on_window_p5)
1940 {
1941    int ret = EFL_UTIL_ERROR_NONE;
1942    efl_util_gesture_h h_gesture = NULL;
1943    Evas_Object *win = NULL;
1944    unsigned int type;
1945
1946    win = _create_normal_win("Gesture Window");
1947    EXPECT_NE(win, nullptr);
1948
1949    h_gesture = efl_util_gesture_initialize();
1950    ret = get_last_result();
1951    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1952    EXPECT_NE(h_gesture, nullptr);
1953
1954    type = EFL_UTIL_GESTURE_TYPE_TAP;
1955    ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
1956    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1957
1958    evas_object_del(win);
1959
1960    ret = efl_util_gesture_deinitialize(h_gesture);
1961    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1962 }
1963
1964 TEST_F(EFLUtil, gesture_activate_set_on_window_n1)
1965 {
1966    int ret = EFL_UTIL_ERROR_NONE;
1967    efl_util_gesture_h h_gesture = NULL;
1968    Evas_Object *win = NULL;
1969    unsigned int type;
1970
1971    win = _create_normal_win("Gesture Window");
1972    EXPECT_NE(win, nullptr);
1973
1974    type = EFL_UTIL_GESTURE_TYPE_TAP;
1975    ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
1976    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1977
1978    evas_object_del(win);
1979 }
1980
1981 TEST_F(EFLUtil, gesture_activate_set_on_window_n2)
1982 {
1983    int ret = EFL_UTIL_ERROR_NONE;
1984    efl_util_gesture_h h_gesture = NULL;
1985    Evas_Object *win = NULL;
1986    unsigned int type;
1987
1988    win = _create_normal_win("Gesture Window");
1989    EXPECT_NE(win, nullptr);
1990
1991    h_gesture = efl_util_gesture_initialize();
1992    ret = get_last_result();
1993    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
1994    EXPECT_NE(h_gesture, nullptr);
1995
1996    type = EFL_UTIL_GESTURE_TYPE_NONE;
1997    ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
1998    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
1999
2000    evas_object_del(win);
2001
2002    ret = efl_util_gesture_deinitialize(h_gesture);
2003    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
2004 }
2005
2006 TEST_F(EFLUtil, gesture_activate_set_on_window_n3)
2007 {
2008    int ret = EFL_UTIL_ERROR_NONE;
2009    efl_util_gesture_h h_gesture = NULL;
2010    Evas_Object *win = NULL;
2011    unsigned int type;
2012
2013    h_gesture = efl_util_gesture_initialize();
2014    ret = get_last_result();
2015    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
2016    EXPECT_NE(h_gesture, nullptr);
2017
2018    type = EFL_UTIL_GESTURE_TYPE_TAP;
2019    ret = efl_util_gesture_activate_set_on_window(h_gesture, win, type, EINA_TRUE);
2020    EXPECT_EQ(ret, EFL_UTIL_ERROR_INVALID_PARAMETER);
2021
2022    ret = efl_util_gesture_deinitialize(h_gesture);
2023    EXPECT_EQ(ret, EFL_UTIL_ERROR_NONE);
2024 }