1 /*
2 * Copyright (C) 2023-2023 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 #define private public
17 #include <gtest/gtest.h>
18 #include <unistd.h>
19 #include "timer_manager.h"
20 #include "timer_proxy.h"
21 #include "time_common.h"
22 #include "time_service_test.h"
23
24 namespace OHOS {
25 namespace MiscServices {
26 using namespace testing::ext;
27 using namespace std::chrono;
28
29 namespace {
30 constexpr uint64_t NANO_TO_MILESECOND = 100000;
31 const uint64_t TIMER_ID = 88887;
32 const int UID = 999996;
33 const int PID = 999997;
34 const int ELAPSED_REALTIME_WAKEUP = 2;
35 }
36 TimerManager* timerManagerHandler_ = nullptr;
37
38 class TimeProxyTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41
42 static void TearDownTestCase(void);
43
44 void SetUp();
45
46 void TearDown();
47 };
48
SetUpTestCase(void)49 void TimeProxyTest::SetUpTestCase(void)
50 {}
51
TearDownTestCase(void)52 void TimeProxyTest::TearDownTestCase(void)
53 {}
54
SetUp(void)55 void TimeProxyTest::SetUp(void)
56 {
57 TIME_HILOGI(TIME_MODULE_SERVICE, "start SetUp.");
58 timerManagerHandler_ = TimerManager::GetInstance();
59 EXPECT_NE(timerManagerHandler_, nullptr);
60 TIME_HILOGI(TIME_MODULE_SERVICE, "end SetUp.");
61 }
62
TearDown(void)63 void TimeProxyTest::TearDown(void)
64 {
65 TIME_HILOGI(TIME_MODULE_SERVICE, "start TearDown.");
66 timerManagerHandler_ = nullptr;
67 TIME_HILOGI(TIME_MODULE_SERVICE, "end TearDown.");
68 }
69
CreateTimer(int uid,int pid)70 uint64_t CreateTimer(int uid, int pid)
71 {
72 TimerPara paras;
73 paras.timerType = ELAPSED_REALTIME_WAKEUP;
74 paras.windowLength = -1;
75 paras.interval = 0;
76 paras.flag = 0;
77 auto wantAgent = std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent>();
78 uint64_t timerId = 0;
79 int32_t ret = timerManagerHandler_->CreateTimer(paras, [] (const uint64_t) {return 0;},
80 wantAgent, uid, pid, timerId, NOT_STORE);
81 EXPECT_EQ(ret, TimeError::E_TIME_OK);
82 return timerId;
83 }
84
StartTimer(uint64_t timerId)85 void StartTimer(uint64_t timerId)
86 {
87 auto nowElapsed = timerManagerHandler_->GetBootTimeNs().time_since_epoch().count() / NANO_TO_MILESECOND;
88 uint64_t triggerTime = 10000000 + nowElapsed;
89 auto ret = timerManagerHandler_->StartTimer(timerId, triggerTime);
90 EXPECT_EQ(ret, TimeError::E_TIME_OK);
91 }
92
93 /**
94 * @tc.name: UidTimerMap001
95 * @tc.desc: start a timer, it can be added into UidTimerMap
96 and can be erase when stop.
97 * @tc.type: FUNC
98 */
99 HWTEST_F(TimeProxyTest, UidTimerMap001, TestSize.Level1)
100 {
101 int32_t uid = 2000;
102 int pid = 1000;
103 uint64_t timerId = CreateTimer(uid, pid);
104 StartTimer(timerId);
105 auto uidTimersMap = TimerProxy::GetInstance().uidTimersMap_;
106 EXPECT_EQ(uidTimersMap.size(), (const unsigned int)1);
107
108 auto itUidTimerMap = uidTimersMap.find(uid);
109 EXPECT_NE(itUidTimerMap, uidTimersMap.end());
110 EXPECT_EQ(itUidTimerMap->second.size(), (const unsigned int)1);
111
112 auto itTimerId = itUidTimerMap->second.find(timerId);
113 EXPECT_NE(itTimerId, itUidTimerMap->second.end());
114 EXPECT_NE(itTimerId->second, nullptr);
115
116 auto ret = timerManagerHandler_->StopTimer(timerId);
117 EXPECT_EQ(ret, TimeError::E_TIME_OK);
118
119 uidTimersMap = TimerProxy::GetInstance().uidTimersMap_;
120 EXPECT_EQ(uidTimersMap.size(), (const unsigned int)0);
121 timerManagerHandler_->DestroyTimer(timerId);
122 }
123
124 /**
125 * @tc.name: UidTimerMap002
126 * @tc.desc: start a timer, it can be added into UidTimerMap
127 and can be erase when destory.
128 * @tc.type: FUNC
129 */
130 HWTEST_F(TimeProxyTest, UidTimerMap002, TestSize.Level1)
131 {
132 int32_t uid = 2000;
133 int pid = 1000;
134 uint64_t timerId = CreateTimer(uid, pid);
135 StartTimer(timerId);
136
137 auto ret = timerManagerHandler_->DestroyTimer(timerId);
138 EXPECT_EQ(ret, TimeError::E_TIME_OK);
139 auto uidTimersMap = TimerProxy::GetInstance().uidTimersMap_;
140 EXPECT_EQ(uidTimersMap.size(), (const unsigned int)0);
141 }
142
143 /**
144 * @tc.name: UidTimerMap003
145 * @tc.desc: start a timer, it can be added into UidTimerMap
146 and can be erase when triggered.
147 * @tc.type: FUNC
148 */
149 HWTEST_F(TimeProxyTest, UidTimerMap003, TestSize.Level1)
150 {
151 int32_t uid = 2000;
152 int pid = 1000;
153 uint64_t timerId = CreateTimer(uid, pid);
154
155 StartTimer(timerId);
156
157 std::vector<std::shared_ptr<TimerInfo>> triggerList;
158 std::shared_ptr<Batch> batch = timerManagerHandler_->alarmBatches_.at(0);
159 std::chrono::steady_clock::time_point tpRpoch(nanoseconds(1000000000));
160 batch->start_ = tpRpoch;
161 auto retTrigger = timerManagerHandler_->TriggerTimersLocked(triggerList, timerManagerHandler_->GetBootTimeNs());
162 EXPECT_EQ(retTrigger, true);
163 auto uidTimersMap = TimerProxy::GetInstance().uidTimersMap_;
164 EXPECT_EQ(uidTimersMap.size(), (const unsigned int)0);
165 timerManagerHandler_->DestroyTimer(timerId);
166 }
167
168 /**
169 * @tc.name: ProxyTimerByUid001
170 * @tc.desc: test proxytimer in uid
171 * @tc.type: FUNC
172 */
173 HWTEST_F(TimeProxyTest, ProxyTimerByUid001, TestSize.Level1)
174 {
175 int32_t uid = 1000;
176 bool isProxy = true;
177 bool needRetrigger = true;
178 std::set<int> pidList;
179 bool ret = timerManagerHandler_->ProxyTimer(uid, pidList, isProxy, needRetrigger);
180 EXPECT_TRUE(ret);
181
182 auto key = GetProxyKey(uid, 0);
183 auto proxyTimers = TimerProxy::GetInstance().proxyTimers_;
184 EXPECT_EQ(proxyTimers.size(), (const unsigned int)1);
185 auto it = proxyTimers.find(key);
186 EXPECT_NE(it, proxyTimers.end());
187 EXPECT_EQ(it->second.size(), (const unsigned int)0);
188
189 isProxy = false;
190 ret = timerManagerHandler_->ProxyTimer(uid, pidList, isProxy, needRetrigger);
191 EXPECT_TRUE(ret);
192 proxyTimers = TimerProxy::GetInstance().proxyTimers_;
193 EXPECT_EQ(proxyTimers.size(), (const unsigned int)0);
194 }
195
196 /**
197 * @tc.name: ProxyTimerByUid002
198 * @tc.desc: test proxy by uid, the map proxyTimers_ acts.
199 * @tc.type: FUNC
200 */
201 HWTEST_F(TimeProxyTest, ProxyTimerByUid002, TestSize.Level1)
202 {
203 int32_t uid = 2000;
204 int pid = 1000;
205 uint64_t timerId = CreateTimer(uid, pid);
206 StartTimer(timerId);
207 auto uidTimersMap = TimerProxy::GetInstance().uidTimersMap_;
208 std::chrono::steady_clock::time_point originTime = uidTimersMap[uid][timerId]->whenElapsed;
209
210 std::set<int> pidList;
211 bool retProxy = timerManagerHandler_->ProxyTimer(uid, pidList, true, true);
212 EXPECT_TRUE(retProxy);
213 auto key = GetProxyKey(uid, 0);
214 auto proxyTimers = TimerProxy::GetInstance().proxyTimers_;
215 EXPECT_EQ(proxyTimers.size(), (const unsigned int)1);
216 auto it = proxyTimers.find(key);
217 EXPECT_NE(it, proxyTimers.end());
218 EXPECT_EQ(it->second.size(), (const unsigned int)1);
219
220 it = TimerProxy::GetInstance().proxyTimers_.find(key);
221 auto it2 = std::find(it->second.begin(), it->second.end(), timerId);
222 EXPECT_NE(it2, it->second.end());
223 uidTimersMap = TimerProxy::GetInstance().uidTimersMap_;
224 std::chrono::steady_clock::time_point time = uidTimersMap[uid][timerId]->originProxyWhenElapsed;
225 EXPECT_EQ(originTime, time);
226 auto it3 = uidTimersMap.find(uid);
227 EXPECT_NE(it3, uidTimersMap.end());
228 auto it4 = it3->second.find(timerId);
229 EXPECT_NE(it4, it3->second.end());
230 EXPECT_NE(it4->second->whenElapsed, time);
231
232 retProxy = timerManagerHandler_->ProxyTimer(uid, pidList, false, true);
233 EXPECT_TRUE(retProxy);
234 EXPECT_EQ(TimerProxy::GetInstance().proxyTimers_.size(), (const unsigned int)0);
235 uidTimersMap = TimerProxy::GetInstance().uidTimersMap_;
236 auto it5 = uidTimersMap.find(uid);
237 EXPECT_NE(it5, uidTimersMap.end());
238 auto it6 = it5->second.find(timerId);
239 EXPECT_NE(it6, it5->second.end());
240 EXPECT_EQ(it6->second->whenElapsed, time);
241 timerManagerHandler_->DestroyTimer(timerId);
242 }
243
244 /**
245 * @tc.name: ProxyTimerByUid003
246 * @tc.desc: reset all proxy
247 * @tc.type: FUNC
248 */
249 HWTEST_F(TimeProxyTest, ProxyTimerByUid003, TestSize.Level1)
250 {
251 int32_t uid = 2000;
252 std::set<int> pidList;
253 bool retProxy = timerManagerHandler_->ProxyTimer(uid, pidList, true, true);
254 EXPECT_TRUE(retProxy);
255 auto proxyTimers = TimerProxy::GetInstance().proxyTimers_;
256 auto key = GetProxyKey(uid, 0);
257 EXPECT_EQ(proxyTimers.size(), (const unsigned int)1);
258 auto it = proxyTimers.find(key);
259 EXPECT_NE(it, proxyTimers.end());
260 EXPECT_EQ(it->second.size(), (const unsigned int)0);
261
262 uid = 3000;
263 retProxy = timerManagerHandler_->ProxyTimer(uid, pidList, true, true);
264 EXPECT_TRUE(retProxy);
265 proxyTimers = TimerProxy::GetInstance().proxyTimers_;
266 EXPECT_EQ(proxyTimers.size(), (const unsigned int)2);
267 key = GetProxyKey(uid, 0);
268 it = proxyTimers.find(key);
269 EXPECT_NE(it, proxyTimers.end());
270 EXPECT_EQ(it->second.size(), (const unsigned int)0);
271
272 uid = 4000;
273 retProxy = timerManagerHandler_->ProxyTimer(uid, pidList, true, true);
274 EXPECT_TRUE(retProxy);
275 proxyTimers = TimerProxy::GetInstance().proxyTimers_;
276 EXPECT_EQ(proxyTimers.size(), (const unsigned int)3);
277 key = GetProxyKey(uid, 0);
278 it = proxyTimers.find(key);
279 EXPECT_NE(it, proxyTimers.end());
280 EXPECT_EQ(it->second.size(), (const unsigned int)0);
281
282 retProxy = timerManagerHandler_->ResetAllProxy();
283 EXPECT_TRUE(retProxy);
284 EXPECT_TRUE(TimerProxy::GetInstance().proxyTimers_.empty());
285 }
286
287
288 /**
289 * @tc.name: AdjustTimer001
290 * @tc.desc: adjust timer test
291 * @tc.type: FUNC
292 */
293 HWTEST_F(TimeProxyTest, AdjustTimer001, TestSize.Level1)
294 {
295 /* The system timers can be aligned to a unified time and recorded in adjustTimers_. */
296 bool isAdjust = true;
297 uint32_t interval = 100;
298 bool ret = timerManagerHandler_->AdjustTimer(isAdjust, interval, 0);
299 EXPECT_TRUE(ret);
300 EXPECT_EQ(TimerProxy::GetInstance().adjustTimers_.size(), (const unsigned int)0);
301
302 /* The unified heartbeat can be deleted successfully and deleted from adjustTimers_. */
303 isAdjust = false;
304 interval = 0;
305 ret = timerManagerHandler_->AdjustTimer(isAdjust, interval, 0);
306 EXPECT_TRUE(ret);
307 EXPECT_EQ(TimerProxy::GetInstance().adjustTimers_.size(), (const unsigned int)0);
308 }
309
310 /**
311 * @tc.name: AdjustTimer002
312 * @tc.desc: set timer exemption
313 * @tc.type: FUNC
314 */
315 HWTEST_F(TimeProxyTest, AdjustTimer002, TestSize.Level1)
316 {
317 int32_t uid = 2000;
318 int32_t pid = 1000;
319 uint64_t timerId = CreateTimer(uid, pid);
320
321 /* Create a timer */
322 StartTimer(timerId);
323
324 /* Exempt the timer of the app and update the record to adjustExemptionList_. */
325 std::unordered_set<std::string> nameArr{"time_service"};
326 timerManagerHandler_->SetTimerExemption(nameArr, true);
327 EXPECT_NE(TimerProxy::GetInstance().adjustExemptionList_.size(), (const unsigned int)0);
328
329 /* Unified heartbeat is triggered. The heartbeat of exempted applications is not unified. */
330 bool isAdjust = true;
331 uint32_t interval = 200;
332 bool adjustRet = timerManagerHandler_->AdjustTimer(isAdjust, interval, 0);
333 EXPECT_TRUE(adjustRet);
334 EXPECT_NE(TimerProxy::GetInstance().adjustTimers_.size(), (const unsigned int)0);
335 bool isExemption = true;
336 for (auto timer : TimerProxy::GetInstance().adjustTimers_) {
337 if (timer->bundleName == "time_service") {
338 isExemption = false;
339 }
340 }
341 EXPECT_TRUE(isExemption);
342 timerManagerHandler_->DestroyTimer(timerId);
343 }
344
345 /**
346 * @tc.name: ProxyTimerByPid001
347 * @tc.desc: test proxytimer in Pid
348 * @tc.type: FUNC
349 */
350 HWTEST_F(TimeProxyTest, ProxyTimerByPid001, TestSize.Level1)
351 {
352 int pid = 1003;
353 int uid = 2003;
354 std::set<int> pidList;
355 pidList.insert(pid);
356 bool isProxy = true;
357 bool needRetrigger = true;
358 bool ret = timerManagerHandler_->ProxyTimer(uid, pidList, isProxy, needRetrigger);
359 EXPECT_TRUE(ret);
360 auto key = GetProxyKey(uid, pid);
361 auto proxyTimers = TimerProxy::GetInstance().proxyTimers_;
362 EXPECT_EQ(proxyTimers.size(), (const unsigned int)1);
363 auto it = proxyTimers.find(key);
364 EXPECT_NE(it, proxyTimers.end());
365 EXPECT_EQ(it->second.size(), (const unsigned int)0);
366
367 isProxy = false;
368 ret = timerManagerHandler_->ProxyTimer(uid, pidList, isProxy, needRetrigger);
369 EXPECT_TRUE(ret);
370 EXPECT_EQ(TimerProxy::GetInstance().proxyTimers_.size(), (const unsigned int)0);
371 }
372
373 /**
374 * @tc.name: ProxyTimerByPid002
375 * @tc.desc: test proxy by pid, the map proxyTimers_ acts.
376 * @tc.type: FUNC
377 */
378 HWTEST_F(TimeProxyTest, ProxyTimerByPid002, TestSize.Level1)
379 {
380 int32_t uid = 2000;
381 int pid = 1000;
382 std::set<int> pidList;
383 pidList.insert(pid);
384 uint64_t timerId = CreateTimer(uid, pid);
385 StartTimer(timerId);
386 auto uidTimersMap = TimerProxy::GetInstance().uidTimersMap_;
387 std::chrono::steady_clock::time_point originTime = uidTimersMap[uid][timerId]->whenElapsed;
388
389 bool retProxy = timerManagerHandler_->ProxyTimer(uid, pidList, true, true);
390 EXPECT_TRUE(retProxy);
391 auto proxyTimers = TimerProxy::GetInstance().proxyTimers_;
392 EXPECT_EQ(proxyTimers.size(), (const unsigned int)1);
393 auto key = GetProxyKey(uid, pid);
394 auto it = proxyTimers.find(key);
395 EXPECT_NE(it, proxyTimers.end());
396 EXPECT_EQ(it->second.size(), (const unsigned int)1);
397
398 it = TimerProxy::GetInstance().proxyTimers_.find(key);
399 auto it2 = std::find(it->second.begin(), it->second.end(), timerId);
400 EXPECT_NE(it2, it->second.end());
401 uidTimersMap = TimerProxy::GetInstance().uidTimersMap_;
402 std::chrono::steady_clock::time_point time = uidTimersMap[uid][timerId]->originProxyWhenElapsed;
403 EXPECT_EQ(originTime, time);
404
405 auto it3 = uidTimersMap.find(uid);
406 EXPECT_NE(it3, uidTimersMap.end());
407 auto it4 = it3->second.find(timerId);
408 EXPECT_NE(it4, it3->second.end());
409 EXPECT_NE(it4->second->whenElapsed, time);
410
411 retProxy = timerManagerHandler_->ProxyTimer(uid, pidList, false, true);
412 EXPECT_TRUE(retProxy);
413 EXPECT_EQ(TimerProxy::GetInstance().proxyTimers_.size(), (const unsigned int)0);
414 uidTimersMap = TimerProxy::GetInstance().uidTimersMap_;
415 auto it5 = uidTimersMap.find(uid);
416 EXPECT_NE(it5, uidTimersMap.end());
417 auto it6 = it5->second.find(timerId);
418 EXPECT_NE(it6, it5->second.end());
419 EXPECT_EQ(it6->second->whenElapsed, time);
420 timerManagerHandler_->DestroyTimer(timerId);
421 }
422
423 /**
424 * @tc.name: PidProxyTimer003
425 * @tc.desc: reset all proxy测试
426 * @tc.type: FUNC
427 */
428 HWTEST_F(TimeProxyTest, PidProxyTimer003, TestSize.Level1)
429 {
430 int uid = 1000;
431 int pid1 = 2000;
432 std::set<int> pidList;
433 pidList.insert(pid1);
434
435 int pid2 = 3000;
436 pidList.insert(pid2);
437
438 int pid3 = 4000;
439 pidList.insert(pid3);
440
441 bool retProxy = timerManagerHandler_->ProxyTimer(uid, pidList, true, true);
442 EXPECT_TRUE(retProxy);
443 EXPECT_EQ(TimerProxy::GetInstance().proxyTimers_.size(), (const unsigned int)3);
444 uint64_t key1 = GetProxyKey(uid, pid1);
445 uint64_t key2 = GetProxyKey(uid, pid2);
446 uint64_t key3 = GetProxyKey(uid, pid3);
447 auto it = TimerProxy::GetInstance().proxyTimers_.find(key1);
448 EXPECT_NE(it, TimerProxy::GetInstance().proxyTimers_.end());
449 it = TimerProxy::GetInstance().proxyTimers_.find(key2);
450 EXPECT_NE(it, TimerProxy::GetInstance().proxyTimers_.end());
451 it = TimerProxy::GetInstance().proxyTimers_.find(key3);
452 EXPECT_NE(it, TimerProxy::GetInstance().proxyTimers_.end());
453 EXPECT_EQ(it->second.size(), (const unsigned int)0);
454
455 retProxy = timerManagerHandler_->ResetAllProxy();
456 EXPECT_TRUE(retProxy);
457 EXPECT_TRUE(TimerProxy::GetInstance().proxyTimers_.empty());
458 }
459
460 /**
461 * @tc.name: PidProxyTimer004
462 * @tc.desc: test proxy of same pid but different uid.
463 * @tc.type: FUNC
464 */
465 HWTEST_F(TimeProxyTest, PidProxyTimer004, TestSize.Level1)
466 {
467 int32_t uid1 = 2000;
468 int32_t uid2 = 2001;
469 int pid = 1000;
470 uint64_t timerId1 = CreateTimer(uid1, pid);
471 uint64_t timerId2 = CreateTimer(uid2, pid);
472
473 StartTimer(timerId1);
474 StartTimer(timerId2);
475
476 std::set<int> pidList;
477 pidList.insert(pid);
478 /* proxy uid1 expect proxyTimers_ only has one element */
479 auto ret = timerManagerHandler_->ProxyTimer(uid1, pidList, true, true);
480 EXPECT_TRUE(ret);
481 uint64_t key = GetProxyKey(uid1, pid);
482 EXPECT_EQ(TimerProxy::GetInstance().proxyTimers_[key].size(), (const unsigned int)1);
483 EXPECT_EQ(TimerProxy::GetInstance().IsProxy(uid1, pid), true);
484 EXPECT_EQ(TimerProxy::GetInstance().IsProxy(uid2, pid), false);
485 timerManagerHandler_->DestroyTimer(timerId1);
486 timerManagerHandler_->DestroyTimer(timerId2);
487 }
488
489 /**
490 * @tc.name: AdjustTimerProxy001
491 * @tc.desc: Determine whether to unify the heartbeat when the timer proxy is disabled.
492 * @tc.type: FUNC
493 */
494 HWTEST_F(TimeProxyTest, AdjustTimerProxy001, TestSize.Level1)
495 {
496 int32_t uid = 2001;
497 int pid = 1111;
498 std::set<int> pidList;
499 pidList.insert(pid);
500 uint64_t timerId = CreateTimer(uid, pid);
501
502 /* clear pidTimersMap_ */
503 TimerProxy::GetInstance().uidTimersMap_.clear();
504 TimerProxy::GetInstance().proxyTimers_.clear();
505
506 /* Start a timer. The timer can be started successfully and can be recorded in pidTimerMap_. */
507 StartTimer(timerId);
508 EXPECT_EQ(TimerProxy::GetInstance().uidTimersMap_.size(), (const unsigned int)1);
509
510 /* The proxy of a timer is successful and can be recorded in proxyPid_. */
511 bool retProxy = timerManagerHandler_->ProxyTimer(uid, pidList, true, true);
512 EXPECT_TRUE(retProxy);
513 EXPECT_EQ(TimerProxy::GetInstance().proxyTimers_.size(), (const unsigned int)1);
514 uint64_t key = GetProxyKey(uid, pid);
515 auto it = TimerProxy::GetInstance().proxyTimers_.find(key);
516 EXPECT_NE(it, TimerProxy::GetInstance().proxyTimers_.end());
517 EXPECT_EQ(it->second.size(), (const unsigned int)1);
518
519 /* Cancel a proxy timer. The proxy is canceled successfully, and the proxyPid_ table is updated. */
520 retProxy = timerManagerHandler_->ProxyTimer(uid, pidList, false, true);
521 EXPECT_TRUE(retProxy);
522 EXPECT_EQ(TimerProxy::GetInstance().proxyTimers_.size(), (const unsigned int)0);
523
524 /* After the proxy is disabled, determine whether unified heartbeat is required again. */
525 bool isAdjust = true;
526 uint32_t interval = 300;
527 bool adjret = timerManagerHandler_->AdjustTimer(isAdjust, interval, 0);
528 EXPECT_TRUE(adjret);
529 EXPECT_NE(TimerProxy::GetInstance().adjustTimers_.size(), (const unsigned int)0);
530 timerManagerHandler_->DestroyTimer(timerId);
531 }
532
533 /**
534 * @tc.name: AdjustTimerExemption001.
535 * @tc.desc: test adjust timer exemption list.
536 * @tc.type: FUNC
537 */
538 HWTEST_F(TimeProxyTest, AdjustTimerExemption001, TestSize.Level0)
539 {
540 TIME_HILOGI(TIME_MODULE_SERVICE, "AdjustTimerExemption001 start");
541 std::unordered_set<std::string> exemptionSet = {"bundleName|name"};
542 TimerProxy::GetInstance().SetTimerExemption(exemptionSet, true);
543 auto duration = std::chrono::milliseconds::zero();
544 auto timePoint = std::chrono::steady_clock::now();
545 auto timerInfo = TimerInfo("name", 0, 0, duration, timePoint, duration, timePoint, duration, nullptr,
546 nullptr, 0, false, 0, 0, "bundleName");
547 auto timerInfoPtr = std::make_shared<TimerInfo>(timerInfo);
548 auto ret = TimerProxy::GetInstance().IsTimerExemption(timerInfoPtr);
549 EXPECT_EQ(ret, true);
550 }
551
552 /**
553 * @tc.name: ProxyTimerCover001
554 * @tc.desc: test CallbackAlarmIfNeed
555 * @tc.type: FUNC
556 */
557 HWTEST_F(TimeProxyTest, ProxyTimerCover001, TestSize.Level1)
558 {
559 auto res = TimerProxy::GetInstance().CallbackAlarmIfNeed(nullptr);
560 EXPECT_EQ(res, E_TIME_NULLPTR);
561 }
562
563 /**
564 * @tc.name: ProxyTimerCover002
565 * @tc.desc: test UID
566 * @tc.type: FUNC
567 */
568 HWTEST_F(TimeProxyTest, ProxyTimerCover002, TestSize.Level1)
569 {
570 std::set<int> pidList;
571 auto retProxy = timerManagerHandler_->ProxyTimer(UID, pidList, true, true);
572 EXPECT_TRUE(retProxy);
573 TimerProxy::GetInstance().EraseTimerFromProxyTimerMap(0, UID, 0);
574 }
575
576
577 /**
578 * @tc.name: ProxyTimerCover003
579 * @tc.desc: test PID
580 * @tc.type: FUNC
581 */
582 HWTEST_F(TimeProxyTest, ProxyTimerCover003, TestSize.Level1)
583 {
584 TimerProxy::GetInstance().uidTimersMap_.clear();
585 TimerProxy::GetInstance().proxyTimers_.clear();
586 int uid = 2000;
587 std::set<int> pidList;
588 pidList.insert(PID);
589 auto retProxy = timerManagerHandler_->ProxyTimer(uid, pidList, true, true);
590 EXPECT_TRUE(retProxy);
591 TimerProxy::GetInstance().EraseTimerFromProxyTimerMap(0, uid, PID);
592 }
593
594 /**
595 * @tc.name: ProxyTimerCover004
596 * @tc.desc: test CallbackAlarmIfNeed
597 * @tc.type: FUNC
598 */
599 HWTEST_F(TimeProxyTest, ProxyTimerCover004, TestSize.Level1)
600 {
601 TimerProxy::GetInstance().RecordUidTimerMap(nullptr, false);
602 TimerProxy::GetInstance().RemoveUidTimerMap(nullptr);
603
604 auto duration = std::chrono::milliseconds::zero();
605 auto timePoint = std::chrono::steady_clock::now();
606 auto timerInfo = std::make_shared<TimerInfo>("", TIMER_ID, 0, duration, timePoint, duration, timePoint, duration,
607 nullptr, nullptr, 0, false, UID, PID, "");
608 TimerProxy::GetInstance().RecordUidTimerMap(timerInfo, false);
609 {
610 std::lock_guard<std::mutex> lock(TimerProxy::GetInstance().uidTimersMutex_);
611 auto it = TimerProxy::GetInstance().uidTimersMap_.find(UID);
612 EXPECT_NE(it, TimerProxy::GetInstance().uidTimersMap_.end());
613 }
614 TimerProxy::GetInstance().RemoveUidTimerMap(timerInfo);
615 {
616 std::lock_guard<std::mutex> lock(TimerProxy::GetInstance().uidTimersMutex_);
617 auto it = TimerProxy::GetInstance().uidTimersMap_.find(UID);
618 EXPECT_EQ(it, TimerProxy::GetInstance().uidTimersMap_.end());
619 }
620 }
621
622 } // MiscServices
623 } // OHOS