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
24namespace OHOS {
25namespace MMI {
26namespace {
27using namespace testing::ext;
28constexpr int32_t errCode { -1 };
29constexpr int32_t rationId { 0 };
30constexpr int32_t rightId { 1 };
31} // namespace
32
33class TimerManagerTest : public testing::Test {
34public:
35    static void SetUpTestCase(void) {}
36    static void TearDownTestCase(void) {}
37};
38
39void AddTimerCallback()
40{
41    return;
42}
43
44/**
45 * @tc.name: TimerManagerTest_ManagerTimer_001
46 * @tc.desc: Test the function AddTimer
47 * @tc.type: FUNC
48 * @tc.require:
49 */
50HWTEST_F(TimerManagerTest, TimerManagerTest_ManagerTimer_001, TestSize.Level1)
51{
52    CALL_TEST_DEBUG;
53    int32_t repeatCount = 3;
54    int32_t intervalMs = 1000;
55    int32_t timerld = TimerMgr->AddTimer(intervalMs, repeatCount, AddTimerCallback);
56    EXPECT_EQ(timerld, rightId);
57}
58
59/**
60 * @tc.name: TimerManagerTest_ManagerTimer_002
61 * @tc.desc: Test the function RemoveTimer
62 * @tc.type: FUNC
63 * @tc.require:
64 */
65HWTEST_F(TimerManagerTest, TimerManagerTest_ManagerTimer_002, TestSize.Level1)
66{
67    CALL_TEST_DEBUG;
68    int32_t repeatCount = 3;
69    int32_t intervalMs = 1000;
70    int32_t timerld = TimerMgr->AddTimer(intervalMs, repeatCount, AddTimerCallback);
71    ASSERT_EQ(TimerMgr->RemoveTimer(timerld), rationId);
72}
73
74/**
75 * @tc.name: TimerManagerTest_ManagerTimer_003
76 * @tc.desc: Test the function ResetTimer
77 * @tc.type: FUNC
78 * @tc.require:
79 */
80HWTEST_F(TimerManagerTest, TimerManagerTest_ManagerTimer_003, TestSize.Level1)
81{
82    CALL_TEST_DEBUG;
83    int32_t repeatCount = 3;
84    int32_t intervalMs = 1000;
85    int32_t timerld = TimerMgr->AddTimer(intervalMs, repeatCount, AddTimerCallback);
86    int32_t result = TimerMgr->ResetTimer(timerld);
87    EXPECT_EQ(result, rationId);
88}
89
90/**
91 * @tc.name: TimerManagerTest_ManagerTimer_004
92 * @tc.desc: Test the function IsExist
93 * @tc.type: FUNC
94 * @tc.require:
95 */
96HWTEST_F(TimerManagerTest, TimerManagerTest_ManagerTimer_004, TestSize.Level1)
97{
98    CALL_TEST_DEBUG;
99    int32_t repeatCount = 3;
100    int32_t intervalMs = 1000;
101    int32_t timerld = TimerMgr->AddTimer(intervalMs, repeatCount, AddTimerCallback);
102    ASSERT_TRUE(TimerMgr->IsExist(timerld));
103}
104
105/**
106 * @tc.name: TimerManagerTest_ManagerTimer_005
107 * @tc.desc: Test the function AddTimer
108 * @tc.type: FUNC
109 * @tc.require:
110 */
111HWTEST_F(TimerManagerTest, TimerManagerTest_ManagerTimer_005, TestSize.Level1)
112{
113    CALL_TEST_DEBUG;
114    int32_t repeatCount = 3;
115    int32_t intervalMs = 1000;
116    int32_t timerld = TimerMgr->AddTimer(intervalMs, repeatCount, nullptr);
117    EXPECT_EQ(timerld, errCode);
118}
119
120/**
121 * @tc.name: TimerManagerTest_AddTimer_001
122 * @tc.desc: Test adding a timer to the TimerManager
123 * @tc.type: FUNC
124 * @tc.require:
125 */
126HWTEST_F(TimerManagerTest, TimerManagerTest_AddTimer_001, TestSize.Level1)
127{
128    CALL_TEST_DEBUG;
129    TimerManager timermanager;
130    int32_t intervalMs = 0;
131    int32_t repeatCount = 1;
132    auto callback = []() {};
133    auto ret = timermanager.AddTimer(intervalMs, repeatCount, callback);
134    EXPECT_EQ(ret, 0);
135    intervalMs = -1;
136    repeatCount = 1;
137    ret = timermanager.AddTimer(intervalMs, repeatCount, callback);
138    EXPECT_EQ(ret, 1);
139}
140
141/**
142 * @tc.name: TimerManagerTest_RemoveTimer_001
143 * @tc.desc: Test removing a timer from the TimerManager
144 * @tc.type: FUNC
145 * @tc.require:
146 */
147HWTEST_F(TimerManagerTest, TimerManagerTest_RemoveTimer_001, TestSize.Level1)
148{
149    CALL_TEST_DEBUG;
150    TimerManager timermanager;
151    int32_t timerId = 1;
152    auto ret = timermanager.RemoveTimer(timerId);
153    EXPECT_EQ(ret, -1);
154    timerId = -1;
155    ret = timermanager.RemoveTimer(timerId);
156    EXPECT_EQ(ret, -1);
157}
158
159/**
160 * @tc.name: TimerManagerTest_ResetTimer_001
161 * @tc.desc: Test resetting a timer in the TimerManager
162 * @tc.type: FUNC
163 * @tc.require:
164 */
165HWTEST_F(TimerManagerTest, TimerManagerTest_ResetTimer_001, TestSize.Level1)
166{
167    CALL_TEST_DEBUG;
168    TimerManager timermanager;
169    int32_t timerId = 1;
170    auto ret = timermanager.ResetTimer(timerId);
171    EXPECT_EQ(ret, -1);
172    timerId = -1;
173    ret = timermanager.ResetTimer(timerId);
174    EXPECT_EQ(ret, -1);
175    ASSERT_NO_FATAL_FAILURE(timermanager.ProcessTimers());
176}
177
178/**
179 * @tc.name: TimerManagerTest_IsExist_001
180 * @tc.desc: Test checking if a timer exists in the TimerManager
181 * @tc.type: FUNC
182 * @tc.require:
183 */
184HWTEST_F(TimerManagerTest, TimerManagerTest_IsExist_001, TestSize.Level1)
185{
186    CALL_TEST_DEBUG;
187    TimerManager timermanager;
188    int32_t timerId = 1;
189    auto ret = timermanager.IsExist(timerId);
190    EXPECT_FALSE(ret);
191    timerId = -1;
192    ret = timermanager.IsExist(timerId);
193    EXPECT_FALSE(ret);
194}
195
196/**
197 * @tc.name: TimerManagerTest_CalcNextDelay_001
198 * @tc.desc: Test calculating the next delayed timer in the TimerManager
199 * @tc.type: FUNC
200 * @tc.require:
201 */
202HWTEST_F(TimerManagerTest, TimerManagerTest_CalcNextDelay_001, TestSize.Level1)
203{
204    CALL_TEST_DEBUG;
205    TimerManager timermanager;
206    auto ret = timermanager.CalcNextDelay();
207    EXPECT_EQ(ret, -1);;
208}
209
210/**
211 * @tc.name: TimerManagerTest_TakeNextTimerId_001
212 * @tc.desc: Test obtaining the ID of the next timer in the TimerManager
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216HWTEST_F(TimerManagerTest, TimerManagerTest_TakeNextTimerId_001, TestSize.Level1)
217{
218    CALL_TEST_DEBUG;
219    TimerManager timermanager;
220    auto ret = timermanager.TakeNextTimerId();
221    EXPECT_EQ(ret, 0);
222}
223
224/**
225 * @tc.name: TimerManagerTest_AddTimerInternal_001
226 * @tc.desc: Test adding a timer internally within the TimerManager
227 * @tc.type: FUNC
228 * @tc.require:
229 */
230HWTEST_F(TimerManagerTest, TimerManagerTest_AddTimerInternal_001, TestSize.Level1)
231{
232    CALL_TEST_DEBUG;
233    TimerManager timermanager;
234    int32_t intervalMs = 50;
235    int32_t repeatCount = 1;
236    auto callback = []() {};
237    auto ret = timermanager.AddTimerInternal(intervalMs, repeatCount, callback);
238    EXPECT_EQ(ret, 0);
239    intervalMs = 11000;
240    repeatCount = 1;
241    ret = timermanager.AddTimerInternal(intervalMs, repeatCount, callback);
242    EXPECT_EQ(ret, 1);
243    intervalMs = 500;
244    repeatCount = 1;
245    ret = timermanager.AddTimerInternal(intervalMs, repeatCount, callback);
246    EXPECT_EQ(ret, 2);
247}
248
249/**
250 * @tc.name: TimerManagerTest_RemoveTimerInternal_001
251 * @tc.desc: Test removing a timer internally within the TimerManager
252 * @tc.type: FUNC
253 * @tc.require:
254 */
255HWTEST_F(TimerManagerTest, TimerManagerTest_RemoveTimerInternal_001, TestSize.Level1)
256{
257    CALL_TEST_DEBUG;
258    TimerManager timermanager;
259    int32_t timerId = 1;
260    auto ret = timermanager.RemoveTimerInternal(timerId);
261    EXPECT_EQ(ret, -1);
262    timerId = -1;
263    ret = timermanager.RemoveTimerInternal(timerId);
264    EXPECT_EQ(ret, -1);
265}
266
267/**
268 * @tc.name: TimerManagerTest_ResetTimerInternal_001
269 * @tc.desc: Test resetting a timer internally within the TimerManager
270 * @tc.type: FUNC
271 * @tc.require:
272 */
273HWTEST_F(TimerManagerTest, TimerManagerTest_ResetTimerInternal_001, TestSize.Level1)
274{
275    CALL_TEST_DEBUG;
276    TimerManager timermanager;
277    int32_t timerId = 1;
278    timermanager.AddTimer(timerId, 1000, []() {});
279    auto ret = timermanager.ResetTimerInternal(timerId);
280    EXPECT_EQ(ret, -1);
281}
282
283/**
284 * @tc.name: TimerManagerTest_IsExistInternal_001
285 * @tc.desc: Test checking if a timer exists internally within the TimerManager
286 * @tc.type: FUNC
287 * @tc.require:
288 */
289HWTEST_F(TimerManagerTest, TimerManagerTest_IsExistInternal_001, TestSize.Level1)
290{
291    CALL_TEST_DEBUG;
292    TimerManager timermanager;
293    int32_t timerId = 1;
294    auto ret = timermanager.IsExistInternal(timerId);
295    EXPECT_FALSE(ret);
296    timerId = 2;
297    ret = timermanager.IsExistInternal(timerId);
298    EXPECT_FALSE(ret);
299    timerId = -1;
300    ret = timermanager.IsExistInternal(timerId);
301    EXPECT_FALSE(ret);
302}
303
304/**
305 * @tc.name: TimerManagerTest_InsertTimerInternal_001
306 * @tc.desc: Test inserting a timer internally within the TimerManager
307 * @tc.type: FUNC
308 * @tc.require:
309 */
310HWTEST_F(TimerManagerTest, TimerManagerTest_InsertTimerInternal_001, TestSize.Level1)
311{
312    CALL_TEST_DEBUG;
313    TimerManager timermanager;
314    auto timer = std::make_unique<TimerManager::TimerItem>();
315    timer->nextCallTime = 100;
316    timermanager.InsertTimerInternal(timer);
317    EXPECT_EQ(timermanager.timers_.front()->nextCallTime, 100);
318}
319
320/**
321 * @tc.name: TimerManagerTest_InsertTimerInternal_002
322 * @tc.desc: Test inserting a timer internally within the TimerManager
323 * @tc.type: FUNC
324 * @tc.require:
325 */
326HWTEST_F(TimerManagerTest, TimerManagerTest_InsertTimerInternal_002, TestSize.Level1)
327{
328    CALL_TEST_DEBUG;
329    TimerManager timermanager;
330    auto timer1 = std::make_unique<TimerManager::TimerItem>();
331    timer1->nextCallTime = 100;
332    timermanager.InsertTimerInternal(timer1);
333    auto timer2 = std::make_unique<TimerManager::TimerItem>();
334    timer2->nextCallTime = 50;
335    timermanager.InsertTimerInternal(timer2);
336    EXPECT_EQ(timermanager.timers_.front()->nextCallTime, 50);
337}
338
339/**
340 * @tc.name: TimerManagerTest_InsertTimerInternal_003
341 * @tc.desc: Test inserting a timer internally within the TimerManager
342 * @tc.type: FUNC
343 * @tc.require:
344 */
345HWTEST_F(TimerManagerTest, TimerManagerTest_InsertTimerInternal_003, TestSize.Level1)
346{
347    CALL_TEST_DEBUG;
348    TimerManager timermanager;
349    auto timer1 = std::make_unique<TimerManager::TimerItem>();
350    timer1->nextCallTime = 100;
351    timermanager.InsertTimerInternal(timer1);
352    auto timer2 = std::make_unique<TimerManager::TimerItem>();
353    timer2->nextCallTime = 200;
354    timermanager.InsertTimerInternal(timer2);
355    auto timer3 = std::make_unique<TimerManager::TimerItem>();
356    timer3->nextCallTime = 200;
357    timermanager.InsertTimerInternal(timer3);
358    EXPECT_EQ(timermanager.timers_.front()->nextCallTime, 100);
359}
360
361/**
362 * @tc.name: TimerManagerTest_CalcNextDelayInternal_001
363 * @tc.desc: Test calculating the next delay internally within the TimerManager
364 * @tc.type: FUNC
365 * @tc.require:
366 */
367HWTEST_F(TimerManagerTest, TimerManagerTest_CalcNextDelayInternal_001, TestSize.Level1)
368{
369    CALL_TEST_DEBUG;
370    TimerManager timermanager;
371    int32_t timerId = 1;
372    timermanager.AddTimer(timerId, 1000, []() {});
373    int64_t millisTime = 36;
374    EXPECT_EQ(timermanager.CalcNextDelayInternal(), millisTime);
375}
376
377/**
378 * @tc.name: TimerManagerTest_CalcNextDelayInternal
379 * @tc.desc: Test calculating the next delay internally within the TimerManager
380 * @tc.type: FUNC
381 * @tc.require:
382 */
383HWTEST_F(TimerManagerTest, TimerManagerTest_CalcNextDelayInternal, TestSize.Level1)
384{
385    CALL_TEST_DEBUG;
386    TimerManager tMgr;
387    auto timer = std::make_unique<TimerManager::TimerItem>();
388    timer->nextCallTime = -1;
389    tMgr.InsertTimerInternal(timer);
390    EXPECT_EQ(tMgr.CalcNextDelayInternal(), 0);
391}
392
393/**
394 * @tc.name: TimerManagerTest_ProcessTimersInternal_001
395 * @tc.desc: Test processing timers internally within the TimerManager
396 * @tc.type: FUNC
397 * @tc.require:
398 */
399HWTEST_F(TimerManagerTest, TimerManagerTest_ProcessTimersInternal_001, TestSize.Level1)
400{
401    CALL_TEST_DEBUG;
402    TimerManager timermanager;
403    ASSERT_NO_FATAL_FAILURE(timermanager.ProcessTimersInternal());
404}
405
406/**
407 * @tc.name: TimerManagerTest_ProcessTimersInternal
408 * @tc.desc: Test processing timers internally within the TimerManager
409 * @tc.type: FUNC
410 * @tc.require:
411 */
412HWTEST_F(TimerManagerTest, TimerManagerTest_ProcessTimersInternal, TestSize.Level1)
413{
414    CALL_TEST_DEBUG;
415    TimerManager tMgr;
416    auto timer = std::make_unique<TimerManager::TimerItem>();
417    timer->nextCallTime = 10000000000;
418    tMgr.InsertTimerInternal(timer);
419    ASSERT_NO_FATAL_FAILURE(tMgr.ProcessTimersInternal());
420}
421} // namespace MMI
422} // namespace OHOS