TC/testcase/utc_alarm.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
  18 #include <tet_api.h>
  19 #include <app.h>
  20 #include <glib.h>
  21
  22 static int passed =1;
  23 int tid;
  24 GMainLoop *loop;
  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_alarm_schedule_after_delay_positive(void);
  33 static void utc_alarm_schedule_after_delay_negative(void);
  34 static void utc_alarm_cancel_positive(void);
  35 static void utc_alarm_cancel_negative(void);
  36 static void utc_alarm_cancel_all_positive(void);
  37 static void utc_alarm_foreach_registered_alarm_positive(void);
  38 static void utc_alarm_foreach_registered_alarm_negative(void);
  39 static void utc_alarm_get_scheduled_date_positive(void);
  40 static void utc_alarm_get_scheduled_date_negative(void);
  41 static void utc_alarm_get_scheduled_period_positive(void);
  42 static void utc_alarm_get_scheduled_period_negative(void);
  43 static void utc_alarm_schedule_at_date_positive(void);
  44 static void utc_alarm_schedule_at_date_negative(void);
  45 static void utc_alarm_schedule_with_recurrence_week_flag_positive(void);
  46 static void utc_alarm_schedule_with_recurrence_week_flag_negative(void);
  47 static void utc_alarm_get_scheduled_recurrence_week_flag_positive(void);
  48 static void utc_alarm_get_scheduled_recurrence_week_flag_negative(void);
  49 static void utc_alarm_get_current_time_positive(void);
  50 static void utc_alarm_get_current_time_negative(void);
  51 static void utc_alarm_get_service_positive(void);
  52 static void utc_alarm_get_service_negative(void);
  53
  54
  55
  56 struct tet_testlist tet_testlist[] = {
  57         { utc_alarm_schedule_after_delay_positive, 1 },
  58         { utc_alarm_schedule_after_delay_negative, 2 },
  59         { utc_alarm_cancel_positive, 1 },
  60         { utc_alarm_cancel_negative, 2 },
  61         { utc_alarm_cancel_all_positive, 1 },
  62         { utc_alarm_foreach_registered_alarm_positive, 1 },
  63         { utc_alarm_foreach_registered_alarm_negative, 2 },
  64         { utc_alarm_get_scheduled_date_positive, 1 },
  65         { utc_alarm_get_scheduled_date_negative, 2 },
  66         { utc_alarm_get_scheduled_period_positive, 1 },
  67         { utc_alarm_get_scheduled_period_negative, 2 },
  68         { utc_alarm_schedule_at_date_positive, 1 },
  69         { utc_alarm_schedule_at_date_negative, 2 },
  70         { utc_alarm_schedule_with_recurrence_week_flag_positive, 1 },
  71         { utc_alarm_schedule_with_recurrence_week_flag_negative, 2 },
  72         { utc_alarm_get_scheduled_recurrence_week_flag_positive, 1 },
  73         { utc_alarm_get_scheduled_recurrence_week_flag_negative, 2 },
  74         { utc_alarm_get_current_time_positive, 1 },
  75         { utc_alarm_get_current_time_negative, 2 },
  76         { utc_alarm_get_service_positive, 1 },
  77         { utc_alarm_get_service_negative, 2 },
  78         { NULL, 0 },
  79 };
  80
  81 static void startup(void)
  82 {
  83         /* start of TC */
  84         g_type_init();
  85 }
  86
  87 static void cleanup(void)
  88 {
  89         /* end of TC */
  90         alarm_cancel_all();
  91 }
  92
  93 static bool foreach_alarm_cb(int alarm, void* user_data)
  94 {
  95         if(alarm == tid)
  96         {
  97                 dts_pass("utc_alarm_foreach_registered_alarm_positive");
  98         }
  99
 100         dts_message("utc_alarm_foreach_registered_alarm_positive", "registered id = %d callback id = %d", alarm, tid);
 101
 102         return true;
 103 }
 104
 105 static gboolean timeout(gpointer data)
 106 {
 107     printf("timeout called\n");
 108     g_main_loop_quit(data);
 109     return FALSE;
 110 }
 111
 112 /**
 113  * @brief Positive test case of alarm_schedule_after_delay()
 114  */
 115 static void utc_alarm_schedule_after_delay_positive(void)
 116 {
 117         time_t current_time;
 118         struct tm current_tm;
 119         service_h service;
 120         int tid;
 121         GMainLoop *loop;
 122         int ret = ALARM_ERROR_NONE;
 123
 124         service_create(&service);
 125         service_set_operation(service, SERVICE_OPERATION_DEFAULT);
 126         service_set_package(service, "com.samsung.memo");
 127
 128         loop = g_main_loop_new(NULL, FALSE);
 129         g_timeout_add(5000,timeout , loop);
 130
 131         ret = alarm_schedule_after_delay(service, 1, 1, &tid);
 132
 133         g_main_loop_run(loop);
 134
 135         if(ret == ALARM_ERROR_NONE)
 136         {
 137                 dts_pass("utc_alarm_schedule_after_delay_positive", "passed");
 138         }
 139         else
 140         {
 141                 dts_fail("utc_alarm_schedule_after_delay_positive", "failed");
 142         }
 143
 144         service_destory(service);
 145         alarm_cancel_all();
 146 }
 147
 148 /**
 149  * @brief Negative test case of alarm_schedule_after_delay()
 150  */
 151 static void utc_alarm_schedule_after_delay_negative(void)
 152 {
 153         time_t current_time;
 154         struct tm current_tm;
 155         service_h service;
 156         int ret = ALARM_ERROR_NONE;
 157         int tid;
 158         GMainLoop *loop;
 159
 160         service_create(&service);
 161         service_set_package(service, "com.samsung.memo");
 162         service_set_operation(service, SERVICE_OPERATION_DEFAULT);
 163
 164         ret = alarm_schedule_after_delay(service, 1, 1, NULL);
 165
 166         g_main_loop_run(loop);
 167
 168         if(ret == ALARM_ERROR_NONE)
 169         {
 170                 dts_fail("utc_alarm_schedule_after_delay_negative", "failed");
 171         }
 172         else
 173         {
 174                 dts_pass("utc_alarm_schedule_after_delay_negative", "passed");
 175         }
 176
 177         service_destory(service);
 178         alarm_cancel_all();
 179
 180 }
 181
 182
 183 /**
 184  * @brief Positive test case of alarm_cancel()
 185  */
 186 static void utc_alarm_cancel_positive(void)
 187 {
 188         time_t current_time;
 189         struct tm current_tm;
 190         service_h service;
 191         int ret = ALARM_ERROR_NONE;
 192         int tid;
 193         GMainLoop *loop;
 194
 195         service_create(&service);
 196         service_set_package(service, "com.samsung.memo");
 197         service_set_operation(service, SERVICE_OPERATION_DEFAULT);
 198
 199         loop = g_main_loop_new(NULL, FALSE);
 200         g_timeout_add(5000,timeout , loop);
 201
 202         ret = alarm_schedule_after_delay(service, 1, 1, &tid);
 203         ret = alarm_cancel(tid);
 204
 205         g_main_loop_run(loop);
 206
 207         if(ret == ALARM_ERROR_NONE)
 208         {
 209                 dts_pass("utc_alarm_cancel_positive", "passed");
 210         }
 211         else
 212         {
 213                 dts_fail("utc_alarm_cancel_positive", "passed");
 214         }
 215
 216         service_destory(service);
 217         alarm_cancel_all();
 218 }
 219
 220 /**
 221  * @brief Negative test case of alarm_cancel()
 222  */
 223 static void utc_alarm_cancel_negative(void)
 224 {
 225         int ret = ALARM_ERROR_NONE;
 226
 227         ret = alarm_cancel(NULL);
 228         if(ret == ALARM_ERROR_NONE)
 229         {
 230                 dts_fail("utc_alarm_cancel_negative", "failed");
 231         }
 232         else
 233         {
 234                 dts_pass("utc_alarm_cancel_negative", "passed");
 235         }
 236         alarm_cancel_all();
 237 }
 238
 239 /**
 240  * @brief Positive test case of alarm_cancel_all()
 241  */
 242 static void utc_alarm_cancel_all_positive(void)
 243 {
 244         int ret = ALARM_ERROR_NONE;
 245
 246         ret = alarm_cancel_all();
 247
 248         if(ret == ALARM_ERROR_NONE)
 249         {
 250                 dts_pass("utc_alarm_cancel_all_positive", "passed");
 251         }
 252         else
 253         {
 254                 dts_fail("utc_alarm_cancel_all_positive", "failed");
 255         }
 256
 257         alarm_cancel_all();
 258
 259 }
 260
 261
 262 /**
 263  * @brief Positive test case of alarm_foreach_registered_alarm()
 264  */
 265 static void utc_alarm_foreach_registered_alarm_positive(void)
 266 {
 267         int ret = ALARM_ERROR_NONE;
 268         time_t current_time;
 269         struct tm current_tm;
 270         service_h service;
 271         int tid;
 272         GMainLoop *loop;
 273
 274         loop = g_main_loop_new(NULL, FALSE);
 275         g_timeout_add(1000,timeout , loop);
 276
 277         service_create(&service);
 278         service_set_package(service, "com.samsung.memo");
 279         service_set_operation(service, SERVICE_OPERATION_DEFAULT);
 280         alarm_schedule_after_delay(service, 1, 5, &tid);
 281
 282         ret = alarm_foreach_registered_alarm(foreach_alarm_cb,NULL);
 283
 284         g_main_loop_run(loop);
 285
 286         if(ret != ALARM_ERROR_NONE)
 287         {
 288                 dts_fail("utc_alarm_foreach_registered_alarm_positive", "failed");
 289         }
 290         else
 291         {
 292                 dts_pass("utc_alarm_foreach_registered_alarm_positive" , "passed");
 293         }
 294
 295         service_destory(service);
 296         alarm_cancel_all();
 297
 298 }
 299
 300
 301 /**
 302  * @brief Negative test case of alarm_foreach_registered_alarm()
 303  */
 304 static void utc_alarm_foreach_registered_alarm_negative(void)
 305 {
 306         int ret = ALARM_ERROR_NONE;
 307
 308         // do i need to call alarm_init??
 309         ret = alarm_foreach_registered_alarm(NULL,NULL);
 310
 311         if(ret == ALARM_ERROR_NONE)
 312         {
 313                 dts_fail("utc_alarm_foreach_registered_alarm_negative", "failed");
 314         }
 315         else
 316         {
 317                 dts_pass("utc_alarm_foreach_registered_alarm_negative", "passed");
 318         }
 319         alarm_cancel_all();
 320 }
 321
 322
 323 /**
 324  * @brief Positive test case of alarm_get_scheduled_date()
 325  */
 326 static void utc_alarm_get_scheduled_date_positive(void)
 327 {
 328         struct tm date;
 329         service_h service;
 330         int ret = ALARM_ERROR_NONE;
 331         int tid;
 332         GMainLoop *loop;
 333
 334         loop = g_main_loop_new(NULL, FALSE);
 335         g_timeout_add(5000,timeout , loop);
 336
 337         service_create(&service);
 338         service_set_package(service, "com.samsung.memo");
 339         service_set_operation(service, SERVICE_OPERATION_DEFAULT);
 340         alarm_schedule_after_delay(service, 1, 5, &tid);
 341
 342         ret = alarm_get_scheduled_date(tid, &date);
 343
 344         g_main_loop_run(loop);
 345
 346         if(ret == ALARM_ERROR_NONE)
 347         {
 348                 dts_pass("utc_alarm_get_date_positive", "passed");
 349         }
 350         else
 351         {
 352                 dts_fail("utc_alarm_get_date_positive", "failed");
 353         }
 354
 355         service_destory(service);
 356         alarm_cancel_all();
 357 }
 358
 359 /**
 360  * @brief Negative test case of alarm_get_scheduled_date()
 361  */
 362 static void utc_alarm_get_scheduled_date_negative(void)
 363 {
 364         struct tm date;
 365         int ret = ALARM_ERROR_NONE;
 366
 367         ret =  alarm_get_scheduled_date(NULL, &date);
 368
 369         if(ret == ALARM_ERROR_NONE)
 370         {
 371                 dts_fail("utc_alarm_get_scheduled_date_negative", "failed");
 372         }
 373         else
 374         {
 375                 dts_pass("utc_alarm_get_scheduled_date_negative", "passed");
 376         }
 377         alarm_cancel_all();
 378 }
 379
 380
 381 /**
 382  * @brief Positive test case of alarm_get_period()
 383  */
 384 static void utc_alarm_get_scheduled_period_positive(void)
 385 {
 386         time_t current_time;
 387         struct tm current_tm;
 388         service_h service;
 389         int ret = ALARM_ERROR_NONE;
 390         int period = 0;
 391         int tid;
 392         GMainLoop *loop;
 393
 394         loop = g_main_loop_new(NULL, FALSE);
 395         g_timeout_add(1000,timeout , loop);
 396
 397         service_create(&service);
 398         service_set_package(service, "com.samsung.memo");
 399         service_set_operation(service, SERVICE_OPERATION_DEFAULT);
 400         alarm_schedule_after_delay(service, 1, 1, &tid);
 401
 402         ret = alarm_get_scheduled_period(tid, &period);
 403
 404         g_main_loop_run(loop);
 405
 406         if(ret != ALARM_ERROR_NONE)
 407         {
 408                 dts_fail("utc_alarm_get_scheduled_period_positive", "failed");
 409         }
 410
 411         if(period == 1)
 412         {
 413                 dts_pass("utc_alarm_get_scheduled_period_positive", "passed");
 414         }
 415         else
 416         {
 417                 dts_fail("utc_alarm_get_scheduled_period_positive", "failed");
 418         }
 419
 420         service_destory(service);
 421         alarm_cancel_all();
 422
 423 }
 424
 425 /**
 426  * @brief Negative test case of alarm_get_scheduled_period()
 427  */
 428 static void utc_alarm_get_scheduled_period_negative(void)
 429 {
 430         time_t current_time;
 431         struct tm current_tm;
 432         int ret = ALARM_ERROR_NONE;
 433         int period = 0;
 434         int tid;
 435         GMainLoop *loop;
 436
 437         ret = alarm_get_scheduled_period(NULL,&period);
 438
 439         if(ret == ALARM_ERROR_NONE)
 440         {
 441                 dts_fail("utc_alarm_get_scheduled_period_negative", "failed");
 442         }
 443         else
 444         {
 445                 dts_pass("utc_alarm_get_scheduled_period_negative", "passed");
 446         }
 447
 448         alarm_cancel_all();
 449
 450 }
 451
 452 /**
 453  * @brief Positive test case of alarm_schedule_at_date()
 454  */
 455 static void utc_alarm_schedule_at_date_positive(void)
 456 {
 457         time_t current_time;
 458         struct tm date;
 459         time_t now;
 460         service_h service;
 461         int tid;
 462         GMainLoop *loop;
 463
 464         int ret = ALARM_ERROR_NONE;
 465
 466         loop = g_main_loop_new(NULL, FALSE);
 467         g_timeout_add(5000,timeout , loop);
 468
 469         time(&now);
 470         localtime_r(&now, &date);
 471
 472         date.tm_sec += 3;
 473         service_create(&service);
 474         service_set_package(service, "com.samsung.memo");
 475         service_set_operation(service, SERVICE_OPERATION_DEFAULT);
 476
 477         ret = alarm_schedule_at_date(service, &date, 2, &tid);
 478
 479         g_main_loop_run(loop);
 480
 481         if(ret == ALARM_ERROR_NONE)
 482         {
 483                 dts_pass("utc_alarm_schedule_at_date_positive", "passed");
 484
 485         }
 486         else
 487         {
 488                 dts_fail("utc_alarm_schedule_at_date_positive", "failed");
 489         }
 490
 491         service_destory(service);
 492         alarm_cancel_all();
 493
 494 }
 495
 496
 497 /**
 498  * @brief Negative test case of alarm_schedule_at_date()
 499  */
 500 static void utc_alarm_schedule_at_date_negative(void)
 501 {
 502         time_t current_time;
 503         struct tm current_tm;
 504         int ret = ALARM_ERROR_NONE;
 505         service_h service;
 506
 507         service_create(&service);
 508         service_set_package(service, "com.samsung.memo");
 509         service_set_operation(service, SERVICE_OPERATION_DEFAULT);
 510         ret = alarm_schedule_at_date(service, NULL, 1, &tid);
 511
 512         if(ret == ALARM_ERROR_NONE)
 513         {
 514                 dts_fail("utc_alarm_schedule_at_date_negative", "failed");
 515         }
 516         else
 517         {
 518                 dts_pass("utc_alarm_schedule_at_date_negative", "passed");
 519         }
 520
 521         service_destory(service);
 522         alarm_cancel_all();
 523
 524 }
 525
 526 /**
 527  * @brief Negative test case of alarm_schedule_at_date()
 528  */
 529 static void utc_alarm_schedule_with_recurrence_week_flag_positive(void)
 530 {
 531         time_t current_time;
 532         struct tm date;
 533         time_t now;
 534         service_h service;
 535         int tid;
 536         GMainLoop *loop;
 537
 538         int ret = ALARM_ERROR_NONE;
 539
 540         loop = g_main_loop_new(NULL, FALSE);
 541         g_timeout_add(5000,timeout , loop);
 542
 543         time(&now);
 544         localtime_r(&now, &date);
 545         date.tm_sec += 3;
 546         service_create(&service);
 547         service_set_package(service, "com.samsung.memo");
 548         service_set_operation(service, SERVICE_OPERATION_DEFAULT);
 549
 550         alarm_schedule_with_recurrence_week_flag(service, &date, ALARM_WEEK_FLAG_MONDAY, &tid);
 551
 552         g_main_loop_run(loop);
 553
 554         if(ret == ALARM_ERROR_NONE)
 555         {
 556                 dts_pass("utc_alarm_schedule_with_recurrence_week_flag_positive", "passed");
 557         }
 558         else
 559         {
 560                 dts_fail("utc_alarm_schedule_with_recurrence_week_flag_positive", "failed");
 561         }
 562
 563         service_destory(service);
 564         alarm_cancel_all();
 565
 566 }
 567
 568 static void utc_alarm_schedule_with_recurrence_week_flag_negative(void)
 569 {
 570
 571         time_t current_time;
 572         struct tm date;
 573         time_t now;
 574
 575         int ret = ALARM_ERROR_NONE;
 576
 577         time(&now);
 578         localtime_r(&now, &date);
 579         date.tm_sec += 3;
 580
 581         ret = alarm_schedule_with_recurrence_week_flag(NULL, &date, ALARM_WEEK_FLAG_MONDAY, &tid);
 582
 583         if(ret == ALARM_ERROR_NONE)
 584         {
 585                 dts_fail("utc_alarm_schedule_at_date_negative", "failed");
 586         }
 587         else
 588         {
 589                 dts_pass("utc_alarm_schedule_at_date_negative", "passed");
 590         }
 591
 592         alarm_cancel_all();
 593
 594 }
 595
 596
 597 /**
 598  * @brief Negative test case of alarm_schedule_at_date()
 599  */
 600 static void utc_alarm_get_scheduled_recurrence_week_flag_positive(void)
 601 {
 602         time_t current_time;
 603         struct tm date;
 604         time_t now;
 605         service_h service;
 606         int tid;
 607         GMainLoop *loop;
 608         int week_flag = 0;
 609
 610         int ret = ALARM_ERROR_NONE;
 611
 612         time(&now);
 613         localtime_r(&now, &date);
 614         date.tm_sec += 3;
 615         service_create(&service);
 616         service_set_package(service, "com.samsung.memo");
 617         service_set_operation(service, SERVICE_OPERATION_DEFAULT);
 618
 619         alarm_schedule_with_recurrence_week_flag(service, &date, ALARM_WEEK_FLAG_MONDAY, &tid);
 620
 621         alarm_get_scheduled_recurrence_week_flag(tid,  &week_flag);
 622
 623
 624         if(ret != ALARM_ERROR_NONE)
 625         {
 626                 dts_fail("utc_alarm_get_scheduled_recurrence_week_flag_positive", "failed");
 627         }
 628
 629         if(week_flag == ALARM_WEEK_FLAG_MONDAY)
 630         {
 631                 dts_pass("utc_alarm_get_scheduled_recurrence_week_flag_positive", "passed");
 632         }
 633         else
 634         {
 635                 dts_fail("utc_alarm_get_scheduled_recurrence_week_flag_positive", "failed");
 636         }
 637         service_destory(service);
 638         alarm_cancel_all();
 639
 640 }
 641
 642 static void utc_alarm_get_scheduled_recurrence_week_flag_negative(void)
 643 {
 644
 645         time_t current_time;
 646         struct tm date;
 647         time_t now;
 648
 649         int ret = ALARM_ERROR_NONE;
 650
 651         ret = alarm_get_scheduled_recurrence_week_flag(NULL ,NULL);
 652
 653         if(ret == ALARM_ERROR_NONE)
 654         {
 655                 dts_fail("utc_alarm_get_scheduled_recurrence_week_flag_negative", "failed");
 656         }
 657         else
 658         {
 659                 dts_pass("utc_alarm_get_scheduled_recurrence_week_flag_negative", "passed");
 660         }
 661
 662         alarm_cancel_all();
 663
 664 }
 665
 666 static void utc_alarm_get_current_time_positive(void)
 667 {
 668         struct tm date;
 669         int ret = ALARM_ERROR_NONE;
 670
 671         ret = alarm_get_current_time(&date);
 672         if(ret == ALARM_ERROR_NONE)
 673         {
 674                 dts_pass("utc_alarm_get_current_time_positive", "passed");
 675         }
 676         else
 677         {
 678                 dts_fail("utc_alarm_get_current_time_positive", "failed");
 679         }
 680 }
 681
 682 static void utc_alarm_get_current_time_negative(void)
 683 {
 684         int ret = ALARM_ERROR_NONE;
 685
 686         ret = alarm_get_current_time(NULL);
 687         if(ret == ALARM_ERROR_NONE)
 688         {
 689                 dts_fail("utc_alarm_get_current_time_negative", "failed");
 690         }
 691         else
 692         {
 693                 dts_pass("utc_alarm_get_current_time_negative", "passed");
 694         }
 695 }
 696
 697 static void utc_alarm_get_service_positive(void)
 698 {
 699         time_t current_time;
 700         struct tm current_tm;
 701         service_h service;
 702         service_h service_return;
 703
 704         int ret = ALARM_ERROR_NONE;
 705         int tid;
 706         GMainLoop *loop;
 707         char *package;
 708
 709         loop = g_main_loop_new(NULL, FALSE);
 710         g_timeout_add(1000,timeout , loop);
 711
 712         service_create(&service);
 713         service_set_package(service, "com.samsung.memo");
 714         service_set_operation(service, SERVICE_OPERATION_DEFAULT);
 715         alarm_schedule_after_delay(service, 3, 0, &tid);
 716
 717         ret = alarm_get_service(tid, &service_return);
 718
 719         g_main_loop_run(loop);
 720
 721         if(ret != ALARM_ERROR_NONE)
 722         {
 723                 dts_fail("utc_alarm_get_service_positive", "failed");
 724         }
 725
 726         ret = service_get_package(service_return, &package);
 727
 728         if(ret != SERVICE_ERROR_NONE)
 729         {
 730                 dts_fail("utc_alarm_get_service_positive", "failed");
 731         }
 732
 733         if(!strcmp(package, "com.samsung.memo"))
 734         {
 735                 dts_pass("utc_alarm_get_service_positive", "passed");
 736         }
 737         else
 738         {
 739                 dts_fail("utc_alarm_get_service_positive", "failed");
 740         }
 741
 742         if(package != NULL)
 743         {
 744                 free(package);
 745         }
 746         service_destory(service);
 747         service_destory(service_return);
 748         alarm_cancel_all();
 749
 750 }
 751 static void utc_alarm_get_service_negative(void)
 752 {
 753         int ret = ALARM_ERROR_NONE;
 754
 755         ret = alarm_get_service(NULL,NULL);
 756
 757         if(ret == ALARM_ERROR_NONE)
 758         {
 759                 dts_fail("utc_alarm_get_service_negative", "failed");
 760         }
 761         else
 762         {
 763                 dts_pass("utc_alarm_get_service_negative", "passed");
 764         }
 765 }
 766