2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
26 static void startup(void);
27 static void cleanup(void);
29 void (*tet_startup)(void) = startup;
30 void (*tet_cleanup)(void) = cleanup;
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);
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 },
81 static void startup(void)
87 static void cleanup(void)
93 static bool foreach_alarm_cb(int alarm, void* user_data)
97 dts_pass("utc_alarm_foreach_registered_alarm_positive");
100 dts_message("utc_alarm_foreach_registered_alarm_positive", "registered id = %d callback id = %d", alarm, tid);
105 static gboolean timeout(gpointer data)
107 printf("timeout called\n");
108 g_main_loop_quit(data);
113 * @brief Positive test case of alarm_schedule_after_delay()
115 static void utc_alarm_schedule_after_delay_positive(void)
118 struct tm current_tm;
122 int ret = ALARM_ERROR_NONE;
124 service_create(&service);
125 service_set_operation(service, SERVICE_OPERATION_DEFAULT);
126 service_set_package(service, "com.samsung.memo");
128 loop = g_main_loop_new(NULL, FALSE);
129 g_timeout_add(5000,timeout , loop);
131 ret = alarm_schedule_after_delay(service, 1, 1, &tid);
133 g_main_loop_run(loop);
135 if(ret == ALARM_ERROR_NONE)
137 dts_pass("utc_alarm_schedule_after_delay_positive", "passed");
141 dts_fail("utc_alarm_schedule_after_delay_positive", "failed");
144 service_destory(service);
149 * @brief Negative test case of alarm_schedule_after_delay()
151 static void utc_alarm_schedule_after_delay_negative(void)
154 struct tm current_tm;
156 int ret = ALARM_ERROR_NONE;
160 service_create(&service);
161 service_set_package(service, "com.samsung.memo");
162 service_set_operation(service, SERVICE_OPERATION_DEFAULT);
164 ret = alarm_schedule_after_delay(service, 1, 1, NULL);
166 g_main_loop_run(loop);
168 if(ret == ALARM_ERROR_NONE)
170 dts_fail("utc_alarm_schedule_after_delay_negative", "failed");
174 dts_pass("utc_alarm_schedule_after_delay_negative", "passed");
177 service_destory(service);
184 * @brief Positive test case of alarm_cancel()
186 static void utc_alarm_cancel_positive(void)
189 struct tm current_tm;
191 int ret = ALARM_ERROR_NONE;
195 service_create(&service);
196 service_set_package(service, "com.samsung.memo");
197 service_set_operation(service, SERVICE_OPERATION_DEFAULT);
199 loop = g_main_loop_new(NULL, FALSE);
200 g_timeout_add(5000,timeout , loop);
202 ret = alarm_schedule_after_delay(service, 1, 1, &tid);
203 ret = alarm_cancel(tid);
205 g_main_loop_run(loop);
207 if(ret == ALARM_ERROR_NONE)
209 dts_pass("utc_alarm_cancel_positive", "passed");
213 dts_fail("utc_alarm_cancel_positive", "passed");
216 service_destory(service);
221 * @brief Negative test case of alarm_cancel()
223 static void utc_alarm_cancel_negative(void)
225 int ret = ALARM_ERROR_NONE;
227 ret = alarm_cancel(NULL);
228 if(ret == ALARM_ERROR_NONE)
230 dts_fail("utc_alarm_cancel_negative", "failed");
234 dts_pass("utc_alarm_cancel_negative", "passed");
240 * @brief Positive test case of alarm_cancel_all()
242 static void utc_alarm_cancel_all_positive(void)
244 int ret = ALARM_ERROR_NONE;
246 ret = alarm_cancel_all();
248 if(ret == ALARM_ERROR_NONE)
250 dts_pass("utc_alarm_cancel_all_positive", "passed");
254 dts_fail("utc_alarm_cancel_all_positive", "failed");
263 * @brief Positive test case of alarm_foreach_registered_alarm()
265 static void utc_alarm_foreach_registered_alarm_positive(void)
267 int ret = ALARM_ERROR_NONE;
269 struct tm current_tm;
274 loop = g_main_loop_new(NULL, FALSE);
275 g_timeout_add(1000,timeout , loop);
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);
282 ret = alarm_foreach_registered_alarm(foreach_alarm_cb,NULL);
284 g_main_loop_run(loop);
286 if(ret != ALARM_ERROR_NONE)
288 dts_fail("utc_alarm_foreach_registered_alarm_positive", "failed");
292 dts_pass("utc_alarm_foreach_registered_alarm_positive" , "passed");
295 service_destory(service);
302 * @brief Negative test case of alarm_foreach_registered_alarm()
304 static void utc_alarm_foreach_registered_alarm_negative(void)
306 int ret = ALARM_ERROR_NONE;
308 // do i need to call alarm_init??
309 ret = alarm_foreach_registered_alarm(NULL,NULL);
311 if(ret == ALARM_ERROR_NONE)
313 dts_fail("utc_alarm_foreach_registered_alarm_negative", "failed");
317 dts_pass("utc_alarm_foreach_registered_alarm_negative", "passed");
324 * @brief Positive test case of alarm_get_scheduled_date()
326 static void utc_alarm_get_scheduled_date_positive(void)
330 int ret = ALARM_ERROR_NONE;
334 loop = g_main_loop_new(NULL, FALSE);
335 g_timeout_add(5000,timeout , loop);
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);
342 ret = alarm_get_scheduled_date(tid, &date);
344 g_main_loop_run(loop);
346 if(ret == ALARM_ERROR_NONE)
348 dts_pass("utc_alarm_get_date_positive", "passed");
352 dts_fail("utc_alarm_get_date_positive", "failed");
355 service_destory(service);
360 * @brief Negative test case of alarm_get_scheduled_date()
362 static void utc_alarm_get_scheduled_date_negative(void)
365 int ret = ALARM_ERROR_NONE;
367 ret = alarm_get_scheduled_date(NULL, &date);
369 if(ret == ALARM_ERROR_NONE)
371 dts_fail("utc_alarm_get_scheduled_date_negative", "failed");
375 dts_pass("utc_alarm_get_scheduled_date_negative", "passed");
382 * @brief Positive test case of alarm_get_period()
384 static void utc_alarm_get_scheduled_period_positive(void)
387 struct tm current_tm;
389 int ret = ALARM_ERROR_NONE;
394 loop = g_main_loop_new(NULL, FALSE);
395 g_timeout_add(1000,timeout , loop);
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);
402 ret = alarm_get_scheduled_period(tid, &period);
404 g_main_loop_run(loop);
406 if(ret != ALARM_ERROR_NONE)
408 dts_fail("utc_alarm_get_scheduled_period_positive", "failed");
413 dts_pass("utc_alarm_get_scheduled_period_positive", "passed");
417 dts_fail("utc_alarm_get_scheduled_period_positive", "failed");
420 service_destory(service);
426 * @brief Negative test case of alarm_get_scheduled_period()
428 static void utc_alarm_get_scheduled_period_negative(void)
431 struct tm current_tm;
432 int ret = ALARM_ERROR_NONE;
437 ret = alarm_get_scheduled_period(NULL,&period);
439 if(ret == ALARM_ERROR_NONE)
441 dts_fail("utc_alarm_get_scheduled_period_negative", "failed");
445 dts_pass("utc_alarm_get_scheduled_period_negative", "passed");
453 * @brief Positive test case of alarm_schedule_at_date()
455 static void utc_alarm_schedule_at_date_positive(void)
464 int ret = ALARM_ERROR_NONE;
466 loop = g_main_loop_new(NULL, FALSE);
467 g_timeout_add(5000,timeout , loop);
470 localtime_r(&now, &date);
473 service_create(&service);
474 service_set_package(service, "com.samsung.memo");
475 service_set_operation(service, SERVICE_OPERATION_DEFAULT);
477 ret = alarm_schedule_at_date(service, &date, 2, &tid);
479 g_main_loop_run(loop);
481 if(ret == ALARM_ERROR_NONE)
483 dts_pass("utc_alarm_schedule_at_date_positive", "passed");
488 dts_fail("utc_alarm_schedule_at_date_positive", "failed");
491 service_destory(service);
498 * @brief Negative test case of alarm_schedule_at_date()
500 static void utc_alarm_schedule_at_date_negative(void)
503 struct tm current_tm;
504 int ret = ALARM_ERROR_NONE;
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);
512 if(ret == ALARM_ERROR_NONE)
514 dts_fail("utc_alarm_schedule_at_date_negative", "failed");
518 dts_pass("utc_alarm_schedule_at_date_negative", "passed");
521 service_destory(service);
527 * @brief Negative test case of alarm_schedule_at_date()
529 static void utc_alarm_schedule_with_recurrence_week_flag_positive(void)
538 int ret = ALARM_ERROR_NONE;
540 loop = g_main_loop_new(NULL, FALSE);
541 g_timeout_add(5000,timeout , loop);
544 localtime_r(&now, &date);
546 service_create(&service);
547 service_set_package(service, "com.samsung.memo");
548 service_set_operation(service, SERVICE_OPERATION_DEFAULT);
550 alarm_schedule_with_recurrence_week_flag(service, &date, ALARM_WEEK_FLAG_MONDAY, &tid);
552 g_main_loop_run(loop);
554 if(ret == ALARM_ERROR_NONE)
556 dts_pass("utc_alarm_schedule_with_recurrence_week_flag_positive", "passed");
560 dts_fail("utc_alarm_schedule_with_recurrence_week_flag_positive", "failed");
563 service_destory(service);
568 static void utc_alarm_schedule_with_recurrence_week_flag_negative(void)
575 int ret = ALARM_ERROR_NONE;
578 localtime_r(&now, &date);
581 ret = alarm_schedule_with_recurrence_week_flag(NULL, &date, ALARM_WEEK_FLAG_MONDAY, &tid);
583 if(ret == ALARM_ERROR_NONE)
585 dts_fail("utc_alarm_schedule_at_date_negative", "failed");
589 dts_pass("utc_alarm_schedule_at_date_negative", "passed");
598 * @brief Negative test case of alarm_schedule_at_date()
600 static void utc_alarm_get_scheduled_recurrence_week_flag_positive(void)
610 int ret = ALARM_ERROR_NONE;
613 localtime_r(&now, &date);
615 service_create(&service);
616 service_set_package(service, "com.samsung.memo");
617 service_set_operation(service, SERVICE_OPERATION_DEFAULT);
619 alarm_schedule_with_recurrence_week_flag(service, &date, ALARM_WEEK_FLAG_MONDAY, &tid);
621 alarm_get_scheduled_recurrence_week_flag(tid, &week_flag);
624 if(ret != ALARM_ERROR_NONE)
626 dts_fail("utc_alarm_get_scheduled_recurrence_week_flag_positive", "failed");
629 if(week_flag == ALARM_WEEK_FLAG_MONDAY)
631 dts_pass("utc_alarm_get_scheduled_recurrence_week_flag_positive", "passed");
635 dts_fail("utc_alarm_get_scheduled_recurrence_week_flag_positive", "failed");
637 service_destory(service);
642 static void utc_alarm_get_scheduled_recurrence_week_flag_negative(void)
649 int ret = ALARM_ERROR_NONE;
651 ret = alarm_get_scheduled_recurrence_week_flag(NULL ,NULL);
653 if(ret == ALARM_ERROR_NONE)
655 dts_fail("utc_alarm_get_scheduled_recurrence_week_flag_negative", "failed");
659 dts_pass("utc_alarm_get_scheduled_recurrence_week_flag_negative", "passed");
666 static void utc_alarm_get_current_time_positive(void)
669 int ret = ALARM_ERROR_NONE;
671 ret = alarm_get_current_time(&date);
672 if(ret == ALARM_ERROR_NONE)
674 dts_pass("utc_alarm_get_current_time_positive", "passed");
678 dts_fail("utc_alarm_get_current_time_positive", "failed");
682 static void utc_alarm_get_current_time_negative(void)
684 int ret = ALARM_ERROR_NONE;
686 ret = alarm_get_current_time(NULL);
687 if(ret == ALARM_ERROR_NONE)
689 dts_fail("utc_alarm_get_current_time_negative", "failed");
693 dts_pass("utc_alarm_get_current_time_negative", "passed");
697 static void utc_alarm_get_service_positive(void)
700 struct tm current_tm;
702 service_h service_return;
704 int ret = ALARM_ERROR_NONE;
709 loop = g_main_loop_new(NULL, FALSE);
710 g_timeout_add(1000,timeout , loop);
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);
717 ret = alarm_get_service(tid, &service_return);
719 g_main_loop_run(loop);
721 if(ret != ALARM_ERROR_NONE)
723 dts_fail("utc_alarm_get_service_positive", "failed");
726 ret = service_get_package(service_return, &package);
728 if(ret != SERVICE_ERROR_NONE)
730 dts_fail("utc_alarm_get_service_positive", "failed");
733 if(!strcmp(package, "com.samsung.memo"))
735 dts_pass("utc_alarm_get_service_positive", "passed");
739 dts_fail("utc_alarm_get_service_positive", "failed");
746 service_destory(service);
747 service_destory(service_return);
751 static void utc_alarm_get_service_negative(void)
753 int ret = ALARM_ERROR_NONE;
755 ret = alarm_get_service(NULL,NULL);
757 if(ret == ALARM_ERROR_NONE)
759 dts_fail("utc_alarm_get_service_negative", "failed");
763 dts_pass("utc_alarm_get_service_negative", "passed");