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