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