1 /*
2 * Copyright (c) 2025 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 <gtest/gtest.h>
17 #include <test_header.h>
18
19 #include "ffrt_inner.h"
20 #include "hgm_test_base.h"
21 #include "hgm_one_shot_timer.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 class HgmSimpleTimerTest : public HgmTestBase {
29 public:
SetUpTestCase()30 static void SetUpTestCase() {}
31 static void TearDownTestCase();
32 void SetUp();
TearDown()33 void TearDown() {}
34 };
35
TearDownTestCase()36 void HgmSimpleTimerTest::TearDownTestCase()
37 {
38 HgmTaskHandleThread::Instance().queue_ = std::make_shared<ffrt::queue>(
39 static_cast<ffrt::queue_type>(ffrt_inner_queue_type_t::ffrt_queue_eventhandler_adapter), "HgmTaskHandleThread",
40 ffrt::queue_attr().qos(ffrt::qos_user_interactive));
41 }
42
SetUp()43 void HgmSimpleTimerTest::SetUp()
44 {
45 if (!HgmTaskHandleThread::Instance().queue_) {
46 HgmTaskHandleThread::Instance().queue_ = std::make_shared<ffrt::queue>(
47 static_cast<ffrt::queue_type>(ffrt_inner_queue_type_t::ffrt_queue_eventhandler_adapter),
48 "HgmTaskHandleThread", ffrt::queue_attr().qos(ffrt::qos_user_interactive));
49 }
50 }
51
52 /**
53 * @tc.name : HgmSimpleTimerTest
54 * @tc.number: Start_001
55 * @tc.desc : Test Start
56 */
57 HWTEST_F(HgmSimpleTimerTest, Start_001, Function | SmallTest | Level1)
58 {
59 HgmTaskHandleThread& instance = HgmTaskHandleThread::Instance();
60 int32_t interval = 200;
61 HgmSimpleTimer timer("test_timer", std::chrono::milliseconds(interval), nullptr, nullptr);
62
63 EXPECT_NE(instance.queue_, nullptr);
64 auto taskCount = instance.queue_->get_task_cnt();
65 timer.Start();
66 EXPECT_EQ(instance.queue_->get_task_cnt(), taskCount + 1);
67 timer.Stop();
68 EXPECT_EQ(instance.queue_->get_task_cnt(), taskCount);
69
70 instance.queue_ = nullptr;
71 timer.Start();
72 }
73
74 /**
75 * @tc.name : HgmSimpleTimerTest
76 * @tc.number: Stop_001
77 * @tc.desc : Test Stop
78 */
79 HWTEST_F(HgmSimpleTimerTest, Stop_001, Function | SmallTest | Level1)
80 {
81 HgmTaskHandleThread& instance = HgmTaskHandleThread::Instance();
82 int32_t interval = 200;
83 HgmSimpleTimer timer("test_timer", std::chrono::milliseconds(interval), nullptr, nullptr);
84
85 EXPECT_NE(instance.queue_, nullptr);
86 auto taskCount = instance.queue_->get_task_cnt();
87 timer.running_ = false;
88 timer.Start();
89 EXPECT_EQ(instance.queue_->get_task_cnt(), taskCount + 1);
90 timer.running_ = false;
91 timer.Stop();
92 EXPECT_EQ(instance.queue_->get_task_cnt(), taskCount + 1);
93
94 timer.running_ = true;
95 timer.Stop();
96 EXPECT_EQ(instance.queue_->get_task_cnt(), taskCount);
97
98 instance.queue_ = nullptr;
99 timer.running_ = false;
100 timer.Stop();
101
102 timer.running_ = true;
103 timer.Stop();
104 }
105
106 /**
107 * @tc.name : HgmSimpleTimerTest
108 * @tc.number: Loop_001
109 * @tc.desc : Test Loop
110 */
111 HWTEST_F(HgmSimpleTimerTest, Loop_001, Function | SmallTest | Level1)
112 {
113 HgmTaskHandleThread& instance = HgmTaskHandleThread::Instance();
114 int32_t interval = 200;
115 HgmSimpleTimer timer("test_timer", std::chrono::milliseconds(interval), nullptr, nullptr);
116
117 timer.running_ = true;
118 timer.Reset();
119 timer.Loop();
120 EXPECT_TRUE(timer.running_);
121
122 std::this_thread::sleep_for(std::chrono::milliseconds(interval * 2));
123 timer.Loop();
124 EXPECT_FALSE(timer.running_);
125 }
126
127 /**
128 * @tc.name : HgmSimpleTimerTest
129 * @tc.number: Loop_002
130 * @tc.desc : Test Loop
131 */
132 HWTEST_F(HgmSimpleTimerTest, Loop_002, Function | SmallTest | Level1)
133 {
134 HgmTaskHandleThread& instance = HgmTaskHandleThread::Instance();
135 int32_t interval = 200;
136 HgmSimpleTimer timer("test_timer", std::chrono::milliseconds(interval), nullptr, nullptr);
137
138 EXPECT_NE(instance.queue_, nullptr);
139 auto taskCount = instance.queue_->get_task_cnt();
140 timer.running_ = true;
141 timer.Reset();
142 timer.Loop();
143 EXPECT_EQ(instance.queue_->get_task_cnt(), taskCount + 1);
144
145 timer.running_ = false;
146 timer.Loop();
147 EXPECT_EQ(instance.queue_->get_task_cnt(), taskCount + 1);
148 timer.Stop();
149
150 instance.queue_ = nullptr;
151 timer.running_ = true;
152 timer.Reset();
153 timer.Loop();
154
155 timer.running_ = false;
156 timer.Loop();
157 }
158 } // namespace Rosen
159 } // namespace OHOS