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 time_later;
162     auto errCodeRealTime = TimeServiceClient::GetInstance()->GetRealTimeMs(time_later);
163     EXPECT_EQ(errCodeRealTime, TimeError::E_TIME_OK);
164     EXPECT_GT(time_later, 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 */
HWTEST_F(TimeClientTest, GetNtpTimeMs001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, GetNtpTimeMsAndGetRealTimeMs001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, SetTime001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, SetTime002, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, SetTime003, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, SetTime004, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, SetTimeZone001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, SetTimeZone002, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, SetTimeZone003, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, GetWallTimeMs001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, GetWallTimeNs001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, GetBootTimeNs001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, GetBootTimeMs001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, GetMonotonicTimeMs001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, GetMonotonicTimeNs001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, GetThreadTimeMs001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, GetThreadTimeNs001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, CreateTimer001, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, CreateTimer002, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, CreateTimer003, TestSize.Level1)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 */
HWTEST_F(TimeClientTest, CreateTimer004, TestSize.Level1)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     int64_t time;
495     TimeServiceClient::GetInstance()->GetBootTimeMs(time);
496     errCode = TimeServiceClient::GetInstance()->StartTimerV9(timerId, time + 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 */
HWTEST_F(TimeClientTest, CreateTimer005, TestSize.Level1)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     errCode = TimeServiceClient::GetInstance()->StartTimerV9(timerId, static_cast<uint64_t>(currentTime));
530     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
531     errCode = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
532     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
533     EXPECT_EQ(g_data1, 1);
534     errCode = TimeServiceClient::GetInstance()->StopTimerV9(timerId);
535     EXPECT_NE(errCode, TimeError::E_TIME_OK);
536 }
537 
538 /**
539 * @tc.name: CreateTimer006
540 * @tc.desc: Create system timer.
541 * @tc.type: FUNC
542 */
HWTEST_F(TimeClientTest, CreateTimer006, TestSize.Level1)543 HWTEST_F(TimeClientTest, CreateTimer006, TestSize.Level1)
544 {
545     uint64_t timerId;
546     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(nullptr, timerId);
547     EXPECT_NE(errCode, TimeError::E_TIME_OK);
548     EXPECT_EQ(timerId, 0);
549 }
550 
551 /**
552 * @tc.name: CreateTimer007
553 * @tc.desc: Create system timer.
554 * @tc.type: FUNC
555 */
HWTEST_F(TimeClientTest, CreateTimer007, TestSize.Level1)556 HWTEST_F(TimeClientTest, CreateTimer007, TestSize.Level1)
557 {
558     DeletePermission();
559     auto timerInfo = std::make_shared<TimerInfoTest>();
560     timerInfo->SetType(0);
561     timerInfo->SetRepeat(false);
562     timerInfo->SetCallbackInfo(TimeOutCallback1);
563 
564     struct timeval timeOfDay {};
565     gettimeofday(&timeOfDay, nullptr);
566     int64_t currentTime = (timeOfDay.tv_sec + 100) * 1000 + timeOfDay.tv_usec / 1000;
567     if (currentTime < 0) {
568         currentTime = 0;
569     }
570     uint64_t timerId = TimeServiceClient::GetInstance()->CreateTimer(timerInfo);
571     EXPECT_EQ(timerId, 0);
572     auto codeCreateTimer = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
573     EXPECT_NE(codeCreateTimer, TimeError::E_TIME_OK);
574     auto codeStartTimer = TimeServiceClient::GetInstance()->StartTimerV9(timerId, currentTime + 1000);
575     EXPECT_NE(codeStartTimer, TimeError::E_TIME_OK);
576     auto codeStopTimer = TimeServiceClient::GetInstance()->StopTimerV9(timerId);
577     EXPECT_NE(codeStopTimer, TimeError::E_TIME_OK);
578     auto codeDestroyTimer = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
579     EXPECT_NE(codeDestroyTimer, TimeError::E_TIME_OK);
580 }
581 
582 /**
583 * @tc.name: StartTimer001
584 * @tc.desc: Start system timer.
585 * @tc.type: FUNC
586 */
HWTEST_F(TimeClientTest, StartTimer001, TestSize.Level1)587 HWTEST_F(TimeClientTest, StartTimer001, TestSize.Level1)
588 {
589     g_data1 = 0;
590     uint64_t timerId;
591     auto timerInfo = std::make_shared<TimerInfoTest>();
592     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
593     timerInfo->SetRepeat(false);
594     timerInfo->SetCallbackInfo(TimeOutCallback1);
595     auto wantAgent = std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent>();
596     timerInfo->SetWantAgent(wantAgent);
597     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
598     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
599     EXPECT_NE(timerId, 0);
600     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
601     TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
602     WaitForAlarm(&g_data1, FIVE_HUNDRED * MICRO_TO_MILLISECOND);
603     EXPECT_EQ(g_data1, 1);
604     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
605 }
606 
607 /**
608 * @tc.name: StartTimer002
609 * @tc.desc: Start system timer.
610 * @tc.type: FUNC
611 */
HWTEST_F(TimeClientTest, StartTimer002, TestSize.Level1)612 HWTEST_F(TimeClientTest, StartTimer002, TestSize.Level1)
613 {
614     uint64_t timerId;
615     auto timerInfo = std::make_shared<TimerInfoTest>();
616     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
617     timerInfo->SetRepeat(false);
618     auto wantAgent = std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent>();
619     timerInfo->SetWantAgent(wantAgent);
620     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
621     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
622     EXPECT_NE(timerId, 0);
623     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
624     auto result = TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + 1000);
625     EXPECT_EQ(result, TimeError::E_TIME_OK);
626     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
627 }
628 
629 /**
630 * @tc.name: StartTimer003
631 * @tc.desc: Start system timer.
632 * @tc.type: FUNC
633 */
HWTEST_F(TimeClientTest, StartTimer003, TestSize.Level1)634 HWTEST_F(TimeClientTest, StartTimer003, TestSize.Level1)
635 {
636     g_data1 = 0;
637     uint64_t timerId;
638     auto timerInfo = std::make_shared<TimerInfoTest>();
639     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT | timerInfo->TIMER_TYPE_WAKEUP);
640     timerInfo->SetRepeat(true);
641     timerInfo->SetInterval(1000);
642     timerInfo->SetCallbackInfo(TimeOutCallback1);
643     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
644     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
645     EXPECT_NE(timerId, 0);
646     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
647     TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
648     sleep(2);
649     EXPECT_GT(g_data1, 1);
650     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
651 }
652 
653 /**
654 * @tc.name: StartTimer004
655 * @tc.desc: Start system timer.
656 * @tc.type: FUNC
657 */
HWTEST_F(TimeClientTest, StartTimer004, TestSize.Level1)658 HWTEST_F(TimeClientTest, StartTimer004, TestSize.Level1)
659 {
660     g_data1 = 0;
661     uint64_t timerId;
662     auto timerInfo = std::make_shared<TimerInfoTest>();
663     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
664     timerInfo->SetRepeat(true);
665     timerInfo->SetInterval(1000);
666     timerInfo->SetCallbackInfo(TimeOutCallback1);
667     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
668     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
669     EXPECT_NE(timerId, 0);
670     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
671     TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
672     sleep(2);
673     EXPECT_GT(g_data1, 1);
674     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
675 }
676 
677 /**
678 * @tc.name: StartTimer005
679 * @tc.desc: Start system timer.
680 * @tc.type: FUNC
681 */
HWTEST_F(TimeClientTest, StartTimer005, TestSize.Level1)682 HWTEST_F(TimeClientTest, StartTimer005, TestSize.Level1)
683 {
684     g_data1 = 0;
685     uint64_t timerId;
686     auto timerInfo = std::make_shared<TimerInfoTest>();
687     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
688     timerInfo->SetRepeat(false);
689     timerInfo->SetCallbackInfo(TimeOutCallback1);
690     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
691     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
692     EXPECT_NE(timerId, 0);
693     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
694     TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
695     pid_t uid = IPCSkeleton::GetCallingUid();
696     TimeServiceClient::GetInstance()->ProxyTimer(uid, true, true);
697     usleep(FIVE_HUNDRED * MICRO_TO_MILLISECOND);
698     TimeServiceClient::GetInstance()->ProxyTimer(uid, false, true);
699     WaitForAlarm(&g_data1, 0);
700     EXPECT_EQ(g_data1, 1);
701     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
702 }
703 
704 /**
705 * @tc.name: StartTimer006
706 * @tc.desc: Start system timer.
707 * @tc.type: FUNC
708 */
HWTEST_F(TimeClientTest, StartTimer006, TestSize.Level1)709 HWTEST_F(TimeClientTest, StartTimer006, TestSize.Level1)
710 {
711     g_data1 = 0;
712     uint64_t timerId;
713     auto timerInfo = std::make_shared<TimerInfoTest>();
714     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
715     timerInfo->SetRepeat(false);
716     timerInfo->SetCallbackInfo(TimeOutCallback1);
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     pid_t uid = IPCSkeleton::GetCallingUid();
723     TimeServiceClient::GetInstance()->ProxyTimer(uid, true, true);
724     usleep(FIVE_HUNDRED * MICRO_TO_MILLISECOND);
725     TimeServiceClient::GetInstance()->ResetAllProxy();
726     WaitForAlarm(&g_data1, 0);
727     EXPECT_EQ(g_data1, 1);
728     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
729 }
730 
731 /**
732 * @tc.name: StartTimer007
733 * @tc.desc: Start system timer.
734 * @tc.type: FUNC
735 */
HWTEST_F(TimeClientTest, StartTimer007, TestSize.Level1)736 HWTEST_F(TimeClientTest, StartTimer007, TestSize.Level1)
737 {
738     g_data1 = 0;
739     uint64_t timerId;
740     auto timerInfo = std::make_shared<TimerInfoTest>();
741     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
742     timerInfo->SetRepeat(false);
743     timerInfo->SetCallbackInfo(TimeOutCallback1);
744     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
745     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
746     EXPECT_NE(timerId, 0);
747     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
748     TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
749     pid_t uid = IPCSkeleton::GetCallingUid();
750     TimeServiceClient::GetInstance()->ProxyTimer(uid, true, true);
751     sleep(1);
752     TimeServiceClient::GetInstance()->ResetAllProxy();
753     WaitForAlarm(&g_data1, 0);
754     EXPECT_EQ(g_data1, 1);
755     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
756 }
757 
758 /**
759 * @tc.name: StartTimer008
760 * @tc.desc: Start system timer.
761 * @tc.type: FUNC
762 */
HWTEST_F(TimeClientTest, StartTimer008, TestSize.Level1)763 HWTEST_F(TimeClientTest, StartTimer008, TestSize.Level1)
764 {
765     g_data1 = 0;
766     g_data2 = 0;
767     uint64_t timerId1;
768     auto timerInfo1 = std::make_shared<TimerInfoTest>();
769     timerInfo1->SetType(timerInfo1->TIMER_TYPE_EXACT);
770     timerInfo1->SetRepeat(false);
771     timerInfo1->SetCallbackInfo(TimeOutCallback1);
772     auto errCode1 = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo1, timerId1);
773     EXPECT_EQ(errCode1, TimeError::E_TIME_OK);
774     EXPECT_NE(timerId1, 0);
775     auto triggerTime1 = TimeServiceClient::GetInstance()->GetWallTimeMs();
776     TimeServiceClient::GetInstance()->StartTimerV9(timerId1, triggerTime1 + FIVE_HUNDRED);
777     pid_t uid1 = IPCSkeleton::GetCallingUid();
778     TimeServiceClient::GetInstance()->ProxyTimer(uid1, true, true);
779 
780     uint64_t timerId2;
781     auto timerInfo2 = std::make_shared<TimerInfoTest>();
782     timerInfo2->SetType(timerInfo2->TIMER_TYPE_EXACT);
783     timerInfo2->SetRepeat(false);
784     timerInfo2->SetCallbackInfo(TimeOutCallback2);
785     auto errCode2 = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo2, timerId2);
786     EXPECT_EQ(errCode2, TimeError::E_TIME_OK);
787     EXPECT_NE(timerId1, 0);
788     auto triggerTime2 = TimeServiceClient::GetInstance()->GetWallTimeMs();
789     TimeServiceClient::GetInstance()->StartTimerV9(timerId2, triggerTime2 + FIVE_HUNDRED);
790     pid_t uid2 = IPCSkeleton::GetCallingUid();
791     TimeServiceClient::GetInstance()->ProxyTimer(uid2, true, true);
792     sleep(1);
793     TimeServiceClient::GetInstance()->ResetAllProxy();
794     WaitForAlarm(&g_data1, 0);
795     WaitForAlarm(&g_data2, 0);
796     EXPECT_EQ(g_data1, 1);
797     EXPECT_EQ(g_data2, 1);
798     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId1);
799     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId2);
800 }
801 
802 /**
803 * @tc.name: StartTimer009
804 * @tc.desc: Start a system time, then use the pid of this timer to start a proxy.
805             Cancel the proxy by this pid.
806 * @tc.type: FUNC
807 */
HWTEST_F(TimeClientTest, StartTimer009, TestSize.Level1)808 HWTEST_F(TimeClientTest, StartTimer009, TestSize.Level1)
809 {
810     g_data1 = 0;
811     uint64_t timerId;
812     auto timerInfo = std::make_shared<TimerInfoTest>();
813     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
814     timerInfo->SetRepeat(false);
815     timerInfo->SetCallbackInfo(TimeOutCallback1);
816     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
817     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
818     EXPECT_NE(timerId, 0);
819     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
820     TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
821     pid_t pid = IPCSkeleton::GetCallingPid();
822     std::set<int> pidList;
823     pidList.insert(pid);
824     TimeServiceClient::GetInstance()->ProxyTimer(pidList, true, true);
825     usleep(FIVE_HUNDRED * MICRO_TO_MILLISECOND);
826     TimeServiceClient::GetInstance()->ProxyTimer(pidList, false, true);
827     WaitForAlarm(&g_data1, 0);
828     EXPECT_EQ(g_data1, 1);
829     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
830 }
831 
832 /**
833 * @tc.name: StartTimer010
834 * @tc.desc: Start system timer, then use the pid of this timer to start a proxy.
835             Cancel all the proxy.
836 * @tc.type: FUNC
837 */
HWTEST_F(TimeClientTest, StartTimer010, TestSize.Level1)838 HWTEST_F(TimeClientTest, StartTimer010, TestSize.Level1)
839 {
840     g_data1 = 0;
841     uint64_t timerId;
842     auto timerInfo = std::make_shared<TimerInfoTest>();
843     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
844     timerInfo->SetRepeat(false);
845     timerInfo->SetCallbackInfo(TimeOutCallback1);
846     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
847     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
848     EXPECT_NE(timerId, 0);
849     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
850     TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
851     pid_t pid = IPCSkeleton::GetCallingPid();
852     std::set<int> pidList;
853     pidList.insert(pid);
854     TimeServiceClient::GetInstance()->ProxyTimer(pidList, true, true);
855     usleep(FIVE_HUNDRED * MICRO_TO_MILLISECOND);
856     TimeServiceClient::GetInstance()->ResetAllProxy();
857     WaitForAlarm(&g_data1, 0);
858     EXPECT_EQ(g_data1, 1);
859     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
860 }
861 
862 /**
863 * @tc.name: StartTimer011
864 * @tc.desc: Start system timer, then use the pid of this timer to start a proxy.
865             Cancel all the proxy.
866 * @tc.type: FUNC
867 */
HWTEST_F(TimeClientTest, StartTimer011, TestSize.Level1)868 HWTEST_F(TimeClientTest, StartTimer011, TestSize.Level1)
869 {
870     g_data1 = 0;
871     uint64_t timerId;
872     auto timerInfo = std::make_shared<TimerInfoTest>();
873     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
874     timerInfo->SetRepeat(false);
875     timerInfo->SetCallbackInfo(TimeOutCallback1);
876     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
877     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
878     EXPECT_NE(timerId, 0);
879     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
880     TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
881     pid_t pid = IPCSkeleton::GetCallingPid();
882     std::set<int> pidList;
883     pidList.insert(pid);
884     TimeServiceClient::GetInstance()->ProxyTimer(pidList, true, true);
885     sleep(1);
886     TimeServiceClient::GetInstance()->ResetAllProxy();
887     WaitForAlarm(&g_data1, 0);
888     EXPECT_EQ(g_data1, 1);
889     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
890 }
891 
892 /**
893 * @tc.name: StartTimer012
894 * @tc.desc: Start two system timers, record two pids, then start a proxy by two pids.
895             Cancel all the proxy.
896 * @tc.type: FUNC
897 */
HWTEST_F(TimeClientTest, StartTimer012, TestSize.Level1)898 HWTEST_F(TimeClientTest, StartTimer012, TestSize.Level1)
899 {
900     g_data1 = 0;
901     g_data2 = 0;
902     uint64_t timerId1;
903     auto timerInfo1 = std::make_shared<TimerInfoTest>();
904     timerInfo1->SetType(timerInfo1->TIMER_TYPE_EXACT);
905     timerInfo1->SetRepeat(false);
906     timerInfo1->SetCallbackInfo(TimeOutCallback1);
907     auto errCode1 = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo1, timerId1);
908     EXPECT_EQ(errCode1, TimeError::E_TIME_OK);
909     EXPECT_NE(timerId1, 0);
910     auto triggerTime1 = TimeServiceClient::GetInstance()->GetWallTimeMs();
911     TimeServiceClient::GetInstance()->StartTimerV9(timerId1, triggerTime1 + FIVE_HUNDRED);
912     pid_t pid1 = IPCSkeleton::GetCallingPid();
913 
914     uint64_t timerId2;
915     auto timerInfo2 = std::make_shared<TimerInfoTest>();
916     timerInfo2->SetType(timerInfo2->TIMER_TYPE_EXACT);
917     timerInfo2->SetRepeat(false);
918     timerInfo2->SetCallbackInfo(TimeOutCallback2);
919     auto errCode2 = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo2, timerId2);
920     EXPECT_EQ(errCode2, TimeError::E_TIME_OK);
921     EXPECT_NE(timerId2, 0);
922     auto triggerTime2 = TimeServiceClient::GetInstance()->GetWallTimeMs();
923     TimeServiceClient::GetInstance()->StartTimerV9(timerId2, triggerTime2 + FIVE_HUNDRED);
924     pid_t pid2 = IPCSkeleton::GetCallingUid();
925 
926     std::set<int> pidList;
927     pidList.insert(pid1);
928     pidList.insert(pid2);
929     TimeServiceClient::GetInstance()->ProxyTimer(pidList, true, true);
930 
931     sleep(1);
932     TimeServiceClient::GetInstance()->ResetAllProxy();
933     WaitForAlarm(&g_data1, 0);
934     WaitForAlarm(&g_data2, 0);
935     EXPECT_EQ(g_data1, 1);
936     EXPECT_EQ(g_data2, 1);
937     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId1);
938     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId2);
939 }
940 
941 /**
942 * @tc.name: StartTimer013
943 * @tc.desc: Start a timer which is disposable. It will be destroyed by time service.
944 * @tc.type: FUNC
945 */
HWTEST_F(TimeClientTest, StartTimer013, TestSize.Level1)946 HWTEST_F(TimeClientTest, StartTimer013, TestSize.Level1)
947 {
948     TIME_HILOGI(TIME_MODULE_CLIENT, "StartTimer013 start");
949     g_data1 = 0;
950     g_data2 = 0;
951     uint64_t timerId;
952     auto timerInfo = std::make_shared<TimerInfoTest>();
953     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
954     timerInfo->SetRepeat(false);
955     timerInfo->SetDisposable(true);
956     timerInfo->SetCallbackInfo(TimeOutCallback1);
957     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
958     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
959     EXPECT_NE(timerId, 0);
960     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
961     errCode = TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
962     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
963     sleep(1);
964     errCode = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
965     EXPECT_NE(errCode, TimeError::E_TIME_OK);
966 }
967 
968 /**
969 * @tc.name: StartTimer014
970 * @tc.desc: Start a repeat timer which is disposable. It will not be destroyed by time service.
971 * @tc.type: FUNC
972 */
HWTEST_F(TimeClientTest, StartTimer014, TestSize.Level1)973 HWTEST_F(TimeClientTest, StartTimer014, TestSize.Level1)
974 {
975     TIME_HILOGI(TIME_MODULE_CLIENT, "StartTimer014 start");
976     g_data1 = 0;
977     g_data2 = 0;
978     uint64_t timerId;
979     auto timerInfo = std::make_shared<TimerInfoTest>();
980     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
981     timerInfo->SetRepeat(true);
982     timerInfo->SetInterval(1000);
983     timerInfo->SetDisposable(true);
984     timerInfo->SetCallbackInfo(TimeOutCallback1);
985     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
986     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
987     EXPECT_NE(timerId, 0);
988     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
989     errCode = TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
990     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
991     sleep(1);
992     errCode = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
993     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
994 }
995 
996 /**
997 * @tc.name: RecoverTimer001
998 * @tc.desc: Create system timer, check whether the corresponding data is recorded when the timer is created.
999 * @tc.type: FUNC
1000 */
HWTEST_F(TimeClientTest, RecoverTimer001, TestSize.Level1)1001 HWTEST_F(TimeClientTest, RecoverTimer001, TestSize.Level1)
1002 {
1003     auto timerInfo = std::make_shared<TimerInfoTest>();
1004     timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
1005     timerInfo->SetRepeat(false);
1006     timerInfo->SetInterval(0);
1007     timerInfo->SetWantAgent(nullptr);
1008     timerInfo->SetCallbackInfo(TimeOutCallback1);
1009     uint64_t timerId;
1010     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1011     TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
1012     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1013     {
1014         std::lock_guard<std::mutex> lock(TimeServiceClient::GetInstance()->recoverTimerInfoLock_);
1015         auto info = TimeServiceClient::GetInstance()->recoverTimerInfoMap_.find(timerId);
1016         EXPECT_NE(info, TimeServiceClient::GetInstance()->recoverTimerInfoMap_.end());
1017         EXPECT_NE(info->second->timerInfo, nullptr);
1018         EXPECT_EQ(info->second->state, 0);
1019         EXPECT_EQ(info->second->triggerTime, 0);
1020     }
1021     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1022 }
1023 
1024 /**
1025 * @tc.name: RecoverTimer002
1026 * @tc.desc: Create system timer, then start it,
1027 *           check whether the corresponding data is recorded when the timer is started.
1028 * @tc.type: FUNC
1029 */
HWTEST_F(TimeClientTest, RecoverTimer002, TestSize.Level1)1030 HWTEST_F(TimeClientTest, RecoverTimer002, TestSize.Level1)
1031 {
1032     auto timerInfo = std::make_shared<TimerInfoTest>();
1033     timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
1034     timerInfo->SetRepeat(false);
1035     timerInfo->SetInterval(0);
1036     timerInfo->SetWantAgent(nullptr);
1037     timerInfo->SetCallbackInfo(TimeOutCallback1);
1038     uint64_t timerId;
1039     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1040     TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
1041     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1042     int64_t time;
1043     TimeServiceClient::GetInstance()->GetBootTimeMs(time);
1044     auto startRet = TimeServiceClient::GetInstance()->StartTimerV9(timerId, time + FIVE_HUNDRED);
1045     EXPECT_EQ(startRet, TimeError::E_TIME_OK);
1046     {
1047         std::lock_guard<std::mutex> lock(TimeServiceClient::GetInstance()->recoverTimerInfoLock_);
1048         auto info = TimeServiceClient::GetInstance()->recoverTimerInfoMap_.find(timerId);
1049         EXPECT_NE(info, TimeServiceClient::GetInstance()->recoverTimerInfoMap_.end());
1050         EXPECT_NE(info->second->timerInfo, nullptr);
1051         EXPECT_EQ(info->second->state, 1);
1052         EXPECT_EQ(info->second->triggerTime, time + FIVE_HUNDRED);
1053     }
1054     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1055 }
1056 
1057 /**
1058 * @tc.name: RecoverTimer003
1059 * @tc.desc: Create system timer, then start it, then stop it,
1060 *           check whether the corresponding data is recorded when the timer is stoped.
1061 * @tc.type: FUNC
1062 */
HWTEST_F(TimeClientTest, RecoverTimer003, TestSize.Level1)1063 HWTEST_F(TimeClientTest, RecoverTimer003, TestSize.Level1)
1064 {
1065     auto timerInfo = std::make_shared<TimerInfoTest>();
1066     timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
1067     timerInfo->SetRepeat(false);
1068     timerInfo->SetInterval(0);
1069     timerInfo->SetWantAgent(nullptr);
1070     timerInfo->SetCallbackInfo(TimeOutCallback1);
1071     uint64_t timerId;
1072     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1073     TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
1074     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1075     int64_t time;
1076     TimeServiceClient::GetInstance()->GetBootTimeMs(time);
1077     auto startRet = TimeServiceClient::GetInstance()->StartTimerV9(timerId, time + FIVE_HUNDRED);
1078     EXPECT_EQ(startRet, TimeError::E_TIME_OK);
1079     auto stopRet = TimeServiceClient::GetInstance()->StopTimerV9(timerId);
1080     EXPECT_EQ(stopRet, TimeError::E_TIME_OK);
1081     {
1082         std::lock_guard<std::mutex> lock(TimeServiceClient::GetInstance()->recoverTimerInfoLock_);
1083         auto info = TimeServiceClient::GetInstance()->recoverTimerInfoMap_.find(timerId);
1084         EXPECT_NE(info, TimeServiceClient::GetInstance()->recoverTimerInfoMap_.end());
1085         EXPECT_NE(info->second->timerInfo, nullptr);
1086         EXPECT_EQ(info->second->state, 0);
1087 
1088         EXPECT_EQ(info->second->triggerTime, time + FIVE_HUNDRED);
1089     }
1090     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1091 }
1092 
1093 /**
1094 * @tc.name: RecoverTimer004
1095 * @tc.desc: Create system timer, then start it, then destroy it,
1096 *           check whether the corresponding data is recorded when the timer is destroyed.
1097 * @tc.type: FUNC
1098 */
HWTEST_F(TimeClientTest, RecoverTimer004, TestSize.Level1)1099 HWTEST_F(TimeClientTest, RecoverTimer004, TestSize.Level1)
1100 {
1101     auto timerInfo = std::make_shared<TimerInfoTest>();
1102     timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
1103     timerInfo->SetRepeat(false);
1104     timerInfo->SetInterval(0);
1105     timerInfo->SetWantAgent(nullptr);
1106     timerInfo->SetCallbackInfo(TimeOutCallback1);
1107     uint64_t timerId;
1108     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1109     TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
1110     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1111     int64_t time;
1112     TimeServiceClient::GetInstance()->GetBootTimeMs(time);
1113     auto startRet = TimeServiceClient::GetInstance()->StartTimerV9(timerId, time + FIVE_HUNDRED);
1114     EXPECT_EQ(startRet, TimeError::E_TIME_OK);
1115     auto destroyRet = TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1116     EXPECT_EQ(destroyRet, TimeError::E_TIME_OK);
1117     {
1118         std::lock_guard<std::mutex> lock(TimeServiceClient::GetInstance()->recoverTimerInfoLock_);
1119         auto info = TimeServiceClient::GetInstance()->recoverTimerInfoMap_.find(timerId);
1120         EXPECT_EQ(info, TimeServiceClient::GetInstance()->recoverTimerInfoMap_.end());
1121     }
1122     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1123 }
1124 
1125 
1126 /**
1127 * @tc.name: AdjustTimer001
1128 * @tc.desc: adjust timer.
1129 * @tc.type: FUNC
1130 */
HWTEST_F(TimeClientTest, AdjustTimer001, TestSize.Level1)1131 HWTEST_F(TimeClientTest, AdjustTimer001, 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);
1137     timerInfo->SetRepeat(false);
1138     timerInfo->SetCallbackInfo(TimeOutCallback1);
1139     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1140     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1141     EXPECT_NE(timerId, 0);
1142     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
1143     TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
1144     TimeServiceClient::GetInstance()->AdjustTimer(true, 5);
1145     TimeServiceClient::GetInstance()->AdjustTimer(false, 0);
1146     WaitForAlarm(&g_data1, FIVE_HUNDRED * MICRO_TO_MILLISECOND);
1147     EXPECT_EQ(g_data1, 1);
1148     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1149 }
1150 
1151 /**
1152 * @tc.name: AdjustTimer002
1153 * @tc.desc: adjust timer.
1154 * @tc.type: FUNC
1155 */
HWTEST_F(TimeClientTest, AdjustTimer002, TestSize.Level1)1156 HWTEST_F(TimeClientTest, AdjustTimer002, TestSize.Level1)
1157 {
1158     g_data1 = 0;
1159     std::unordered_set<std::string> nameArr{"timer"};
1160     TimeServiceClient::GetInstance()->SetTimerExemption(nameArr, false);
1161     TimeServiceClient::GetInstance()->SetTimerExemption(nameArr, true);
1162     uint64_t timerId;
1163     auto timerInfo = std::make_shared<TimerInfoTest>();
1164     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
1165     timerInfo->SetRepeat(false);
1166     timerInfo->SetCallbackInfo(TimeOutCallback1);
1167     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1168     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1169     EXPECT_NE(timerId, 0);
1170     auto triggerTime = TimeServiceClient::GetInstance()->GetWallTimeMs();
1171     TimeServiceClient::GetInstance()->StartTimerV9(timerId, triggerTime + FIVE_HUNDRED);
1172     WaitForAlarm(&g_data1, FIVE_HUNDRED * MICRO_TO_MILLISECOND);
1173     EXPECT_EQ(g_data1, 1);
1174     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1175 }
1176 
1177 /**
1178 * @tc.name: AdjustTimer003
1179 * @tc.desc: Create system timer and start it, after adjust system time, check whether it will be successful.
1180 * @tc.type: FUNC
1181 */
HWTEST_F(TimeClientTest, AdjustTimer003, TestSize.Level1)1182 HWTEST_F(TimeClientTest, AdjustTimer003, TestSize.Level1)
1183 {
1184     g_data1 = 0;
1185     uint64_t timerId;
1186     auto timerInfo = std::make_shared<TimerInfoTest>();
1187     timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT | timerInfo->TIMER_TYPE_WAKEUP);
1188     timerInfo->SetRepeat(false);
1189     timerInfo->SetInterval(0);
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 
1197     struct timeval currentTime {};
1198     gettimeofday(&currentTime, nullptr);
1199     int64_t time = (currentTime.tv_sec + 3600) * 1000 + currentTime.tv_usec / 1000;
1200     ASSERT_GT(time, 0);
1201     TIME_HILOGI(TIME_MODULE_CLIENT, "Time now : %{public}" PRId64 "", time);
1202     int32_t result = TimeServiceClient::GetInstance()->SetTimeV9(time);
1203     EXPECT_EQ(result, TimeError::E_TIME_OK);
1204     WaitForAlarm(&g_data1, 0);
1205     EXPECT_EQ(g_data1, 1);
1206     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1207 }
1208 
1209 /**
1210 * @tc.name: ReBatchAllTimers001
1211 * @tc.desc: Start a long-time timer, then start a proxy of this timer.
1212             Cancel the proxy of the timer, and then rebatch it.
1213             Expect this timer does not trigger.
1214 * @tc.type: FUNC
1215 */
HWTEST_F(TimeClientTest, ReBatchAllTimers001, TestSize.Level1)1216 HWTEST_F(TimeClientTest, ReBatchAllTimers001, TestSize.Level1)
1217 {
1218     g_data1 = 0;
1219 
1220     auto timerInfo = std::make_shared<TimerInfoTest>();
1221     timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
1222     timerInfo->SetRepeat(false);
1223     timerInfo->SetInterval(0);
1224     timerInfo->SetWantAgent(nullptr);
1225     timerInfo->SetCallbackInfo(TimeOutCallback1);
1226     uint64_t timerId;
1227     auto errCode = TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
1228     TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
1229     EXPECT_EQ(errCode, TimeError::E_TIME_OK);
1230     int64_t time=0;
1231     TimeServiceClient::GetInstance()->GetBootTimeMs(time);
1232     auto startRet = TimeServiceClient::GetInstance()->StartTimerV9(timerId, time + 300000);
1233     EXPECT_EQ(startRet, TimeError::E_TIME_OK);
1234     TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
1235     pid_t pid = IPCSkeleton::GetCallingPid();
1236     std::set<int> pidList;
1237     pidList.insert(pid);
1238     TimeServiceClient::GetInstance()->ProxyTimer(pidList, true, true);
1239     TimeSystemAbility::GetInstance()->ProxyTimer(pidList, false, true);
1240 
1241     struct timeval currentTime {};
1242     gettimeofday(&currentTime, nullptr);
1243     int64_t time1 = (currentTime.tv_sec + 10) * 1000 + currentTime.tv_usec / 1000;
1244     ASSERT_GT(time1, 0);
1245     TIME_HILOGI(TIME_MODULE_CLIENT, "Time now : %{public}" PRId64 "", time1);
1246     int32_t result = TimeServiceClient::GetInstance()->SetTimeV9(time1);
1247     EXPECT_EQ(result, TimeError::E_TIME_OK);
1248     WaitForAlarm(&g_data1, 0);
1249     EXPECT_EQ(g_data1, 0);
1250     TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
1251 }
1252 } // namespace