1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <fstream>
17
18 #include <gtest/gtest.h>
19
20 #include "mmi_log.h"
21 #include "uds_server.h"
22 #include "timer_manager.h"
23
24 namespace OHOS {
25 namespace MMI {
26 namespace {
27 using namespace testing::ext;
28 constexpr int32_t MAX_INTERVAL_MS { 10000 };
29 constexpr int32_t MIN_INTERVAL { 36 };
30 constexpr int32_t MAX_LONG_INTERVAL_MS { 30000 };
31 constexpr int32_t NONEXISTENT_ID { -1 };
32 } // namespace
33
34 class TimerManagerTest : public testing::Test {
35 public:
SetUpTestCase(void)36 static void SetUpTestCase(void) {}
TearDownTestCase(void)37 static void TearDownTestCase(void) {}
38 };
39
AddTimerCallback()40 void AddTimerCallback()
41 {
42 return;
43 }
44
45 /**
46 * @tc.name: TimerManagerTest_ManagerTimer_001
47 * @tc.desc: Test the function AddTimer
48 * @tc.type: FUNC
49 * @tc.require:
50 */
51 HWTEST_F(TimerManagerTest, TimerManagerTest_ManagerTimer_001, TestSize.Level1)
52 {
53 CALL_TEST_DEBUG;
54 int32_t repeatCount = 3;
55 int32_t intervalMs = 1000;
56 int32_t timerld = TimerMgr->AddTimer(intervalMs, repeatCount, AddTimerCallback);
57 EXPECT_EQ(timerld, 0);
58 }
59
60 /**
61 * @tc.name: TimerManagerTest_ManagerTimer_002
62 * @tc.desc: Test the function RemoveTimer
63 * @tc.type: FUNC
64 * @tc.require:
65 */
66 HWTEST_F(TimerManagerTest, TimerManagerTest_ManagerTimer_002, TestSize.Level1)
67 {
68 CALL_TEST_DEBUG;
69 int32_t repeatCount = 3;
70 int32_t intervalMs = 1000;
71 int32_t timerld = TimerMgr->AddTimer(intervalMs, repeatCount, AddTimerCallback);
72 ASSERT_EQ(TimerMgr->RemoveTimer(timerld), 0);
73 }
74
75 /**
76 * @tc.name: TimerManagerTest_ManagerTimer_003
77 * @tc.desc: Test the function ResetTimer
78 * @tc.type: FUNC
79 * @tc.require:
80 */
81 HWTEST_F(TimerManagerTest, TimerManagerTest_ManagerTimer_003, TestSize.Level1)
82 {
83 CALL_TEST_DEBUG;
84 int32_t repeatCount = 3;
85 int32_t intervalMs = 1000;
86 int32_t timerld = TimerMgr->AddTimer(intervalMs, repeatCount, AddTimerCallback);
87 int32_t result = TimerMgr->ResetTimer(timerld);
88 EXPECT_EQ(result, 0);
89 }
90
91 /**
92 * @tc.name: TimerManagerTest_ManagerTimer_004
93 * @tc.desc: Test the function IsExist
94 * @tc.type: FUNC
95 * @tc.require:
96 */
97 HWTEST_F(TimerManagerTest, TimerManagerTest_ManagerTimer_004, TestSize.Level1)
98 {
99 CALL_TEST_DEBUG;
100 int32_t repeatCount = 3;
101 int32_t intervalMs = 1000;
102 int32_t timerld = TimerMgr->AddTimer(intervalMs, repeatCount, AddTimerCallback);
103 ASSERT_TRUE(TimerMgr->IsExist(timerld));
104 }
105
106 /**
107 * @tc.name: TimerManagerTest_ManagerTimer_005
108 * @tc.desc: Test the function AddTimer
109 * @tc.type: FUNC
110 * @tc.require:
111 */
112 HWTEST_F(TimerManagerTest, TimerManagerTest_ManagerTimer_005, TestSize.Level1)
113 {
114 CALL_TEST_DEBUG;
115 int32_t repeatCount = 3;
116 int32_t intervalMs = 1000;
117 int32_t timerld = TimerMgr->AddTimer(intervalMs, repeatCount, nullptr);
118 EXPECT_EQ(timerld, -1);
119 }
120
121 /**
122 * @tc.name: TimerManagerTest_ManagerTimer_006
123 * @tc.desc: Test the function RemoveTimer
124 * @tc.type: FUNC
125 * @tc.require:
126 */
127 HWTEST_F(TimerManagerTest, TimerManagerTest_ManagerTimer_006, TestSize.Level1)
128 {
129 CALL_TEST_DEBUG;
130 int32_t repeatCount = 3;
131 int32_t intervalMs = 1000;
132 int32_t timerld = TimerMgr->AddTimerInternal(intervalMs, repeatCount, AddTimerCallback, "test006");
133 ASSERT_EQ(TimerMgr->RemoveTimer(timerld, "test006"), 0);
134 }
135
136 /**
137 * @tc.name: TimerManagerTest_AddTimer_001
138 * @tc.desc: Test adding a timer to the TimerManager
139 * @tc.type: FUNC
140 * @tc.require:
141 */
142 HWTEST_F(TimerManagerTest, TimerManagerTest_AddTimer_001, TestSize.Level1)
143 {
144 CALL_TEST_DEBUG;
145 TimerManager timermanager;
146 int32_t intervalMs = 0;
147 int32_t repeatCount = 1;
__anon92939f6b0202() 148 auto callback = []() {};
149 auto ret = timermanager.AddTimer(intervalMs, repeatCount, callback);
150 EXPECT_EQ(ret, 0);
151 intervalMs = -1;
152 repeatCount = 1;
153 ret = timermanager.AddTimer(intervalMs, repeatCount, callback);
154 EXPECT_EQ(ret, 1);
155 }
156
157 /**
158 * @tc.name: TimerManagerTest_RemoveTimer_001
159 * @tc.desc: Test removing a timer from the TimerManager
160 * @tc.type: FUNC
161 * @tc.require:
162 */
163 HWTEST_F(TimerManagerTest, TimerManagerTest_RemoveTimer_001, TestSize.Level1)
164 {
165 CALL_TEST_DEBUG;
166 TimerManager timermanager;
167 int32_t timerId = 1;
168 auto ret = timermanager.RemoveTimer(timerId);
169 EXPECT_EQ(ret, -1);
170 timerId = -1;
171 ret = timermanager.RemoveTimer(timerId);
172 EXPECT_EQ(ret, -1);
173 }
174
175 /**
176 * @tc.name: TimerManagerTest_ResetTimer_001
177 * @tc.desc: Test resetting a timer in the TimerManager
178 * @tc.type: FUNC
179 * @tc.require:
180 */
181 HWTEST_F(TimerManagerTest, TimerManagerTest_ResetTimer_001, TestSize.Level1)
182 {
183 CALL_TEST_DEBUG;
184 TimerManager timermanager;
185 int32_t timerId = 1;
186 auto ret = timermanager.ResetTimer(timerId);
187 EXPECT_EQ(ret, -1);
188 timerId = -1;
189 ret = timermanager.ResetTimer(timerId);
190 EXPECT_EQ(ret, -1);
191 ASSERT_NO_FATAL_FAILURE(timermanager.ProcessTimers());
192 }
193
194 /**
195 * @tc.name: TimerManagerTest_IsExist_001
196 * @tc.desc: Test checking if a timer exists in the TimerManager
197 * @tc.type: FUNC
198 * @tc.require:
199 */
200 HWTEST_F(TimerManagerTest, TimerManagerTest_IsExist_001, TestSize.Level1)
201 {
202 CALL_TEST_DEBUG;
203 TimerManager timermanager;
204 int32_t timerId = 1;
205 auto ret = timermanager.IsExist(timerId);
206 EXPECT_FALSE(ret);
207 timerId = -1;
208 ret = timermanager.IsExist(timerId);
209 EXPECT_FALSE(ret);
210 }
211
212 /**
213 * @tc.name: TimerManagerTest_CalcNextDelay_001
214 * @tc.desc: Test calculating the next delayed timer in the TimerManager
215 * @tc.type: FUNC
216 * @tc.require:
217 */
218 HWTEST_F(TimerManagerTest, TimerManagerTest_CalcNextDelay_001, TestSize.Level1)
219 {
220 CALL_TEST_DEBUG;
221 TimerManager timermanager;
222 auto ret = timermanager.CalcNextDelay();
223 EXPECT_EQ(ret, -1);;
224 }
225
226 /**
227 * @tc.name: TimerManagerTest_TakeNextTimerId_001
228 * @tc.desc: Test obtaining the ID of the next timer in the TimerManager
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(TimerManagerTest, TimerManagerTest_TakeNextTimerId_001, TestSize.Level1)
233 {
234 CALL_TEST_DEBUG;
235 TimerManager timermanager;
236 auto ret = timermanager.TakeNextTimerId();
237 EXPECT_EQ(ret, 0);
238 }
239
240 /**
241 * @tc.name: TimerManagerTest_AddTimerInternal_001
242 * @tc.desc: Test adding a timer internally within the TimerManager
243 * @tc.type: FUNC
244 * @tc.require:
245 */
246 HWTEST_F(TimerManagerTest, TimerManagerTest_AddTimerInternal_001, TestSize.Level1)
247 {
248 CALL_TEST_DEBUG;
249 TimerManager timermanager;
250 int32_t intervalMs = 50;
251 int32_t repeatCount = 1;
__anon92939f6b0302() 252 auto callback = []() {};
253 auto ret = timermanager.AddTimerInternal(intervalMs, repeatCount, callback);
254 EXPECT_EQ(ret, 0);
255 intervalMs = 11000;
256 repeatCount = 1;
257 ret = timermanager.AddTimerInternal(intervalMs, repeatCount, callback);
258 EXPECT_EQ(ret, 1);
259 intervalMs = 500;
260 repeatCount = 1;
261 ret = timermanager.AddTimerInternal(intervalMs, repeatCount, callback);
262 EXPECT_EQ(ret, 2);
263 }
264
265 /**
266 * @tc.name: TimerManagerTest_RemoveTimerInternal_001
267 * @tc.desc: Test removing a timer internally within the TimerManager
268 * @tc.type: FUNC
269 * @tc.require:
270 */
271 HWTEST_F(TimerManagerTest, TimerManagerTest_RemoveTimerInternal_001, TestSize.Level1)
272 {
273 CALL_TEST_DEBUG;
274 TimerManager timermanager;
275 int32_t timerId = 1;
276 auto ret = timermanager.RemoveTimerInternal(timerId);
277 EXPECT_EQ(ret, -1);
278 timerId = -1;
279 ret = timermanager.RemoveTimerInternal(timerId);
280 EXPECT_EQ(ret, -1);
281 }
282
283 /**
284 * @tc.name: TimerManagerTest_ResetTimerInternal_001
285 * @tc.desc: Test resetting a timer internally within the TimerManager
286 * @tc.type: FUNC
287 * @tc.require:
288 */
289 HWTEST_F(TimerManagerTest, TimerManagerTest_ResetTimerInternal_001, TestSize.Level1)
290 {
291 CALL_TEST_DEBUG;
292 TimerManager timermanager;
293 int32_t timerId = 1;
__anon92939f6b0402() 294 timermanager.AddTimer(timerId, 1000, []() {});
295 auto ret = timermanager.ResetTimerInternal(timerId);
296 EXPECT_EQ(ret, -1);
297 }
298
299 /**
300 * @tc.name: TimerManagerTest_IsExistInternal_001
301 * @tc.desc: Test checking if a timer exists internally within the TimerManager
302 * @tc.type: FUNC
303 * @tc.require:
304 */
305 HWTEST_F(TimerManagerTest, TimerManagerTest_IsExistInternal_001, TestSize.Level1)
306 {
307 CALL_TEST_DEBUG;
308 TimerManager timermanager;
309 int32_t timerId = 1;
310 auto ret = timermanager.IsExistInternal(timerId);
311 EXPECT_FALSE(ret);
312 timerId = 2;
313 ret = timermanager.IsExistInternal(timerId);
314 EXPECT_FALSE(ret);
315 timerId = -1;
316 ret = timermanager.IsExistInternal(timerId);
317 EXPECT_FALSE(ret);
318 }
319
320 /**
321 * @tc.name: TimerManagerTest_InsertTimerInternal_001
322 * @tc.desc: Test inserting a timer internally within the TimerManager
323 * @tc.type: FUNC
324 * @tc.require:
325 */
326 HWTEST_F(TimerManagerTest, TimerManagerTest_InsertTimerInternal_001, TestSize.Level1)
327 {
328 CALL_TEST_DEBUG;
329 TimerManager timermanager;
330 auto timer = std::make_unique<TimerManager::TimerItem>();
331 timer->nextCallTime = 100;
332 timermanager.InsertTimerInternal(timer);
333 EXPECT_EQ(timermanager.timers_.front()->nextCallTime, 100);
334 }
335
336 /**
337 * @tc.name: TimerManagerTest_InsertTimerInternal_002
338 * @tc.desc: Test inserting a timer internally within the TimerManager
339 * @tc.type: FUNC
340 * @tc.require:
341 */
342 HWTEST_F(TimerManagerTest, TimerManagerTest_InsertTimerInternal_002, TestSize.Level1)
343 {
344 CALL_TEST_DEBUG;
345 TimerManager timermanager;
346 auto timer1 = std::make_unique<TimerManager::TimerItem>();
347 timer1->nextCallTime = 100;
348 timermanager.InsertTimerInternal(timer1);
349 auto timer2 = std::make_unique<TimerManager::TimerItem>();
350 timer2->nextCallTime = 50;
351 timermanager.InsertTimerInternal(timer2);
352 EXPECT_EQ(timermanager.timers_.front()->nextCallTime, 50);
353 }
354
355 /**
356 * @tc.name: TimerManagerTest_InsertTimerInternal_003
357 * @tc.desc: Test inserting a timer internally within the TimerManager
358 * @tc.type: FUNC
359 * @tc.require:
360 */
361 HWTEST_F(TimerManagerTest, TimerManagerTest_InsertTimerInternal_003, TestSize.Level1)
362 {
363 CALL_TEST_DEBUG;
364 TimerManager timermanager;
365 auto timer1 = std::make_unique<TimerManager::TimerItem>();
366 timer1->nextCallTime = 100;
367 timermanager.InsertTimerInternal(timer1);
368 auto timer2 = std::make_unique<TimerManager::TimerItem>();
369 timer2->nextCallTime = 200;
370 timermanager.InsertTimerInternal(timer2);
371 auto timer3 = std::make_unique<TimerManager::TimerItem>();
372 timer3->nextCallTime = 200;
373 timermanager.InsertTimerInternal(timer3);
374 EXPECT_EQ(timermanager.timers_.front()->nextCallTime, 100);
375 }
376
377 /**
378 * @tc.name: TimerManagerTest_CalcNextDelayInternal_001
379 * @tc.desc: Test calculating the next delay internally within the TimerManager
380 * @tc.type: FUNC
381 * @tc.require:
382 */
383 HWTEST_F(TimerManagerTest, TimerManagerTest_CalcNextDelayInternal_001, TestSize.Level1)
384 {
385 CALL_TEST_DEBUG;
386 TimerManager timermanager;
387 int32_t timerId = 1;
__anon92939f6b0502() 388 timermanager.AddTimer(timerId, 1000, []() {});
389 int64_t millisTime = 36;
390 EXPECT_EQ(timermanager.CalcNextDelayInternal(), millisTime);
391 }
392
393 /**
394 * @tc.name: TimerManagerTest_CalcNextDelayInternal
395 * @tc.desc: Test calculating the next delay internally within the TimerManager
396 * @tc.type: FUNC
397 * @tc.require:
398 */
399 HWTEST_F(TimerManagerTest, TimerManagerTest_CalcNextDelayInternal, TestSize.Level1)
400 {
401 TimerManager tMgr;
402 auto timer = std::make_unique<TimerManager::TimerItem>();
403 timer->nextCallTime = -1;
404 tMgr.InsertTimerInternal(timer);
405 EXPECT_EQ(tMgr.CalcNextDelayInternal(), 0);
406 }
407
408 /**
409 * @tc.name: TimerManagerTest_ProcessTimersInternal_001
410 * @tc.desc: Test processing timers internally within the TimerManager
411 * @tc.type: FUNC
412 * @tc.require:
413 */
414 HWTEST_F(TimerManagerTest, TimerManagerTest_ProcessTimersInternal_001, TestSize.Level1)
415 {
416 CALL_TEST_DEBUG;
417 TimerManager timermanager;
418 ASSERT_NO_FATAL_FAILURE(timermanager.ProcessTimersInternal());
419 }
420
421 /**
422 * @tc.name: TimerManagerTest_ProcessTimersInternal
423 * @tc.desc: Test processing timers internally within the TimerManager
424 * @tc.type: FUNC
425 * @tc.require:
426 */
427 HWTEST_F(TimerManagerTest, TimerManagerTest_ProcessTimersInternal, TestSize.Level1)
428 {
429 TimerManager tMgr;
430 auto timer = std::make_unique<TimerManager::TimerItem>();
431 timer->nextCallTime = 10000000000;
432 tMgr.InsertTimerInternal(timer);
433 ASSERT_NO_FATAL_FAILURE(tMgr.ProcessTimersInternal());
434 }
435
436 /**
437 * @tc.name: TimerManagerTest_AddTimer_002
438 * @tc.desc: Verify AddTimer adjusts intervalMs to MIN_INTERVAL when less than MIN_INTERVAL
439 * @tc.type: FUNC
440 * @tc.require:
441 */
442 HWTEST_F(TimerManagerTest, TimerManagerTest_AddTimer_002, TestSize.Level1)
443 {
444 TimerManager timermanager;
445 int32_t intervalMs = -100;
446 int32_t repeatCount = 2;
447 bool callbackInvoked = false;
__anon92939f6b0602() 448 auto callback = [&callbackInvoked]() { callbackInvoked = true; };
449 auto ret = timermanager.AddTimer(intervalMs, repeatCount, callback, "TestTimerMin");
450 EXPECT_GE(ret, 0);
451 }
452
453 /**
454 * @tc.name: TimerManagerTest_AddTimer_003
455 * @tc.desc: Verify AddTimer adjusts intervalMs to MAX_INTERVAL_MS when greater than MAX_INTERVAL_MS
456 * @tc.type: FUNC
457 * @tc.require:
458 */
459 HWTEST_F(TimerManagerTest, TimerManagerTest_AddTimer_003, TestSize.Level1)
460 {
461 TimerManager timermanager;
462 int32_t intervalMs = MAX_INTERVAL_MS + 5000;
463 int32_t repeatCount = 3;
464 bool callbackInvoked = false;
__anon92939f6b0702() 465 auto callback = [&callbackInvoked]() { callbackInvoked = true; };
466 auto ret = timermanager.AddTimer(intervalMs, repeatCount, callback, "TestTimerMax");
467 EXPECT_GE(ret, 0);
468 }
469
470 /**
471 * @tc.name: TimerManagerTest_AddTimer_004
472 * @tc.desc: Verify AddTimer works with a normal valid interval
473 * @tc.type: FUNC
474 * @tc.require:
475 */
476 HWTEST_F(TimerManagerTest, TimerManagerTest_AddTimer_004, TestSize.Level1)
477 {
478 TimerManager timermanager;
479 int32_t intervalMs = 500;
480 int32_t repeatCount = 1;
481 bool callbackInvoked = false;
__anon92939f6b0802() 482 auto callback = [&callbackInvoked]() { callbackInvoked = true; };
483 auto ret = timermanager.AddTimer(intervalMs, repeatCount, callback, "TestTimerNormal");
484 EXPECT_GE(ret, 0);
485 }
486
487 /**
488 * @tc.name: TimerManagerTest_AddLongTimer_001
489 * @tc.desc: Verify AddLongTimer adjusts intervalMs to MIN_INTERVAL when less than MIN_INTERVAL
490 * @tc.type: FUNC
491 * @tc.require:
492 */
493 HWTEST_F(TimerManagerTest, TimerManagerTest_AddLongTimer_001, TestSize.Level1)
494 {
495 TimerManager timermanager;
496 int32_t intervalMs = MIN_INTERVAL - 10;
497 int32_t repeatCount = 1;
498 bool callbackInvoked = false;
__anon92939f6b0902() 499 auto callback = [&callbackInvoked]() { callbackInvoked = true; };
500 int32_t ret = timermanager.AddLongTimer(intervalMs, repeatCount, callback, "LongTimerMin");
501 EXPECT_GE(ret, 0);
502 }
503
504 /**
505 * @tc.name: TimerManagerTest_AddLongTimer_002
506 * @tc.desc: Verify AddLongTimer adjusts intervalMs to MAX_INTERVAL_MS when greater than MAX_LONG_INTERVAL_MS
507 * @tc.type: FUNC
508 * @tc.require:
509 */
510 HWTEST_F(TimerManagerTest, TimerManagerTest_AddLongTimer_002, TestSize.Level1)
511 {
512 TimerManager timermanager;
513 int32_t intervalMs = MAX_LONG_INTERVAL_MS + 5000;
514 int32_t repeatCount = 2;
515 bool callbackInvoked = false;
__anon92939f6b0a02() 516 auto callback = [&callbackInvoked]() { callbackInvoked = true; };
517 int32_t ret = timermanager.AddLongTimer(intervalMs, repeatCount, callback, "LongTimerMax");
518 EXPECT_GE(ret, 0);
519 }
520
521 /**
522 * @tc.name: TimerManagerTest_AddLongTimer_003
523 * @tc.desc: Verify AddLongTimer works correctly with valid interval
524 * @tc.type: FUNC
525 * @tc.require:
526 */
527 HWTEST_F(TimerManagerTest, TimerManagerTest_AddLongTimer_003, TestSize.Level1)
528 {
529 TimerManager timermanager;
530 int32_t intervalMs = 2000;
531 int32_t repeatCount = 1;
532 bool callbackInvoked = false;
__anon92939f6b0b02() 533 auto callback = [&callbackInvoked]() { callbackInvoked = true; };
534 int32_t ret = timermanager.AddLongTimer(intervalMs, repeatCount, callback, "LongTimerNormal");
535 EXPECT_GE(ret, 0);
536 }
537
538 /**
539 * @tc.name: TimerManagerTest_AddTimerInternal_002
540 * @tc.desc: Return NONEXISTENT_ID when callback is nullptr
541 * @tc.type: FUNC
542 * @tc.require:
543 */
544 HWTEST_F(TimerManagerTest, TimerManagerTest_AddTimerInternal_002, TestSize.Level1)
545 {
546 TimerManager timermanager;
547 int32_t intervalMs = 100;
548 int32_t repeatCount = 1;
549 std::function<void()> cb;
550 auto ret = timermanager.AddTimerInternal(intervalMs, repeatCount, cb, "null_cb");
551 EXPECT_EQ(ret, NONEXISTENT_ID);
552 }
553
554 /**
555 * @tc.name: TimerManagerTest_AddTimerInternal_003
556 * @tc.desc: Add many timers to ensure id keeps increasing monotonically
557 * @tc.type: FUNC
558 * @tc.require:
559 */
560 HWTEST_F(TimerManagerTest, TimerManagerTest_AddTimerInternal_003, TestSize.Level1)
561 {
562 TimerManager timermanager;
__anon92939f6b0c02() 563 auto cb = []() {};
564 const int kCount = 20;
565 for (int i = 0; i < kCount; i++) {
566 int32_t ret = timermanager.AddTimerInternal(100 + i, 1, cb, "bulk_" + std::to_string(i));
567 EXPECT_EQ(ret, i);
568 }
569 }
570
571 /**
572 * @tc.name: TimerManagerTest_AddTimerInternal_004
573 * @tc.desc: Add timer with repeatCount = 0 (edge value) should still return a valid id
574 * @tc.type: FUNC
575 * @tc.require:
576 */
577 HWTEST_F(TimerManagerTest, TimerManagerTest_AddTimerInternal_004, TestSize.Level1)
578 {
579 TimerManager timermanager;
__anon92939f6b0d02() 580 auto cb = []() {};
581 int32_t ret = timermanager.AddTimerInternal(200, 0, cb, "repeat_zero");
582 EXPECT_GE(ret, 0);
583 }
584
585 /**
586 * @tc.name: TimerManagerTest_AddTimerInternal_005
587 * @tc.desc: Add timer with very large intervalMs to ensure it is handled (no overflow path reachable here)
588 * @tc.type: FUNC
589 * @tc.require:
590 */
591 HWTEST_F(TimerManagerTest, TimerManagerTest_AddTimerInternal_005, TestSize.Level1)
592 {
593 TimerManager timermanager;
__anon92939f6b0e02() 594 auto cb = []() {};
595 int32_t ret = timermanager.AddTimerInternal(INT32_MAX, 1, cb, "large_interval");
596 EXPECT_GE(ret, 0);
597 }
598
599 /**
600 * @tc.name: TimerManagerTest_ResetTimerInternal_002
601 * @tc.desc: Add a timer and reset it successfully
602 * @tc.type: FUNC
603 * @tc.require:
604 */
605 HWTEST_F(TimerManagerTest, TimerManagerTest_ResetTimerInternal_002, TestSize.Level1)
606 {
607 TimerManager timermanager;
__anon92939f6b0f02() 608 auto callback = []() {};
609 int32_t timerId = timermanager.AddTimerInternal(100, 1, callback, "reset_ok");
610 ASSERT_GE(timerId, 0);
611 int32_t ret = timermanager.ResetTimerInternal(timerId);
612 EXPECT_EQ(ret, RET_OK);
613 }
614
615 /**
616 * @tc.name: TimerManagerTest_ResetTimerInternal_003
617 * @tc.desc: Add multiple timers and reset one of them
618 * @tc.type: FUNC
619 * @tc.require:
620 */
621 HWTEST_F(TimerManagerTest, TimerManagerTest_ResetTimerInternal_003, TestSize.Level1)
622 {
623 TimerManager timermanager;
__anon92939f6b1002() 624 auto callback = []() {};
625
626 int32_t id1 = timermanager.AddTimerInternal(200, 1, callback, "t1");
627 int32_t id2 = timermanager.AddTimerInternal(300, 1, callback, "t2");
628 int32_t id3 = timermanager.AddTimerInternal(400, 1, callback, "t3");
629 ASSERT_GE(id1, 0);
630 ASSERT_GE(id2, 0);
631 ASSERT_GE(id3, 0);
632 int32_t ret = timermanager.ResetTimerInternal(id2);
633 EXPECT_EQ(ret, RET_OK);
634 EXPECT_EQ(timermanager.ResetTimerInternal(id1), RET_OK);
635 }
636
637 /**
638 * @tc.name: TimerManagerTest_ResetTimerInternal_004
639 * @tc.desc: Attempt to reset non-existing timerId after timers have been added
640 * @tc.type: FUNC
641 * @tc.require:
642 */
643 HWTEST_F(TimerManagerTest, TimerManagerTest_ResetTimerInternal_004, TestSize.Level1)
644 {
645 TimerManager timermanager;
__anon92939f6b1102() 646 auto callback = []() {};
647 timermanager.AddTimerInternal(100, 1, callback, "t1");
648 int32_t ret = timermanager.ResetTimerInternal(9999);
649 EXPECT_EQ(ret, RET_ERR);
650 }
651
652 /**
653 * @tc.name: TimerManagerTest_ProcessTimersInternal_002
654 * @tc.desc: Add one timer and ensure its callback is executed once
655 * @tc.type: FUNC
656 * @tc.require:
657 */
658 HWTEST_F(TimerManagerTest, TimerManagerTest_ProcessTimersInternal_002, TestSize.Level1)
659 {
660 TimerManager timermanager;
661 bool callbackExecuted = false;
__anon92939f6b1202() 662 auto callback = [&callbackExecuted]() { callbackExecuted = true; };
663 int32_t timerId = timermanager.AddTimerInternal(0, 1, callback, "test_timer");
664 ASSERT_GE(timerId, 0);
665 timermanager.ProcessTimersInternal();
666 EXPECT_TRUE(callbackExecuted);
667 }
668
669 /**
670 * @tc.name: TimerManagerTest_ProcessTimersInternal_003
671 * @tc.desc: Add a single timer with repeatCount=1 and verify callback is called once
672 * @tc.type: FUNC
673 * @tc.require:
674 */
675 HWTEST_F(TimerManagerTest, TimerManagerTest_ProcessTimersInternal_003, TestSize.Level1)
676 {
677 TimerManager timermanager;
678 int callCount = 0;
__anon92939f6b1302() 679 auto callback = [&callCount]() { callCount++; };
680 int32_t timerId = timermanager.AddTimerInternal(0, 1, callback, "single_shot");
681 ASSERT_GE(timerId, 0);
682 timermanager.ProcessTimersInternal();
683 EXPECT_EQ(callCount, 1);
684 }
685
686 /**
687 * @tc.name: TimerManagerTest_ProcessTimersInternal_004
688 * @tc.desc: Add multiple timers with different intervals and process them
689 * @tc.type: FUNC
690 * @tc.require:
691 */
692 HWTEST_F(TimerManagerTest, TimerManagerTest_ProcessTimersInternal_004, TestSize.Level1)
693 {
694 TimerManager timermanager;
695 int callCount1 = 0;
696 int callCount2 = 0;
__anon92939f6b1402() 697 auto cb1 = [&callCount1]() { callCount1++; };
__anon92939f6b1502() 698 auto cb2 = [&callCount2]() { callCount2++; };
699 timermanager.AddTimerInternal(0, 1, cb1, "t1");
700 timermanager.AddTimerInternal(0, 1, cb2, "t2");
701 timermanager.ProcessTimersInternal();
702 EXPECT_EQ(callCount1, 1);
703 EXPECT_EQ(callCount2, 1);
704 }
705
706 /**
707 * @tc.name: TimerManagerTest_ProcessTimersInternal_005
708 * @tc.desc: ProcessTimersInternal with future timer (nextCallTime > nowTime) should not invoke callback
709 * @tc.type: FUNC
710 * @tc.require:
711 */
712 HWTEST_F(TimerManagerTest, TimerManagerTest_ProcessTimersInternal_005, TestSize.Level1)
713 {
714 TimerManager timermanager;
715 bool callbackExecuted = false;
__anon92939f6b1602() 716 auto callback = [&callbackExecuted]() { callbackExecuted = true; };
717 int32_t timerId = timermanager.AddTimerInternal(5000, 1, callback, "future_timer");
718 ASSERT_GE(timerId, 0);
719 timermanager.ProcessTimersInternal();
720 EXPECT_FALSE(callbackExecuted);
721 }
722 } // namespace MMI
723 } // namespace OHOS