TC/testcase/utc_badge.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 <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <unistd.h>
  21 #include <fcntl.h>
  22 #include <libintl.h>
  23 #include <tet_api.h>
  24 #include <badge.h>
  25
  26 #define TEST_PKG "org.tizen.tetware"
  27
  28 enum {
  29         POSITIVE_TC_IDX = 0x01,
  30         NEGATIVE_TC_IDX,
  31 };
  32
  33 static void startup(void);
  34 static void cleanup(void);
  35
  36 static void utc_badge_create_n(void);
  37 static void utc_badge_create_p(void);
  38 static void utc_badge_remove_n(void);
  39 static void utc_badge_remove_p(void);
  40 static void utc_badge_set_count_n(void);
  41 static void utc_badge_set_count_p(void);
  42 static void utc_badge_get_count_n(void);
  43 static void utc_badge_get_count_p(void);
  44 static void utc_badge_set_display_n(void);
  45 static void utc_badge_set_display_p(void);
  46 static void utc_badge_get_display_n(void);
  47 static void utc_badge_get_display_p(void);
  48 static void utc_badge_is_existing_n(void);
  49 static void utc_badge_is_existing_p(void);
  50 static void utc_badge_foreach_existed_n(void);
  51 static void utc_badge_foreach_existed_p(void);
  52 static void utc_badge_register_changed_cb_n(void);
  53 static void utc_badge_register_changed_cb_p(void);
  54 static void utc_badge_unregister_changed_n(void);
  55 static void utc_badge_unregister_changed_p(void);
  56
  57 #define TEST_PKG "org.tizen.tetware"
  58
  59 void (*tet_startup)(void) = startup;
  60 void (*tet_cleanup)(void) = cleanup;
  61
  62 struct tet_testlist tet_testlist[] = {
  63         {utc_badge_create_n , NEGATIVE_TC_IDX},
  64         {utc_badge_create_p, POSITIVE_TC_IDX},
  65         {utc_badge_remove_n , NEGATIVE_TC_IDX},
  66         {utc_badge_remove_p, POSITIVE_TC_IDX},
  67         {utc_badge_set_count_n , NEGATIVE_TC_IDX},
  68         {utc_badge_set_count_p, POSITIVE_TC_IDX},
  69         {utc_badge_get_count_n , NEGATIVE_TC_IDX},
  70         {utc_badge_get_count_p, POSITIVE_TC_IDX},
  71         {utc_badge_set_display_n , NEGATIVE_TC_IDX},
  72         {utc_badge_set_display_p, POSITIVE_TC_IDX},
  73         {utc_badge_get_display_n , NEGATIVE_TC_IDX},
  74         {utc_badge_get_display_p, POSITIVE_TC_IDX},
  75         {utc_badge_is_existing_n , NEGATIVE_TC_IDX},
  76         {utc_badge_is_existing_p, POSITIVE_TC_IDX},
  77         {utc_badge_foreach_existed_n , NEGATIVE_TC_IDX},
  78         {utc_badge_foreach_existed_p, POSITIVE_TC_IDX},
  79         {utc_badge_register_changed_cb_n , NEGATIVE_TC_IDX},
  80         {utc_badge_register_changed_cb_p, POSITIVE_TC_IDX},
  81         {utc_badge_unregister_changed_n , NEGATIVE_TC_IDX},
  82         {utc_badge_unregister_changed_p, POSITIVE_TC_IDX},
  83         { NULL, 0 },
  84 };
  85
  86 static void _badge_foreach_cb(const char *pkgname, unsigned int count, void *data) {
  87
  88 }
  89
  90 static void _badge_changed_cb(unsigned int action, const char *pkgname,
  91                         unsigned int count, void *data) {
  92
  93 }
  94
  95 static void startup(void)
  96 {
  97         /* start of TC */
  98         tet_printf("\n TC start");
  99         badge_remove(TEST_PKG);
 100 }
 101
 102
 103 static void cleanup(void)
 104 {
 105         /* end of TC */
 106         tet_printf("\n TC end");
 107 }
 108
 109 /**
 110  * @brief Negative test case of badge_create()
 111  */
 112 static void utc_badge_create_n(void)
 113 {
 114         int ret;
 115
 116         ret = badge_create(NULL, NULL);
 117
 118         dts_check_eq("badge_create", ret, BADGE_ERROR_INVALID_DATA,
 119                 "Must return BADGE_ERROR_INVALID_DATA in case of invalid parameter");
 120 }
 121
 122 /**
 123  * @brief Positive test case of badge_create()
 124  */
 125 static void utc_badge_create_p(void)
 126 {
 127         int ret;
 128
 129         ret = badge_create(TEST_PKG, TEST_PKG);
 130
 131         dts_check_eq("badge_create", ret, BADGE_ERROR_NONE,
 132                 "Must return BADGE_ERROR_NONE in case of invalid parameter");
 133 }
 134
 135
 136 /**
 137  * @brief Negative test case of badge_remove()
 138  */
 139 static void utc_badge_remove_n(void)
 140 {
 141         int ret;
 142
 143         ret = badge_remove(NULL);
 144
 145         dts_check_eq("badge_remove", ret, BADGE_ERROR_INVALID_DATA,
 146                 "Must return BADGE_ERROR_INVALID_DATA in case of invalid parameter");
 147 }
 148
 149 /**
 150  * @brief Positive test case of badge_remove()
 151  */
 152 static void utc_badge_remove_p(void)
 153 {
 154         int ret;
 155
 156         ret = badge_create(TEST_PKG, TEST_PKG);
 157         ret = badge_remove(TEST_PKG);
 158
 159         dts_check_eq("badge_create", ret, BADGE_ERROR_NONE,
 160                 "Must return BADGE_ERROR_NONE in case of invalid parameter");
 161 }
 162
 163 /**
 164  * @brief Negative test case of badge_set_count()
 165  */
 166 static void utc_badge_set_count_n(void)
 167 {
 168         int ret;
 169
 170         ret = badge_set_count(NULL, 0);
 171
 172         dts_check_eq("badge_set_count", ret, BADGE_ERROR_INVALID_DATA,
 173                 "Must return BADGE_ERROR_INVALID_DATA in case of invalid parameter");
 174 }
 175
 176 /**
 177  * @brief Positive test case of badge_set_count()
 178  */
 179 static void utc_badge_set_count_p(void)
 180 {
 181         int ret;
 182
 183         ret = badge_create(TEST_PKG, TEST_PKG);
 184         ret = badge_set_count(TEST_PKG, 1);
 185
 186         dts_check_eq("badge_set_count", ret, BADGE_ERROR_NONE,
 187                 "Must return BADGE_ERROR_NONE in case of invalid parameter");
 188 }
 189
 190
 191 /**
 192  * @brief Negative test case of badge_get_count()
 193  */
 194 static void utc_badge_get_count_n(void)
 195 {
 196         int ret;
 197
 198         ret = badge_get_count(NULL, NULL);
 199
 200         dts_check_eq("badge_get_count", ret, BADGE_ERROR_INVALID_DATA,
 201                 "Must return BADGE_ERROR_INVALID_DATA in case of invalid parameter");
 202 }
 203
 204 /**
 205  * @brief Positive test case of badge_get_count()
 206  */
 207 static void utc_badge_get_count_p(void)
 208 {
 209         int ret;
 210         int count = 0;
 211
 212         ret = badge_create(TEST_PKG, TEST_PKG);
 213         ret = badge_set_count(TEST_PKG, 1);
 214         ret = badge_get_count(TEST_PKG, &count);
 215
 216         dts_check_eq("badge_get_count", ret, BADGE_ERROR_NONE,
 217                 "Must return BADGE_ERROR_NONE in case of invalid parameter");
 218 }
 219
 220 /**
 221  * @brief Negative test case of badge_set_display()
 222  */
 223 static void utc_badge_set_display_n(void)
 224 {
 225         int ret;
 226
 227         ret = badge_set_display(NULL, 0);
 228
 229         dts_check_eq("badge_set_display", ret, BADGE_ERROR_INVALID_DATA,
 230                 "Must return BADGE_ERROR_INVALID_DATA in case of invalid parameter");
 231 }
 232
 233 /**
 234  * @brief Positive test case of badge_set_display()
 235  */
 236 static void utc_badge_set_display_p(void)
 237 {
 238         int ret;
 239         int count = 0;
 240
 241         ret = badge_create(TEST_PKG, TEST_PKG);
 242         ret = badge_set_count(TEST_PKG, 1);
 243         ret = badge_set_display(TEST_PKG, 1);
 244
 245         dts_check_eq("badge_set_display", ret, BADGE_ERROR_NONE,
 246                 "Must return BADGE_ERROR_NONE in case of invalid parameter");
 247 }
 248
 249 /**
 250  * @brief Negative test case of badge_get_display()
 251  */
 252 static void utc_badge_get_display_n(void)
 253 {
 254         int ret;
 255
 256         ret = badge_get_display(NULL, NULL);
 257
 258         dts_check_eq("badge_get_display", ret, BADGE_ERROR_INVALID_DATA,
 259                 "Must return BADGE_ERROR_INVALID_DATA in case of invalid parameter");
 260 }
 261
 262 /**
 263  * @brief Positive test case of badge_get_display()
 264  */
 265 static void utc_badge_get_display_p(void)
 266 {
 267         int ret;
 268         int count = 0;
 269
 270         ret = badge_create(TEST_PKG, TEST_PKG);
 271         ret = badge_set_count(TEST_PKG, 1);
 272         ret = badge_get_display(TEST_PKG, &count);
 273
 274         dts_check_eq("badge_get_display", ret, BADGE_ERROR_NONE,
 275                 "Must return BADGE_ERROR_NONE in case of invalid parameter");
 276 }
 277
 278 /**
 279  * @brief Negative test case of badge_is_existing()
 280  */
 281 static void utc_badge_is_existing_n(void)
 282 {
 283         int ret;
 284
 285         ret = badge_is_existing(NULL, NULL);
 286
 287         dts_check_eq("badge_is_existing", ret, BADGE_ERROR_INVALID_DATA,
 288                 "Must return BADGE_ERROR_INVALID_DATA in case of invalid parameter");
 289 }
 290
 291 /**
 292  * @brief Positive test case of badge_is_existing()
 293  */
 294 static void utc_badge_is_existing_p(void)
 295 {
 296         int ret;
 297         int is_existing;
 298
 299         ret = badge_create(TEST_PKG, TEST_PKG);
 300         ret = badge_is_existing(TEST_PKG, &is_existing);
 301
 302         dts_check_eq("badge_is_existing", ret, BADGE_ERROR_NONE,
 303                 "Must return BADGE_ERROR_NONE in case of invalid parameter");
 304 }
 305
 306 /**
 307  * @brief Negative test case of badge_foreach_existed()
 308  */
 309 static void utc_badge_foreach_existed_n(void)
 310 {
 311         int ret;
 312
 313         ret = badge_foreach_existed(NULL, NULL);
 314
 315         dts_check_eq("badge_foreach_existed", ret, BADGE_ERROR_INVALID_DATA,
 316                 "Must return BADGE_ERROR_INVALID_DATA in case of invalid parameter");
 317 }
 318
 319 /**
 320  * @brief Positive test case of badge_foreach_existed()
 321  */
 322 static void utc_badge_foreach_existed_p(void)
 323 {
 324         int ret;
 325
 326         ret = badge_create(TEST_PKG, TEST_PKG);
 327         ret = badge_foreach_existed(_badge_foreach_cb, NULL);
 328
 329         dts_check_eq("badge_foreach_existed", ret, BADGE_ERROR_NONE,
 330                 "Must return BADGE_ERROR_NONE in case of invalid parameter");
 331 }
 332
 333 /**
 334  * @brief Negative test case of badge_register_changed_cb()
 335  */
 336 static void utc_badge_register_changed_cb_n(void)
 337 {
 338         int ret;
 339
 340         ret = badge_register_changed_cb(NULL, NULL);
 341
 342         dts_check_eq("badge_register_changed_cb", ret, BADGE_ERROR_INVALID_DATA,
 343                 "Must return BADGE_ERROR_INVALID_DATA in case of invalid parameter");
 344 }
 345
 346 /**
 347  * @brief Positive test case of badge_register_changed_cb()
 348  */
 349 static void utc_badge_register_changed_cb_p(void)
 350 {
 351         int ret;
 352
 353         ret = badge_register_changed_cb(_badge_changed_cb, NULL);
 354
 355         dts_check_eq("badge_register_changed_cb", ret, BADGE_ERROR_NONE,
 356                 "Must return BADGE_ERROR_NONE in case of invalid parameter");
 357 }
 358
 359 /**
 360  * @brief Negative test case of badge_unregister_changed()
 361  */
 362 static void utc_badge_unregister_changed_n(void)
 363 {
 364         int ret;
 365
 366         ret = badge_unregister_changed_cb(NULL);
 367
 368         dts_check_eq("badge_unregister_changed_cb", ret, BADGE_ERROR_INVALID_DATA,
 369                 "Must return BADGE_ERROR_INVALID_DATA in case of invalid parameter");
 370 }
 371
 372 /**
 373  * @brief Positive test case of badge_unregister_changed()
 374  */
 375 static void utc_badge_unregister_changed_p(void)
 376 {
 377         int ret;
 378
 379         ret = badge_register_changed_cb(_badge_changed_cb, NULL);
 380         ret = badge_unregister_changed_cb(_badge_changed_cb);
 381
 382         dts_check_eq("badge_unregister_changed_cb", ret, BADGE_ERROR_NONE,
 383                 "Must return BADGE_ERROR_NONE in case of invalid parameter");
 384 }