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
  42 static void utc_efl_util_get_notification_window_level_positive_1(void);
  43 static void utc_efl_util_get_notification_window_level_positive_2(void);
  44
  45
  46 struct tet_testlist tet_testlist[] = {
  47         { utc_efl_util_set_notification_window_level_negative_1, 1 },
  48         { utc_efl_util_set_notification_window_level_negative_2, 1 },
  49         { utc_efl_util_set_notification_window_level_negative_3, 1 },
  50         { utc_efl_util_get_notification_window_level_negative_1, 1 },
  51         { utc_efl_util_get_notification_window_level_negative_2, 1 },
  52         { utc_efl_util_set_notification_window_level_positive_1, 1 },
  53         { utc_efl_util_set_notification_window_level_positive_2, 1 },
  54         { utc_efl_util_get_notification_window_level_positive_1, 1 },
  55         { utc_efl_util_get_notification_window_level_positive_2, 1 },
  56         { NULL, 0 },
  57 };
  58
  59
  60 static void startup(void)
  61 {
  62         /* start of TC */
  63         elm_init(0, NULL);
  64 }
  65
  66
  67 static void cleanup(void)
  68 {
  69         /* end of TC */
  70         elm_shutdown();
  71 }
  72
  73
  74 static void win_del(void *data, Evas_Object *obj, void *event)
  75 {
  76         elm_exit();
  77 }
  78
  79
  80 static Evas_Object* create_normal_win(const char *name)
  81 {
  82         Evas_Object *eo;
  83
  84         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
  85         if (eo)
  86         {
  87                 elm_win_title_set(eo, name);
  88                 elm_win_borderless_set(eo, EINA_TRUE);
  89                 evas_object_smart_callback_add(eo, "delete,request",
  90                                 win_del, NULL);
  91                 elm_win_indicator_state_set(eo, EINA_TRUE);
  92         }
  93
  94         return eo;
  95 }
  96
  97
  98 static Evas_Object* create_notification_win(const char *name)
  99 {
 100         Evas_Object *eo;
 101
 102         eo = elm_win_add(NULL, name, ELM_WIN_NOTIFICATION);
 103         if (eo)
 104         {
 105                 elm_win_title_set(eo, name);
 106                 elm_win_borderless_set(eo, EINA_TRUE);
 107                 evas_object_smart_callback_add(eo, "delete,request",
 108                                 win_del, NULL);
 109                 elm_win_indicator_state_set(eo, EINA_TRUE);
 110         }
 111
 112         return eo;
 113 }
 114
 115
 116 /**
 117  * @brief Negative test case of efl_util_set_notification_window_level()
 118  */
 119 static void utc_efl_util_set_notification_window_level_negative_1(void)
 120 {
 121         int ret;
 122
 123         ret = efl_util_set_notification_window_level(NULL,  EFL_UTIL_NOTIFICATION_LEVEL_2);
 124
 125         if (ret == EFL_UTIL_ERROR_INVALID_PARAMETER)
 126         {
 127                 dts_pass(API_SET_NOTIFICATION_WINDOW_LEVEL, "passed");
 128         }
 129         else
 130         {
 131                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed");
 132         }
 133 }
 134
 135
 136 /**
 137  * @brief Negative test case of efl_util_set_notification_window_level()
 138  */
 139 static void utc_efl_util_set_notification_window_level_negative_2(void)
 140 {
 141         Evas_Object *win;
 142         int ret;
 143
 144         win = create_normal_win("Normal window");
 145         if (!win)
 146         {
 147                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 148         }
 149
 150         ret = efl_util_set_notification_window_level(win,  EFL_UTIL_NOTIFICATION_LEVEL_2);
 151
 152         if (ret == EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE)
 153         {
 154                 dts_pass(API_SET_NOTIFICATION_WINDOW_LEVEL, "passed");
 155         }
 156         else
 157         {
 158                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed");
 159         }
 160 }
 161
 162
 163 /**
 164  * @brief Negative test case of efl_util_set_notification_window_level()
 165  */
 166 static void utc_efl_util_set_notification_window_level_negative_3(void)
 167 {
 168         Evas_Object *win;
 169         int ret;
 170
 171         win = create_notification_win("Notification Type Window");
 172         if (!win)
 173         {
 174                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 175         }
 176
 177         ret = efl_util_set_notification_window_level(win, 100);
 178
 179         if (ret == EFL_UTIL_ERROR_INVALID_PARAMETER)
 180         {
 181                 dts_pass(API_SET_NOTIFICATION_WINDOW_LEVEL, "passed");
 182         }
 183         else
 184         {
 185                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed");
 186         }
 187 }
 188
 189
 190 /**
 191  * @brief Negative test case of efl_util_set_notification_window_level()
 192  */
 193 static void utc_efl_util_get_notification_window_level_negative_1(void)
 194 {
 195         int ret;
 196         int level;
 197
 198         ret = efl_util_get_notification_window_level(NULL,  &level);
 199
 200         if (ret == EFL_UTIL_ERROR_INVALID_PARAMETER)
 201         {
 202                 dts_pass(API_GET_NOTIFICATION_WINDOW_LEVEL, "passed");
 203         }
 204         else
 205         {
 206                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed");
 207         }
 208 }
 209
 210
 211 /**
 212  * @brief Negative test case of efl_util_set_notification_window_level()
 213  */
 214 static void utc_efl_util_get_notification_window_level_negative_2(void)
 215 {
 216         Evas_Object *win;
 217         int ret;
 218         int level;
 219
 220         win = create_normal_win("Normal Type Window");
 221         if (!win)
 222         {
 223                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 224         }
 225
 226         ret = efl_util_get_notification_window_level(win,  &level);
 227
 228         if (ret == EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE)
 229         {
 230                 dts_pass(API_GET_NOTIFICATION_WINDOW_LEVEL, "passed");
 231         }
 232         else
 233         {
 234                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed");
 235         }
 236 }
 237
 238
 239 /**
 240  * @brief Positive test case of efl_util_set_notification_window_level()
 241  */
 242 static void utc_efl_util_set_notification_window_level_positive_1(void)
 243 {
 244         Evas_Object *win;
 245         int ret;
 246
 247         win = create_notification_win("Notification Type Window");
 248         if (!win)
 249         {
 250                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 251         }
 252
 253         ret = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_1);
 254
 255         if (ret == EFL_UTIL_ERROR_NONE)
 256         {
 257                 dts_pass(API_SET_NOTIFICATION_WINDOW_LEVEL, "passed");
 258         }
 259         else
 260         {
 261                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed");
 262         }
 263 }
 264
 265
 266 /**
 267  * @brief Positive test case of efl_util_set_notification_window_level()
 268  */
 269 static void utc_efl_util_set_notification_window_level_positive_2(void)
 270 {
 271         Evas_Object *win;
 272         int ret1, ret2;
 273
 274         win = create_notification_win("Notification Type Window");
 275         if (!win)
 276         {
 277                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 278         }
 279
 280         ret1 = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_1);
 281         ret2 = efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_2);
 282
 283         if (ret2 == EFL_UTIL_ERROR_NONE)
 284         {
 285                 dts_pass(API_SET_NOTIFICATION_WINDOW_LEVEL, "passed");
 286         }
 287         else
 288         {
 289                 dts_fail(API_SET_NOTIFICATION_WINDOW_LEVEL, "failed");
 290         }
 291 }
 292
 293
 294 /**
 295  * @brief Positive test case of efl_util_set_notification_window_level()
 296  */
 297 static void utc_efl_util_get_notification_window_level_positive_1(void)
 298 {
 299         Evas_Object *win;
 300         int ret;
 301         int level;
 302
 303         win = create_notification_win("Notification Type Window");
 304         if (!win)
 305         {
 306                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 307         }
 308         efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_1);
 309
 310         level = -1;
 311         ret = efl_util_get_notification_window_level(win,  &level);
 312
 313         if (ret == EFL_UTIL_ERROR_NONE)
 314         {
 315                 if (level == EFL_UTIL_NOTIFICATION_LEVEL_1)
 316                 {
 317                         dts_pass(API_GET_NOTIFICATION_WINDOW_LEVEL, "passed");
 318                 }
 319                 else
 320                 {
 321                         dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed - level is wrong");
 322                 }
 323         }
 324         else
 325         {
 326                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed - return value is wrong");
 327         }
 328 }
 329
 330
 331 /**
 332  * @brief Positive test case of efl_util_set_notification_window_level()
 333  */
 334 static void utc_efl_util_get_notification_window_level_positive_2(void)
 335 {
 336         Evas_Object *win;
 337         int ret;
 338         int level;
 339
 340         win = create_notification_win("Notification Type Window");
 341         if (!win)
 342         {
 343                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed to create window");
 344         }
 345         efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_1);
 346         efl_util_set_notification_window_level(win, EFL_UTIL_NOTIFICATION_LEVEL_2);
 347
 348         level = -1;
 349         ret = efl_util_get_notification_window_level(win,  &level);
 350
 351         if (ret == EFL_UTIL_ERROR_NONE)
 352         {
 353                 if (level == EFL_UTIL_NOTIFICATION_LEVEL_2)
 354                 {
 355                         dts_pass(API_GET_NOTIFICATION_WINDOW_LEVEL, "passed");
 356                 }
 357                 else
 358                 {
 359                         dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed - level is wrong");
 360                 }
 361         }
 362         else
 363         {
 364                 dts_fail(API_GET_NOTIFICATION_WINDOW_LEVEL, "failed - return value is wrong");
 365         }
 366 }
 367