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 <gtest/gtest.h>
17 #include <test_header.h>
18
19 #include "hgm_idle_detector.h"
20 #include "pipeline/rs_render_node.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Rosen {
27 namespace {
28 const std::string bufferName = "frameBuffer";
29 const std::string aceAnimator = "AceAnimato";
30 const std::string rosenWeb = "RosenWeb";
31 const std::string flutterBuffer = "oh_flutter";
32 const std::string otherSurface = "Other_SF";
33 constexpr uint64_t fromtest = 3;
34 constexpr uint64_t currTime = 100000000;
35 constexpr uint64_t lastTime = 200000000;
36 constexpr uint32_t fps30HZ = 30;
37 constexpr uint32_t fps60HZ = 60;
38 constexpr uint32_t fps90HZ = 90;
39 constexpr uint32_t fps120HZ = 120;
40 constexpr pid_t Pid = 0;
41 const NodeId id = 0;
42 }
43 class HgmIdleDetectorTest : public testing::Test {
44 public:
45 static void SetUpTestCase();
46 static void TearDownTestCase();
47 void SetUp();
48 void TearDown();
49 };
50
SetUpTestCase()51 void HgmIdleDetectorTest::SetUpTestCase() {}
TearDownTestCase()52 void HgmIdleDetectorTest::TearDownTestCase() {}
SetUp()53 void HgmIdleDetectorTest::SetUp() {}
TearDown()54 void HgmIdleDetectorTest::TearDown() {}
55
56 /**
57 * @tc.name: SetAndGetAppSupportState
58 * @tc.desc: Verify the result of SetAndGetAppSupportState function
59 * @tc.type: FUNC
60 * @tc.require: IAFG2V
61 */
62 HWTEST_F(HgmIdleDetectorTest, SetAndGetAppSupportState, Function | SmallTest | Level1)
63 {
64 std::unique_ptr<HgmIdleDetector> idleDetector = std::make_unique<HgmIdleDetector>();
65
66 PART("CaseDescription") {
67 STEP("1. get an idleDetector") {
68 STEP_ASSERT_NE(idleDetector, nullptr);
69 }
70 STEP("2. set app support status") {
71 idleDetector->SetAppSupportedState(false);
72 }
73 STEP("3. get app support status") {
74 bool ret = idleDetector->GetAppSupportedState();
75 STEP_ASSERT_EQ(ret, false);
76 }
77 }
78 }
79
80 /**
81 * @tc.name: SetAndGetAceAnimatorIdleState
82 * @tc.desc: Verify the result of SetAndGetAceAnimatorIdleState function
83 * @tc.type: FUNC
84 * @tc.require: IAFG2V
85 */
86 HWTEST_F(HgmIdleDetectorTest, SetAndGetAceAnimatorIdleState, Function | SmallTest | Level1)
87 {
88 std::unique_ptr<HgmIdleDetector> idleDetector = std::make_unique<HgmIdleDetector>();
89
90 // fail case: when AppSupportedState false && bufferFpsMap_ not contains
91 ASSERT_NE(idleDetector, nullptr);
92 idleDetector->SetAceAnimatorIdleState(false);
93 ASSERT_TRUE(idleDetector->GetAceAnimatorIdleState());
94
95 // fail case: when AppSupportedState false
96 idleDetector->SetAppSupportedState(false);
97 idleDetector->bufferFpsMap_[aceAnimator] = fps120HZ;
98 idleDetector->SetAceAnimatorIdleState(false);
99 ASSERT_TRUE(idleDetector->GetAceAnimatorIdleState());
100
101 // fail case: when bufferFpsMap_ not contains
102 idleDetector->SetAppSupportedState(true);
103 idleDetector->bufferFpsMap_.clear();
104 idleDetector->SetAceAnimatorIdleState(false);
105 ASSERT_TRUE(idleDetector->GetAceAnimatorIdleState());
106
107 // success case: fits all
108 idleDetector->SetAppSupportedState(true);
109 idleDetector->bufferFpsMap_[aceAnimator] = fps120HZ;
110 idleDetector->SetAceAnimatorIdleState(false);
111 ASSERT_FALSE(idleDetector->GetAceAnimatorIdleState());
112 }
113
114 /**
115 * @tc.name: SetAndGetSurfaceTimeState
116 * @tc.desc: Verify the result of SetAndGetSurfaceTimeState function
117 * @tc.type: FUNC
118 * @tc.require: IAFG2V
119 */
120 HWTEST_F(HgmIdleDetectorTest, SetAndGetSurfaceTimeState, Function | SmallTest | Level1)
121 {
122 std::unique_ptr<HgmIdleDetector> idleDetector = std::make_unique<HgmIdleDetector>();
123
124 // fail case: when AppSupportedState false && bufferFpsMap_ not contains
125 ASSERT_NE(idleDetector, nullptr);
126 idleDetector->surfaceTimeMap_.clear();
127 ASSERT_TRUE(idleDetector->GetSurfaceIdleState());
128
129 // fail case: when AppSupportedState false
130 idleDetector->SetAppSupportedState(false);
131 idleDetector->bufferFpsMap_[bufferName] = fps120HZ;
132 idleDetector->UpdateSurfaceTime(bufferName, currTime, Pid, UIFWKType::FROM_SURFACE);
133 ASSERT_TRUE(idleDetector->GetSurfaceIdleState());
134 idleDetector->surfaceTimeMap_.clear();
135
136 // fail case: when bufferFpsMap_ not contains
137 idleDetector->SetAppSupportedState(true);
138 idleDetector->bufferFpsMap_.clear();
139 idleDetector->UpdateSurfaceTime(bufferName, currTime, Pid, UIFWKType::FROM_SURFACE);
140 ASSERT_TRUE(idleDetector->GetSurfaceIdleState());
141 idleDetector->bufferFpsMap_[otherSurface] = 0;
142 idleDetector->UpdateSurfaceTime(bufferName, currTime, Pid, UIFWKType::FROM_SURFACE);
143 ASSERT_TRUE(idleDetector->GetSurfaceIdleState());
144 idleDetector->bufferFpsMap_[otherSurface] = fps120HZ;
145 idleDetector->UpdateSurfaceTime(bufferName, currTime, Pid, UIFWKType::FROM_SURFACE);
146 ASSERT_FALSE(idleDetector->GetSurfaceIdleState());
147 idleDetector->surfaceTimeMap_.clear();
148
149 // success case: fits all && match bufferName
150 idleDetector->bufferFpsMap_[bufferName] = fps120HZ;
151 idleDetector->UpdateSurfaceTime(bufferName, currTime, Pid, UIFWKType::FROM_SURFACE);
152 ASSERT_FALSE(idleDetector->GetSurfaceIdleState());
153 idleDetector->surfaceTimeMap_.clear();
154
155 // fail case: black list
156 idleDetector->bufferFpsMap_.clear();
157 idleDetector->bufferFpsMap_[bufferName] = 0;
158 idleDetector->bufferFpsMap_[otherSurface] = fps120HZ;
159 idleDetector->UpdateSurfaceTime(bufferName, currTime, Pid, UIFWKType::FROM_SURFACE);
160 ASSERT_TRUE(idleDetector->GetSurfaceIdleState());
161 idleDetector->surfaceTimeMap_.clear();
162
163 // fail case: not match otherSurface
164 idleDetector->bufferFpsMap_.clear();
165 idleDetector->bufferFpsMap_[otherSurface] = fps120HZ;
166 idleDetector->UpdateSurfaceTime(bufferName, currTime, Pid, UIFWKType::FROM_UNKNOWN);
167 ASSERT_TRUE(idleDetector->GetSurfaceIdleState());
168 idleDetector->UpdateSurfaceTime("", currTime, Pid, UIFWKType::FROM_SURFACE);
169 OHOS::Rosen::UIFWKType pidType = static_cast<OHOS::Rosen::UIFWKType>(fromtest);
170 idleDetector->UpdateSurfaceTime(bufferName, currTime, Pid, pidType);
171 std::string surfaceName = "surfaceName";
172 idleDetector->surfaceTimeMap_.try_emplace(surfaceName, currTime);
173 idleDetector->UpdateSurfaceState(currTime);
174 }
175
176 /**
177 * @tc.name: GetTouchUpExpectedFPS001
178 * @tc.desc: Verify the result of ThirdFrameNeedHighRefresh function
179 * @tc.type: FUNC
180 * @tc.require: IAFG2V
181 */
182 HWTEST_F(HgmIdleDetectorTest, GetTouchUpExpectedFPS001, Function | SmallTest | Level1)
183 {
184 std::unique_ptr<HgmIdleDetector> idleDetector = std::make_unique<HgmIdleDetector>();
185
186 // bufferFpsMap_ not contains
187 idleDetector->SetAppSupportedState(true);
188 idleDetector->bufferFpsMap_.clear();
189 ASSERT_EQ(idleDetector->GetTouchUpExpectedFPS(), 0);
190
191 // bufferFpsMap_ contains && check AceAnimatorIdleState
192 idleDetector->bufferFpsMap_[aceAnimator] = fps90HZ;
193 idleDetector->SetAceAnimatorIdleState(true);
194 ASSERT_EQ(idleDetector->GetTouchUpExpectedFPS(), 0);
195 idleDetector->SetAceAnimatorIdleState(false);
196 ASSERT_EQ(idleDetector->GetTouchUpExpectedFPS(), fps90HZ);
197
198 // bufferFpsMap_ contains && check bufferName
199 idleDetector->bufferFpsMap_[bufferName] = fps60HZ;
200 idleDetector->surfaceTimeMap_[bufferName] = currTime;
201 ASSERT_EQ(idleDetector->GetTouchUpExpectedFPS(), fps90HZ);
202 idleDetector->bufferFpsMap_[bufferName] = fps120HZ;
203 ASSERT_EQ(idleDetector->GetTouchUpExpectedFPS(), fps120HZ);
204
205 // decide max
206 idleDetector->bufferFpsMap_[flutterBuffer] = fps90HZ;
207 idleDetector->surfaceTimeMap_[flutterBuffer] = currTime;
208 ASSERT_EQ(idleDetector->GetTouchUpExpectedFPS(), fps120HZ);
209
210 // decide max
211 idleDetector->surfaceTimeMap_[rosenWeb] = currTime;
212 ASSERT_EQ(idleDetector->GetTouchUpExpectedFPS(), fps120HZ);
213 }
214
215 /**
216 * @tc.name: GetTouchUpExpectedFPS002
217 * @tc.desc: Verify the result of GetTouchUpExpectedFPS function
218 * @tc.type: FUNC
219 * @tc.require: IAFG2V
220 */
221 HWTEST_F(HgmIdleDetectorTest, GetTouchUpExpectedFPS002, Function | SmallTest | Level1)
222 {
223 std::unique_ptr<HgmIdleDetector> idleDetector = std::make_unique<HgmIdleDetector>();
224 ASSERT_NE(idleDetector, nullptr);
225
226 idleDetector->SetAppSupportedState(true);
227 idleDetector->bufferFpsMap_.clear();
228 idleDetector->bufferFpsMap_[aceAnimator] = fps120HZ;
229 idleDetector->bufferFpsMap_[rosenWeb] = fps90HZ;
230 idleDetector->bufferFpsMap_[bufferName] = fps60HZ;
231 idleDetector->surfaceTimeMap_.clear();
232
233 // max of rosenWeb & bufferName
234 idleDetector->surfaceTimeMap_[rosenWeb] = currTime;
235 idleDetector->surfaceTimeMap_[bufferName] = currTime;
236 ASSERT_EQ(idleDetector->GetTouchUpExpectedFPS(), fps90HZ);
237
238 // check effective: aceAnimator
239 idleDetector->SetAceAnimatorIdleState(false);
240 ASSERT_EQ(idleDetector->GetTouchUpExpectedFPS(), fps120HZ);
241
242 // check aceAnimator ineffective
243 idleDetector->SetAceAnimatorIdleState(true);
244 ASSERT_EQ(idleDetector->GetTouchUpExpectedFPS(), fps90HZ);
245 }
246
247 /**
248 * @tc.name: UpdateAndGetAceAnimatorExpectedFrameRate001
249 * @tc.desc: Verify the result of UpdateAndGetAceAnimatorExpectedFrameRate001 function
250 * @tc.type: FUNC
251 * @tc.require: IAW09K
252 */
253 HWTEST_F(HgmIdleDetectorTest, UpdateAndGetAceAnimatorExpectedFrameRate001, Function | SmallTest | Level1)
254 {
255 std::unique_ptr<HgmIdleDetector> idleDetector = std::make_unique<HgmIdleDetector>();
256
257 PART("CaseDescription") {
258 STEP("1. get an idleDetector") {
259 STEP_ASSERT_NE(idleDetector, nullptr);
260 }
261 STEP("2. update ace animator expected frame rate") {
262 // verify out of range conditions
263 idleDetector->UpdateAceAnimatorExpectedFrameRate(-2);
264 }
265 STEP("3. get ace animator expected frame rate") {
266 STEP_ASSERT_EQ(idleDetector->aceAnimatorExpectedFrameRate_, HgmIdleDetector::ANIMATOR_NOT_RUNNING);
267 }
268 }
269 }
270
271 /**
272 * @tc.name: UpdateAndGetAceAnimatorExpectedFrameRate002
273 * @tc.desc: Verify the result of UpdateAndGetAceAnimatorExpectedFrameRate002 function
274 * @tc.type: FUNC
275 * @tc.require: IAW09K
276 */
277 HWTEST_F(HgmIdleDetectorTest, UpdateAndGetAceAnimatorExpectedFrameRate002, Function | SmallTest | Level1)
278 {
279 std::unique_ptr<HgmIdleDetector> idleDetector = std::make_unique<HgmIdleDetector>();
280
281 PART("CaseDescription") {
282 STEP("1. get an idleDetector") {
283 STEP_ASSERT_NE(idleDetector, nullptr);
284 }
285 STEP("2. update ace animator expected frame rate") {
286 idleDetector->UpdateAceAnimatorExpectedFrameRate(60);
287 }
288 STEP("3. get ace animator expected frame rate") {
289 STEP_ASSERT_EQ(idleDetector->aceAnimatorExpectedFrameRate_, 60);
290 }
291 }
292 }
293
294 /**
295 * @tc.name: ResetAceAnimatorExpectedFrameRate
296 * @tc.desc: Verify the result of ResetAceAnimatorExpectedFrameRate function
297 * @tc.type: FUNC
298 * @tc.require: IAW09K
299 */
300 HWTEST_F(HgmIdleDetectorTest, ResetAceAnimatorExpectedFrameRate, Function | SmallTest | Level1)
301 {
302 std::unique_ptr<HgmIdleDetector> idleDetector = std::make_unique<HgmIdleDetector>();
303
304 PART("CaseDescription") {
305 STEP("1. get an idleDetector") {
306 STEP_ASSERT_NE(idleDetector, nullptr);
307 }
308 STEP("2. update ace animator expected frame rate") {
309 idleDetector->UpdateAceAnimatorExpectedFrameRate(120);
310 }
311 STEP("3. reset ace animator expected frame rate") {
312 idleDetector->ResetAceAnimatorExpectedFrameRate();
313 }
314 STEP("4. get ace animator expected frame rate") {
315 STEP_ASSERT_EQ(idleDetector->aceAnimatorExpectedFrameRate_, HgmIdleDetector::ANIMATOR_NOT_RUNNING);
316 }
317 }
318 }
319 } // namespace Rosen
320 } // namespace OHOS