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