1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <chrono>
17 #include <climits>
18 #include <cstdlib>
19 #include <ctime>
20 #include <fstream>
21 #include <thread>
22 #include <unordered_set>
23
24 #include "accesstoken_kit.h"
25 #include "ipc_skeleton.h"
26 #include "nativetoken_kit.h"
27 #include "time_common.h"
28 #include "timer_info_test.h"
29 #include "token_setproc.h"
30 #include "want_agent.h"
31 #include "time_service_test.h"
32 #include "ntp_trusted_time.h"
33
34 #define private public
35 #include "time_system_ability.h"
36 #include "time_service_client.h"
37 #include "timer_database.h"
38
39 namespace {
40 using namespace testing::ext;
41 using namespace OHOS;
42 using namespace OHOS::MiscServices;
43 using namespace std::chrono;
44 using namespace OHOS::Security::AccessToken;
45
46 constexpr int ONE_HUNDRED = 100;
47 constexpr int FIVE_HUNDRED = 500;
48 constexpr uint64_t MICRO_TO_MILLISECOND = 1000;
49
50 static HapPolicyParams g_policyA = {
51 .apl = APL_SYSTEM_CORE,
52 .domain = "test.domain",
53 .permList = {
54 {
55 .permissionName = "ohos.permission.SET_TIME",
56 .bundleName = "ohos.permission_test.demoB",
57 .grantMode = 1,
58 .availableLevel = APL_NORMAL,
59 .label = "label",
60 .labelId = 1,
61 .description = "test",
62 .descriptionId = 1
63 },
64 {
65 .permissionName = "ohos.permission.SET_TIME_ZONE",
66 .bundleName = "ohos.permission_test.demoB",
67 .grantMode = 1,
68 .availableLevel = APL_NORMAL,
69 .label = "label",
70 .labelId = 1,
71 .description = "test",
72 .descriptionId = 1
73 }
74 },
75 .permStateList = {
76 {
77 .permissionName = "ohos.permission.SET_TIME",
78 .isGeneral = true,
79 .resDeviceID = { "local" },
80 .grantStatus = { PermissionState::PERMISSION_GRANTED },
81 .grantFlags = { 1 }
82 },
83 {
84 .permissionName = "ohos.permission.SET_TIME_ZONE",
85 .isGeneral = true,
86 .resDeviceID = { "local" },
87 .grantStatus = { PermissionState::PERMISSION_GRANTED },
88 .grantFlags = { 1 }
89 }
90 }
91 };
92
93 /* push_managere_service is in the exemption list of adjust timer */
94 /* use push_manager_service to prevent timers from being adjusted */
95 static HapInfoParams g_systemInfoParams = {
96 .userID = 1,
97 .bundleName = "push_manager_service",
98 .instIndex = 0,
99 .appIDDesc = "test",
100 .apiVersion = 8,
101 .isSystemApp = true
102 };
103
104 static HapPolicyParams g_policyB = { .apl = APL_NORMAL, .domain = "test.domain" };
105
106 static HapInfoParams g_notSystemInfoParams = {
107 .userID = 100,
108 .bundleName = "push_manager_service",
109 .instIndex = 0,
110 .appIDDesc = "test",
111 .apiVersion = 9,
112 .isSystemApp = false
113 };
114
115 class TimeClientTest : public testing::Test {
116 public:
117 static void SetUpTestCase(void);
118 static void TearDownTestCase(void);
119 void SetUp();
120 void TearDown();
121 static void AddPermission();
122 void DeletePermission();
123 };
124
AddPermission()125 void TimeClientTest::AddPermission()
126 {
127 AccessTokenIDEx tokenIdEx = { 0 };
128 tokenIdEx = AccessTokenKit::AllocHapToken(g_systemInfoParams, g_policyA);
129 SetSelfTokenID(tokenIdEx.tokenIDEx);
130 }
131
DeletePermission()132 void TimeClientTest::DeletePermission()
133 {
134 AccessTokenIDEx tokenIdEx = { 0 };
135 tokenIdEx = AccessTokenKit::AllocHapToken(g_notSystemInfoParams, g_policyB);
136 SetSelfTokenID(tokenIdEx.tokenIDEx);
137 }
138
SetUpTestCase(void)139 void TimeClientTest::SetUpTestCase(void)
140 {
141 }
142
TearDownTestCase(void)143 void TimeClientTest::TearDownTestCase(void)
144 {
145 }
146
SetUp(void)147 void TimeClientTest::SetUp(void)
148 {
149 AddPermission();
150 }
151
TearDown(void)152 void TimeClientTest::TearDown(void)
153 {
154 }
155
TestNtpThread(const char * name)156 void TestNtpThread(const char *name)
157 {
158 int64_t time;
159 auto errCode = TimeServiceClient::GetInstance()->GetNtpTimeMs(time);
160 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
161 }
162
163 /**
164 * @brief Wait for timer trigger
165 * @param data the global variable that callback function changes
166 * @param interval the time need to wait
167 */
WaitForAlarm(std::atomic<int> * data,int interval)168 void WaitForAlarm(std::atomic<int> * data, int interval)
169 {
170 int i = 0;
171 if (interval > 0) {
172 usleep(interval);
173 }
174 while (*data == 0 && i < ONE_HUNDRED) {
175 ++i;
176 usleep(ONE_HUNDRED);
177 }
178 }
179
180 /**
181 * @tc.name: GetNtpTimeMs001
182 * @tc.desc: get ntp time.
183 * @tc.type: FUNC
184 */
185 HWTEST_F(TimeClientTest, GetNtpTimeMs001, TestSize.Level1)
186 {
187 int64_t time;
188 auto errCode = TimeServiceClient::GetInstance()->GetNtpTimeMs(time);
189 TIME_HILOGI(TIME_MODULE_CLIENT, "time now : %{public}" PRId64 "", time);
190 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
191 }
192
193 /**
194 * @tc.name: GetNtpTimeMs002
195 * @tc.desc: get ntp time.
196 * @tc.type: FUNC
197 */
198 HWTEST_F(TimeClientTest, GetNtpTimeMs002, TestSize.Level1)
199 {
200 std::thread thread1(TestNtpThread, "thread1");
201 std::thread thread2(TestNtpThread, "thread2");
202 std::thread thread3(TestNtpThread, "thread3");
203 std::thread thread4(TestNtpThread, "thread4");
204 thread1.join();
205 thread2.join();
206 thread3.join();
207 thread4.join();
208 }
209
210 /**
211 * @tc.name: SetTime001
212 * @tc.desc: set system time.
213 * @tc.type: FUNC
214 */
215 HWTEST_F(TimeClientTest, SetTime001, TestSize.Level1)
216 {
217 struct timeval currentTime {};
218 gettimeofday(¤tTime, nullptr);
219 int64_t time = (currentTime.tv_sec + 1000) * 1000 + currentTime.tv_usec / 1000;
220 ASSERT_GT(time, 0);
221 TIME_HILOGI(TIME_MODULE_CLIENT, "Time now : %{public}" PRId64 "", time);
222 int32_t result = TimeServiceClient::GetInstance()->SetTimeV9(time);
223 EXPECT_EQ(result, TimeError::E_TIME_OK);
224 }
225
226 /**
227 * @tc.name: SetTime002
228 * @tc.desc: set system time.
229 * @tc.type: FUNC
230 */
231 HWTEST_F(TimeClientTest, SetTime002, TestSize.Level1)
232 {
233 int32_t result = TimeServiceClient::GetInstance()->SetTimeV9(-1);
234 EXPECT_NE(result, TimeError::E_TIME_OK);
235 }
236
237 /**
238 * @tc.name: SetTime003
239 * @tc.desc: set system time.
240 * @tc.type: FUNC
241 */
242 HWTEST_F(TimeClientTest, SetTime003, TestSize.Level1)
243 {
244 int32_t result = TimeServiceClient::GetInstance()->SetTimeV9(LLONG_MAX);
245 EXPECT_NE(result, TimeError::E_TIME_OK);
246 }
247
248 /**
249 * @tc.name: SetTime004
250 * @tc.desc: set system time.
251 * @tc.type: FUNC
252 */
253 HWTEST_F(TimeClientTest, SetTime004, TestSize.Level1)
254 {
255 DeletePermission();
256 struct timeval currentTime {};
257 gettimeofday(¤tTime, nullptr);
258 int64_t time = (currentTime.tv_sec + 1000) * 1000 + currentTime.tv_usec / 1000;
259 ASSERT_GT(time, 0);
260 int32_t result = TimeServiceClient::GetInstance()->SetTimeV9(time);
261 EXPECT_NE(result, TimeError::E_TIME_OK);
262 int32_t code;
263 bool ret = TimeServiceClient::GetInstance()->SetTime(time, code);
264 EXPECT_EQ(ret, false);
265 EXPECT_NE(code, TimeError::E_TIME_OK);
266 }
267
268 /**
269 * @tc.name: SetTimeZone001
270 * @tc.desc: set system time zone.
271 * @tc.type: FUNC
272 */
273 HWTEST_F(TimeClientTest, SetTimeZone001, TestSize.Level1)
274 {
275 time_t t;
276 (void)time(&t);
277 TIME_HILOGI(TIME_MODULE_CLIENT, "Time before: %{public}s", asctime(localtime(&t)));
278 auto getCurrentTimeZone = TimeServiceClient::GetInstance()->GetTimeZone();
279 EXPECT_FALSE(getCurrentTimeZone.empty());
280 std::string timeZoneNicosia("Asia/Nicosia");
281 int32_t result = TimeServiceClient::GetInstance()->SetTimeZoneV9(timeZoneNicosia);
282 EXPECT_EQ(result, TimeError::E_TIME_OK);
283 std::string getTimeZoneNicosia;
284 int32_t getTimeZoneResult = TimeServiceClient::GetInstance()->GetTimeZone(getTimeZoneNicosia);
285 EXPECT_EQ(getTimeZoneResult, TimeError::E_TIME_OK);;
286 EXPECT_EQ(timeZoneNicosia, getTimeZoneNicosia);
287 int32_t ret = TimeServiceClient::GetInstance()->SetTimeZoneV9(getCurrentTimeZone);
288 EXPECT_EQ(ret, TimeError::E_TIME_OK);
289 }
290
291 /**
292 * @tc.name: SetTimeZone002
293 * @tc.desc: set system time zone.
294 * @tc.type: FUNC
295 */
296 HWTEST_F(TimeClientTest, SetTimeZone002, TestSize.Level1)
297 {
298 int32_t result = TimeServiceClient::GetInstance()->SetTimeZoneV9("123");
299 EXPECT_NE(result, TimeError::E_TIME_OK);
300 }
301
302 /**
303 * @tc.name: SetTimeZone003
304 * @tc.desc: set system time zone.
305 * @tc.type: FUNC
306 */
307 HWTEST_F(TimeClientTest, SetTimeZone003, TestSize.Level1)
308 {
309 DeletePermission();
310 int32_t result = TimeServiceClient::GetInstance()->SetTimeZoneV9("Asia/Shanghai");
311 EXPECT_NE(result, TimeError::E_TIME_OK);
312 bool ret = TimeServiceClient::GetInstance()->SetTimeZone("Asia/Shanghai");
313 EXPECT_FALSE(ret);
314 }
315
316 /**
317 * @tc.name: GetWallTimeMs001
318 * @tc.desc: get wall time (ms).
319 * @tc.type: FUNC
320 */
321 HWTEST_F(TimeClientTest, GetWallTimeMs001, TestSize.Level1)
322 {
323 int64_t time;
324 auto errCode = TimeServiceClient::GetInstance()->GetWallTimeMs(time);
325 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
326 }
327
328 /**
329 * @tc.name: GetWallTimeNs001
330 * @tc.desc: get wall time (ns).
331 * @tc.type: FUNC
332 */
333 HWTEST_F(TimeClientTest, GetWallTimeNs001, TestSize.Level1)
334 {
335 int64_t time;
336 auto errCode = TimeServiceClient::GetInstance()->GetWallTimeNs(time);
337 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
338 }
339
340 /**
341 * @tc.name: GetBootTimeNs001
342 * @tc.desc: get boot time (ns).
343 * @tc.type: FUNC
344 */
345 HWTEST_F(TimeClientTest, GetBootTimeNs001, TestSize.Level1)
346 {
347 int64_t time;
348 auto errCode = TimeServiceClient::GetInstance()->GetBootTimeNs(time);
349 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
350 }
351
352 /**
353 * @tc.name: GetBootTimeMs001
354 * @tc.desc: get boot time (ms).
355 * @tc.type: FUNC
356 */
357 HWTEST_F(TimeClientTest, GetBootTimeMs001, TestSize.Level1)
358 {
359 int64_t time;
360 auto errCode = TimeServiceClient::GetInstance()->GetBootTimeMs(time);
361 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
362 }
363
364 /**
365 * @tc.name: GetMonotonicTimeMs001
366 * @tc.desc: get monotonic time (ms).
367 * @tc.type: FUNC
368 */
369 HWTEST_F(TimeClientTest, GetMonotonicTimeMs001, TestSize.Level1)
370 {
371 int64_t time;
372 auto errCode = TimeServiceClient::GetInstance()->GetMonotonicTimeMs(time);
373 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
374 }
375
376 /**
377 * @tc.name: GetMonotonicTimeNs001
378 * @tc.desc: get monotonic time (ns).
379 * @tc.type: FUNC
380 */
381 HWTEST_F(TimeClientTest, GetMonotonicTimeNs001, TestSize.Level1)
382 {
383 int64_t time;
384 auto errCode = TimeServiceClient::GetInstance()->GetMonotonicTimeNs(time);
385 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
386 }
387
388 /**
389 * @tc.name: GetThreadTimeMs001
390 * @tc.desc: get thread time (ms).
391 * @tc.type: FUNC
392 */
393 HWTEST_F(TimeClientTest, GetThreadTimeMs001, TestSize.Level1)
394 {
395 int64_t time;
396 auto errCode = TimeServiceClient::GetInstance()->GetThreadTimeMs(time);
397 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
398 }
399
400 /**
401 * @tc.name: GetThreadTimeNs001
402 * @tc.desc: get thread time (ns).
403 * @tc.type: FUNC
404 */
405 HWTEST_F(TimeClientTest, GetThreadTimeNs001, TestSize.Level1)
406 {
407 int64_t time;
408 auto errCode = TimeServiceClient::GetInstance()->GetThreadTimeNs(time);
409 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
410 }
411
412 /**
413 * @tc.name: CreateTimer001
414 * @tc.desc: Create system timer.
415 * @tc.type: FUNC
416 */
417 HWTEST_F(TimeClientTest, CreateTimer001, TestSize.Level1)
418 {
419 uint64_t timerId = 0;
420 auto ret = TimeServiceClient::GetInstance()->StartTimerV9(timerId, 5);
421 EXPECT_NE(ret, TimeError::E_TIME_OK);
422 ret = TimeServiceClient::GetInstance()->StopTimerV9(timerId);
423 EXPECT_NE(ret, TimeError::E_TIME_OK);
424 ret = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
425 EXPECT_NE(ret, TimeError::E_TIME_OK);
426 }
427
428 /**
429 * @tc.name: CreateTimer002
430 * @tc.desc: Create system timer.
431 * @tc.type: FUNC
432 */
433 HWTEST_F(TimeClientTest, CreateTimer002, TestSize.Level1)
434 {
435 auto timerInfo = std::make_shared<TimerInfoTest>();
436 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
437 timerInfo->SetRepeat(false);
438 timerInfo->SetInterval(0);
439 timerInfo->SetWantAgent(nullptr);
440 timerInfo->SetCallbackInfo(TimeOutCallback1);
441 uint64_t timerId;
442 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
443 TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
444 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
445 auto ret = TimeServiceClient::GetInstance()->StartTimerV9(timerId, 2000);
446 EXPECT_EQ(ret, TimeError::E_TIME_OK);
447 ret = TimeServiceClient::GetInstance()->StopTimerV9(timerId);
448 EXPECT_EQ(ret, TimeError::E_TIME_OK);
449 ret = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
450 EXPECT_EQ(ret, TimeError::E_TIME_OK);
451 }
452
453 /**
454 * @tc.name: CreateTimer003
455 * @tc.desc: Create system timer.
456 * @tc.type: FUNC
457 */
458 HWTEST_F(TimeClientTest, CreateTimer003, TestSize.Level1)
459 {
460 auto timerInfo = std::make_shared<TimerInfoTest>();
461 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
462 timerInfo->SetRepeat(false);
463 timerInfo->SetInterval(0);
464 auto ability = std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent>();
465 timerInfo->SetWantAgent(ability);
466 timerInfo->SetCallbackInfo(TimeOutCallback1);
467 uint64_t timerId;
468 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
469 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
470 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
471 }
472
473 /**
474 * @tc.name: CreateTimer004
475 * @tc.desc: Create system timer.
476 * @tc.type: FUNC
477 */
478 HWTEST_F(TimeClientTest, CreateTimer004, TestSize.Level1)
479 {
480 g_data1 = 0;
481 auto timerInfo = std::make_shared<TimerInfoTest>();
482 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
483 timerInfo->SetRepeat(false);
484 timerInfo->SetInterval(0);
485 timerInfo->SetWantAgent(nullptr);
486 timerInfo->SetCallbackInfo(TimeOutCallback1);
487 uint64_t timerId;
488 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
489 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
490 auto bootTimeNano = system_clock::now().time_since_epoch().count();
491 auto bootTimeMilli = bootTimeNano / NANO_TO_MILESECOND;
492 errCode = TimeServiceClient::GetInstance()->StartTimerV9(timerId, bootTimeMilli + 2000);
493 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
494 errCode = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
495 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
496 EXPECT_EQ(g_data1, 0);
497 errCode = TimeServiceClient::GetInstance()->StopTimerV9(timerId);
498 EXPECT_NE(errCode, TimeError::E_TIME_OK);
499 }
500
501 /**
502 * @tc.name: CreateTimer005
503 * @tc.desc: Create system timer.
504 * @tc.type: FUNC
505 */
506 HWTEST_F(TimeClientTest, CreateTimer005, TestSize.Level1)
507 {
508 g_data1 = 1;
509 auto timerInfo = std::make_shared<TimerInfoTest>();
510 timerInfo->SetType(0);
511 timerInfo->SetRepeat(false);
512 timerInfo->SetInterval(0);
513 timerInfo->SetWantAgent(nullptr);
514 timerInfo->SetCallbackInfo(TimeOutCallback1);
515
516 struct timeval timeOfDay {};
517 gettimeofday(&timeOfDay, NULL);
518 int64_t currentTime = (timeOfDay.tv_sec + 100) * 1000 + timeOfDay.tv_usec / 1000;
519 if (currentTime < 0) {
520 currentTime = 0;
521 }
522 uint64_t timerId;
523 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
524 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
525
526 errCode = TimeServiceClient::GetInstance()->StartTimerV9(timerId, static_cast<uint64_t>(currentTime));
527 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
528 errCode = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
529 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
530 EXPECT_EQ(g_data1, 1);
531 errCode = TimeServiceClient::GetInstance()->StopTimerV9(timerId);
532 EXPECT_NE(errCode, TimeError::E_TIME_OK);
533 }
534
535 /**
536 * @tc.name: CreateTimer006
537 * @tc.desc: Create system timer.
538 * @tc.type: FUNC
539 */
540 HWTEST_F(TimeClientTest, CreateTimer006, TestSize.Level1)
541 {
542 uint64_t timerId;
543 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(nullptr, timerId);
544 EXPECT_NE(errCode, TimeError::E_TIME_OK);
545 EXPECT_EQ(timerId, 0);
546 }
547
548 /**
549 * @tc.name: CreateTimer007
550 * @tc.desc: Create system timer.
551 * @tc.type: FUNC
552 */
553 HWTEST_F(TimeClientTest, CreateTimer007, TestSize.Level1)
554 {
555 DeletePermission();
556 auto timerInfo = std::make_shared<TimerInfoTest>();
557 timerInfo->SetType(0);
558 timerInfo->SetRepeat(false);
559 timerInfo->SetCallbackInfo(TimeOutCallback1);
560
561 struct timeval timeOfDay {};
562 gettimeofday(&timeOfDay, nullptr);
563 int64_t currentTime = (timeOfDay.tv_sec + 100) * 1000 + timeOfDay.tv_usec / 1000;
564 if (currentTime < 0) {
565 currentTime = 0;
566 }
567 uint64_t timerId = TimeServiceClient::GetInstance()->CreateTimer(timerInfo);
568 EXPECT_EQ(timerId, 0);
569 auto codeCreateTimer = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
570 EXPECT_NE(codeCreateTimer, TimeError::E_TIME_OK);
571 auto codeStartTimer = TimeServiceClient::GetInstance()->StartTimerV9(timerId, currentTime + 1000);
572 EXPECT_NE(codeStartTimer, TimeError::E_TIME_OK);
573 auto codeStopTimer = TimeServiceClient::GetInstance()->StopTimerV9(timerId);
574 EXPECT_NE(codeStopTimer, TimeError::E_TIME_OK);
575 auto codeDestroyTimer = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
576 EXPECT_NE(codeDestroyTimer, TimeError::E_TIME_OK);
577 }
578
579 /**
580 * @tc.name: StartTimer001
581 * @tc.desc: Start system timer.
582 * @tc.type: FUNC
583 */
584 HWTEST_F(TimeClientTest, StartTimer001, TestSize.Level1)
585 {
586 g_data1 = 0;
587 uint64_t timerId;
588 auto timerInfo = std::make_shared<TimerInfoTest>();
589 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
590 timerInfo->SetRepeat(false);
591 timerInfo->SetCallbackInfo(TimeOutCallback1);
592 auto wantAgent = std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent>();
593 timerInfo->SetWantAgent(wantAgent);
594 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
595 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
596 EXPECT_NE(timerId, 0);
597 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
598 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
599 WaitForAlarm(&g_data1, FIVE_HUNDRED * MICRO_TO_MILLISECOND);
600 EXPECT_EQ(g_data1, 1);
601 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
602 }
603
604 /**
605 * @tc.name: StartTimer002
606 * @tc.desc: Start system timer.
607 * @tc.type: FUNC
608 */
609 HWTEST_F(TimeClientTest, StartTimer002, TestSize.Level1)
610 {
611 uint64_t timerId;
612 auto timerInfo = std::make_shared<TimerInfoTest>();
613 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
614 timerInfo->SetRepeat(false);
615 auto wantAgent = std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent>();
616 timerInfo->SetWantAgent(wantAgent);
617 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
618 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
619 EXPECT_NE(timerId, 0);
620 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
621 auto result = TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + 1000);
622 EXPECT_EQ(result, TimeError::E_TIME_OK);
623 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
624 }
625
626 /**
627 * @tc.name: StartTimer003
628 * @tc.desc: Start system timer.
629 * @tc.type: FUNC
630 */
631 HWTEST_F(TimeClientTest, StartTimer003, TestSize.Level1)
632 {
633 g_data1 = 0;
634 uint64_t timerId;
635 auto timerInfo = std::make_shared<TimerInfoTest>();
636 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT | timerInfo->TIMER_TYPE_WAKEUP);
637 timerInfo->SetRepeat(true);
638 timerInfo->SetInterval(1000);
639 timerInfo->SetCallbackInfo(TimeOutCallback1);
640 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
641 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
642 EXPECT_NE(timerId, 0);
643 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
644 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
645 sleep(2);
646 EXPECT_GT(g_data1, 1);
647 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
648 }
649
650 /**
651 * @tc.name: StartTimer004
652 * @tc.desc: Start system timer.
653 * @tc.type: FUNC
654 */
655 HWTEST_F(TimeClientTest, StartTimer004, TestSize.Level1)
656 {
657 g_data1 = 0;
658 uint64_t timerId;
659 auto timerInfo = std::make_shared<TimerInfoTest>();
660 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
661 timerInfo->SetRepeat(true);
662 timerInfo->SetInterval(1000);
663 timerInfo->SetCallbackInfo(TimeOutCallback1);
664 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
665 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
666 EXPECT_NE(timerId, 0);
667 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
668 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
669 sleep(2);
670 EXPECT_GT(g_data1, 1);
671 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
672 }
673
674 /**
675 * @tc.name: StartTimer005
676 * @tc.desc: Start system timer.
677 * @tc.type: FUNC
678 */
679 HWTEST_F(TimeClientTest, StartTimer005, TestSize.Level1)
680 {
681 g_data1 = 0;
682 uint64_t timerId;
683 auto timerInfo = std::make_shared<TimerInfoTest>();
684 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
685 timerInfo->SetRepeat(false);
686 timerInfo->SetCallbackInfo(TimeOutCallback1);
687 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
688 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
689 EXPECT_NE(timerId, 0);
690 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
691 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
692 pid_t uid = IPCSkeleton::GetCallingUid();
693 TimeServiceClient::GetInstance()->ProxyTimer(uid, true, true);
694 usleep(FIVE_HUNDRED * MICRO_TO_MILLISECOND);
695 TimeServiceClient::GetInstance()->ProxyTimer(uid, false, true);
696 WaitForAlarm(&g_data1, 0);
697 EXPECT_EQ(g_data1, 1);
698 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
699 }
700
701 /**
702 * @tc.name: StartTimer006
703 * @tc.desc: Start system timer.
704 * @tc.type: FUNC
705 */
706 HWTEST_F(TimeClientTest, StartTimer006, TestSize.Level1)
707 {
708 g_data1 = 0;
709 uint64_t timerId;
710 auto timerInfo = std::make_shared<TimerInfoTest>();
711 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
712 timerInfo->SetRepeat(false);
713 timerInfo->SetCallbackInfo(TimeOutCallback1);
714 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
715 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
716 EXPECT_NE(timerId, 0);
717 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
718 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
719 pid_t uid = IPCSkeleton::GetCallingUid();
720 TimeServiceClient::GetInstance()->ProxyTimer(uid, true, true);
721 usleep(FIVE_HUNDRED * MICRO_TO_MILLISECOND);
722 TimeServiceClient::GetInstance()->ResetAllProxy();
723 WaitForAlarm(&g_data1, 0);
724 EXPECT_EQ(g_data1, 1);
725 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
726 }
727
728 /**
729 * @tc.name: StartTimer007
730 * @tc.desc: Start system timer.
731 * @tc.type: FUNC
732 */
733 HWTEST_F(TimeClientTest, StartTimer007, TestSize.Level1)
734 {
735 g_data1 = 0;
736 uint64_t timerId;
737 auto timerInfo = std::make_shared<TimerInfoTest>();
738 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
739 timerInfo->SetRepeat(false);
740 timerInfo->SetCallbackInfo(TimeOutCallback1);
741 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
742 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
743 EXPECT_NE(timerId, 0);
744 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
745 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
746 pid_t uid = IPCSkeleton::GetCallingUid();
747 TimeServiceClient::GetInstance()->ProxyTimer(uid, true, true);
748 sleep(1);
749 TimeServiceClient::GetInstance()->ResetAllProxy();
750 WaitForAlarm(&g_data1, 0);
751 EXPECT_EQ(g_data1, 1);
752 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
753 }
754
755 /**
756 * @tc.name: StartTimer008
757 * @tc.desc: Start system timer.
758 * @tc.type: FUNC
759 */
760 HWTEST_F(TimeClientTest, StartTimer008, TestSize.Level1)
761 {
762 g_data1 = 0;
763 g_data2 = 0;
764 uint64_t timerId1;
765 auto timerInfo1 = std::make_shared<TimerInfoTest>();
766 timerInfo1->SetType(timerInfo1->TIMER_TYPE_EXACT);
767 timerInfo1->SetRepeat(false);
768 timerInfo1->SetCallbackInfo(TimeOutCallback1);
769 auto errCode1 = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo1, timerId1);
770 EXPECT_EQ(errCode1, TimeError::E_TIME_OK);
771 EXPECT_NE(timerId1, 0);
772 auto triggerTime1 = TimeServiceClient::GetInstance()->GetWallTimeMs();
773 TimeServiceClient::GetInstance()->StartTimerV9(timerId1, triggerTime1 + FIVE_HUNDRED);
774 pid_t uid1 = IPCSkeleton::GetCallingUid();
775 TimeServiceClient::GetInstance()->ProxyTimer(uid1, true, true);
776
777 uint64_t timerId2;
778 auto timerInfo2 = std::make_shared<TimerInfoTest>();
779 timerInfo2->SetType(timerInfo2->TIMER_TYPE_EXACT);
780 timerInfo2->SetRepeat(false);
781 timerInfo2->SetCallbackInfo(TimeOutCallback2);
782 auto errCode2 = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo2, timerId2);
783 EXPECT_EQ(errCode2, TimeError::E_TIME_OK);
784 EXPECT_NE(timerId1, 0);
785 auto triggerTime2 = TimeServiceClient::GetInstance()->GetWallTimeMs();
786 TimeServiceClient::GetInstance()->StartTimerV9(timerId2, triggerTime2 + FIVE_HUNDRED);
787 pid_t uid2 = IPCSkeleton::GetCallingUid();
788 TimeServiceClient::GetInstance()->ProxyTimer(uid2, true, true);
789 sleep(1);
790 TimeServiceClient::GetInstance()->ResetAllProxy();
791 WaitForAlarm(&g_data1, 0);
792 WaitForAlarm(&g_data2, 0);
793 EXPECT_EQ(g_data1, 1);
794 EXPECT_EQ(g_data2, 1);
795 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId1);
796 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId2);
797 }
798
799 /**
800 * @tc.name: StartTimer009
801 * @tc.desc: Start a system time, then use the pid of this timer to start a proxy.
802 Cancel the proxy by this pid.
803 * @tc.type: FUNC
804 */
805 HWTEST_F(TimeClientTest, StartTimer009, TestSize.Level1)
806 {
807 g_data1 = 0;
808 uint64_t timerId;
809 auto timerInfo = std::make_shared<TimerInfoTest>();
810 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
811 timerInfo->SetRepeat(false);
812 timerInfo->SetCallbackInfo(TimeOutCallback1);
813 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
814 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
815 EXPECT_NE(timerId, 0);
816 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
817 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
818 pid_t pid = IPCSkeleton::GetCallingPid();
819 pid_t uid = IPCSkeleton::GetCallingUid();
820 std::set<int> pidList;
821 pidList.insert(pid);
822 TimeServiceClient::GetInstance()->ProxyTimer(uid, pidList, true, true);
823 usleep(FIVE_HUNDRED * MICRO_TO_MILLISECOND);
824 TimeServiceClient::GetInstance()->ProxyTimer(uid, pidList, false, true);
825 WaitForAlarm(&g_data1, 0);
826 EXPECT_EQ(g_data1, 1);
827 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
828 }
829
830 /**
831 * @tc.name: StartTimer010
832 * @tc.desc: Start system timer, then use the pid of this timer to start a proxy.
833 Cancel all the proxy.
834 * @tc.type: FUNC
835 */
836 HWTEST_F(TimeClientTest, StartTimer010, TestSize.Level1)
837 {
838 g_data1 = 0;
839 uint64_t timerId;
840 auto timerInfo = std::make_shared<TimerInfoTest>();
841 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
842 timerInfo->SetRepeat(false);
843 timerInfo->SetCallbackInfo(TimeOutCallback1);
844 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
845 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
846 EXPECT_NE(timerId, 0);
847 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
848 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
849 pid_t uid = IPCSkeleton::GetCallingUid();
850 pid_t pid = IPCSkeleton::GetCallingPid();
851 std::set<int> pidList;
852 pidList.insert(pid);
853 TimeServiceClient::GetInstance()->ProxyTimer(uid, pidList, true, true);
854 usleep(FIVE_HUNDRED * MICRO_TO_MILLISECOND);
855 TimeServiceClient::GetInstance()->ResetAllProxy();
856 WaitForAlarm(&g_data1, 0);
857 EXPECT_EQ(g_data1, 1);
858 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
859 }
860
861 /**
862 * @tc.name: StartTimer011
863 * @tc.desc: Start system timer, then use the pid of this timer to start a proxy.
864 Cancel all the proxy.
865 * @tc.type: FUNC
866 */
867 HWTEST_F(TimeClientTest, StartTimer011, TestSize.Level1)
868 {
869 g_data1 = 0;
870 uint64_t timerId;
871 auto timerInfo = std::make_shared<TimerInfoTest>();
872 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
873 timerInfo->SetRepeat(false);
874 timerInfo->SetCallbackInfo(TimeOutCallback1);
875 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
876 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
877 EXPECT_NE(timerId, 0);
878 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
879 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
880 pid_t uid = IPCSkeleton::GetCallingUid();
881 pid_t pid = IPCSkeleton::GetCallingPid();
882 std::set<int> pidList;
883 pidList.insert(pid);
884 TimeServiceClient::GetInstance()->ProxyTimer(uid, pidList, true, true);
885 sleep(1);
886 TimeServiceClient::GetInstance()->ResetAllProxy();
887 WaitForAlarm(&g_data1, 0);
888 EXPECT_EQ(g_data1, 1);
889 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
890 }
891
892 /**
893 * @tc.name: StartTimer012
894 * @tc.desc: Start two system timers, record two pids, then start a proxy by two pids.
895 Cancel all the proxy.
896 * @tc.type: FUNC
897 */
898 HWTEST_F(TimeClientTest, StartTimer012, TestSize.Level1)
899 {
900 g_data1 = 0;
901 g_data2 = 0;
902 uint64_t timerId1;
903 auto timerInfo1 = std::make_shared<TimerInfoTest>();
904 timerInfo1->SetType(timerInfo1->TIMER_TYPE_EXACT);
905 timerInfo1->SetRepeat(false);
906 timerInfo1->SetCallbackInfo(TimeOutCallback1);
907 auto errCode1 = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo1, timerId1);
908 EXPECT_EQ(errCode1, TimeError::E_TIME_OK);
909 EXPECT_NE(timerId1, 0);
910 auto triggerTime1 = TimeServiceClient::GetInstance()->GetWallTimeMs();
911 TimeServiceClient::GetInstance()->StartTimerV9(timerId1, triggerTime1 + FIVE_HUNDRED);
912 pid_t pid1 = IPCSkeleton::GetCallingPid();
913
914 uint64_t timerId2;
915 auto timerInfo2 = std::make_shared<TimerInfoTest>();
916 timerInfo2->SetType(timerInfo2->TIMER_TYPE_EXACT);
917 timerInfo2->SetRepeat(false);
918 timerInfo2->SetCallbackInfo(TimeOutCallback2);
919 auto errCode2 = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo2, timerId2);
920 EXPECT_EQ(errCode2, TimeError::E_TIME_OK);
921 EXPECT_NE(timerId2, 0);
922 auto triggerTime2 = TimeServiceClient::GetInstance()->GetWallTimeMs();
923 TimeServiceClient::GetInstance()->StartTimerV9(timerId2, triggerTime2 + FIVE_HUNDRED);
924 pid_t pid2 = IPCSkeleton::GetCallingUid();
925 pid_t uid = IPCSkeleton::GetCallingUid();
926
927 std::set<int> pidList;
928 pidList.insert(pid1);
929 pidList.insert(pid2);
930 TimeServiceClient::GetInstance()->ProxyTimer(uid, pidList, true, true);
931
932 sleep(1);
933 TimeServiceClient::GetInstance()->ResetAllProxy();
934 WaitForAlarm(&g_data1, 0);
935 WaitForAlarm(&g_data2, 0);
936 EXPECT_EQ(g_data1, 1);
937 EXPECT_EQ(g_data2, 1);
938 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId1);
939 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId2);
940 }
941
942 /**
943 * @tc.name: StartTimer013
944 * @tc.desc: Start a timer which is disposable. It will be destroyed by time service.
945 * @tc.type: FUNC
946 */
947 HWTEST_F(TimeClientTest, StartTimer013, TestSize.Level1)
948 {
949 TIME_HILOGI(TIME_MODULE_CLIENT, "StartTimer013 start");
950 g_data1 = 0;
951 g_data2 = 0;
952 uint64_t timerId;
953 auto timerInfo = std::make_shared<TimerInfoTest>();
954 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
955 timerInfo->SetRepeat(false);
956 timerInfo->SetDisposable(true);
957 timerInfo->SetCallbackInfo(TimeOutCallback1);
958 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
959 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
960 EXPECT_NE(timerId, 0);
961 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
962 errCode = TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
963 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
964 sleep(1);
965 errCode = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
966 EXPECT_NE(errCode, TimeError::E_TIME_OK);
967 }
968
969 /**
970 * @tc.name: StartTimer014
971 * @tc.desc: Start a repeat timer which is disposable. It will not be destroyed by time service.
972 * @tc.type: FUNC
973 */
974 HWTEST_F(TimeClientTest, StartTimer014, TestSize.Level1)
975 {
976 TIME_HILOGI(TIME_MODULE_CLIENT, "StartTimer014 start");
977 g_data1 = 0;
978 g_data2 = 0;
979 uint64_t timerId;
980 auto timerInfo = std::make_shared<TimerInfoTest>();
981 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
982 timerInfo->SetRepeat(true);
983 timerInfo->SetInterval(1000);
984 timerInfo->SetDisposable(true);
985 timerInfo->SetCallbackInfo(TimeOutCallback1);
986 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
987 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
988 EXPECT_NE(timerId, 0);
989 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
990 errCode = TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
991 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
992 sleep(1);
993 errCode = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
994 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
995 }
996
997 /**
998 * @tc.name: RecoverTimer001
999 * @tc.desc: Create system timer, check whether the corresponding data is recorded when the timer is created.
1000 * @tc.type: FUNC
1001 */
1002 HWTEST_F(TimeClientTest, RecoverTimer001, TestSize.Level1)
1003 {
1004 auto timerInfo = std::make_shared<TimerInfoTest>();
1005 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
1006 timerInfo->SetRepeat(false);
1007 timerInfo->SetInterval(0);
1008 timerInfo->SetWantAgent(nullptr);
1009 timerInfo->SetCallbackInfo(TimeOutCallback1);
1010 uint64_t timerId;
1011 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1012 TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
1013 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1014 {
1015 std::lock_guard<std::mutex> lock(TimeServiceClient::GetInstance()->recoverTimerInfoLock_);
1016 auto info = TimeServiceClient::GetInstance()->recoverTimerInfoMap_.find(timerId);
1017 EXPECT_NE(info, TimeServiceClient::GetInstance()->recoverTimerInfoMap_.end());
1018 EXPECT_NE(info->second->timerInfo, nullptr);
1019 EXPECT_EQ(info->second->state, 0);
1020 EXPECT_EQ(info->second->triggerTime, 0);
1021 }
1022 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1023 }
1024
1025 /**
1026 * @tc.name: RecoverTimer002
1027 * @tc.desc: Create system timer, then start it,
1028 * check whether the corresponding data is recorded when the timer is started.
1029 * @tc.type: FUNC
1030 */
1031 HWTEST_F(TimeClientTest, RecoverTimer002, TestSize.Level1)
1032 {
1033 auto timerInfo = std::make_shared<TimerInfoTest>();
1034 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
1035 timerInfo->SetRepeat(false);
1036 timerInfo->SetInterval(0);
1037 timerInfo->SetWantAgent(nullptr);
1038 timerInfo->SetCallbackInfo(TimeOutCallback1);
1039 uint64_t timerId;
1040 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1041 TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
1042 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1043 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
1044 auto startRet = TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime);
1045 EXPECT_EQ(startRet, TimeError::E_TIME_OK);
1046 {
1047 std::lock_guard<std::mutex> lock(TimeServiceClient::GetInstance()->recoverTimerInfoLock_);
1048 auto info = TimeServiceClient::GetInstance()->recoverTimerInfoMap_.find(timerId);
1049 EXPECT_NE(info, TimeServiceClient::GetInstance()->recoverTimerInfoMap_.end());
1050 EXPECT_NE(info->second->timerInfo, nullptr);
1051 EXPECT_EQ(info->second->state, 1);
1052 EXPECT_EQ(info->second->triggerTime, triggerTime);
1053 }
1054 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1055 }
1056
1057 /**
1058 * @tc.name: RecoverTimer003
1059 * @tc.desc: Create system timer, then start it, then stop it,
1060 * check whether the corresponding data is recorded when the timer is stoped.
1061 * @tc.type: FUNC
1062 */
1063 HWTEST_F(TimeClientTest, RecoverTimer003, TestSize.Level1)
1064 {
1065 auto timerInfo = std::make_shared<TimerInfoTest>();
1066 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
1067 timerInfo->SetRepeat(false);
1068 timerInfo->SetInterval(0);
1069 timerInfo->SetWantAgent(nullptr);
1070 timerInfo->SetCallbackInfo(TimeOutCallback1);
1071 uint64_t timerId;
1072 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1073 TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
1074 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1075 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
1076 auto startRet = TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
1077 EXPECT_EQ(startRet, TimeError::E_TIME_OK);
1078 auto stopRet = TimeServiceClient::GetInstance()->StopTimerV9(timerId);
1079 EXPECT_EQ(stopRet, TimeError::E_TIME_OK);
1080 {
1081 std::lock_guard<std::mutex> lock(TimeServiceClient::GetInstance()->recoverTimerInfoLock_);
1082 auto info = TimeServiceClient::GetInstance()->recoverTimerInfoMap_.find(timerId);
1083 EXPECT_NE(info, TimeServiceClient::GetInstance()->recoverTimerInfoMap_.end());
1084 EXPECT_NE(info->second->timerInfo, nullptr);
1085 EXPECT_EQ(info->second->state, 0);
1086 EXPECT_EQ(info->second->triggerTime, triggerTime + FIVE_HUNDRED);
1087 }
1088 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1089 }
1090
1091 /**
1092 * @tc.name: RecoverTimer004
1093 * @tc.desc: Create system timer, then start it, then destroy it,
1094 * check whether the corresponding data is recorded when the timer is destroyed.
1095 * @tc.type: FUNC
1096 */
1097 HWTEST_F(TimeClientTest, RecoverTimer004, TestSize.Level1)
1098 {
1099 auto timerInfo = std::make_shared<TimerInfoTest>();
1100 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
1101 timerInfo->SetRepeat(false);
1102 timerInfo->SetInterval(0);
1103 timerInfo->SetWantAgent(nullptr);
1104 timerInfo->SetCallbackInfo(TimeOutCallback1);
1105 uint64_t timerId;
1106 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1107 TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
1108 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1109 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
1110 auto startRet = TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
1111 EXPECT_EQ(startRet, TimeError::E_TIME_OK);
1112 auto destroyRet = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1113 EXPECT_EQ(destroyRet, TimeError::E_TIME_OK);
1114 {
1115 std::lock_guard<std::mutex> lock(TimeServiceClient::GetInstance()->recoverTimerInfoLock_);
1116 auto info = TimeServiceClient::GetInstance()->recoverTimerInfoMap_.find(timerId);
1117 EXPECT_EQ(info, TimeServiceClient::GetInstance()->recoverTimerInfoMap_.end());
1118 }
1119 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1120 }
1121
1122 /**
1123 * @tc.name: RecoverTimer005
1124 * @tc.desc: Create and start system timer, kill timer_service process, recover it.
1125 * @tc.type: FUNC
1126 */
1127 HWTEST_F(TimeClientTest, RecoverTimer005, TestSize.Level1)
1128 {
1129 g_data1 = 0;
1130 uint64_t timerId;
1131 auto timerInfo = std::make_shared<TimerInfoTest>();
1132 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT | timerInfo->TIMER_TYPE_WAKEUP);
1133 timerInfo->SetRepeat(true);
1134 timerInfo->SetInterval(1000);
1135 timerInfo->SetCallbackInfo(TimeOutCallback1);
1136 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1137 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1138 EXPECT_NE(timerId, 0);
1139 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
1140 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
1141 // Kill time_service by hand.
1142 sleep(5);
1143 WaitForAlarm(&g_data1, 0);
1144 EXPECT_GT(g_data1, 1);
1145 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1146 }
1147
1148 /**
1149 * @tc.name: RecoverTimer006
1150 * @tc.desc: Create system timer, kill timer_service process, and start it.
1151 * @tc.type: FUNC
1152 */
1153 HWTEST_F(TimeClientTest, RecoverTimer006, TestSize.Level1)
1154 {
1155 g_data1 = 0;
1156 uint64_t timerId;
1157 auto timerInfo = std::make_shared<TimerInfoTest>();
1158 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT | timerInfo->TIMER_TYPE_WAKEUP);
1159 timerInfo->SetRepeat(true);
1160 timerInfo->SetInterval(1000);
1161 timerInfo->SetCallbackInfo(TimeOutCallback1);
1162 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1163 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1164 EXPECT_NE(timerId, 0);
1165 // Kill time_service by hand.
1166 sleep(5);
1167 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
1168 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
1169 WaitForAlarm(&g_data1, FIVE_HUNDRED * MICRO_TO_MILLISECOND);
1170 EXPECT_EQ(g_data1, 1);
1171 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1172 }
1173
1174 /**
1175 * @tc.name: AdjustTimer001
1176 * @tc.desc: adjust timer.
1177 * @tc.type: FUNC
1178 */
1179 HWTEST_F(TimeClientTest, AdjustTimer001, TestSize.Level1)
1180 {
1181 g_data1 = 0;
1182 uint64_t timerId;
1183 auto timerInfo = std::make_shared<TimerInfoTest>();
1184 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
1185 timerInfo->SetRepeat(false);
1186 timerInfo->SetCallbackInfo(TimeOutCallback1);
1187 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1188 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1189 EXPECT_NE(timerId, 0);
1190 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
1191 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
1192 TimeServiceClient::GetInstance()->AdjustTimer(true, 5);
1193 TimeServiceClient::GetInstance()->AdjustTimer(false, 0);
1194 WaitForAlarm(&g_data1, FIVE_HUNDRED * MICRO_TO_MILLISECOND);
1195 EXPECT_EQ(g_data1, 1);
1196 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1197 }
1198
1199 /**
1200 * @tc.name: AdjustTimer002
1201 * @tc.desc: adjust timer.
1202 * @tc.type: FUNC
1203 */
1204 HWTEST_F(TimeClientTest, AdjustTimer002, TestSize.Level1)
1205 {
1206 g_data1 = 0;
1207 std::unordered_set<std::string> nameArr{"timer"};
1208 TimeServiceClient::GetInstance()->SetTimerExemption(nameArr, false);
1209 TimeServiceClient::GetInstance()->SetTimerExemption(nameArr, true);
1210 uint64_t timerId;
1211 auto timerInfo = std::make_shared<TimerInfoTest>();
1212 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
1213 timerInfo->SetRepeat(false);
1214 timerInfo->SetCallbackInfo(TimeOutCallback1);
1215 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1216 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1217 EXPECT_NE(timerId, 0);
1218 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
1219 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
1220 WaitForAlarm(&g_data1, FIVE_HUNDRED * MICRO_TO_MILLISECOND);
1221 EXPECT_EQ(g_data1, 1);
1222 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1223 }
1224
1225 /**
1226 * @tc.name: AdjustTimer003
1227 * @tc.desc: Create system timer and start it, after adjust system time, check whether it will be successful.
1228 * @tc.type: FUNC
1229 */
1230 HWTEST_F(TimeClientTest, AdjustTimer003, TestSize.Level1)
1231 {
1232 g_data1 = 0;
1233 uint64_t timerId;
1234 auto timerInfo = std::make_shared<TimerInfoTest>();
1235 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT | timerInfo->TIMER_TYPE_WAKEUP);
1236 timerInfo->SetRepeat(false);
1237 timerInfo->SetInterval(0);
1238 timerInfo->SetCallbackInfo(TimeOutCallback1);
1239 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1240 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1241 EXPECT_NE(timerId, 0);
1242 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
1243 TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
1244
1245 struct timeval currentTime {};
1246 gettimeofday(¤tTime, nullptr);
1247 int64_t time = (currentTime.tv_sec + 3600) * 1000 + currentTime.tv_usec / 1000;
1248 ASSERT_GT(time, 0);
1249 TIME_HILOGI(TIME_MODULE_CLIENT, "Time now : %{public}" PRId64 "", time);
1250 int32_t result = TimeServiceClient::GetInstance()->SetTimeV9(time);
1251 EXPECT_EQ(result, TimeError::E_TIME_OK);
1252 WaitForAlarm(&g_data1, 0);
1253 EXPECT_EQ(g_data1, 1);
1254 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1255 }
1256
1257 /**
1258 * @tc.name: ReBatchAllTimers001
1259 * @tc.desc: Start a long-time timer, then start a proxy of this timer.
1260 Cancel the proxy of the timer, and then rebatch it.
1261 Expect this timer does not trigger.
1262 * @tc.type: FUNC
1263 */
1264 HWTEST_F(TimeClientTest, ReBatchAllTimers001, TestSize.Level1)
1265 {
1266 g_data1 = 0;
1267
1268 auto timerInfo = std::make_shared<TimerInfoTest>();
1269 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
1270 timerInfo->SetRepeat(false);
1271 timerInfo->SetInterval(0);
1272 timerInfo->SetWantAgent(nullptr);
1273 timerInfo->SetCallbackInfo(TimeOutCallback1);
1274 uint64_t timerId;
1275 auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1276 TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
1277 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1278 auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
1279 auto startRet = TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + 300000);
1280 EXPECT_EQ(startRet, TimeError::E_TIME_OK);
1281 TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
1282
1283 pid_t pid = IPCSkeleton::GetCallingPid();
1284 pid_t uid = IPCSkeleton::GetCallingUid();
1285 std::set<int> pidList;
1286 pidList.insert(pid);
1287 TimeServiceClient::GetInstance()->ProxyTimer(uid, pidList, true, true);
1288 TimeSystemAbility::GetInstance()->ProxyTimer(uid, pidList, false, true);
1289
1290 struct timeval currentTime {};
1291 gettimeofday(¤tTime, nullptr);
1292 int64_t time = (currentTime.tv_sec + 10) * 1000 + currentTime.tv_usec / 1000;
1293 ASSERT_GT(time, 0);
1294 TIME_HILOGI(TIME_MODULE_CLIENT, "Time now : %{public}" PRId64 "", time);
1295 int32_t result = TimeServiceClient::GetInstance()->SetTimeV9(time);
1296 EXPECT_EQ(result, TimeError::E_TIME_OK);
1297 WaitForAlarm(&g_data1, 0);
1298 EXPECT_EQ(g_data1, 0);
1299 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1300 }
1301 } // namespace