TC/testcase/utc_efl_util_set_notification_window_level.c

   1 /*
   2  * Copyright (c) 2011 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 <tet_api.h>
  18 #include <efl_util.h>
  19 #include <Elementary.h>
  20 #include <Ecore_X.h>
  21
  22 #define API_SET_NOTIFICATION_WINDOW_LEVEL "efl_util_set_notification_window_level"
  23 #define API_GET_NOTIFICATION_WINDOW_LEVEL "efl_util_get_notification_window_level"
  24
  25
  26 static void startup(void);
  27 static void cleanup(void);
  28
  29 void (*tet_startup)(void) = startup;
  30 void (*tet_cleanup)(void) = cleanup;
  31
  32 static void utc_efl_util_set_notification_window_level_negative_1(void);
  33 static void utc_efl_util_set_notification_window_level_negative_2(void);
  34 static void utc_efl_util_set_notification_window_level_negative_3(void);
  35
  36 static void utc_efl_util_get_notification_window_level_negative_1(void);
  37 static void utc_efl_util_get_notification_window_level_negative_2(void);
  38
  39 static void utc_efl_util_set_notification_window_level_positive_1(void);
  40 static void utc_efl_util_set_notification_window_level_positive_2(void);
  41 static void utc_efl_util_set_notification_window_level_positive_3(void);
  42
  43 static void utc_efl_util_get_notification_window_level_positive_1(void);
  44 static void utc_efl_util_get_notification_window_level_positive_2(void);
  45 static void utc_efl_util_get_notification_window_level_positive_3(void);
  46
  47
  48 struct tet_testlist tet_testlist[] = {
  49         { utc_efl_util_set_notification_window_level_negative_1, 1 },
  50         { utc_efl_util_set_notification_window_level_negative_2, 1 },
  51         { utc_efl_util_set_notification_window_level_negative_3, 1 },
  52         { utc_efl_util_get_notification_window_level_negative_1, 1 },
  53         { utc_efl_util_get_notification_window_level_negative_2, 1 },
  54         { utc_efl_util_set_notification_window_level_positive_1, 1 },
  55         { utc_efl_util_set_notification_window_level_positive_2, 1 },
  56         { utc_efl_util_set_notification_window_level_positive_3, 1 },
  57         { utc_efl_util_get_notification_window_level_positive_1, 1 },
  58         { utc_efl_util_get_notification_window_level_positive_2, 1 },
  59         { utc_efl_util_get_notification_window_level_positive_3, 1 },
  60         { NULL, 0 },
  61 };
  62
  63
  64 static void startup(void)
  65 {
  66         /* start of TC */
  67         elm_init(0, NULL);
  68 }
  69
  70
  71 static void cleanup(void)
  72 {
  73         /* end of TC */
  74         elm_shutdown();
  75 }
  76
  77
  78 static void win_del(void *data, Evas_Object *obj, void *event)
  79 {
  80         elm_exit();
  81 }
  82
  83
  84 static Evas_Object* create_normal_win(const char *name)
  85 {
  86         Evas_Object *eo;
  87
  88         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
  89         if (eo)
  90         {
  91                 elm_win_title_set(eo, name);
  92                 elm_win_borderless_set(eo, EINA_TRUE);
  93                 evas_object_smart_callback_add(eo, "delete,request",
  94                                 win_del, NULL);
  95                 elm_win_indicator_mode_set(eo, ELM_WIN_INDICATOR_SHOW);
  96         }
  97
  98         return eo;
  99 }
 100
 101
 102 static Evas_Object* create_notification_win(const char *name)
 103 {
 104         Evas_Object *eo;
 105
 106         eo = elm_win_add(NULL, name, ELM_WIN_NOTIFICATION);
 107         if (eo)
 108         {
 109                 elm_win_title_set(eo, name);
 110                 elm_win_borderless_set(eo, EINA_TRUE);
 111                 evas_object_smart_callback_add(eo, "delete,request",
 112                                 win_del, NULL);
 113                 elm_win_indicator_mode_set(eo, ELM_WIN_INDICATOR_SHOW);
 114         }
 115
 116         return eo;
 117 }
 118
 119
 120 /**
 121  * @brief Negative test case of efl_util_set_notification_window_level()
 122  */
 123 static void utc_efl_util_set_notification_window_level_negative_1(void)
 124 {
 125         int ret;
 126
 127         ret = efl_util_set_notification_window_level(NULL,  EFL_UTIL_NOTIFICATION_LEVEL_2);
 128
 129         if (ret == EFL_UTIL_ERROR_INVALID_PARAMETER)
 130         {
 131                 dts_pass(API_SET_NOTIFICATION_WINDOW_LEVEL, "passed");
 132         }
 133         else
 134         {
 135                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed");
 136         }
 137 }
 138
 139
 140 /**
 141  * @brief Negative test case of efl_util_set_notification_window_level()
 142  */
 143 static void utc_efl_util_set_notification_window_level_negative_2(void)
 144 {
 145         Evas_Object *win;
 146         int ret;
 147
 148         win = create_normal_win("Normal window");
 149         if (!win)
 150         {
 151                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 152         }
 153
 154         ret = efl_util_set_notification_window_level(win,  EFL_UTIL_NOTIFICATION_LEVEL_2);
 155
 156         if (ret == EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE)
 157         {
 158                 dts_pass(API_SET_NOTIFICATION_WINDOW_LEVEL, "passed");
 159         }
 160         else
 161         {
 162                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed");
 163         }
 164 }
 165
 166
 167 /**
 168  * @brief Negative test case of efl_util_set_notification_window_level()
 169  */
 170 static void utc_efl_util_set_notification_window_level_negative_3(void)
 171 {
 172         Evas_Object *win;
 173         int ret;
 174
 175         win = create_notification_win("Notification Type Window");
 176         if (!win)
 177         {
 178                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 179         }
 180
 181         ret = efl_util_set_notification_window_level(win, 100);
 182
 183         if (ret == EFL_UTIL_ERROR_INVALID_PARAMETER)
 184         {
 185                 dts_pass(API_SET_NOTIFICATION_WINDOW_LEVEL, "passed");
 186         }
 187         else
 188         {
 189                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed");
 190         }
 191 }
 192
 193
 194 /**
 195  * @brief Negative test case of efl_util_set_notification_window_level()
 196  */
 197 static void utc_efl_util_get_notification_window_level_negative_1(void)
 198 {
 199         int ret;
 200         int level;
 201
 202         ret = efl_util_get_notification_window_level(NULL,  &level);
 203
 204         if (ret == EFL_UTIL_ERROR_INVALID_PARAMETER)
 205         {
 206                 dts_pass(API_GET_NOTIFICATION_WINDOW_LEVEL, "passed");
 207         }
 208         else
 209         {
 210                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed");
 211         }
 212 }
 213
 214
 215 /**
 216  * @brief Negative test case of efl_util_set_notification_window_level()
 217  */
 218 static void utc_efl_util_get_notification_window_level_negative_2(void)
 219 {
 220         Evas_Object *win;
 221         int ret;
 222         int level;
 223
 224         win = create_normal_win("Normal Type Window");
 225         if (!win)
 226         {
 227                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 228         }
 229
 230         ret = efl_util_get_notification_window_level(win,  &level);
 231
 232         if (ret == EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE)
 233         {
 234                 dts_pass(API_GET_NOTIFICATION_WINDOW_LEVEL, "passed");
 235         }
 236         else
 237         {
 238                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed");
 239         }
 240 }
 241
 242
 243 /**
 244  * @brief Positive test case of efl_util_set_notification_window_level()
 245  */
 246 static void utc_efl_util_set_notification_window_level_positive_1(void)
 247 {
 248         Evas_Object *win;
 249         int ret;
 250
 251         win = create_notification_win("Notification Type Window");
 252         if (!win)
 253         {
 254                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 255         }
 256
 257         ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_1);
 258
 259         if (ret == EFL_UTIL_ERROR_NONE)
 260         {
 261                 dts_pass(API_SET_NOTIFICATION_WINDOW_LEVEL, "passed");
 262         }
 263         else
 264         {
 265                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed");
 266         }
 267 }
 268
 269
 270 /**
 271  * @brief Positive test case of efl_util_set_notification_window_level()
 272  */
 273 static void utc_efl_util_set_notification_window_level_positive_2(void)
 274 {
 275         Evas_Object *win;
 276         int ret1, ret2;
 277
 278         win = create_notification_win("Notification Type Window");
 279         if (!win)
 280         {
 281                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 282         }
 283
 284         ret1 = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_1);
 285         ret2 = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_2);
 286
 287         if (ret2 == EFL_UTIL_ERROR_NONE)
 288         {
 289                 dts_pass(API_SET_NOTIFICATION_WINDOW_LEVEL, "passed");
 290         }
 291         else
 292         {
 293                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed");
 294         }
 295 }
 296
 297
 298 /**
 299  * @brief Positive test case of efl_util_set_notification_window_level()
 300  */
 301 static void utc_efl_util_set_notification_window_level_positive_3(void)
 302 {
 303         Evas_Object *win;
 304         int ret1, ret2, ret3;
 305
 306         win = create_notification_win("Notification Type Window");
 307         if (!win)
 308         {
 309                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 310         }
 311
 312         ret1 = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_1);
 313         ret2 = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_2);
 314         ret3 = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_3);
 315
 316         if (ret3 == EFL_UTIL_ERROR_NONE)
 317         {
 318                 dts_pass(API_SET_NOTIFICATION_WINDOW_LEVEL, "passed");
 319         }
 320         else
 321         {
 322                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed");
 323         }
 324 }
 325
 326
 327 /**
 328  * @brief Positive test case of efl_util_set_notification_window_level()
 329  */
 330 static void utc_efl_util_get_notification_window_level_positive_1(void)
 331 {
 332         Evas_Object *win;
 333         int ret;
 334         int level;
 335
 336         win = create_notification_win("Notification Type Window");
 337         if (!win)
 338         {
 339                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 340         }
 341         efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_1);
 342
 343         level = -1;
 344         ret = efl_util_get_notification_window_level(win,  &level);
 345
 346         if (ret == EFL_UTIL_ERROR_NONE)
 347         {
 348                 if (level == EFL_UTIL_NOTIFICATION_LEVEL_1)
 349                 {
 350                         dts_pass(API_GET_NOTIFICATION_WINDOW_LEVEL, "passed");
 351                 }
 352                 else
 353                 {
 354                         dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed - level is wrong");
 355                 }
 356         }
 357         else
 358         {
 359                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed - return value is wrong");
 360         }
 361 }
 362
 363
 364 /**
 365  * @brief Positive test case of efl_util_set_notification_window_level()
 366  */
 367 static void utc_efl_util_get_notification_window_level_positive_2(void)
 368 {
 369         Evas_Object *win;
 370         int ret;
 371         int level;
 372
 373         win = create_notification_win("Notification Type Window");
 374         if (!win)
 375         {
 376                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 377         }
 378         efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_1);
 379         efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_2);
 380
 381         level = -1;
 382         ret = efl_util_get_notification_window_level(win,  &level);
 383
 384         if (ret == EFL_UTIL_ERROR_NONE)
 385         {
 386                 if (level == EFL_UTIL_NOTIFICATION_LEVEL_2)
 387                 {
 388                         dts_pass(API_GET_NOTIFICATION_WINDOW_LEVEL, "passed");
 389                 }
 390                 else
 391                 {
 392                         dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed - level is wrong");
 393                 }
 394         }
 395         else
 396         {
 397                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed - return value is wrong");
 398         }
 399 }
 400
 401
 402 /**
 403  * @brief Positive test case of efl_util_set_notification_window_level()
 404  */
 405 static void utc_efl_util_get_notification_window_level_positive_3(void)
 406 {
 407         Evas_Object *win;
 408         int ret;
 409         int level;
 410
 411         win = create_notification_win("Notification Type Window");
 412         if (!win)
 413         {
 414                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 415         }
 416         efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_1);
 417         efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_3);
 418
 419         level = -1;
 420         ret = efl_util_get_notification_window_level(win,  &level);
 421
 422         if (ret == EFL_UTIL_ERROR_NONE)
 423         {
 424                 if (level == EFL_UTIL_NOTIFICATION_LEVEL_3)
 425                 {
 426                         dts_pass(API_GET_NOTIFICATION_WINDOW_LEVEL, "passed");
 427                 }
 428                 else
 429                 {
 430                         dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed - level is wrong");
 431                 }
 432         }
 433         else
 434         {
 435                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed - return value is wrong");
 436         }
 437 }
 438