test/test._error_case.c

   1 /*
   2  *  alarm-manager
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Venkatesha Sarpangala <sarpangala.v@samsung.com>, Jayoun Lee <airjany@samsung.com>,
   7  * Sewook Park <sewook7.park@samsung.com>, Jaeho Lee <jaeho81.lee@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include<stdio.h>
  24 #include<stdlib.h>
  25 #include<glib.h>
  26 #include<noti.h>
  27
  28 #include "alarm.h"
  29
  30 int callback(alarm_id_t alarm_id)
  31 {
  32     time_t current_time;
  33     time(&current_time);
  34
  35     printf("Alarm[%d] has expired at %s\n", alarm_id, ctime(&current_time));
  36
  37     return 0;
  38
  39 }
  40
  41 void test_alarm_update_fail_case_normal()
  42 {
  43         time_t current_time;
  44         struct tm current_tm;
  45         alarm_info_t alarm_info;
  46         alarm_id_t alarm_id;
  47         int error_code;
  48         bool result = false;
  49
  50
  51         time(&current_time);
  52
  53         localtime_r(&current_time, &current_tm);
  54
  55         alarm_info.start.year = 0;
  56         alarm_info.start.month = 0;
  57         alarm_info.start.day = 0;
  58
  59         alarm_info.end.year = 0;
  60         alarm_info.end.month = 0;
  61         alarm_info.end.day = 0;
  62
  63         alarm_info.start.hour = 0;
  64         alarm_info.start.min = 0;
  65
  66         alarm_info.mode.day_of_week = 0;
  67         alarm_info.mode.repeat = 1;
  68
  69         alarm_info.activation = true;
  70         alarm_info.auto_powerup = false;
  71
  72         result = alarm_create(&alarm_info, &alarm_id, &error_code);
  73         // result must be false
  74         if ( result == true )
  75         {
  76                 result = alarm_update(alarm_id, &alarm_info, &error_code);
  77
  78                 if ( result == true )
  79                 {
  80                         printf("Test Success: %s\n", __FUNCTION__);
  81                         alarm_delete(alarm_id, &error_code);
  82                 }
  83                 else
  84                 {
  85                         printf("Test Failed: %s: error(%d)\n", __FUNCTION__, error_code);
  86                 }
  87
  88         }
  89         else
  90         {
  91                 printf("Test Failed: %s\n", __FUNCTION__);
  92         }
  93 }
  94
  95 void test_alarm_update_fail_case_invalid_id()
  96 {
  97         time_t current_time;
  98         struct tm current_tm;
  99         alarm_info_t alarm_info;
 100         int error_code;
 101         bool result = false;
 102
 103
 104         time(&current_time);
 105
 106         localtime_r(&current_time, &current_tm);
 107
 108                 result = alarm_update(1234, &alarm_info, &error_code);
 109         // result must be false
 110
 111                 if ( result == false )
 112                 {
 113                         printf("Test Success: %s\n", __FUNCTION__);
 114                 }
 115                 else
 116                 {
 117                         printf("Test Failed: %s: error(%d)\n", __FUNCTION__, error_code);
 118                 }
 119
 120
 121 }
 122
 123
 124
 125 void test_alarm_delete_fail_case_normal()
 126 {
 127         time_t current_time;
 128         struct tm current_tm;
 129         alarm_info_t alarm_info;
 130         alarm_id_t alarm_id;
 131         int error_code;
 132         bool result = false;
 133
 134
 135         time(&current_time);
 136
 137         localtime_r(&current_time, &current_tm);
 138
 139         alarm_info.start.year = 0;
 140         alarm_info.start.month = 0;
 141         alarm_info.start.day = 0;
 142
 143         alarm_info.end.year = 0;
 144         alarm_info.end.month = 0;
 145         alarm_info.end.day = 0;
 146
 147         alarm_info.start.hour = 0;
 148         alarm_info.start.min = 0;
 149
 150         alarm_info.mode.day_of_week = 0;
 151         alarm_info.mode.repeat = 1;
 152
 153         alarm_info.activation = true;
 154         alarm_info.auto_powerup = false;
 155
 156         result = alarm_create(&alarm_info, &alarm_id, &error_code);
 157         // result must be false
 158         if ( result == true )
 159         {
 160                 result = alarm_delete(alarm_id, &error_code);
 161
 162                 if ( result == true )
 163                 {
 164                         printf("Test Success: %s\n", __FUNCTION__);
 165                 }
 166                 else
 167                 {
 168                         printf("Test Failed: %s: error(%d)\n", __FUNCTION__, error_code);
 169                 }
 170
 171         }
 172         else
 173         {
 174                 printf("Test Failed: %s\n", __FUNCTION__);
 175         }
 176 }
 177
 178 void test_alarm_delete_fail_case_invalid_id()
 179 {
 180         time_t current_time;
 181         struct tm current_tm;
 182         alarm_info_t alarm_info;
 183         int error_code;
 184         bool result = false;
 185
 186         result = alarm_delete(1234, &error_code);
 187
 188         if ( result == false)
 189         {
 190                 printf("Test Success: %s\n", __FUNCTION__);
 191         }
 192         else
 193         {
 194                 printf("Test Failed: %s\n", __FUNCTION__);
 195         }
 196 }
 197
 198 void test_alarm_create_fail_case_start_start_1()
 199 {
 200     time_t current_time;
 201     struct tm current_tm;
 202     alarm_info_t alarm_info;
 203     alarm_id_t alarm_id;
 204     int error_code;
 205         bool result = false;
 206
 207
 208     time(&current_time);
 209
 210     localtime_r(&current_time, &current_tm);
 211
 212     alarm_info.start.year = 0;
 213     alarm_info.start.month = 0;
 214     alarm_info.start.day = 0;
 215
 216     alarm_info.end.year = 0;
 217     alarm_info.end.month = 0;
 218     alarm_info.end.day = 0;
 219
 220     alarm_info.start.hour = 24;
 221     alarm_info.start.min = 1;
 222
 223     alarm_info.mode.day_of_week = 0;
 224     alarm_info.mode.repeat = 1;
 225
 226     alarm_info.activation = true;
 227     alarm_info.auto_powerup = false;
 228
 229     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 230 // result must be false
 231         if ( result == false )
 232                 printf("Test Success: %s\n", __FUNCTION__);
 233         else
 234         {
 235                 printf("Test Failed: %s\n", __FUNCTION__);
 236                 alarm_delete(alarm_id, &error_code);
 237         }
 238 }
 239
 240 void test_alarm_create_fail_case_start_start_2()
 241 {
 242     time_t current_time;
 243     struct tm current_tm;
 244     alarm_info_t alarm_info;
 245     alarm_id_t alarm_id;
 246     int error_code;
 247         bool result = false;
 248
 249
 250     time(&current_time);
 251
 252     localtime_r(&current_time, &current_tm);
 253
 254     alarm_info.start.year = 0;
 255     alarm_info.start.month = 0;
 256     alarm_info.start.day = 0;
 257
 258     alarm_info.end.year = 0;
 259     alarm_info.end.month = 0;
 260     alarm_info.end.day = 0;
 261
 262     alarm_info.start.hour = -1;
 263     alarm_info.start.min = 1;
 264
 265     alarm_info.mode.day_of_week = 0;
 266     alarm_info.mode.repeat = 1;
 267
 268     alarm_info.activation = true;
 269     alarm_info.auto_powerup = false;
 270
 271     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 272 // result must be false
 273         if ( result == false )
 274                 printf("Test Success: %s\n", __FUNCTION__);
 275         else
 276         {
 277                 printf("Test Failed: %s\n", __FUNCTION__);
 278                 alarm_delete(alarm_id, &error_code);
 279         }
 280 }
 281
 282 void test_alarm_create_fail_case_start_start_3()
 283 {
 284     time_t current_time;
 285     struct tm current_tm;
 286     alarm_info_t alarm_info;
 287     alarm_id_t alarm_id;
 288     int error_code;
 289         bool result = false;
 290
 291
 292     time(&current_time);
 293
 294     localtime_r(&current_time, &current_tm);
 295
 296     alarm_info.start.year = 0;
 297     alarm_info.start.month = 0;
 298     alarm_info.start.day = 0;
 299
 300     alarm_info.end.year = 0;
 301     alarm_info.end.month = 0;
 302     alarm_info.end.day = 0;
 303
 304     alarm_info.start.hour = 0;
 305     alarm_info.start.min = 60;
 306
 307     alarm_info.mode.day_of_week = 0;
 308     alarm_info.mode.repeat = 1;
 309
 310     alarm_info.activation = true;
 311     alarm_info.auto_powerup = false;
 312
 313     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 314 // result must be false
 315         if ( result == false )
 316                 printf("Test Success: %s\n", __FUNCTION__);
 317         else
 318         {
 319                 printf("Test Failed: %s\n", __FUNCTION__);
 320                 alarm_delete(alarm_id, &error_code);
 321         }
 322 }
 323
 324 void test_alarm_create_fail_case_start_start_4()
 325 {
 326     time_t current_time;
 327     struct tm current_tm;
 328     alarm_info_t alarm_info;
 329     alarm_id_t alarm_id;
 330     int error_code;
 331         bool result = false;
 332
 333
 334     time(&current_time);
 335
 336     localtime_r(&current_time, &current_tm);
 337
 338     alarm_info.start.year = 0;
 339     alarm_info.start.month = 0;
 340     alarm_info.start.day = 0;
 341
 342     alarm_info.end.year = 0;
 343     alarm_info.end.month = 0;
 344     alarm_info.end.day = 0;
 345
 346     alarm_info.start.hour = 0;
 347     alarm_info.start.min = -1;
 348
 349     alarm_info.mode.day_of_week = 0;
 350     alarm_info.mode.repeat = 1;
 351
 352     alarm_info.activation = true;
 353     alarm_info.auto_powerup = false;
 354
 355     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 356 // result must be false
 357         if ( result == false )
 358                 printf("Test Success: %s\n", __FUNCTION__);
 359         else
 360         {
 361                 printf("Test Failed: %s\n", __FUNCTION__);
 362                 alarm_delete(alarm_id, &error_code);
 363         }
 364 }
 365
 366
 367
 368 void test_alarm_create_fail_case_start_day_1()
 369 {
 370     time_t current_time;
 371     struct tm current_tm;
 372     alarm_info_t alarm_info;
 373     alarm_id_t alarm_id;
 374     int error_code;
 375         bool result = false;
 376
 377
 378     time(&current_time);
 379
 380     localtime_r(&current_time, &current_tm);
 381
 382     alarm_info.start.year = 0;
 383     alarm_info.start.month = 2;
 384     alarm_info.start.day = 31;
 385
 386     alarm_info.end.year = 0;
 387     alarm_info.end.month = 0;
 388     alarm_info.end.day = 0;
 389
 390     alarm_info.start.hour = current_tm.tm_hour;
 391     alarm_info.start.min = current_tm.tm_min+1;
 392
 393     alarm_info.mode.day_of_week = 0;
 394     alarm_info.mode.repeat = 1;
 395
 396     alarm_info.activation = true;
 397     alarm_info.auto_powerup = false;
 398
 399     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 400 // result must be false
 401         if ( result == false )
 402                 printf("Test Success: %s\n", __FUNCTION__);
 403         else
 404         {
 405                 printf("Test Failed: %s\n", __FUNCTION__);
 406                 alarm_delete(alarm_id, &error_code);
 407         }
 408 }
 409
 410 void test_alarm_create_fail_case_start_day_2()
 411 {
 412     time_t current_time;
 413     struct tm current_tm;
 414     alarm_info_t alarm_info;
 415     alarm_id_t alarm_id;
 416     int error_code;
 417         bool result = false;
 418
 419
 420     time(&current_time);
 421
 422     localtime_r(&current_time, &current_tm);
 423
 424     alarm_info.start.year = 0;
 425     alarm_info.start.month = 2;
 426     alarm_info.start.day = 30;
 427
 428     alarm_info.end.year = 0;
 429     alarm_info.end.month = 0;
 430     alarm_info.end.day = 0;
 431
 432     alarm_info.start.hour = current_tm.tm_hour;
 433     alarm_info.start.min = current_tm.tm_min+1;
 434
 435     alarm_info.mode.day_of_week = 0;
 436     alarm_info.mode.repeat = 1;
 437
 438     alarm_info.activation = true;
 439     alarm_info.auto_powerup = false;
 440
 441     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 442 // result must be false
 443         if ( result == false )
 444                 printf("Test Success: %s\n", __FUNCTION__);
 445         else
 446         {
 447                 printf("Test Failed: %s\n", __FUNCTION__);
 448                 alarm_delete(alarm_id, &error_code);
 449         }
 450 }
 451
 452 void test_alarm_create_fail_case_start_day_3()
 453 {
 454     time_t current_time;
 455     struct tm current_tm;
 456     alarm_info_t alarm_info;
 457     alarm_id_t alarm_id;
 458     int error_code;
 459         bool result = false;
 460
 461
 462     time(&current_time);
 463
 464     localtime_r(&current_time, &current_tm);
 465
 466     alarm_info.start.year = 2000;
 467     alarm_info.start.month = 2;
 468     alarm_info.start.day = 29;
 469
 470     alarm_info.end.year = 0;
 471     alarm_info.end.month = 0;
 472     alarm_info.end.day = 0;
 473
 474     alarm_info.start.hour = current_tm.tm_hour;
 475     alarm_info.start.min = current_tm.tm_min+1;
 476
 477     alarm_info.mode.day_of_week = 0;
 478     alarm_info.mode.repeat = 1;
 479
 480     alarm_info.activation = true;
 481     alarm_info.auto_powerup = false;
 482
 483     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 484         // result must be false
 485         if ( result == false )
 486                 printf("Test Failed: %s\n", __FUNCTION__);
 487         else
 488         {
 489                 printf("Test Success: %s\n", __FUNCTION__);
 490                 alarm_delete(alarm_id, &error_code);
 491         }
 492 }
 493
 494 void test_alarm_create_fail_case_start_day_4()
 495 {
 496     time_t current_time;
 497     struct tm current_tm;
 498     alarm_info_t alarm_info;
 499     alarm_id_t alarm_id;
 500     int error_code;
 501         bool result = false;
 502
 503
 504     time(&current_time);
 505
 506     localtime_r(&current_time, &current_tm);
 507
 508     alarm_info.start.year = 1900;
 509     alarm_info.start.month = 2;
 510     alarm_info.start.day = 29;
 511
 512     alarm_info.end.year = 0;
 513     alarm_info.end.month = 0;
 514     alarm_info.end.day = 0;
 515
 516     alarm_info.start.hour = current_tm.tm_hour;
 517     alarm_info.start.min = current_tm.tm_min+1;
 518
 519     alarm_info.mode.day_of_week = 0;
 520     alarm_info.mode.repeat = 1;
 521
 522     alarm_info.activation = true;
 523     alarm_info.auto_powerup = false;
 524
 525     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 526         // result must be false
 527         if ( result == false )
 528         {
 529                 printf("Test Success: %s\n", __FUNCTION__);
 530         }
 531         else
 532         {
 533                 printf("Test Failed: %s\n", __FUNCTION__);
 534                 alarm_delete(alarm_id, &error_code);
 535         }
 536 }
 537
 538 void test_alarm_create_fail_case_start_day_5()
 539 {
 540     time_t current_time;
 541     struct tm current_tm;
 542     alarm_info_t alarm_info;
 543     alarm_id_t alarm_id;
 544     int error_code;
 545         bool result = false;
 546
 547
 548     time(&current_time);
 549
 550     localtime_r(&current_time, &current_tm);
 551
 552     alarm_info.start.year = 1900;
 553     alarm_info.start.month = 1;
 554     alarm_info.start.day = 32;
 555
 556     alarm_info.end.year = 0;
 557     alarm_info.end.month = 0;
 558     alarm_info.end.day = 0;
 559
 560     alarm_info.start.hour = current_tm.tm_hour;
 561     alarm_info.start.min = current_tm.tm_min+1;
 562
 563     alarm_info.mode.day_of_week = 0;
 564     alarm_info.mode.repeat = 1;
 565
 566     alarm_info.activation = true;
 567     alarm_info.auto_powerup = false;
 568
 569     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 570         // result must be false
 571         if ( result == false )
 572         {
 573                 printf("Test Success: %s\n", __FUNCTION__);
 574         }
 575         else
 576         {
 577                 printf("Test Failed: %s\n", __FUNCTION__);
 578                 alarm_delete(alarm_id, &error_code);
 579         }
 580 }
 581
 582 void test_alarm_create_fail_case_start_day_6()
 583 {
 584     time_t current_time;
 585     struct tm current_tm;
 586     alarm_info_t alarm_info;
 587     alarm_id_t alarm_id;
 588     int error_code;
 589         bool result = false;
 590
 591
 592     time(&current_time);
 593
 594     localtime_r(&current_time, &current_tm);
 595
 596     alarm_info.start.year = 1900;
 597     alarm_info.start.month = 4;
 598     alarm_info.start.day = 31;
 599
 600     alarm_info.end.year = 0;
 601     alarm_info.end.month = 0;
 602     alarm_info.end.day = 0;
 603
 604     alarm_info.start.hour = current_tm.tm_hour;
 605     alarm_info.start.min = current_tm.tm_min+1;
 606
 607     alarm_info.mode.day_of_week = 0;
 608     alarm_info.mode.repeat = 1;
 609
 610     alarm_info.activation = true;
 611     alarm_info.auto_powerup = false;
 612
 613     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 614         // result must be false
 615         if ( result == false )
 616         {
 617                 printf("Test Success: %s\n", __FUNCTION__);
 618         }
 619         else
 620         {
 621                 printf("Test Failed: %s\n", __FUNCTION__);
 622                 alarm_delete(alarm_id, &error_code);
 623         }
 624 }
 625
 626
 627
 628 void test_alarm_create_fail_case_start_month_1()
 629 {
 630     time_t current_time;
 631     struct tm current_tm;
 632     alarm_info_t alarm_info;
 633     alarm_id_t alarm_id;
 634     int error_code;
 635         bool result = false;
 636
 637
 638     time(&current_time);
 639
 640     localtime_r(&current_time, &current_tm);
 641
 642     alarm_info.start.year = 0;
 643     alarm_info.start.month = -1;
 644     alarm_info.start.day = 0;
 645
 646     alarm_info.end.year = 0;
 647     alarm_info.end.month = 0;
 648     alarm_info.end.day = 0;
 649
 650     alarm_info.start.hour = current_tm.tm_hour;
 651     alarm_info.start.min = current_tm.tm_min+1;
 652
 653     alarm_info.mode.day_of_week = 0;
 654     alarm_info.mode.repeat = 1;
 655
 656     alarm_info.activation = true;
 657     alarm_info.auto_powerup = false;
 658
 659     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 660 // result must be false
 661         if ( result == false )
 662                 printf("Test Success: %s\n", __FUNCTION__);
 663         else
 664         {
 665                 printf("Test Failed: %s\n", __FUNCTION__);
 666                 alarm_delete(alarm_id, &error_code);
 667         }
 668 }
 669
 670 void test_alarm_create_fail_case_start_month_2()
 671 {
 672     time_t current_time;
 673     struct tm current_tm;
 674     alarm_info_t alarm_info;
 675     alarm_id_t alarm_id;
 676     int error_code;
 677         bool result = false;
 678
 679
 680     time(&current_time);
 681
 682     localtime_r(&current_time, &current_tm);
 683
 684     alarm_info.start.year = 0;
 685     alarm_info.start.month = 13;
 686     alarm_info.start.day = 0;
 687
 688     alarm_info.end.year = 0;
 689     alarm_info.end.month = 0;
 690     alarm_info.end.day = 0;
 691
 692     alarm_info.start.hour = current_tm.tm_hour;
 693     alarm_info.start.min = current_tm.tm_min+1;
 694
 695     alarm_info.mode.day_of_week = 0;
 696     alarm_info.mode.repeat = 1;
 697
 698     alarm_info.activation = true;
 699     alarm_info.auto_powerup = false;
 700
 701     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 702 // result must be false
 703         if ( result == false )
 704                 printf("Test Success: %s\n", __FUNCTION__);
 705         else
 706         {
 707                 printf("Test Failed: %s\n", __FUNCTION__);
 708                 alarm_delete(alarm_id, &error_code);
 709         }
 710 }
 711
 712 // Invalid day of week
 713 void test_alarm_create_fail_case_day_of_week()
 714 {
 715     time_t current_time;
 716     struct tm current_tm;
 717     alarm_info_t alarm_info;
 718     alarm_id_t alarm_id;
 719     int error_code;
 720         bool result = false;
 721
 722
 723     time(&current_time);
 724
 725     localtime_r(&current_time, &current_tm);
 726
 727     alarm_info.start.year = 0;
 728     alarm_info.start.month = 0;
 729     alarm_info.start.day = 0;
 730
 731     alarm_info.end.year = 0;
 732     alarm_info.end.month = 0;
 733     alarm_info.end.day = 0;
 734
 735     alarm_info.start.hour = current_tm.tm_hour;
 736     alarm_info.start.min = current_tm.tm_min+1;
 737
 738     alarm_info.mode.day_of_week = ALARM_WDAY_SATURDAY << 1;
 739     alarm_info.mode.repeat = ALARM_REPEAT_MODE_ANNUALLY;
 740
 741     alarm_info.activation = true;
 742     alarm_info.auto_powerup = false;
 743
 744     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 745
 746         // result must be false
 747         if ( result == false )
 748                 printf("Test Success: %s\n", __FUNCTION__);
 749         else
 750         {
 751                 printf("Test Failed: %s\n", __FUNCTION__);
 752                 alarm_delete(alarm_id, &error_code);
 753         }
 754 }
 755
 756
 757 /* Invalid repeat mode */
 758 void test_alarm_create_fail_case_repeat_mode()
 759 {
 760     time_t current_time;
 761     struct tm current_tm;
 762     alarm_info_t alarm_info;
 763     alarm_id_t alarm_id;
 764     int error_code;
 765
 766         bool result = false;
 767
 768
 769     time(&current_time);
 770
 771     localtime_r(&current_time, &current_tm);
 772
 773     alarm_info.start.year = 0;
 774     alarm_info.start.month = 0;
 775     alarm_info.start.day = 0;
 776
 777     alarm_info.end.year = 0;
 778     alarm_info.end.month = 0;
 779     alarm_info.end.day = 0;
 780
 781     alarm_info.start.hour = current_tm.tm_hour;
 782     alarm_info.start.min = current_tm.tm_min+1;
 783
 784     alarm_info.mode.day_of_week = 0;
 785     alarm_info.mode.repeat = ALARM_REPEAT_MODE_ANNUALLY + 1;
 786
 787     alarm_info.activation = true;
 788     alarm_info.auto_powerup = false;
 789
 790     result = alarm_create(&alarm_info, &alarm_id, &error_code);
 791
 792         // result must be false
 793         if ( result == false )
 794                 printf("Test Success: %s\n", __FUNCTION__);
 795         else
 796         {
 797                 printf("Test Failed: %s\n", __FUNCTION__);
 798                 alarm_delete(alarm_id, &error_code);
 799         }
 800 }
 801
 802
 803 int main(int argc, char** argv)
 804 {
 805         int error_code;
 806         noti_init(&error_code);
 807
 808     alarm_init(&error_code);
 809     alarm_set_cb(callback, &error_code);
 810
 811         test_alarm_create_fail_case_repeat_mode();
 812         test_alarm_create_fail_case_day_of_week();
 813         test_alarm_create_fail_case_start_month_1();
 814         test_alarm_create_fail_case_start_month_2();
 815         test_alarm_create_fail_case_start_day_1();
 816         test_alarm_create_fail_case_start_day_2();
 817         test_alarm_create_fail_case_start_day_3();
 818         test_alarm_create_fail_case_start_day_4();
 819         test_alarm_create_fail_case_start_day_5();
 820         test_alarm_create_fail_case_start_day_6();
 821         test_alarm_create_fail_case_start_start_1();
 822         test_alarm_create_fail_case_start_start_2();
 823         test_alarm_create_fail_case_start_start_3();
 824         test_alarm_create_fail_case_start_start_4();
 825         test_alarm_delete_fail_case_normal();
 826         test_alarm_delete_fail_case_invalid_id();
 827         test_alarm_update_fail_case_normal();
 828         test_alarm_update_fail_case_invalid_id();
 829
 830         noti_finish(&error_code);
 831     alarm_fini(&error_code);
 832 }