1 /*
2 * Copyright (C) 2021 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 #include "time_service_test.h"
16
17 #include <chrono>
18 #include <climits>
19 #include <cstdlib>
20 #include <ctime>
21 #include <fstream>
22 #include <sys/stat.h>
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 "timer_call_back.h"
32 #include "time_common.h"
33 #include "event_manager.h"
34 #include "ntp_update_time.h"
35 #include "cjson_helper.h"
36
37 #define private public
38 #define protected public
39 #include "sntp_client.h"
40 #include "ntp_update_time.h"
41 #include "time_system_ability.h"
42 #include "ntp_trusted_time.h"
43 #include "time_tick_notify.h"
44 #include "timer_proxy.h"
45 #include "time_service_test.h"
46
47 namespace {
48 using namespace testing::ext;
49 using namespace OHOS;
50 using namespace OHOS::MiscServices;
51 using namespace std::chrono;
52 using namespace OHOS::Security::AccessToken;
53
54 const int32_t RESERVED_UID = 99999;
55 std::set<int> RESERVED_PIDLIST = {1111, 2222};
56 const std::string NETWORK_TIME_STATUS_OFF = "OFF";
57 const std::string NETWORK_TIME_STATUS_ON = "ON";
58 const std::string AUTO_TIME_STATUS_ON = "ON";
59 uint64_t g_idleTimerId = 0;
60 const uint64_t TIMER_ID = 88888;
61 const uint32_t MAX_EXEMPTION_SIZE = 1000;
62 const int UID = 999998;
63 const int PID = 999999;
64 constexpr int ONE_HUNDRED = 100;
65 constexpr int FIVE_HUNDRED = 500;
66 constexpr uint64_t MICRO_TO_MILLISECOND = 1000;
67 constexpr int TIMER_ALARM_COUNT = 50;
68 static const int MAX_PID_LIST_SIZE = 1024;
69 #ifdef SET_AUTO_REBOOT_ENABLE
70 static const int POWER_ON_ALARM = 6;
71 constexpr int64_t TEN_YEARS_TO_SECOND = 10 * 365 * 24 * 60 * 60;
72 constexpr uint64_t SECOND_TO_MILLISECOND = 1000;
73 #endif
74
75 static HapPolicyParams g_policyA = {
76 .apl = APL_SYSTEM_CORE,
77 .domain = "test.domain",
78 .permList = {
79 {
80 .permissionName = "ohos.permission.SET_TIME",
81 .bundleName = "ohos.permission_test.demoB",
82 .grantMode = 1,
83 .availableLevel = APL_NORMAL,
84 .label = "label",
85 .labelId = 1,
86 .description = "test",
87 .descriptionId = 1
88 },
89 {
90 .permissionName = "ohos.permission.SET_TIME_ZONE",
91 .bundleName = "ohos.permission_test.demoB",
92 .grantMode = 1,
93 .availableLevel = APL_NORMAL,
94 .label = "label",
95 .labelId = 1,
96 .description = "test",
97 .descriptionId = 1
98 },
99 {
100 .permissionName = "ohos.permission.MANAGE_LOCAL_ACCOUNTS",
101 .bundleName = "ohos.permission_test.demoB",
102 .grantMode = 1,
103 .availableLevel = APL_NORMAL,
104 .label = "label",
105 .labelId = 1,
106 .description = "test",
107 .descriptionId = 1
108 }
109 },
110 .permStateList = {
111 {
112 .permissionName = "ohos.permission.SET_TIME",
113 .isGeneral = true,
114 .resDeviceID = { "local" },
115 .grantStatus = { PermissionState::PERMISSION_GRANTED },
116 .grantFlags = { 1 }
117 },
118 {
119 .permissionName = "ohos.permission.SET_TIME_ZONE",
120 .isGeneral = true,
121 .resDeviceID = { "local" },
122 .grantStatus = { PermissionState::PERMISSION_GRANTED },
123 .grantFlags = { 1 }
124 },
125 {
126 .permissionName = "ohos.permission.MANAGE_LOCAL_ACCOUNTS",
127 .isGeneral = true,
128 .resDeviceID = { "local" },
129 .grantStatus = { PermissionState::PERMISSION_GRANTED },
130 .grantFlags = { 1 }
131 }
132 }
133 };
134
135 static HapInfoParams g_systemInfoParams = {
136 .userID = 1,
137 .bundleName = "timer",
138 .instIndex = 0,
139 .appIDDesc = "test",
140 .apiVersion = 8,
141 .isSystemApp = true
142 };
143
144 static HapPolicyParams g_policyB = { .apl = APL_NORMAL, .domain = "test.domain" };
145
146 static HapInfoParams g_notSystemInfoParams = {
147 .userID = 100,
148 .bundleName = "timer",
149 .instIndex = 0,
150 .appIDDesc = "test",
151 .apiVersion = 8,
152 .isSystemApp = false
153 };
154
155 class TimeServiceTimerTest : public testing::Test {
156 public:
157 static void SetUpTestCase(void);
158 static void TearDownTestCase(void);
159 void SetUp();
160 void TearDown();
161 void AddPermission();
162 void DeletePermission();
163 void StartIdleTimer();
164 void DestroyIdleTimer();
165 };
166
SetUpTestCase(void)167 void TimeServiceTimerTest::SetUpTestCase(void)
168 {
169 }
170
TearDownTestCase(void)171 void TimeServiceTimerTest::TearDownTestCase(void)
172 {
173 }
174
SetUp(void)175 void TimeServiceTimerTest::SetUp(void)
176 {
177 }
178
TearDown(void)179 void TimeServiceTimerTest::TearDown(void)
180 {
181 }
182
AddPermission()183 void TimeServiceTimerTest::AddPermission()
184 {
185 AccessTokenIDEx tokenIdEx = { 0 };
186 tokenIdEx = AccessTokenKit::AllocHapToken(g_systemInfoParams, g_policyA);
187 SetSelfTokenID(tokenIdEx.tokenIDEx);
188 }
189
DeletePermission()190 void TimeServiceTimerTest::DeletePermission()
191 {
192 AccessTokenIDEx tokenIdEx = { 0 };
193 tokenIdEx = AccessTokenKit::AllocHapToken(g_notSystemInfoParams, g_policyB);
194 SetSelfTokenID(tokenIdEx.tokenIDEx);
195 }
196
StartIdleTimer()197 void TimeServiceTimerTest::StartIdleTimer()
198 {
199 auto timerInfo = std::make_shared<TimerInfoTest>();
200 timerInfo->SetType(timerInfo->TIMER_TYPE_IDLE);
201 timerInfo->SetRepeat(false);
202 TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, g_idleTimerId);
203 struct timeval currentTime {};
204 gettimeofday(¤tTime, nullptr);
205 int64_t time = currentTime.tv_sec * 1000 + currentTime.tv_usec / 1000;
206 // 5000 means timer triggers after 5s
207 TimeServiceClient::GetInstance()->StartTimerV9(g_idleTimerId, time + 5000);
208 }
209
DestroyIdleTimer()210 void TimeServiceTimerTest::DestroyIdleTimer()
211 {
212 TimeServiceClient::GetInstance()->DestroyTimerV9(g_idleTimerId);
213 }
214
215 /**
216 * @brief Check timeId in json table
217 * @param tableName the tableName
218 * @param timerId the timerId need check
219 */
CheckInJson(std::string tableName,uint64_t timerId)220 bool CheckInJson(std::string tableName, uint64_t timerId)
221 {
222 bool flag = false;
223 cJSON* db1 = NULL;
224 cJSON* data1 = CjsonHelper::GetInstance().QueryTable(tableName, &db1);
225 if (data1 != NULL) {
226 int size = cJSON_GetArraySize(data1);
227 for (int i = 0; i < size; ++i) {
228 cJSON* obj = cJSON_GetArrayItem(data1, i);
229
230 if (cJSON_GetObjectItem(obj, "timerId")->valuestring == std::to_string(timerId)) {
231 flag = true;
232 break;
233 }
234 }
235 }
236 cJSON_Delete(db1);
237 return flag;
238 }
239
240 /**
241 * @brief Wait for timer trigger
242 * @param data the global variable that callback function changes
243 * @param interval the time need to wait
244 */
WaitForAlarm(std::atomic<int> * data,int interval)245 void WaitForAlarm(std::atomic<int> * data, int interval)
246 {
247 int i = 0;
248 if (interval > 0) {
249 usleep(interval);
250 }
251 while (*data == 0 && i < ONE_HUNDRED) {
252 ++i;
253 usleep(ONE_HUNDRED*MICRO_TO_MILLISECOND);
254 }
255 }
256
257 /**
258 * @tc.name: Batch001
259 * @tc.desc: Verify the value of newly Batch as expected.
260 * @tc.type: FUNC
261 */
262 HWTEST_F(TimeServiceTimerTest, Batch001, TestSize.Level0)
263 {
264 Batch batch;
265 EXPECT_EQ(batch.GetStart(), std::chrono::steady_clock::time_point::min());
266 EXPECT_EQ(batch.GetEnd(), std::chrono::steady_clock::time_point::max());
267 EXPECT_EQ(batch.GetFlags(), 0);
268 }
269
270 /**
271 * @tc.name: SystemAbility001
272 * @tc.desc: test OnStop.
273 * @tc.type: FUNC
274 */
275 HWTEST_F(TimeServiceTimerTest, SystemAbility001, TestSize.Level0)
276 {
277 TimeSystemAbility::GetInstance()->OnStop();
278 EXPECT_EQ(TimeSystemAbility::GetInstance()->state_, ServiceRunningState::STATE_NOT_START);
279 }
280
281 #ifdef RDB_ENABLE
282 /**
283 * @tc.name: SystemAbility002
284 * @tc.desc: test RecoverTimer.
285 * @tc.type: FUNC
286 */
287 HWTEST_F(TimeServiceTimerTest, SystemAbility002, TestSize.Level0)
288 {
289 uint64_t timerId1 = TIMER_ID;
290 uint64_t timerId2 = TIMER_ID + 1;
291
292 auto map = TimerManager::GetInstance()->timerEntryMap_;
293 auto it = map.find(timerId1);
294 if (it != map.end()) {
295 map.erase(it);
296 }
297 it = map.find(timerId2);
298 if (it != map.end()) {
299 map.erase(it);
300 }
301
302 OHOS::NativeRdb::ValuesBucket insertValues1;
303 insertValues1.PutLong("timerId", timerId1);
304 insertValues1.PutInt("type", 0);
305 insertValues1.PutInt("flag", 0);
306 insertValues1.PutLong("windowLength", 0);
307 insertValues1.PutLong("interval", 0);
308 insertValues1.PutInt("uid", 0);
309 insertValues1.PutString("bundleName", "");
310 std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent> wantAgent = nullptr;
311 insertValues1.PutString("wantAgent", OHOS::AbilityRuntime::WantAgent::WantAgentHelper::ToString(wantAgent));
312 insertValues1.PutInt("state", 0);
313 insertValues1.PutLong("triggerTime", static_cast<int64_t>(std::numeric_limits<int64_t>::max()));
314 TimeDatabase::GetInstance().Insert(HOLD_ON_REBOOT, insertValues1);
315
316 OHOS::NativeRdb::ValuesBucket insertValues2;
317 insertValues2.PutLong("timerId", timerId2);
318 insertValues2.PutInt("type", 0);
319 insertValues2.PutInt("flag", 0);
320 insertValues2.PutLong("windowLength", 0);
321 insertValues2.PutLong("interval", 0);
322 insertValues2.PutInt("uid", 0);
323 insertValues2.PutString("bundleName", "");
324 wantAgent = std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent>();
325 insertValues2.PutString("wantAgent", OHOS::AbilityRuntime::WantAgent::WantAgentHelper::ToString(wantAgent));
326 insertValues2.PutInt("state", 0);
327 insertValues2.PutLong("triggerTime", static_cast<int64_t>(std::numeric_limits<int64_t>::max()));
328 TimeDatabase::GetInstance().Insert(DROP_ON_REBOOT, insertValues2);
329
330 TimeSystemAbility::GetInstance()->RecoverTimer();
331
332 it = map.find(timerId1);
333 EXPECT_EQ(it, map.end());
334 it = map.find(timerId2);
335 EXPECT_EQ(it, map.end());
336
337 OHOS::NativeRdb::RdbPredicates rdbPredicatesDelete1(HOLD_ON_REBOOT);
338 rdbPredicatesDelete1.EqualTo("timerId", static_cast<int64_t>(timerId1));
339 TimeDatabase::GetInstance().Delete(rdbPredicatesDelete1);
340
341 OHOS::NativeRdb::RdbPredicates rdbPredicatesDelete2(DROP_ON_REBOOT);
342 rdbPredicatesDelete2.EqualTo("timerId", static_cast<int64_t>(timerId2));
343 TimeDatabase::GetInstance().Delete(rdbPredicatesDelete2);
344 }
345 #endif
346
347 #ifdef SET_AUTO_REBOOT_ENABLE
348 /**
349 * @tc.name: SystemAbility003
350 * @tc.desc: test SetAutoReboot when triggerTime is smaller than currenttime plus 2min.
351 * @tc.type: FUNC
352 */
353 HWTEST_F(TimeServiceTimerTest, SystemAbility003, TestSize.Level0)
354 {
355 uint64_t timerId1 = TIMER_ID;
356
357 TimeSystemAbility::GetInstance()->SetAutoReboot();
358
359 OHOS::NativeRdb::ValuesBucket insertValues1;
360 insertValues1.PutLong("timerId", timerId1);
361 insertValues1.PutInt("type", 0);
362 insertValues1.PutInt("flag", 0);
363 insertValues1.PutLong("windowLength", 0);
364 insertValues1.PutLong("interval", 0);
365 insertValues1.PutInt("uid", 0);
366 insertValues1.PutString("bundleName", "anything");
367 insertValues1.PutString("wantAgent", "");
368 insertValues1.PutInt("state", 1);
369 insertValues1.PutLong("triggerTime", static_cast<int64_t>(0));
370 auto res = TimeDatabase::GetInstance().Insert(HOLD_ON_REBOOT, insertValues1);
371 EXPECT_EQ(res, true);
372
373 TimeSystemAbility::GetInstance()->SetAutoReboot();
374
375 OHOS::NativeRdb::RdbPredicates rdbPredicatesDelete1(HOLD_ON_REBOOT);
376 rdbPredicatesDelete1.EqualTo("timerId", static_cast<int64_t>(timerId1));
377 TimeDatabase::GetInstance().Delete(rdbPredicatesDelete1);
378 }
379
380 /**
381 * @tc.name: SystemAbility004
382 * @tc.desc: test SetAutoReboot when triggerTime is larger than currenttime plus 2min.
383 * @tc.type: FUNC
384 */
385 HWTEST_F(TimeServiceTimerTest, SystemAbility004, TestSize.Level0)
386 {
387 uint64_t timerId1 = TIMER_ID;
388
389 TimeSystemAbility::GetInstance()->SetAutoReboot();
390
391 OHOS::NativeRdb::ValuesBucket insertValues1;
392 insertValues1.PutLong("timerId", timerId1);
393 insertValues1.PutInt("type", 0);
394 insertValues1.PutInt("flag", 0);
395 insertValues1.PutLong("windowLength", 0);
396 insertValues1.PutLong("interval", 0);
397 insertValues1.PutInt("uid", 0);
398 insertValues1.PutString("bundleName", "anything");
399 insertValues1.PutString("wantAgent", "");
400 insertValues1.PutInt("state", 1);
401 insertValues1.PutLong("triggerTime", std::numeric_limits<int64_t>::max());
402 insertValues1.PutString("name", "");
403 auto res = TimeDatabase::GetInstance().Insert(HOLD_ON_REBOOT, insertValues1);
404 EXPECT_EQ(res, true);
405
406 TimeSystemAbility::GetInstance()->SetAutoReboot();
407
408 OHOS::NativeRdb::RdbPredicates rdbPredicatesDelete1(HOLD_ON_REBOOT);
409 rdbPredicatesDelete1.EqualTo("timerId", static_cast<int64_t>(timerId1));
410 TimeDatabase::GetInstance().Delete(rdbPredicatesDelete1);
411 }
412 #endif
413
414 /**
415 * @tc.name: SystemAbility005
416 * @tc.desc: Verify set negative value by SetRealTime will return false.
417 * @tc.type: FUNC
418 */
419 HWTEST_F(TimeServiceTimerTest, SystemAbility005, TestSize.Level0)
420 {
421 auto res = TimeSystemAbility::GetInstance()->SetRealTime(-1);
422 EXPECT_FALSE(res);
423 }
424
425 #ifdef RDB_ENABLE
426 /**
427 * @tc.name: TimeDatabase001
428 * @tc.desc: test TimeDatabase Insert.
429 * @tc.type: FUNC
430 */
431 HWTEST_F(TimeServiceTimerTest, TimeDatabase001, TestSize.Level0)
432 {
433 OHOS::NativeRdb::ValuesBucket insertValues;
434 insertValues.PutLong("something", 0);
435 auto res = TimeDatabase::GetInstance().Insert(DROP_ON_REBOOT, insertValues);
436 EXPECT_FALSE(res);
437 }
438
439 /**
440 * @tc.name: TimeDatabase002
441 * @tc.desc: test TimeDatabase Update.
442 * @tc.type: FUNC
443 */
444 HWTEST_F(TimeServiceTimerTest, TimeDatabase002, TestSize.Level0)
445 {
446 OHOS::NativeRdb::ValuesBucket values;
447 values.PutInt("something", 1);
448 OHOS::NativeRdb::RdbPredicates rdbPredicates(DROP_ON_REBOOT);
449 rdbPredicates.EqualTo("something", 0)->And()->EqualTo("something", static_cast<int64_t>(0));
450 auto res = TimeDatabase::GetInstance().Update(values, rdbPredicates);
451 EXPECT_FALSE(res);
452 }
453
454 /**
455 * @tc.name: TimeDatabase003
456 * @tc.desc: test TimeDatabase Delete.
457 * @tc.type: FUNC
458 */
459 HWTEST_F(TimeServiceTimerTest, TimeDatabase003, TestSize.Level0)
460 {
461 OHOS::NativeRdb::RdbPredicates rdbPredicatesDelete(DROP_ON_REBOOT);
462 rdbPredicatesDelete.EqualTo("something", static_cast<int64_t>(0));
463 auto res = TimeDatabase::GetInstance().Delete(rdbPredicatesDelete);
464 EXPECT_FALSE(res);
465 }
466 #endif
467
468 /**
469 * @tc.name: Cjson001
470 * @tc.desc: Test Delete of CjsonHelper.
471 * @tc.type: FUNC
472 */
473 HWTEST_F(TimeServiceTimerTest, Cjson001, TestSize.Level0)
474 {
475 auto timerId2 = TIMER_ID + 1;
476
477 auto entry1 = std::make_shared<TimerEntry>(
478 TimerEntry{"", TIMER_ID, 1, 1, 1, 1, false, nullptr, nullptr, 1, 1, "bundleName1"});
479 auto ret = CjsonHelper::GetInstance().Insert(std::string(DROP_ON_REBOOT), entry1);
480 EXPECT_TRUE(ret);
481 auto entry2 = std::make_shared<TimerEntry>(
482 TimerEntry{"", timerId2, 2, 2, 2, 2, true, nullptr, nullptr, 2, 2, "bundleName2"});
483 ret = CjsonHelper::GetInstance().Insert(std::string(HOLD_ON_REBOOT), entry2);
484 EXPECT_TRUE(ret);
485
486 EXPECT_TRUE(CheckInJson(DROP_ON_REBOOT, TIMER_ID));
487 EXPECT_TRUE(CheckInJson(HOLD_ON_REBOOT, timerId2));
488
489 CjsonHelper::GetInstance().Delete(std::string(DROP_ON_REBOOT), TIMER_ID);
490 CjsonHelper::GetInstance().Delete(std::string(HOLD_ON_REBOOT), timerId2);
491
492 EXPECT_FALSE(CheckInJson(DROP_ON_REBOOT, TIMER_ID));
493 EXPECT_FALSE(CheckInJson(HOLD_ON_REBOOT, timerId2));
494 }
495
496 /**
497 * @tc.name: Cjson002
498 * @tc.desc: Test clear of CjsonHelper.
499 * @tc.type: FUNC
500 */
501 HWTEST_F(TimeServiceTimerTest, Cjson002, TestSize.Level0)
502 {
503 auto timerId2 = TIMER_ID + 1;
504
505 auto entry1 = std::make_shared<TimerEntry>(
506 TimerEntry{"", TIMER_ID, 1, 1, 1, 1, false, nullptr, nullptr, 1, 1, "bundleName1"});
507 auto ret = CjsonHelper::GetInstance().Insert(std::string(DROP_ON_REBOOT), entry1);
508 EXPECT_TRUE(ret);
509 auto entry2 = std::make_shared<TimerEntry>(
510 TimerEntry{"", timerId2, 2, 2, 2, 2, true, nullptr, nullptr, 2, 2, "bundleName2"});
511 ret = CjsonHelper::GetInstance().Insert(std::string(HOLD_ON_REBOOT), entry2);
512 EXPECT_TRUE(ret);
513
514 EXPECT_TRUE(CheckInJson(DROP_ON_REBOOT, TIMER_ID));
515 EXPECT_TRUE(CheckInJson(HOLD_ON_REBOOT, timerId2));
516
517 CjsonHelper::GetInstance().Clear(std::string(DROP_ON_REBOOT));
518 CjsonHelper::GetInstance().Clear(std::string(HOLD_ON_REBOOT));
519
520 EXPECT_FALSE(CheckInJson(DROP_ON_REBOOT, TIMER_ID));
521 EXPECT_FALSE(CheckInJson(HOLD_ON_REBOOT, timerId2));
522 }
523
524 /**
525 * @tc.name: Cjson003
526 * @tc.desc: Test QueryTable of cjson.
527 * @tc.type: FUNC
528 */
529 HWTEST_F(TimeServiceTimerTest, Cjson003, TestSize.Level0)
530 {
531 auto triggerTime = 200;
532 auto entry1 = std::make_shared<TimerEntry>(
533 TimerEntry{"", TIMER_ID, 1, 1, 1, 1, false, nullptr, nullptr, 1, 1, "bundleName1"});
534 CjsonHelper::GetInstance().Insert(std::string(DROP_ON_REBOOT), entry1);
535
536 CjsonHelper::GetInstance().UpdateTrigger(std::string(DROP_ON_REBOOT), TIMER_ID, triggerTime);
537
538 bool flag = false;
539 cJSON* db1 = NULL;
540 cJSON* data1 = CjsonHelper::GetInstance().QueryTable(DROP_ON_REBOOT, &db1);
541 if (data1 != NULL) {
542 int size = cJSON_GetArraySize(data1);
543 for (int i = 0; i < size; ++i) {
544 cJSON* obj = cJSON_GetArrayItem(data1, i);
545
546 if (cJSON_GetObjectItem(obj, "timerId")->valuestring == std::to_string(TIMER_ID)) {
547 auto state = cJSON_GetObjectItem(obj, "state")->valueint;
548 EXPECT_EQ(state, 1);
549 string triggerTimeStr = cJSON_GetObjectItem(obj, "triggerTime")->valuestring;
550 EXPECT_EQ(triggerTimeStr, std::to_string(triggerTime));
551 flag = true;
552 break;
553 }
554 }
555 }
556 cJSON_Delete(db1);
557 EXPECT_TRUE(flag);
558 CjsonHelper::GetInstance().UpdateState(std::string(DROP_ON_REBOOT), TIMER_ID);
559 flag = false;
560 db1 = NULL;
561 data1 = CjsonHelper::GetInstance().QueryTable(DROP_ON_REBOOT, &db1);
562 if (data1 != NULL) {
563 int size = cJSON_GetArraySize(data1);
564 for (int i = 0; i < size; ++i) {
565 cJSON* obj = cJSON_GetArrayItem(data1, i);
566
567 if (cJSON_GetObjectItem(obj, "timerId")->valuestring == std::to_string(TIMER_ID)) {
568 auto state = cJSON_GetObjectItem(obj, "state")->valueint;
569 EXPECT_EQ(state, 0);
570 flag = true;
571 break;
572 }
573 }
574 }
575 cJSON_Delete(db1);
576 EXPECT_TRUE(flag);
577
578 CjsonHelper::GetInstance().Delete(std::string(DROP_ON_REBOOT), TIMER_ID);
579 }
580
581 /**
582 * @tc.name: Cjson004
583 * @tc.desc: Test QueryWant of cjson.
584 * @tc.type: FUNC
585 */
586 HWTEST_F(TimeServiceTimerTest, Cjson004, TestSize.Level0)
587 {
588 auto entry1 = std::make_shared<TimerEntry>(
589 TimerEntry{"", TIMER_ID, 1, 1, 1, 1, false, nullptr, nullptr, 1, 1, "bundleName1"});
590 CjsonHelper::GetInstance().Insert(std::string(DROP_ON_REBOOT), entry1);
591 std::string want1 = CjsonHelper::GetInstance().QueryWant(std::string(DROP_ON_REBOOT), TIMER_ID);
592 EXPECT_EQ(want1, "");
593 CjsonHelper::GetInstance().Delete(std::string(DROP_ON_REBOOT), TIMER_ID);
594 }
595
596 /**
597 * @tc.name: Cjson005
598 * @tc.desc: Test QueryAutoReboot of cjson.
599 * @tc.type: FUNC
600 */
601 HWTEST_F(TimeServiceTimerTest, Cjson005, TestSize.Level0)
602 {
603 auto entry1 = std::make_shared<TimerEntry>(
604 TimerEntry{"", TIMER_ID, 1, 1, 1, 1, true, nullptr, nullptr, 1, 1, "bundleName1"});
605 CjsonHelper::GetInstance().Insert(std::string(HOLD_ON_REBOOT), entry1);
606 CjsonHelper::GetInstance().UpdateTrigger(std::string(HOLD_ON_REBOOT), TIMER_ID, 200);
607 auto data = CjsonHelper::GetInstance().QueryAutoReboot();
608 EXPECT_TRUE(data.size() > 0);
609 CjsonHelper::GetInstance().Delete(std::string(HOLD_ON_REBOOT), TIMER_ID);
610 }
611
612 /**
613 * @tc.name: Cjson006
614 * @tc.desc: Test GetEntry will return nullptr when cjson is incomplete and invalid.
615 * @tc.type: FUNC
616 */
617 HWTEST_F(TimeServiceTimerTest, Cjson006, TestSize.Level0)
618 {
619 cJSON* obj = cJSON_CreateObject();
620 auto res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
621 EXPECT_EQ(res, nullptr);
622 cJSON_AddStringToObject(obj, "name", "");
623 res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
624 EXPECT_EQ(res, nullptr);
625 cJSON_AddStringToObject(obj, "timerId", "timerId");
626 res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
627 EXPECT_EQ(res, nullptr);
628 cJSON *new_item = cJSON_CreateString(std::to_string(TIMER_ID).c_str());
629 cJSON_ReplaceItemInObject(obj, "timerId", new_item);
630 res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
631 EXPECT_EQ(res, nullptr);
632 cJSON_AddNumberToObject(obj, "type", 1);
633 res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
634 EXPECT_EQ(res, nullptr);
635 cJSON_AddNumberToObject(obj, "windowLength", 1);
636 res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
637 EXPECT_EQ(res, nullptr);
638 cJSON_AddNumberToObject(obj, "interval", 1);
639 res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
640 EXPECT_EQ(res, nullptr);
641 cJSON_AddNumberToObject(obj, "flag", 1);
642 res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
643 EXPECT_EQ(res, nullptr);
644 cJSON_AddStringToObject(obj, "wantAgent",
645 OHOS::AbilityRuntime::WantAgent::WantAgentHelper::ToString(nullptr).c_str());
646 res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
647 EXPECT_EQ(res, nullptr);
648 cJSON_AddNumberToObject(obj, "uid", 1);
649 res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
650 EXPECT_EQ(res, nullptr);
651 cJSON_AddNumberToObject(obj, "pid", 1);
652 res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
653 EXPECT_EQ(res, nullptr);
654 cJSON_AddStringToObject(obj, "bundleName", "bundleName1");
655 res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
656 EXPECT_NE(res, nullptr);
657 cJSON_Delete(obj);
658 }
659
660 /**
661 * @tc.name: Cjson007
662 * @tc.desc: Test GetEntry will return nullptr when cjson is complete and valid.
663 * @tc.type: FUNC
664 */
665 HWTEST_F(TimeServiceTimerTest, Cjson007, TestSize.Level0)
666 {
667 cJSON* obj = cJSON_CreateObject();
668 cJSON_AddStringToObject(obj, "name", "");
669 cJSON_AddStringToObject(obj, "timerId", std::to_string(TIMER_ID).c_str());
670 cJSON_AddNumberToObject(obj, "type", 1);
671 cJSON_AddNumberToObject(obj, "windowLength", 1);
672 cJSON_AddNumberToObject(obj, "interval", 1);
673 cJSON_AddNumberToObject(obj, "flag", 1);
674 cJSON_AddStringToObject(obj, "wantAgent",
675 OHOS::AbilityRuntime::WantAgent::WantAgentHelper::ToString(nullptr).c_str());
676 cJSON_AddNumberToObject(obj, "uid", 1);
677 cJSON_AddNumberToObject(obj, "pid", 1);
678 cJSON_AddStringToObject(obj, "bundleName", "bundleName1");
679 auto res = TimeSystemAbility::GetInstance()->GetEntry(obj, true);
680 EXPECT_NE(res, nullptr);
681 cJSON_Delete(obj);
682 }
683
684 /**
685 * @tc.name: Cjson008
686 * @tc.desc: Test CjsonIntoDatabase.
687 * @tc.type: FUNC
688 */
689 HWTEST_F(TimeServiceTimerTest, Cjson008, TestSize.Level0)
690 {
691 cJSON* resultSet = cJSON_CreateArray();
692 cJSON* obj1 = cJSON_CreateObject();
693 cJSON_AddItemToArray(resultSet, obj1);
694 cJSON* obj2 = cJSON_CreateObject();
695 cJSON_AddStringToObject(obj2, "name", "");
696 cJSON_AddStringToObject(obj2, "timerId", std::to_string(TIMER_ID).c_str());
697 cJSON_AddNumberToObject(obj2, "type", 1);
698 cJSON_AddNumberToObject(obj2, "windowLength", 1);
699 cJSON_AddNumberToObject(obj2, "interval", 1);
700 cJSON_AddNumberToObject(obj2, "flag", 1);
701 cJSON_AddStringToObject(obj2, "wantAgent", "");
702 cJSON_AddNumberToObject(obj2, "uid", 1);
703 cJSON_AddNumberToObject(obj2, "pid", 1);
704 cJSON_AddStringToObject(obj2, "bundleName", "bundleName1");
705 cJSON_AddItemToArray(resultSet, obj2);
706 TimeSystemAbility::GetInstance()->CjsonIntoDatabase(resultSet, true, HOLD_ON_REBOOT);
707 OHOS::NativeRdb::RdbPredicates rdbPredicatesDelete(HOLD_ON_REBOOT);
708 rdbPredicatesDelete.EqualTo("timerId", static_cast<int64_t>(TIMER_ID));
709 int count = 0;
710 TimeDatabase::GetInstance().Query(rdbPredicatesDelete, {"timerId"})->GetRowCount(count);
711 EXPECT_EQ(count, 0);
712 cJSON_Delete(resultSet);
713 }
714
715 /**
716 * @tc.name: PidProxyTimer001
717 * @tc.desc: proxy timer.
718 * @tc.type: FUNC
719 */
720 HWTEST_F(TimeServiceTimerTest, PidProxyTimer001, TestSize.Level0)
721 {
722 auto ret = TimeServiceClient::GetInstance()->ProxyTimer(RESERVED_UID, RESERVED_PIDLIST, true, true);
723 EXPECT_TRUE(ret);
724 ret = TimeServiceClient::GetInstance()->ProxyTimer(RESERVED_UID, RESERVED_PIDLIST, false, true);
725 EXPECT_TRUE(ret);
726 }
727
728 /**
729 * @tc.name: PidProxyTimer002
730 * @tc.desc: proxy timer.
731 * @tc.type: FUNC
732 */
733 HWTEST_F(TimeServiceTimerTest, PidProxyTimer002, TestSize.Level0)
734 {
735 std::set<int> pidList;
736 auto ret = TimeServiceClient::GetInstance()->ProxyTimer(RESERVED_UID, RESERVED_PIDLIST, true, true);
737 EXPECT_TRUE(ret);
738 ret = TimeServiceClient::GetInstance()->ResetAllProxy();
739 EXPECT_TRUE(ret);
740 }
741
742 /**
743 * @tc.name: PidProxyTimer003
744 * @tc.desc: proxy timer.
745 * @tc.type: FUNC
746 */
747 HWTEST_F(TimeServiceTimerTest, PidProxyTimer003, TestSize.Level0)
748 {
749 auto ret = TimeServiceClient::GetInstance()->ProxyTimer(RESERVED_UID, RESERVED_PIDLIST, false, true);
750 EXPECT_FALSE(ret);
751 }
752
753 /**
754 * @tc.name: PidProxyTimer004
755 * @tc.desc: proxy timer.
756 * @tc.type: FUNC
757 */
758 HWTEST_F(TimeServiceTimerTest, PidProxyTimer004, TestSize.Level0)
759 {
760 auto ret = TimeServiceClient::GetInstance()->ProxyTimer(RESERVED_UID, RESERVED_PIDLIST, true, false);
761 EXPECT_TRUE(ret);
762 ret = TimeServiceClient::GetInstance()->ProxyTimer(RESERVED_UID, RESERVED_PIDLIST, false, false);
763 EXPECT_TRUE(ret);
764 }
765
766 /**
767 * @tc.name: AdjustTimer001
768 * @tc.desc: adjust timer.
769 * @tc.type: FUNC
770 */
771 HWTEST_F(TimeServiceTimerTest, AdjustTimer001, TestSize.Level0)
772 {
773 auto errCode = TimeServiceClient::GetInstance()->AdjustTimer(true, 0, 0);
774 EXPECT_EQ(errCode, TimeError::E_TIME_READ_PARCEL_ERROR);
775 errCode = TimeServiceClient::GetInstance()->AdjustTimer(true, 1, 0);
776 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
777 errCode = TimeServiceClient::GetInstance()->AdjustTimer(false, 0, 0);
778 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
779 errCode = TimeServiceClient::GetInstance()->AdjustTimer(false, 1, 0);
780 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
781 }
782
783 /**
784 * @tc.name: AdjustTimer002
785 * @tc.desc: Check AdjustTimer.
786 * @tc.type: FUNC
787 */
788 HWTEST_F(TimeServiceTimerTest, AdjustTimer002, TestSize.Level1)
789 {
790 auto res = TimeSystemAbility::GetInstance()->AdjustTimer(true, 0, 0);
791 EXPECT_EQ(res, TimeError::E_TIME_READ_PARCEL_ERROR);
792 res = TimeSystemAbility::GetInstance()->AdjustTimer(true, 1, 0);
793 EXPECT_EQ(res, TimeError::E_TIME_OK);
794 res = TimeSystemAbility::GetInstance()->AdjustTimer(false, 0, 0);
795 EXPECT_EQ(res, TimeError::E_TIME_OK);
796 res = TimeSystemAbility::GetInstance()->AdjustTimer(false, 1, 0);
797 EXPECT_EQ(res, TimeError::E_TIME_OK);
798 }
799
800 /**
801 * @tc.name: AdjustTimer003
802 * @tc.desc: exemption timer.
803 * @tc.type: FUNC
804 */
805 HWTEST_F(TimeServiceTimerTest, AdjustTimer003, TestSize.Level0)
806 {
807 std::unordered_set<std::string> nameArr{"timer"};
808 auto errCode = TimeServiceClient::GetInstance()->SetTimerExemption(nameArr, false);
809 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
810 errCode = TimeServiceClient::GetInstance()->SetTimerExemption(nameArr, true);
811 EXPECT_EQ(errCode, TimeError::E_TIME_OK);
812 }
813
814 /**
815 * @tc.name: AdjustTimer004
816 * @tc.desc: Verify SetTimerExemption will return PARAMETERS_INVALID when nameArr is larger than MAX_EXEMPTION_SIZE.
817 * @tc.type: FUNC
818 */
819 HWTEST_F(TimeServiceTimerTest, AdjustTimer004, TestSize.Level1)
820 {
821 std::unordered_set<std::string> nameArr{"timer"};
822 for (int i = 0; i <= MAX_EXEMPTION_SIZE + 1; i++) {
823 nameArr.insert("timer" + std::to_string(i));
824 }
825 auto res = TimeServiceClient::GetInstance()->SetTimerExemption(nameArr, false);
826 EXPECT_EQ(res, E_TIME_PARAMETERS_INVALID);
827 }
828
829 /**
830 * @tc.name: ProxyTimer001
831 * @tc.desc: Verify ProxyTimer will return PARAMETERS_INVALID when pidList is larger than MAX_PID_LIST_SIZE.
832 * @tc.type: FUNC
833 */
834 HWTEST_F(TimeServiceTimerTest, ProxyTimer001, TestSize.Level1)
835 {
836 std::vector<int> pidList{};
837 auto res = TimeSystemAbility::GetInstance()->ProxyTimer(0, pidList, false, false);
838 EXPECT_EQ(res, E_TIME_PARAMETERS_INVALID);
839 for (int i = 0; i <= MAX_PID_LIST_SIZE + 1; i++) {
840 pidList.push_back(0);
841 }
842 res = TimeSystemAbility::GetInstance()->ProxyTimer(0, pidList, false, false);
843 EXPECT_EQ(res, E_TIME_PARAMETERS_INVALID);
844 }
845
846 /**
847 * @tc.name: IdleTimer001
848 * @tc.desc: test create idle timer for app.
849 * @tc.type: FUNC
850 */
851 HWTEST_F(TimeServiceTimerTest, IdleTimer001, TestSize.Level0)
852 {
853 auto timerInfo = std::make_shared<TimerInfoTest>();
854 timerInfo->SetType(timerInfo->TIMER_TYPE_IDLE);
855 timerInfo->SetRepeat(false);
856 uint64_t timerId = 0;
857 TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
858 EXPECT_NE(timerId, static_cast<uint64_t>(0));
859 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
860 }
861
862 /**
863 * @tc.name: IdleTimer002
864 * @tc.desc: test public app start timer when device is sleeping and device sleep quit greater than timer callback.
865 * @tc.type: FUNC
866 */
867 HWTEST_F(TimeServiceTimerTest, IdleTimer002, TestSize.Level0)
868 {
869 g_data1 = 0;
870 auto timerInfo = std::make_shared<TimerInfoTest>();
871 timerInfo->SetType(timerInfo->TIMER_TYPE_INEXACT_REMINDER);
872 timerInfo->SetRepeat(false);
873 timerInfo->SetCallbackInfo(TimeOutCallback1);
874 uint64_t timerId = 0;
875 TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
876 EXPECT_NE(timerId, static_cast<uint64_t>(0));
877 StartIdleTimer();
878 struct timeval currentTime {};
879 gettimeofday(¤tTime, nullptr);
880 int64_t time = currentTime.tv_sec * 1000 + currentTime.tv_usec / 1000;
881 TimeServiceClient::GetInstance()->StartTimerV9(timerId, static_cast<uint64_t>(time) + FIVE_HUNDRED);
882 usleep(FIVE_HUNDRED*MICRO_TO_MILLISECOND);
883 EXPECT_EQ(g_data1, 0);
884 DestroyIdleTimer();
885 WaitForAlarm(&g_data1, FIVE_HUNDRED * MICRO_TO_MILLISECOND);
886 EXPECT_EQ(g_data1, 1);
887 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
888 }
889
890 /**
891 * @tc.name: IdleTimer003
892 * @tc.desc: test public app start timer when device is sleeping and device sleep quit less than timer callback.
893 * @tc.type: FUNC
894 */
895 HWTEST_F(TimeServiceTimerTest, IdleTimer003, TestSize.Level0)
896 {
897 g_data1 = 0;
898 auto timerInfo = std::make_shared<TimerInfoTest>();
899 timerInfo->SetType(timerInfo->TIMER_TYPE_INEXACT_REMINDER);
900 timerInfo->SetRepeat(false);
901 timerInfo->SetCallbackInfo(TimeOutCallback1);
902 uint64_t timerId = 0;
903 TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
904 EXPECT_NE(timerId, static_cast<uint64_t>(0));
905 StartIdleTimer();
906 struct timeval currentTime {};
907 gettimeofday(¤tTime, nullptr);
908 int64_t time = currentTime.tv_sec * 1000 + currentTime.tv_usec / 1000;
909 TimeServiceClient::GetInstance()->StartTimerV9(timerId, static_cast<uint64_t>(time) + FIVE_HUNDRED);
910 EXPECT_EQ(g_data1, 0);
911 DestroyIdleTimer();
912 WaitForAlarm(&g_data1, FIVE_HUNDRED * MICRO_TO_MILLISECOND);
913 EXPECT_EQ(g_data1, 1);
914 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
915 }
916
917 /**
918 * @tc.name: IdleTimer004
919 * @tc.desc: test public app start timer when device is working, device sleep immediately
920 * and timer callback greater than idle quit.
921 * @tc.type: FUNC
922 */
923 HWTEST_F(TimeServiceTimerTest, IdleTimer004, TestSize.Level0)
924 {
925 g_data1 = 0;
926 auto timerInfo = std::make_shared<TimerInfoTest>();
927 timerInfo->SetType(timerInfo->TIMER_TYPE_INEXACT_REMINDER);
928 timerInfo->SetRepeat(false);
929 timerInfo->SetCallbackInfo(TimeOutCallback1);
930 uint64_t timerId = 0;
931 TimeServiceClient::GetInstance()->CreateTimerV9(timerInfo, timerId);
932 EXPECT_NE(timerId, static_cast<uint64_t>(0));
933 struct timeval currentTime {};
934 gettimeofday(¤tTime, nullptr);
935 int64_t time = currentTime.tv_sec * 1000 + currentTime.tv_usec / 1000;
936 TimeServiceClient::GetInstance()->StartTimerV9(timerId, static_cast<uint64_t>(time + FIVE_HUNDRED));
937 StartIdleTimer();
938 usleep(FIVE_HUNDRED * MICRO_TO_MILLISECOND);
939 DestroyIdleTimer();
940 WaitForAlarm(&g_data1, ONE_HUNDRED * MICRO_TO_MILLISECOND);
941 EXPECT_EQ(g_data1, 1);
942 TimeServiceClient::GetInstance()->DestroyTimerV9(timerId);
943 }
944
945 /**
946 * @tc.name: CreateTimer001
947 * @tc.desc: Create system timer.
948 * @tc.type: FUNC
949 */
950 HWTEST_F(TimeServiceTimerTest, CreateTimer001, TestSize.Level1)
951 {
952 AddPermission();
953 uint64_t timerId = 0;
954 auto ret = TimeServiceClient::GetInstance()->StartTimer(timerId, 5);
955 EXPECT_FALSE(ret);
956 ret = TimeServiceClient::GetInstance()->StopTimer(timerId);
957 EXPECT_FALSE(ret);
958 ret = TimeServiceClient::GetInstance()->DestroyTimer(timerId);
959 EXPECT_FALSE(ret);
960 DeletePermission();
961 }
962
963 /**
964 * @tc.name: CreateTimer002
965 * @tc.desc: Create system timer.
966 * @tc.type: FUNC
967 */
968 HWTEST_F(TimeServiceTimerTest, CreateTimer002, TestSize.Level1)
969 {
970 AddPermission();
971 auto timerInfo = std::make_shared<TimerInfoTest>();
972 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
973 timerInfo->SetRepeat(false);
974 timerInfo->SetInterval(0);
975 timerInfo->SetWantAgent(nullptr);
976 timerInfo->SetCallbackInfo(TimeOutCallback1);
977 auto timerId = TimeServiceClient::GetInstance()->CreateTimer(timerInfo);
978 TIME_HILOGI(TIME_MODULE_CLIENT, "timerId now : %{public}" PRId64 "", timerId);
979 EXPECT_GT(timerId, 0);
980 auto ret = TimeServiceClient::GetInstance()->StartTimer(timerId, 2000);
981 EXPECT_TRUE(ret);
982 ret = TimeServiceClient::GetInstance()->StopTimer(timerId);
983 EXPECT_TRUE(ret);
984 ret = TimeServiceClient::GetInstance()->DestroyTimer(timerId);
985 EXPECT_TRUE(ret);
986 DeletePermission();
987 }
988
989 /**
990 * @tc.name: CreateTimer003
991 * @tc.desc: Create system timer.
992 * @tc.type: FUNC
993 */
994 HWTEST_F(TimeServiceTimerTest, CreateTimer003, TestSize.Level1)
995 {
996 AddPermission();
997 auto timerInfo = std::make_shared<TimerInfoTest>();
998 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
999 timerInfo->SetRepeat(false);
1000 timerInfo->SetInterval(0);
1001 auto ability = std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent>();
1002 timerInfo->SetWantAgent(ability);
1003 timerInfo->SetCallbackInfo(TimeOutCallback1);
1004 auto timerId = TimeServiceClient::GetInstance()->CreateTimer(timerInfo);
1005 EXPECT_GT(timerId, 0);
1006 DeletePermission();
1007 }
1008
1009 /**
1010 * @tc.name: CreateTimer004
1011 * @tc.desc: Create system timer.
1012 * @tc.type: FUNC
1013 */
1014 HWTEST_F(TimeServiceTimerTest, CreateTimer004, TestSize.Level1)
1015 {
1016 AddPermission();
1017 g_data1 = 0;
1018 auto timerInfo = std::make_shared<TimerInfoTest>();
1019 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME);
1020 timerInfo->SetRepeat(false);
1021 timerInfo->SetInterval(0);
1022 timerInfo->SetWantAgent(nullptr);
1023 timerInfo->SetCallbackInfo(TimeOutCallback1);
1024 auto timerId = TimeServiceClient::GetInstance()->CreateTimer(timerInfo);
1025 EXPECT_GT(timerId, 0);
1026 auto BootTimeNano = system_clock::now().time_since_epoch().count();
1027 auto BootTimeMilli = BootTimeNano / NANO_TO_MILESECOND;
1028 auto ret = TimeServiceClient::GetInstance()->StartTimer(timerId, BootTimeMilli + 2000);
1029 EXPECT_TRUE(ret);
1030 ret = TimeServiceClient::GetInstance()->DestroyTimer(timerId);
1031 EXPECT_TRUE(ret);
1032 EXPECT_EQ(g_data1, 0);
1033 ret = TimeServiceClient::GetInstance()->StopTimer(timerId);
1034 EXPECT_FALSE(ret);
1035 DeletePermission();
1036 }
1037
1038 /**
1039 * @tc.name: CreateTimer005
1040 * @tc.desc: Create system timer.
1041 * @tc.type: FUNC
1042 */
1043 HWTEST_F(TimeServiceTimerTest, CreateTimer005, TestSize.Level1)
1044 {
1045 AddPermission();
1046 g_data1 = 1;
1047 auto timerInfo = std::make_shared<TimerInfoTest>();
1048 timerInfo->SetType(0);
1049 timerInfo->SetRepeat(false);
1050 timerInfo->SetInterval(0);
1051 timerInfo->SetWantAgent(nullptr);
1052 timerInfo->SetCallbackInfo(TimeOutCallback1);
1053
1054 struct timeval timeOfDay {
1055 };
1056 gettimeofday(&timeOfDay, NULL);
1057 int64_t currentTime = (timeOfDay.tv_sec + 100) * 1000 + timeOfDay.tv_usec / 1000;
1058 if (currentTime < 0) {
1059 currentTime = 0;
1060 }
1061 auto timerId = TimeServiceClient::GetInstance()->CreateTimer(timerInfo);
1062 EXPECT_GT(timerId, 0);
1063
1064 auto ret = TimeServiceClient::GetInstance()->StartTimer(timerId, static_cast<uint64_t>(currentTime));
1065 EXPECT_TRUE(ret);
1066 ret = TimeServiceClient::GetInstance()->DestroyTimer(timerId);
1067 EXPECT_TRUE(ret);
1068 EXPECT_EQ(g_data1, 1);
1069
1070 ret = TimeServiceClient::GetInstance()->StopTimer(timerId);
1071 EXPECT_FALSE(ret);
1072 DeletePermission();
1073 }
1074
1075 /**
1076 * @tc.name: CreateTimer006
1077 * @tc.desc: Create system timer.
1078 * @tc.type: FUNC
1079 */
1080 HWTEST_F(TimeServiceTimerTest, CreateTimer006, TestSize.Level1)
1081 {
1082 AddPermission();
1083 auto timerId = TimeServiceClient::GetInstance()->CreateTimer(nullptr);
1084 uint64_t ret = 0;
1085 EXPECT_EQ(timerId, ret);
1086 DeletePermission();
1087 }
1088
1089 /**
1090 * @tc.name: CreateTimer007
1091 * @tc.desc: Create system timer with TIMER_TYPE_EXACT, then start timer with uint64_t::max.
1092 * @tc.type: FUNC
1093 */
1094 HWTEST_F(TimeServiceTimerTest, CreateTimer007, TestSize.Level1)
1095 {
1096 AddPermission();
1097 g_data1 = 0;
1098 auto timerInfo = std::make_shared<TimerInfoTest>();
1099 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
1100 timerInfo->SetRepeat(false);
1101 timerInfo->SetInterval(0);
1102 timerInfo->SetWantAgent(nullptr);
1103 timerInfo->SetCallbackInfo(TimeOutCallback1);
1104 auto timerId = TimeServiceClient::GetInstance()->CreateTimer(timerInfo);
1105 EXPECT_GT(timerId, 0);
1106 uint64_t max = std::numeric_limits<uint64_t>::max();
1107 auto ret = TimeServiceClient::GetInstance()->StartTimer(timerId, max);
1108 EXPECT_TRUE(ret);
1109 EXPECT_EQ(g_data1, 0);
1110 ret = TimeServiceClient::GetInstance()->StopTimer(timerId);
1111 EXPECT_TRUE(ret);
1112 ret = TimeServiceClient::GetInstance()->DestroyTimer(timerId);
1113 EXPECT_TRUE(ret);
1114 DeletePermission();
1115 }
1116
1117 /**
1118 * @tc.name: CreateTimer008
1119 * @tc.desc: Create system timer with TIMER_TYPE_REALTIME and TIMER_TYPE_EXACT, then start timer with uint64_t::max.
1120 * @tc.type: FUNC
1121 */
1122 HWTEST_F(TimeServiceTimerTest, CreateTimer008, TestSize.Level1)
1123 {
1124 AddPermission();
1125 g_data1 = 0;
1126 auto timerInfo = std::make_shared<TimerInfoTest>();
1127 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME | timerInfo->TIMER_TYPE_EXACT);
1128 timerInfo->SetRepeat(false);
1129 timerInfo->SetInterval(0);
1130 timerInfo->SetWantAgent(nullptr);
1131 timerInfo->SetCallbackInfo(TimeOutCallback1);
1132 auto timerId = TimeServiceClient::GetInstance()->CreateTimer(timerInfo);
1133 EXPECT_GT(timerId, 0);
1134 uint64_t max = std::numeric_limits<uint64_t>::max();
1135 auto ret = TimeServiceClient::GetInstance()->StartTimer(timerId, max);
1136 EXPECT_TRUE(ret);
1137 EXPECT_EQ(g_data1, 0);
1138 ret = TimeServiceClient::GetInstance()->StopTimer(timerId);
1139 EXPECT_TRUE(ret);
1140 ret = TimeServiceClient::GetInstance()->DestroyTimer(timerId);
1141 EXPECT_TRUE(ret);
1142 DeletePermission();
1143 }
1144
1145 /**
1146 * @tc.name: CreateTimer009
1147 * @tc.desc: Create system timer start with one day later, then setTime to one day later.
1148 * @tc.type: FUNC
1149 */
1150 HWTEST_F(TimeServiceTimerTest, CreateTimer009, TestSize.Level1)
1151 {
1152 AddPermission();
1153 g_data1 = 0;
1154 struct timeval currentTime {
1155 };
1156 gettimeofday(¤tTime, NULL);
1157 // Set the time to one day later
1158 int64_t time = (currentTime.tv_sec + 86400) * 1000 + currentTime.tv_usec / 1000;
1159 TIME_HILOGI(TIME_MODULE_CLIENT, "Time now : %{public}" PRId64 "", time);
1160 ASSERT_GT(time, 0);
1161
1162 auto timerInfo = std::make_shared<TimerInfoTest>();
1163 timerInfo->SetType(timerInfo->TIMER_TYPE_EXACT);
1164 timerInfo->SetRepeat(true);
1165 timerInfo->SetInterval(1000);
1166 timerInfo->SetWantAgent(nullptr);
1167 timerInfo->SetCallbackInfo(TimeOutCallback1);
1168 auto timerId = TimeServiceClient::GetInstance()->CreateTimer(timerInfo);
1169 EXPECT_GT(timerId, 0);
1170 auto ret = TimeServiceClient::GetInstance()->StartTimer(timerId, time);
1171 EXPECT_TRUE(ret);
1172
1173 ret = TimeServiceClient::GetInstance()->SetTime(time);
1174 EXPECT_TRUE(ret);
1175
1176 // wait for the second trigger success
1177 while (g_data1 < 2) {
1178 usleep(100000);
1179 }
1180 ret = TimeServiceClient::GetInstance()->StopTimer(timerId);
1181 EXPECT_TRUE(ret);
1182 ret = TimeServiceClient::GetInstance()->DestroyTimer(timerId);
1183 EXPECT_TRUE(ret);
1184 DeletePermission();
1185 }
1186
1187 /**
1188 * @tc.name: CreateTimer010
1189 * @tc.desc: Create system timer.
1190 * @tc.type: FUNC
1191 */
1192 HWTEST_F(TimeServiceTimerTest, CreateTimer010, TestSize.Level1) {
1193 AddPermission();
1194 uint64_t timerId = 0;
1195 auto ret = TimeServiceClient::GetInstance()->StartTimer(timerId, 5);
1196 EXPECT_FALSE(ret);
1197 ret = TimeServiceClient::GetInstance()->StopTimer(timerId);
1198 EXPECT_FALSE(ret);
1199 ret = TimeServiceClient::GetInstance()->DestroyTimerAsync(timerId);
1200 EXPECT_TRUE(ret);
1201 DeletePermission();
1202 }
1203
1204 /**
1205 * @tc.name: CreateTimer011
1206 * @tc.desc: Create system timer.
1207 * @tc.type: FUNC
1208 */
1209 HWTEST_F(TimeServiceTimerTest, CreateTimer011, TestSize.Level1) {
1210 AddPermission();
1211 g_data1 = 0;
1212 auto timerInfo = std::make_shared<TimerInfoTest>();
1213 timerInfo->SetType(timerInfo->TIMER_TYPE_REALTIME |
1214 timerInfo->TIMER_TYPE_EXACT);
1215 timerInfo->SetRepeat(false);
1216 timerInfo->SetInterval(0);
1217 timerInfo->SetWantAgent(nullptr);
1218 timerInfo->SetCallbackInfo(TimeOutCallback1);
1219 auto timerId = TimeServiceClient::GetInstance()->CreateTimer(timerInfo);
1220 EXPECT_GT(timerId, 0);
1221 uint64_t max = std::numeric_limits<uint64_t>::max();
1222 auto ret = TimeServiceClient::GetInstance()->StartTimer(timerId, max);
1223 EXPECT_TRUE(ret);
1224 EXPECT_EQ(g_data1, 0);
1225 ret = TimeServiceClient::GetInstance()->StopTimer(timerId);
1226 EXPECT_TRUE(ret);
1227 ret = TimeServiceClient::GetInstance()->DestroyTimerAsync(timerId);
1228 EXPECT_TRUE(ret);
1229 DeletePermission();
1230 }
1231
1232 /**
1233 * @tc.name: TimerManager001
1234 * @tc.desc: test ReCreateTimer.
1235 * @tc.type: FUNC
1236 */
1237 HWTEST_F(TimeServiceTimerTest, TimerManager001, TestSize.Level0)
1238 {
1239 auto timerId1 = TIMER_ID;
1240 auto entry = std::make_shared<TimerEntry>(
1241 TimerEntry{"", timerId1, 0, 0, 0, 0, false, nullptr, nullptr, 0, 0, "bundleName"});
1242 TimerManager::GetInstance()->ReCreateTimer(timerId1, entry);
1243 std::lock_guard<std::mutex> lock(TimerManager::GetInstance()->entryMapMutex_);
1244
1245 auto map = TimerManager::GetInstance()->timerEntryMap_;
1246 auto it = map.find(timerId1);
1247 EXPECT_NE(it, map.end());
1248 if (it != map.end()) {
1249 map.erase(it);
1250 }
1251 }
1252
1253 /**
1254 * @tc.name: TimerManager002
1255 * @tc.desc: test SetHandler with interval = milliseconds(10) < second(1).
1256 * @tc.type: FUNC
1257 */
1258 HWTEST_F(TimeServiceTimerTest, TimerManager002, TestSize.Level0)
1259 {
1260 uint64_t max = std::numeric_limits<uint64_t>::max();
1261 auto alarm = TimerInfo::CreateTimerInfo("",
1262 TIMER_ID,
1263 0,
1264 max,
1265 10,
1266 0,
1267 1,
1268 false,
1269 nullptr,
1270 nullptr,
1271 0,
1272 0,
1273 "bundleName");
1274 std::lock_guard<std::mutex> lockGuard(TimerManager::GetInstance()->mutex_);
1275 TimerManager::GetInstance()->SetHandlerLocked(alarm);
1276 std::lock_guard<std::mutex> lock(TimerManager::GetInstance()->entryMapMutex_);
1277 auto map = TimerManager::GetInstance()->timerEntryMap_;
1278 auto it = map.find(TIMER_ID);
1279 EXPECT_NE(it, map.end());
1280 if (it != map.end()) {
1281 map.erase(it);
1282 }
1283 }
1284
1285 /**
1286 * @tc.name: TimerManager003
1287 * @tc.desc: test Set() with type > ALARM_TYPE_COUNT.
1288 * @tc.type: FUNC
1289 */
1290 HWTEST_F(TimeServiceTimerTest, TimerManager003, TestSize.Level0)
1291 {
1292 auto when = std::chrono::nanoseconds::zero();
1293 auto bootTime = std::chrono::steady_clock::now();
1294 auto res = TimerManager::GetInstance()->handler_->Set(6, when, bootTime);
1295 EXPECT_EQ(res, -1);
1296 }
1297
1298 /**
1299 * @tc.name: TimerManager004
1300 * @tc.desc: test StartTimer with UidProxy and PidProxy.
1301 * @tc.type: FUNC
1302 */
1303 HWTEST_F(TimeServiceTimerTest, TimerManager004, TestSize.Level0)
1304 {
1305 TimerManager::GetInstance()->DestroyTimer(TIMER_ID);
1306 auto entry = std::make_shared<TimerEntry>(
1307 TimerEntry{"", TIMER_ID, 0, 0, 0, 0, false, nullptr, nullptr, UID, PID, "bundleName"});
1308 TimerManager::GetInstance()->ReCreateTimer(TIMER_ID, entry);
1309 auto key1 = GetProxyKey(UID, 0);
1310 auto key2 = GetProxyKey(UID, PID);
1311 {
1312 std::lock_guard<std::mutex> lock(TimerProxy::GetInstance().proxyMutex_);
1313 std::vector<uint64_t> timerList;
1314 TimerProxy::GetInstance().proxyTimers_.insert(std::make_pair(key1, timerList));
1315 }
1316 auto res = TimerManager::GetInstance()->StartTimer(TIMER_ID, 0);
1317 EXPECT_EQ(res, E_TIME_OK);
1318
1319 {
1320 std::lock_guard<std::mutex> lock(TimerProxy::GetInstance().proxyMutex_);
1321 auto map = TimerProxy::GetInstance().proxyTimers_;
1322 auto it = map.find(key1);
1323 if (it != map.end()) {
1324 map.erase(it);
1325 }
1326 }
1327 {
1328 std::lock_guard<std::mutex> lock(TimerProxy::GetInstance().proxyMutex_);
1329 auto map = TimerProxy::GetInstance().proxyTimers_;
1330 std::vector<uint64_t> timerList;
1331 TimerProxy::GetInstance().proxyTimers_.insert(std::make_pair(key2, timerList));
1332 }
1333 res = TimerManager::GetInstance()->StartTimer(TIMER_ID, 0);
1334 EXPECT_EQ(res, E_TIME_OK);
1335
1336 {
1337 std::lock_guard<std::mutex> lock(TimerProxy::GetInstance().proxyMutex_);
1338 auto map = TimerProxy::GetInstance().proxyTimers_;
1339 auto it = map.find(key2);
1340 if (it != map.end()) {
1341 map.erase(it);
1342 }
1343 }
1344
1345 TimerManager::GetInstance()->DestroyTimer(TIMER_ID);
1346 }
1347
1348 /**
1349 * @tc.name: TimerManager005
1350 * @tc.desc: test NotifyWantAgent.
1351 * @tc.type: FUNC
1352 */
1353 HWTEST_F(TimeServiceTimerTest, TimerManager005, TestSize.Level0)
1354 {
1355 auto duration = std::chrono::milliseconds::zero();
1356 auto timePoint = std::chrono::steady_clock::now();
1357 auto timerInfo = std::make_shared<TimerInfo>("", TIMER_ID, 0, duration, timePoint, duration, timePoint, duration,
1358 nullptr, nullptr, 0, false, 0, 0, "");
1359 auto res = TimerManager::GetInstance()->NotifyWantAgent(timerInfo);
1360 EXPECT_FALSE(res);
1361 #ifdef RDB_ENABLE
1362 OHOS::NativeRdb::ValuesBucket insertValues;
1363 insertValues.PutLong("timerId", TIMER_ID);
1364 insertValues.PutInt("type", 0);
1365 insertValues.PutInt("flag", 0);
1366 insertValues.PutLong("windowLength", 0);
1367 insertValues.PutLong("interval", 0);
1368 insertValues.PutInt("uid", 0);
1369 insertValues.PutString("bundleName", "");
1370 std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent> wantAgent = nullptr;
1371 insertValues.PutString("wantAgent", OHOS::AbilityRuntime::WantAgent::WantAgentHelper::ToString(wantAgent));
1372 insertValues.PutInt("state", 0);
1373 insertValues.PutLong("triggerTime", static_cast<int64_t>(std::numeric_limits<int64_t>::max()));
1374 TimeDatabase::GetInstance().Insert(HOLD_ON_REBOOT, insertValues);
1375 #else
1376 auto entry = std::make_shared<TimerEntry>(
1377 TimerEntry{"", TIMER_ID, 0, 0, 0, 0, false, nullptr, nullptr, 0, 0, "bundleName"});
1378 CjsonHelper::GetInstance().Insert(HOLD_ON_REBOOT, entry);
1379 #endif
1380 res = TimerManager::GetInstance()->NotifyWantAgent(timerInfo);
1381 EXPECT_FALSE(res);
1382 #ifdef RDB_ENABLE
1383 OHOS::NativeRdb::RdbPredicates rdbPredicatesDelete(HOLD_ON_REBOOT);
1384 rdbPredicatesDelete.EqualTo("timerId", static_cast<int64_t>(TIMER_ID));
1385 TimeDatabase::GetInstance().Delete(rdbPredicatesDelete);
1386 #else
1387 CjsonHelper::GetInstance().Delete(HOLD_ON_REBOOT, TIMER_ID);
1388 #endif
1389 }
1390
1391 /**
1392 * @tc.name: TimerManager006
1393 * @tc.desc: test AdjustTimer.
1394 * @tc.type: FUNC
1395 */
1396 HWTEST_F(TimeServiceTimerTest, TimerManager006, TestSize.Level0)
1397 {
1398 uint32_t interval;
1399 bool isAdjust;
1400 // Set 1000 as interval, because interval can not be 0;
1401 uint32_t intervalSet = 1000;
1402 {
1403 std::lock_guard<std::mutex> lock(TimerManager::GetInstance()->mutex_);
1404 interval = TimerManager::GetInstance()->adjustInterval_;
1405 TimerManager::GetInstance()->adjustInterval_ = intervalSet;
1406 isAdjust = TimerManager::GetInstance()->adjustPolicy_;
1407 }
1408
1409 auto res = TimerManager::GetInstance()->AdjustTimer(isAdjust, intervalSet, 0);
1410 EXPECT_FALSE(res);
1411 res = TimerManager::GetInstance()->AdjustTimer(!isAdjust, intervalSet, 0);
1412 EXPECT_TRUE(res);
1413 res = TimerManager::GetInstance()->AdjustTimer(isAdjust, intervalSet + 1, 0);
1414 EXPECT_TRUE(res);
1415 res = TimerManager::GetInstance()->AdjustTimer(isAdjust, intervalSet, 0);
1416 EXPECT_TRUE(res);
1417
1418 std::lock_guard<std::mutex> lock(TimerManager::GetInstance()->mutex_);
1419 TimerManager::GetInstance()->adjustInterval_ = interval;
1420 TimerManager::GetInstance()->adjustPolicy_ = isAdjust;
1421 }
1422
1423 /**
1424 * @tc.name: TimerManager007
1425 * @tc.desc: test AdjustDeliveryTimeBasedOnDeviceIdle.
1426 * @tc.type: FUNC
1427 */
1428 HWTEST_F(TimeServiceTimerTest, TimerManager007, TestSize.Level0)
1429 {
1430 auto duration = std::chrono::milliseconds::zero();
1431 auto timePoint = std::chrono::steady_clock::now();
1432 auto timerInfo1 = std::make_shared<TimerInfo>("", TIMER_ID, 0, duration, timePoint, duration, timePoint, duration,
1433 nullptr, nullptr, 0, false, 0, 0, "");
1434 std::lock_guard<std::mutex> lock(TimerManager::GetInstance()->mutex_);
1435 auto alarm = TimerManager::GetInstance()->mPendingIdleUntil_;
1436 TimerManager::GetInstance()->mPendingIdleUntil_ = timerInfo1;
1437 auto res = TimerManager::GetInstance()->AdjustDeliveryTimeBasedOnDeviceIdle(timerInfo1);
1438 EXPECT_FALSE(res);
1439
1440 TimerManager::GetInstance()->mPendingIdleUntil_ = nullptr;
1441 TimerManager::GetInstance()->delayedTimers_[TIMER_ID] = std::chrono::steady_clock::now();
1442 res = TimerManager::GetInstance()->AdjustDeliveryTimeBasedOnDeviceIdle(timerInfo1);
1443 EXPECT_TRUE(res);
1444 auto duration1 = std::chrono::duration_cast<std::chrono::milliseconds>(
1445 (timePoint + std::chrono::hours(1)).time_since_epoch());
1446 auto timerInfo2 = std::make_shared<TimerInfo>("", TIMER_ID, 1, duration1, timePoint, duration, timePoint, duration,
1447 nullptr, nullptr, 0, false, 0, 0, "");
1448 res = TimerManager::GetInstance()->AdjustDeliveryTimeBasedOnDeviceIdle(timerInfo2);
1449 EXPECT_TRUE(res);
1450 auto timerInfo3 = std::make_shared<TimerInfo>("", TIMER_ID, 2, duration, timePoint, duration, timePoint, duration,
1451 nullptr, nullptr, 0, false, 0, 0, "");
1452 res = TimerManager::GetInstance()->AdjustDeliveryTimeBasedOnDeviceIdle(timerInfo3);
1453 EXPECT_TRUE(res);
1454
1455 TimerManager::GetInstance()->mPendingIdleUntil_ = alarm;
1456 }
1457
1458 #ifdef HIDUMPER_ENABLE
1459 /**
1460 * @tc.name: TimerManager008
1461 * @tc.desc: test ShowTimerEntryById TIMER_ID not in timerEntryMap_.
1462 * @tc.type: FUNC
1463 */
1464 HWTEST_F(TimeServiceTimerTest, TimerManager008, TestSize.Level0)
1465 {
1466 TimerManager::GetInstance()->DestroyTimer(TIMER_ID);
1467
1468 auto res = TimerManager::GetInstance()->ShowTimerEntryById(0, TIMER_ID);
1469 EXPECT_FALSE(res);
1470 }
1471
1472 /**
1473 * @tc.name: TimerManager009.
1474 * @tc.desc: test ShowTimerTriggerById TIMER_ID in alarmBatches_.
1475 * @tc.type: FUNC
1476 */
1477 HWTEST_F(TimeServiceTimerTest, TimerManager009, TestSize.Level0)
1478 {
1479 auto entry = std::make_shared<TimerEntry>(
1480 TimerEntry{"", TIMER_ID, 0, 0, 0, 0, false, nullptr, nullptr, 0, 0, "bundleName"});
1481 TimerManager::GetInstance()->ReCreateTimer(TIMER_ID, entry);
1482 uint64_t triggerTime = std::numeric_limits<uint64_t>::max();
1483 TimerManager::GetInstance()->StartTimer(TIMER_ID, triggerTime);
1484 auto res = TimerManager::GetInstance()->ShowTimerTriggerById(0, TIMER_ID);
1485 TimerManager::GetInstance()->DestroyTimer(TIMER_ID);
1486 EXPECT_TRUE(res);
1487 }
1488 #endif
1489
1490 /**
1491 * @tc.name: TimerManager010
1492 * @tc.desc: test HandleRSSDeath.
1493 * @tc.type: FUNC
1494 */
1495 HWTEST_F(TimeServiceTimerTest, TimerManager010, TestSize.Level0)
1496 {
1497 std::shared_ptr<TimerInfo> alarm;
1498 {
1499 std::lock_guard <std::mutex> lock(TimerManager::GetInstance()->mutex_);
1500 alarm = TimerManager::GetInstance()->mPendingIdleUntil_;
1501 TimerManager::GetInstance()->mPendingIdleUntil_ = nullptr;
1502 }
1503 TimerManager::GetInstance()->HandleRSSDeath();
1504
1505 auto duration = std::chrono::milliseconds::zero();
1506 auto timePoint = std::chrono::steady_clock::now();
1507 auto timerInfo = std::make_shared<TimerInfo>("", TIMER_ID, 0, duration, timePoint, duration, timePoint, duration,
1508 nullptr, nullptr, 0, false, 0, 0, "");
1509 {
1510 std::lock_guard <std::mutex> lock(TimerManager::GetInstance()->mutex_);
1511 TimerManager::GetInstance()->mPendingIdleUntil_ = timerInfo;
1512 }
1513 auto entry = std::make_shared<TimerEntry>(
1514 TimerEntry{"", TIMER_ID, 0, 0, 0, 0, false, nullptr, nullptr, 0, 0, "bundleName"});
1515 TimerManager::GetInstance()->ReCreateTimer(TIMER_ID, entry);
1516 TimerManager::GetInstance()->HandleRSSDeath();
1517 auto res = TimerManager::GetInstance()->DestroyTimer(TIMER_ID);
1518 EXPECT_EQ(res, E_TIME_NOT_FOUND);
1519
1520 {
1521 std::lock_guard <std::mutex> lock(TimerManager::GetInstance()->mutex_);
1522 TimerManager::GetInstance()->mPendingIdleUntil_ = alarm;
1523 }
1524 }
1525
1526 /**
1527 * @tc.name: TimerManager011
1528 * @tc.desc: test OnPackageRemoved.
1529 * @tc.type: FUNC
1530 */
1531 HWTEST_F(TimeServiceTimerTest, TimerManager011, TestSize.Level0)
1532 {
1533 auto timerManager = TimerManager::GetInstance();
1534 {
1535 std::lock_guard<std::mutex> lock(timerManager->entryMapMutex_);
1536 timerManager->timerEntryMap_.clear();
1537 }
1538
1539 auto entry = std::make_shared<TimerEntry>(
1540 TimerEntry{"", TIMER_ID, 0, 0, 0, 0, false, nullptr, nullptr, UID, 0, "bundleName"});
1541 timerManager->ReCreateTimer(TIMER_ID, entry);
1542 timerManager->OnPackageRemoved(UID);
1543
1544 {
1545 std::lock_guard<std::mutex> lock(timerManager->entryMapMutex_);
1546 auto map = timerManager->timerEntryMap_;
1547 auto it = map.find(TIMER_ID);
1548 EXPECT_EQ(it, map.end());
1549 if (it != map.end()) {
1550 map.erase(it);
1551 }
1552 }
1553 }
1554
1555 /**
1556 * @tc.name: TimerManager012
1557 * @tc.desc: test record and delete of timerCount_.
1558 * @tc.type: FUNC
1559 */
1560 HWTEST_F(TimeServiceTimerTest, TimerManager012, TestSize.Level0)
1561 {
1562 int uid1 = UID;
1563 int uid2 = UID + 1;
1564 TimerManager::GetInstance()->timerCount_.clear();
1565 for (int i = 0; i < 10; ++i) {
1566 TimerManager::GetInstance()->IncreaseTimerCount(uid1);
1567 }
1568 EXPECT_EQ(TimerManager::GetInstance()->timerCount_.size(), 1);
1569 auto it = std::find_if(TimerManager::GetInstance()->timerCount_.begin(),
1570 TimerManager::GetInstance()->timerCount_.end(),
__anond7ed28c40202(const std::pair<int32_t, size_t>& pair) 1571 [uid1](const std::pair<int32_t, size_t>& pair) {
1572 return pair.first == uid1;
1573 });
1574 EXPECT_EQ(it->second, 10);
1575 for (int i = 0; i < 10; ++i) {
1576 TimerManager::GetInstance()->IncreaseTimerCount(uid2);
1577 }
1578 EXPECT_EQ(TimerManager::GetInstance()->timerCount_.size(), 2);
1579 for (int i = 0; i < 5; ++i) {
1580 TimerManager::GetInstance()->DecreaseTimerCount(uid2);
1581 }
1582 it = std::find_if(TimerManager::GetInstance()->timerCount_.begin(),
1583 TimerManager::GetInstance()->timerCount_.end(),
__anond7ed28c40302(const std::pair<int32_t, size_t>& pair) 1584 [uid2](const std::pair<int32_t, size_t>& pair) {
1585 return pair.first == uid2;
1586 });
1587 EXPECT_EQ(it->second, 5);
1588 }
1589
1590 /**
1591 * @tc.name: TimerManager013
1592 * @tc.desc: test when create and delete timer, the change of timerOutOfRangeTimes_.
1593 * @tc.type: FUNC
1594 */
1595 HWTEST_F(TimeServiceTimerTest, TimerManager013, TestSize.Level0)
1596 {
1597 TimerManager::GetInstance()->timerEntryMap_.clear();
1598 TimerManager::GetInstance()->timerCount_.clear();
1599 TimerManager::GetInstance()->timerOutOfRangeTimes_ = 0;
1600 uint64_t i = 0;
1601 for (; i <= TIMER_ALARM_COUNT; ++i) {
1602 auto entry = std::make_shared<TimerEntry>(
1603 TimerEntry{"", i, 0, 0, 0, 0, false, nullptr, nullptr, 0, 0, "bundleName"});
1604 TimerManager::GetInstance()->ReCreateTimer(i, entry);
1605 }
1606 EXPECT_EQ(TimerManager::GetInstance()->timerOutOfRangeTimes_, 1);
1607 for (; i <= TIMER_ALARM_COUNT * 2; ++i) {
1608 auto entry = std::make_shared<TimerEntry>(
1609 TimerEntry{"", i, 0, 0, 0, 0, false, nullptr, nullptr, 0, 0, "bundleName"});
1610 TimerManager::GetInstance()->ReCreateTimer(i, entry);
1611 }
1612 EXPECT_EQ(TimerManager::GetInstance()->timerOutOfRangeTimes_, 2);
1613 }
1614
1615 /**
1616 * @tc.name: TimerManager014
1617 * @tc.desc: test create two timer with same name.
1618 * @tc.type: FUNC
1619 */
1620 HWTEST_F(TimeServiceTimerTest, TimerManager014, TestSize.Level0)
1621 {
1622 TIME_HILOGI(TIME_MODULE_CLIENT, "TimerManager014 start");
1623 TimerManager::GetInstance()->timerNameMap_.clear();
1624 auto entry = std::make_shared<TimerEntry>(
1625 TimerEntry{"name", TIMER_ID, 0, 0, 0, 0, false, nullptr, nullptr, UID, 0, "bundleName"});
1626 TimerManager::GetInstance()->ReCreateTimer(TIMER_ID, entry);
1627 auto timerNameMap = TimerManager::GetInstance()->timerNameMap_;
1628 EXPECT_NE(timerNameMap.find(UID), timerNameMap.end());
1629 EXPECT_NE(timerNameMap[UID].find("name"), timerNameMap[UID].end());
1630 EXPECT_EQ(timerNameMap[UID]["name"], TIMER_ID);
1631
1632 entry = std::make_shared<TimerEntry>(
1633 TimerEntry{"name", TIMER_ID + 1, 0, 0, 0, 0, false, nullptr, nullptr, UID, 0, "bundleName"});
1634 TimerManager::GetInstance()->ReCreateTimer(TIMER_ID + 1, entry);
1635 timerNameMap = TimerManager::GetInstance()->timerNameMap_;
1636 EXPECT_NE(timerNameMap.find(UID), timerNameMap.end());
1637 EXPECT_NE(timerNameMap[UID].find("name"), timerNameMap[UID].end());
1638 EXPECT_EQ(timerNameMap[UID]["name"], TIMER_ID + 1);
1639 auto ret = TimerManager::GetInstance()->DestroyTimer(TIMER_ID);
1640 EXPECT_EQ(ret, E_TIME_NOT_FOUND);
1641 }
1642
1643 /**
1644 * @tc.name: TimerManager015
1645 * @tc.desc: test check timer.
1646 * @tc.type: FUNC
1647 */
1648 HWTEST_F(TimeServiceTimerTest, TimerManager015, TestSize.Level0)
1649 {
1650 TimerManager::GetInstance()->timerNameMap_.clear();
1651 for (int i = 0; i < 101; i++)
1652 {
1653 auto entry = std::make_shared<TimerEntry>(
1654 TimerEntry{"name", TIMER_ID + i, 0, 0, 0, 0, false, nullptr, nullptr, UID, 0, "bundleName"});
1655 TimerManager::GetInstance()->ReCreateTimer(TIMER_ID, entry);
1656 }
1657 auto lastTimer = std::chrono::steady_clock::now() - std::chrono::minutes(61);
1658 TimerManager::GetInstance()->lastTimerOutOfRangeTime_ = lastTimer;
1659 TimerManager::GetInstance()->CheckTimerCount();
1660 EXPECT_NE(TimerManager::GetInstance()->lastTimerOutOfRangeTime_, lastTimer);
1661 TimerManager::GetInstance()->timerNameMap_.clear();
1662 }
1663
1664 /**
1665 * @tc.name: TimerManager016
1666 * @tc.desc: test update or delete database.
1667 * @tc.type: FUNC
1668 */
1669 HWTEST_F(TimeServiceTimerTest, TimerManager016, TestSize.Level0)
1670 {
1671 OHOS::NativeRdb::ValuesBucket insertValues;
1672 insertValues.PutLong("timerId", TIMER_ID);
1673 insertValues.PutInt("type", 0);
1674 insertValues.PutInt("flag", 0);
1675 insertValues.PutLong("windowLength", 0);
1676 insertValues.PutLong("interval", 0);
1677 insertValues.PutInt("uid", 0);
1678 insertValues.PutString("bundleName", "");
1679 std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent> wantAgent = nullptr;
1680 insertValues.PutString("wantAgent", OHOS::AbilityRuntime::WantAgent::WantAgentHelper::ToString(wantAgent));
1681 insertValues.PutInt("state", 0);
1682 insertValues.PutLong("triggerTime", static_cast<int64_t>(std::numeric_limits<int64_t>::max()));
1683 TimeDatabase::GetInstance().Insert(HOLD_ON_REBOOT, insertValues);
1684 TimerManager::GetInstance()->UpdateOrDeleteDatabase(true, TIMER_ID, true);
1685 OHOS::NativeRdb::RdbPredicates rdbPredicatesDelete(HOLD_ON_REBOOT);
1686 rdbPredicatesDelete.EqualTo("timerId", static_cast<int64_t>(TIMER_ID));
1687 int count = 0;
1688 TimeDatabase::GetInstance().Query(rdbPredicatesDelete, {"timerId"})->GetRowCount(count);
1689 EXPECT_EQ(count, 0);
1690 }
1691
1692 /**
1693 * @tc.name: TimerManager017
1694 * @tc.desc: test timer database when store is nullptr.
1695 * @tc.type: FUNC
1696 */
1697 HWTEST_F(TimeServiceTimerTest, TimerManager017, TestSize.Level0)
1698 {
1699 auto DataBase = TimeDatabase::GetInstance();
1700 DataBase.ClearDropOnReboot();
1701 DataBase.ClearInvaildDataInHoldOnReboot();
1702 auto storeptr = DataBase.store_;
1703 DataBase.store_ = nullptr;
1704 OHOS::NativeRdb::ValuesBucket Values;
1705 OHOS::NativeRdb::RdbPredicates rdbPredicates(HOLD_ON_REBOOT);
1706 DataBase.ClearDropOnReboot();
1707 DataBase.ClearInvaildDataInHoldOnReboot();
1708 auto res = DataBase.Insert(HOLD_ON_REBOOT, Values);
1709 EXPECT_FALSE(res);
1710 res = DataBase.Update(Values, rdbPredicates);
1711 EXPECT_FALSE(res);
1712 auto queryres = DataBase.Query(rdbPredicates, {"something"});
1713 EXPECT_EQ(queryres, nullptr);
1714 res = DataBase.Delete(rdbPredicates);
1715 EXPECT_FALSE(res);
1716 DataBase.store_ = storeptr;
1717 }
1718
1719 /**
1720 * @tc.name: TimerInfo001
1721 * @tc.desc: test UpdateWhenElapsedFromNow.
1722 * @tc.type: FUNC
1723 */
1724 HWTEST_F(TimeServiceTimerTest, TimerInfo001, TestSize.Level0)
1725 {
1726 auto duration = std::chrono::milliseconds::zero();
1727 auto timePoint = std::chrono::steady_clock::now();
1728 auto timerInfo = TimerInfo("", 0, 0, duration, timePoint, duration, timePoint, duration, nullptr,
1729 nullptr, 0, false, 0, 0, "");
1730 auto res = timerInfo.UpdateWhenElapsedFromNow(timePoint, duration);
1731 EXPECT_FALSE(res);
1732 }
1733
1734 /**
1735 * @tc.name: TimerInfo002
1736 * @tc.desc: test AdjustTimer.
1737 * @tc.type: FUNC
1738 */
1739 HWTEST_F(TimeServiceTimerTest, TimerInfo002, TestSize.Level0)
1740 {
1741 auto duration = std::chrono::milliseconds(0);
1742 auto timePoint = std::chrono::steady_clock::now();
1743 auto timerInfo = TimerInfo("", 0, 0, duration, timePoint, duration, timePoint, duration, nullptr,
1744 nullptr, 0, false, 0, 0, "");
1745 auto res = timerInfo.AdjustTimer(timePoint, 1, 0);
1746 EXPECT_TRUE(res);
1747 }
1748
1749 /**
1750 * @tc.name: TimerInfo003
1751 * @tc.desc: test CreateTimerInfo.
1752 * @tc.type: FUNC
1753 */
1754 HWTEST_F(TimeServiceTimerTest, TimerInfo003, TestSize.Level0)
1755 {
1756 struct timeval timeOfDay {};
1757 gettimeofday(&timeOfDay, nullptr);
1758 int64_t currentTime = (timeOfDay.tv_sec + 100) * 1000 + timeOfDay.tv_usec / 1000;
1759 if (currentTime < 0) {
1760 currentTime = 0;
1761 }
1762 auto timerInfo = TimerInfo::CreateTimerInfo("",
1763 0,
1764 ITimerManager::RTC,
1765 currentTime,
1766 0,
1767 10000,
1768 0,
1769 false,
1770 nullptr,
1771 nullptr,
1772 0,
1773 false,
1774 "");
1775 auto triggerTime = milliseconds(currentTime);
1776 auto triggerElapsed = TimerInfo::ConvertToElapsed(triggerTime, ITimerManager::RTC);
1777 EXPECT_EQ(timerInfo->name, "");
1778 EXPECT_EQ(timerInfo->id, 0);
1779 EXPECT_EQ(timerInfo->type, ITimerManager::RTC);
1780 EXPECT_EQ(timerInfo->when, triggerTime);
1781 EXPECT_EQ(timerInfo->origWhen, triggerTime);
1782 EXPECT_EQ(timerInfo->wakeup, false);
1783 EXPECT_EQ(timerInfo->whenElapsed.time_since_epoch().count() / NANO_TO_SECOND,
1784 triggerElapsed.time_since_epoch().count() / NANO_TO_SECOND);
1785 EXPECT_EQ(timerInfo->maxWhenElapsed.time_since_epoch().count() / NANO_TO_SECOND,
1786 triggerElapsed.time_since_epoch().count() / NANO_TO_SECOND);
1787 EXPECT_EQ(timerInfo->windowLength, milliseconds(0));
1788 EXPECT_EQ(timerInfo->repeatInterval, milliseconds(10000));
1789 EXPECT_EQ(timerInfo->bundleName, "");
1790 EXPECT_EQ(timerInfo->callback, nullptr);
1791 EXPECT_EQ(timerInfo->wantAgent, nullptr);
1792 EXPECT_EQ(timerInfo->autoRestore, false);
1793 }
1794
1795 /**
1796 * @tc.name: TimerInfo004
1797 * @tc.desc: test MaxTriggerTime.
1798 * @tc.type: FUNC
1799 */
1800 HWTEST_F(TimeServiceTimerTest, TimerInfo004, TestSize.Level0)
1801 {
1802 auto currentBootTime = TimeUtils::GetBootTimeNs();
1803 auto maxTriggerTime = TimerInfo::MaxTriggerTime(currentBootTime,
1804 currentBootTime + milliseconds(9999),
1805 milliseconds::zero());
1806 EXPECT_EQ(maxTriggerTime, currentBootTime + milliseconds(9999));
1807
1808 auto maxTriggerTime2 = TimerInfo::MaxTriggerTime(currentBootTime,
1809 currentBootTime + milliseconds(10000),
1810 milliseconds::zero());
1811 EXPECT_EQ(maxTriggerTime2, currentBootTime + milliseconds(10000 + 7500));
1812
1813 auto maxTriggerTime3 = TimerInfo::MaxTriggerTime(currentBootTime,
1814 currentBootTime + milliseconds(9999),
1815 milliseconds(20000));
1816 EXPECT_EQ(maxTriggerTime3, currentBootTime + milliseconds(9999 + 15000));
1817
1818 auto maxTriggerTime4 = TimerInfo::MaxTriggerTime(currentBootTime,
1819 currentBootTime + milliseconds(10000),
1820 milliseconds(20000));
1821 EXPECT_EQ(maxTriggerTime4, currentBootTime + milliseconds(10000 + 15000));
1822 }
1823
1824 /**
1825 * @tc.name: TimerInfo005
1826 * @tc.desc: test ConvertToElapsed.
1827 * @tc.type: FUNC
1828 */
1829 HWTEST_F(TimeServiceTimerTest, TimerInfo005, TestSize.Level0)
1830 {
1831 struct timeval timeOfDay {};
1832 gettimeofday(&timeOfDay, nullptr);
1833 int64_t currentTime = timeOfDay.tv_sec * 1000 + timeOfDay.tv_usec / 1000;
1834 if (currentTime < 0) {
1835 currentTime = 0;
1836 }
1837
1838 auto currentBootTime = TimeUtils::GetBootTimeNs();
1839 auto range = milliseconds(1000);
1840 auto duration = milliseconds(5000);
1841
1842 auto elapsed1 = TimerInfo::ConvertToElapsed(milliseconds(currentTime) + duration,
1843 ITimerManager::RTC);
1844 EXPECT_GT(elapsed1, currentBootTime + duration - range);
1845 EXPECT_GT(currentBootTime + duration + range, elapsed1);
1846
1847 int64_t currentBootTime2 = 0;
1848 TimeUtils::GetBootTimeMs(currentBootTime2);
1849 std::chrono::steady_clock::time_point bootTime2 ((std::chrono::milliseconds(currentBootTime2)));
1850
1851 auto elapsed2 = TimerInfo::ConvertToElapsed(milliseconds(currentBootTime2) + duration,
1852 ITimerManager::ELAPSED_REALTIME);
1853 EXPECT_EQ(elapsed2, bootTime2 + duration);
1854 }
1855
1856 /**
1857 * @tc.name: TimerInfo006
1858 * @tc.desc: test CalculateWhenElapsed.
1859 * @tc.type: FUNC
1860 */
1861 HWTEST_F(TimeServiceTimerTest, TimerInfo006, TestSize.Level0)
1862 {
1863 struct timeval timeOfDay {};
1864 gettimeofday(&timeOfDay, nullptr);
1865 int64_t currentTime = timeOfDay.tv_sec * 1000 + timeOfDay.tv_usec / 1000;
1866 if (currentTime < 0) {
1867 currentTime = 0;
1868 }
1869
1870 auto currentBootTime = TimeUtils::GetBootTimeNs();
1871 auto range = milliseconds(1000);
1872 auto zero = milliseconds(0);
1873
1874 std::chrono::steady_clock::time_point empty (zero);
1875 std::chrono::steady_clock::time_point tp_epoch ((std::chrono::milliseconds(currentTime)));
1876
1877 auto timerInfo = TimerInfo("", 0, ITimerManager::RTC, std::chrono::milliseconds(currentTime), empty, zero,
1878 empty, zero, nullptr, nullptr, 0, false, 0, 0, "");
1879 timerInfo.CalculateWhenElapsed(tp_epoch);
1880 EXPECT_GT(timerInfo.whenElapsed, currentBootTime - range);
1881 EXPECT_GT(currentBootTime + range, timerInfo.whenElapsed);
1882 EXPECT_EQ(timerInfo.whenElapsed, timerInfo.maxWhenElapsed);
1883 }
1884
1885 /**
1886 * @tc.name: TimerInfo007
1887 * @tc.desc: test CalculateOriWhenElapsed.
1888 * @tc.type: FUNC
1889 */
1890 HWTEST_F(TimeServiceTimerTest, TimerInfo007, TestSize.Level0)
1891 {
1892 struct timeval timeOfDay {};
1893 gettimeofday(&timeOfDay, nullptr);
1894 int64_t currentTime = timeOfDay.tv_sec * 1000 + timeOfDay.tv_usec / 1000;
1895 if (currentTime < 0) {
1896 currentTime = 0;
1897 }
1898
1899 auto currentBootTime = TimeUtils::GetBootTimeNs();
1900 auto range = milliseconds(1000);
1901 auto zero = milliseconds(0);
1902
1903 std::chrono::steady_clock::time_point empty (zero);
1904
1905 auto timerInfo = TimerInfo("", 0, ITimerManager::RTC, std::chrono::milliseconds(currentTime), empty, zero,
1906 empty, zero, nullptr, nullptr, 0, false, 0, 0, "");
1907 timerInfo.CalculateOriWhenElapsed();
1908 EXPECT_GT(timerInfo.originWhenElapsed, currentBootTime - range);
1909 EXPECT_GT(currentBootTime + range, timerInfo.originWhenElapsed);
1910 EXPECT_EQ(timerInfo.originWhenElapsed, timerInfo.originMaxWhenElapsed);
1911 }
1912
1913 /**
1914 * @tc.name: TimerInfo008
1915 * @tc.desc: test ProxyTimer.
1916 * @tc.type: FUNC
1917 */
1918 HWTEST_F(TimeServiceTimerTest, TimerInfo008, TestSize.Level0)
1919 {
1920 auto zero = milliseconds(0);
1921 std::chrono::steady_clock::time_point empty (zero);
1922 auto timerInfo = TimerInfo("", 0, ITimerManager::ELAPSED_REALTIME, zero, empty, zero, empty, zero, nullptr,
1923 nullptr, 0, false, 0, 0, "");
1924 EXPECT_EQ(timerInfo.state, TimerInfo::TimerState::INIT);
1925 EXPECT_TRUE(timerInfo.ProxyTimer(empty, milliseconds(3000)));
1926 EXPECT_EQ(timerInfo.state, TimerInfo::TimerState::PROXY);
1927 EXPECT_EQ(timerInfo.whenElapsed, empty + milliseconds(3000));
1928 EXPECT_EQ(timerInfo.maxWhenElapsed, empty + milliseconds(3000));
1929 EXPECT_EQ(timerInfo.when, milliseconds(3000));
1930 }
1931
1932 /**
1933 * @tc.name: TimerInfo009
1934 * @tc.desc: test RestoreProxyTimer.
1935 * @tc.type: FUNC
1936 */
1937 HWTEST_F(TimeServiceTimerTest, TimerInfo009, TestSize.Level0)
1938 {
1939 auto zero = milliseconds(0);
1940 std::chrono::steady_clock::time_point empty (zero);
1941 auto timerInfo = TimerInfo("", 0, ITimerManager::ELAPSED_REALTIME, zero, empty, zero, empty, zero, nullptr,
1942 nullptr, 0, false, 0, 0, "");
1943 EXPECT_EQ(timerInfo.state, TimerInfo::TimerState::INIT);
1944 EXPECT_FALSE(timerInfo.RestoreProxyTimer());
1945 EXPECT_EQ(timerInfo.state, TimerInfo::TimerState::INIT);
1946
1947 timerInfo.state = TimerInfo::TimerState::ADJUST;
1948 EXPECT_FALSE(timerInfo.RestoreProxyTimer());
1949 EXPECT_EQ(timerInfo.state, TimerInfo::TimerState::INIT);
1950
1951 timerInfo.ProxyTimer(empty, milliseconds(3000));
1952 EXPECT_EQ(timerInfo.state, TimerInfo::TimerState::PROXY);
1953 EXPECT_EQ(timerInfo.whenElapsed, empty + milliseconds(3000));
1954 EXPECT_EQ(timerInfo.maxWhenElapsed, empty + milliseconds(3000));
1955 EXPECT_EQ(timerInfo.when, milliseconds(3000));
1956
1957 EXPECT_TRUE(timerInfo.RestoreProxyTimer());
1958 EXPECT_EQ(timerInfo.state, TimerInfo::TimerState::INIT);
1959 EXPECT_EQ(timerInfo.whenElapsed, empty);
1960 EXPECT_EQ(timerInfo.maxWhenElapsed, empty);
1961 EXPECT_EQ(timerInfo.when, milliseconds(0));
1962 }
1963
1964 #ifdef SET_AUTO_REBOOT_ENABLE
1965 /**
1966 * @tc.name: IsPowerOnTimer001.
1967 * @tc.desc: Test function IsPowerOnTimer, use four timer to check the return of function.
1968 * @tc.type: FUNC
1969 */
1970 HWTEST_F(TimeServiceTimerTest, IsPowerOnTimer001, TestSize.Level0)
1971 {
1972 auto timerManager = TimerManager::GetInstance();
1973 timerManager->powerOnApps_ = {"testBundleName", "testTimerName"};
1974 auto duration = std::chrono::milliseconds::zero();
1975 auto timePoint = std::chrono::steady_clock::now();
1976
1977 auto timerInfo1 = std::make_shared<TimerInfo>("testTimerName", TIMER_ID, 0, duration, timePoint, duration,
1978 timePoint, duration, nullptr, nullptr, 0, false, 0, 0, "");
1979 bool ret = true;
1980 ret = timerManager->IsPowerOnTimer(timerInfo1);
1981 EXPECT_EQ(ret, false);
1982
1983 auto timerInfo2 = std::make_shared<TimerInfo>("", TIMER_ID, 0, duration, timePoint, duration, timePoint, duration,
1984 nullptr, nullptr, 0, false, 0, 0, "testBundleName");
1985 ret = true;
1986 ret = timerManager->IsPowerOnTimer(timerInfo2);
1987 EXPECT_EQ(ret, false);
1988
1989 auto timerInfo3 = std::make_shared<TimerInfo>("testTimerName", TIMER_ID, 0, duration, timePoint, duration,
1990 timePoint, duration, nullptr, nullptr, 0, true, 0, 0, "");
1991 ret = false;
1992 ret = timerManager->IsPowerOnTimer(timerInfo3);
1993 EXPECT_EQ(ret, true);
1994
1995 auto timerInfo4 = std::make_shared<TimerInfo>("", TIMER_ID, 0, duration, timePoint, duration, timePoint, duration,
1996 nullptr, nullptr, 0, true, 0, 0, "testBundleName");
1997 ret = false;
1998 ret = timerManager->IsPowerOnTimer(timerInfo4);
1999 EXPECT_EQ(ret, true);
2000 }
2001
2002 /**
2003 * @tc.name: AddPowerOnTimer001.
2004 * @tc.desc: Test function SetHandlerLocked, to prevent same timer put into TriggerTimerList.
2005 * @tc.type: FUNC
2006 */
2007 HWTEST_F(TimeServiceTimerTest, AddPowerOnTimer001, TestSize.Level0)
2008 {
2009 auto timerManager = TimerManager::GetInstance();
2010 timerManager->powerOnTriggerTimerList_.clear();
2011 timerManager->powerOnApps_ = {"testBundleName", "testTimerName"};
2012 int64_t currentTime = 0;
2013 auto ret = TimeUtils::GetWallTimeMs(currentTime);
2014 EXPECT_EQ(ret, ERR_OK);
2015 auto duration = std::chrono::milliseconds(currentTime + 10000);
2016 auto timePoint = std::chrono::steady_clock::now() + std::chrono::milliseconds(10000);
2017
2018 auto timerInfo1 = std::make_shared<TimerInfo>("testTimerName", TIMER_ID, 0, duration, timePoint, duration,
2019 timePoint, duration, nullptr, nullptr, 0, true, 0, 0, "");
2020 timerManager->SetHandlerLocked(timerInfo1, false, false);
2021 EXPECT_EQ(timerManager->powerOnTriggerTimerList_.size(), 1);
2022 timerManager->SetHandlerLocked(timerInfo1, false, false);
2023 EXPECT_EQ(timerManager->powerOnTriggerTimerList_.size(), 1);
2024 timerManager->SetHandlerLocked(timerInfo1, false, false);
2025 EXPECT_EQ(timerManager->powerOnTriggerTimerList_.size(), 1);
2026 timerManager->SetHandlerLocked(timerInfo1, false, false);
2027 EXPECT_EQ(timerManager->powerOnTriggerTimerList_.size(), 1);
2028 timerManager->RemoveLocked(TIMER_ID, true);
2029 EXPECT_EQ(timerManager->powerOnTriggerTimerList_.size(), 0);
2030 }
2031
2032 /**
2033 * @tc.name: DeleteTimerFromPowerOnTimerListById001.
2034 * @tc.desc: Test function ReschedulePowerOnTimer, check delete a timer in powerOnTriggerTimerList_ by timer id.
2035 * @tc.type: FUNC
2036 */
2037 HWTEST_F(TimeServiceTimerTest, DeleteTimerFromPowerOnTimerListById001, TestSize.Level0)
2038 {
2039 auto timerManager = TimerManager::GetInstance();
2040 auto duration = std::chrono::milliseconds(1000);
2041 auto timePoint = std::chrono::steady_clock::now();
2042 auto timerInfo = std::make_shared<TimerInfo>("", TIMER_ID, 0, duration, timePoint, duration, timePoint, duration,
2043 nullptr, nullptr, 0, false, 0, 0, "");
2044 timerManager->powerOnTriggerTimerList_.push_back(timerInfo);
2045 EXPECT_EQ(timerManager->powerOnTriggerTimerList_.size(), 1);
2046 timerManager->DeleteTimerFromPowerOnTimerListById(TIMER_ID);
2047 EXPECT_EQ(timerManager->powerOnTriggerTimerList_.size(), 0);
2048 }
2049
2050 /**
2051 * @tc.name: ReschedulePowerOnTimerLocked001.
2052 * @tc.desc: Test function ReschedulePowerOnTimer, use three timer to test the schedule.
2053 * @tc.type: FUNC
2054 */
2055 HWTEST_F(TimeServiceTimerTest, ReschedulePowerOnTimerLocked001, TestSize.Level0)
2056 {
2057 auto timerManager = TimerManager::GetInstance();
2058 timerManager->lastSetTime_[POWER_ON_ALARM] = 0;
2059 int64_t currentTime = 0;
2060 TimeUtils::GetWallTimeMs(currentTime);
2061 auto triggerTime1 = currentTime + 1000;
2062 auto duration1 = std::chrono::milliseconds(triggerTime1);
2063 auto timePoint = std::chrono::steady_clock::now();
2064 auto timerInfo1 = std::make_shared<TimerInfo>("", TIMER_ID, 0, duration1, timePoint, duration1, timePoint,
2065 duration1, nullptr, nullptr, 0, false, 0, 0, "");
2066 timerManager->powerOnTriggerTimerList_.push_back(timerInfo1);
2067 timerManager->ReschedulePowerOnTimerLocked();
2068 EXPECT_EQ(timerManager->lastSetTime_[POWER_ON_ALARM], triggerTime1);
2069
2070 auto triggerTime2 = currentTime + 2000;
2071 auto duration2 = std::chrono::milliseconds(triggerTime2);
2072 auto timerId2 = TIMER_ID + 1;
2073 auto timerInfo2 = std::make_shared<TimerInfo>("", timerId2, 0, duration2, timePoint, duration2, timePoint,
2074 duration2, nullptr, nullptr, 0, false, 0, 0, "");
2075 timerManager->powerOnTriggerTimerList_.push_back(timerInfo2);
2076 timerManager->ReschedulePowerOnTimerLocked();
2077 EXPECT_EQ(timerManager->lastSetTime_[POWER_ON_ALARM], triggerTime1);
2078
2079 auto triggerTime3 = currentTime + 500;
2080 auto duration3 = std::chrono::milliseconds(triggerTime3);
2081 auto timerId3 = timerId2 + 1;
2082 auto timerInfo3 = std::make_shared<TimerInfo>("", timerId3, 0, duration3, timePoint, duration3, timePoint,
2083 duration3, nullptr, nullptr, 0, false, 0, 0, "");
2084 timerManager->powerOnTriggerTimerList_.push_back(timerInfo3);
2085 timerManager->ReschedulePowerOnTimerLocked();
2086 EXPECT_EQ(timerManager->lastSetTime_[POWER_ON_ALARM], triggerTime3);
2087
2088 timerManager->DeleteTimerFromPowerOnTimerListById(timerId3);
2089 timerManager->ReschedulePowerOnTimerLocked();
2090 EXPECT_EQ(timerManager->lastSetTime_[POWER_ON_ALARM], triggerTime1);
2091
2092 timerManager->DeleteTimerFromPowerOnTimerListById(TIMER_ID);
2093 timerManager->ReschedulePowerOnTimerLocked();
2094 EXPECT_EQ(timerManager->lastSetTime_[POWER_ON_ALARM], triggerTime2);
2095
2096 timerManager->powerOnTriggerTimerList_.clear();
2097 timerManager->ReschedulePowerOnTimerLocked();
2098 EXPECT_EQ(timerManager->lastSetTime_[POWER_ON_ALARM] >= currentTime + TEN_YEARS_TO_SECOND * SECOND_TO_MILLISECOND,
2099 true);
2100 }
2101 #endif
2102
2103 /**
2104 * @tc.name: ResetAllProxy001.
2105 * @tc.desc: test RefreshNetworkTimeByTimer.
2106 * @tc.type: FUNC
2107 */
2108 HWTEST_F(TimeServiceTimerTest, ResetAllProxy001, TestSize.Level0)
2109 {
2110 DeletePermission();
2111 auto res = TimeSystemAbility::GetInstance()->ResetAllProxy();
2112 EXPECT_EQ(res, E_TIME_NO_PERMISSION);
2113 }
2114
2115 /**
2116 * @tc.name: ExactRepeatTimer001.
2117 * @tc.desc: test exact & repeat tiemr.
2118 * @tc.type: FUNC
2119 */
2120 HWTEST_F(TimeServiceTimerTest, ExactRepeatTimer001, TestSize.Level0)
2121 {
2122 auto windowLength = std::chrono::milliseconds::zero();
2123 auto interval = std::chrono::milliseconds(20000);
2124 auto timePoint = std::chrono::steady_clock::now();
2125 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>((timePoint).time_since_epoch());
__anond7ed28c40402(uint64_t id) 2126 auto callback = [this](uint64_t id) -> int32_t {
2127 return 0;
2128 };
2129 auto timerInfo = std::make_shared<TimerInfo>("", TIMER_ID, 0, duration, timePoint, windowLength, timePoint,
2130 interval, callback, nullptr, 0, false, UID, PID, "");
2131 auto bootTime = TimeUtils::GetBootTimeNs();
2132 TimerManager::GetInstance()->HandleRepeatTimer(timerInfo, bootTime);
2133 auto uidTimersMap = TimerProxy::GetInstance().uidTimersMap_;
2134 auto it1 = uidTimersMap.find(UID);
2135 EXPECT_NE(it1, uidTimersMap.end());
2136 auto it2 = it1->second.find(TIMER_ID);
2137 EXPECT_NE(it2, it1->second.end());
2138 EXPECT_EQ(it2->second->whenElapsed, it2->second->maxWhenElapsed);
2139 }
2140
2141 #ifdef MULTI_ACCOUNT_ENABLE
2142 /**
2143 * @tc.name: CheckUserIdForNotify001
2144 * @tc.desc: test CheckUserIdForNotify.
2145 * @tc.type: FUNC
2146 */
2147 HWTEST_F(TimeServiceTimerTest, CheckUserIdForNotify001, TestSize.Level0)
2148 {
2149 auto duration = std::chrono::milliseconds::zero();
2150 auto timePoint = std::chrono::steady_clock::now();
2151 auto timerInfo = std::make_shared<TimerInfo>("", TIMER_ID, 0, duration, timePoint, duration, timePoint, duration,
2152 nullptr, nullptr, 0, false, -1, 0, "");
2153 auto res = TimerManager::GetInstance()->CheckUserIdForNotify(timerInfo);
2154 EXPECT_EQ(res, E_TIME_ACCOUNT_ERROR);
2155 timerInfo = std::make_shared<TimerInfo>("", TIMER_ID, 0, duration, timePoint, duration, timePoint, duration,
2156 nullptr, nullptr, 0, false, 0, 0, "");
2157 res = TimerManager::GetInstance()->CheckUserIdForNotify(timerInfo);
2158 EXPECT_EQ(res, E_TIME_OK);
2159 }
2160 #endif
2161
2162 /**
2163 * @tc.name: AdjustTimerWithNoPermission001
2164 * @tc.desc: Verify AdjustTimer with no permission.
2165 * @tc.type: FUNC
2166 */
2167 HWTEST_F(TimeServiceTimerTest, AdjustTimerWithNoPermission001, TestSize.Level0)
2168 {
2169 DeletePermission();
2170 auto res = TimeSystemAbility::GetInstance()->AdjustTimer(false, 0, 0);
2171 EXPECT_EQ(res, E_TIME_NO_PERMISSION);
2172 }
2173
2174 /**
2175 * @tc.name:ProxyTimerWithNoPermission001
2176 * @tc.desc: Verify ProxyTimer with no permission.
2177 * @tc.type: FUNC
2178 */
2179 HWTEST_F(TimeServiceTimerTest, ProxyTimerWithNoPermission001, TestSize.Level0)
2180 {
2181 DeletePermission();
2182 std::vector<int> pidList{1};
2183 auto res = TimeSystemAbility::GetInstance()->ProxyTimer(1, pidList, false, false);
2184 EXPECT_EQ(res, E_TIME_NO_PERMISSION);
2185 }
2186
2187 /**
2188 * @tc.name: SetTimerExemptionyWithNoPermission001
2189 * @tc.desc: Verify SetTimerExemption with no permission.
2190 * @tc.type: FUNC
2191 */
2192 HWTEST_F(TimeServiceTimerTest, SetTimerExemptionWithNoPermission001, TestSize.Level0)
2193 {
2194 DeletePermission();
2195 std::vector<std::string> nameArr{"timer"};
2196 auto res = TimeSystemAbility::GetInstance()->SetTimerExemption(nameArr, false);
2197 EXPECT_EQ(res, E_TIME_NO_PERMISSION);
2198 }
2199
2200 /**
2201 * @tc.name: ResetAllProxyWithNoPermission004.
2202 * @tc.desc: Verify ResetAllProxy with no permission.
2203 * @tc.type: FUNC
2204 */
2205 HWTEST_F(TimeServiceTimerTest, ResetAllProxyWithNoPermission001, TestSize.Level0)
2206 {
2207 DeletePermission();
2208 auto res = TimeSystemAbility::GetInstance()->ResetAllProxy();
2209 EXPECT_EQ(res, E_TIME_NO_PERMISSION);
2210 }
2211 } // namespace