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