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