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
18 #include "hgm_energy_consumption_policy.h"
19 #include "hgm_test_base.h"
20 #include "common/rs_common_hook.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Rosen {
27 namespace {
28 constexpr int DEFAULT_MAX_FPS = 120;
29 constexpr int IDLE_FPS = 60;
30 }
31
32 class HgmEnergyConsumptionPolicyTest : public HgmTestBase {
33 public:
SetUpTestCase()34 static void SetUpTestCase()
35 {
36 HgmTestBase::SetUpTestCase();
37 }
TearDownTestCase()38 static void TearDownTestCase() {}
SetUp()39 void SetUp() {}
TearDown()40 void TearDown() {}
41 void SetConfigEnable(std::string isEnable);
42 void SetIdleStateEnable(bool isIdle);
43 };
44
SetConfigEnable(std::string isEnable)45 void HgmEnergyConsumptionPolicyTest::SetConfigEnable(std::string isEnable)
46 {
47 std::unordered_map<std::string, std::string> animationPowerConfig = {
48 { "animation_energy_assurance_enable", isEnable },
49 { "animation_idle_fps", "60" },
50 { "animation_idle_duration", "2000" } };
51 std::unordered_map<std::string, std::string> uiPowerConfig = { { "ui_animation", "30" }, { "display_sync", "31" },
52 { "ace_component", "32" }, { "display_soloist", "33" } };
53
54 HgmEnergyConsumptionPolicy::Instance().SetEnergyConsumptionConfig(animationPowerConfig);
55 if (isEnable != "true") {
56 uiPowerConfig.clear();
57 }
58 HgmEnergyConsumptionPolicy::Instance().SetUiEnergyConsumptionConfig(uiPowerConfig);
59 }
60
SetIdleStateEnable(bool isIdle)61 void HgmEnergyConsumptionPolicyTest::SetIdleStateEnable(bool isIdle)
62 {
63 HgmEnergyConsumptionPolicy::Instance().SetAnimationEnergyConsumptionAssuranceMode(isIdle);
64 HgmEnergyConsumptionPolicy::Instance().isTouchIdle_ = isIdle;
65 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().isTouchIdle_, isIdle);
66 }
67
68 /**
69 * @tc.name: SetEnergyConsumptionConfigTest1
70 * @tc.desc: test results of SetEnergyConsumptionConfigTest1
71 * @tc.type: FUNC
72 * @tc.require: issuesIA96Q3
73 */
74 HWTEST_F(HgmEnergyConsumptionPolicyTest, SetEnergyConsumptionConfigTest1, TestSize.Level0)
75 {
76 SetConfigEnable("true");
77 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().isAnimationEnergyAssuranceEnable_, true);
78 }
79
80 /**
81 * @tc.name: SetEnergyConsumptionConfigTest2
82 * @tc.desc: test results of SetEnergyConsumptionConfigTest2
83 * @tc.type: FUNC
84 * @tc.require: issuesIA96Q3
85 */
86 HWTEST_F(HgmEnergyConsumptionPolicyTest, SetEnergyConsumptionConfigTest2, TestSize.Level0)
87 {
88 SetConfigEnable("false");
89 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().isAnimationEnergyAssuranceEnable_, false);
90 }
91
92 /**
93 * @tc.name: SetEnergyConsumptionAssuranceModeTest1
94 * @tc.desc: test results of SetEnergyConsumptionAssuranceModeTest1
95 * @tc.type: FUNC
96 * @tc.require: issuesIA96Q3
97 */
98 HWTEST_F(HgmEnergyConsumptionPolicyTest, SetEnergyConsumptionAssuranceModeTest1, TestSize.Level0)
99 {
100 SetConfigEnable("true");
101 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().isAnimationEnergyAssuranceEnable_, true);
102 SetIdleStateEnable(true);
103 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().isTouchIdle_, true);
104 SetIdleStateEnable(false);
105 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().isTouchIdle_, false);
106 }
107
108 /**
109 * @tc.name: SetEnergyConsumptionAssuranceModeTest2
110 * @tc.desc: test results of SetEnergyConsumptionAssuranceModeTest2
111 * @tc.type: FUNC
112 * @tc.require: issuesIA96Q3
113 */
114 HWTEST_F(HgmEnergyConsumptionPolicyTest, SetEnergyConsumptionAssuranceModeTest2, TestSize.Level0)
115 {
116 SetConfigEnable("true");
117 SetIdleStateEnable(true);
118 SetIdleStateEnable(true);
119 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().isAnimationEnergyAssuranceEnable_, true);
120 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().isTouchIdle_, true);
121 }
122
123 /**
124 * @tc.name: SetEnergyConsumptionAssuranceModeTest3
125 * @tc.desc: test results of SetEnergyConsumptionAssuranceModeTest3
126 * @tc.type: FUNC
127 * @tc.require: issuesIA96Q3
128 */
129 HWTEST_F(HgmEnergyConsumptionPolicyTest, SetEnergyConsumptionAssuranceModeTest3, TestSize.Level0)
130 {
131 SetConfigEnable("false");
132 SetIdleStateEnable(false);
133 SetIdleStateEnable(true);
134 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().isAnimationEnergyAssuranceEnable_, false);
135 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().isTouchIdle_, true);
136 }
137
138 /**
139 * @tc.name: StatisticAnimationTimeTest1
140 * @tc.desc: test results of StatisticAnimationTimeTest1
141 * @tc.type: FUNC
142 * @tc.require: issuesIA96Q3
143 */
144 HWTEST_F(HgmEnergyConsumptionPolicyTest, StatisticAnimationTimeTest1, TestSize.Level1)
145 {
146 HgmEnergyConsumptionPolicy::Instance().lastAnimationTimestamp_ = 0;
147 SetConfigEnable("false");
148 SetIdleStateEnable(false);
149 uint64_t currentTime = 1719544264071;
150 HgmEnergyConsumptionPolicy::Instance().StatisticAnimationTime(currentTime);
151 ASSERT_NE(HgmEnergyConsumptionPolicy::Instance().lastAnimationTimestamp_, currentTime);
152 }
153
154 /**
155 * @tc.name: StatisticAnimationTimeTest2
156 * @tc.desc: test results of StatisticAnimationTimeTest2
157 * @tc.type: FUNC
158 * @tc.require: issuesIA96Q3
159 */
160 HWTEST_F(HgmEnergyConsumptionPolicyTest, StatisticAnimationTimeTest2, TestSize.Level1)
161 {
162 HgmEnergyConsumptionPolicy::Instance().lastAnimationTimestamp_ = 0;
163 SetConfigEnable("true");
164 SetIdleStateEnable(false);
165 uint64_t currentTime = 1719544264072;
166 HgmEnergyConsumptionPolicy::Instance().StatisticAnimationTime(currentTime);
167 ASSERT_NE(HgmEnergyConsumptionPolicy::Instance().lastAnimationTimestamp_, currentTime);
168 }
169
170 /**
171 * @tc.name: StatisticAnimationTimeTest3
172 * @tc.desc: test results of StatisticAnimationTimeTest3
173 * @tc.type: FUNC
174 * @tc.require: issuesIA96Q3
175 */
176 HWTEST_F(HgmEnergyConsumptionPolicyTest, StatisticAnimationTimeTest3, TestSize.Level0)
177 {
178 HgmEnergyConsumptionPolicy::Instance().lastAnimationTimestamp_ = 0;
179 SetConfigEnable("true");
180 SetIdleStateEnable(true);
181 uint64_t currentTime = 1719544264073;
182 HgmEnergyConsumptionPolicy::Instance().StatisticAnimationTime(currentTime);
183 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().lastAnimationTimestamp_, currentTime);
184 }
185
186 /**
187 * @tc.name: StartNewAnimationTest1
188 * @tc.desc: test results of StartNewAnimationTest1
189 * @tc.type: FUNC
190 * @tc.require: issuesIA96Q3
191 */
192 HWTEST_F(HgmEnergyConsumptionPolicyTest, StartNewAnimationTest1, TestSize.Level0)
193 {
194 HgmEnergyConsumptionPolicy::Instance().lastAnimationTimestamp_ = 0;
195 SetConfigEnable("true");
196 std::string componentName = "SWIPER_FLING";
197 HgmCore::Instance().SetTimestamp(0);
198 HgmEnergyConsumptionPolicy::Instance().StartNewAnimation(componentName);
199 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().lastAnimationTimestamp_, 0);
200 }
201
202 /**
203 * @tc.name: StartNewAnimationTest2
204 * @tc.desc: test results of StartNewAnimationTest2
205 * @tc.type: FUNC
206 * @tc.require: issuesIA96Q3
207 */
208 HWTEST_F(HgmEnergyConsumptionPolicyTest, StartNewAnimationTest2, TestSize.Level1)
209 {
210 HgmEnergyConsumptionPolicy::Instance().lastAnimationTimestamp_ = 0;
211 SetConfigEnable("true");
212 SetIdleStateEnable(true);
213 std::string componentName = "";
214 HgmCore::Instance().SetActualTimestamp(0);
215 for (int i = 0; i < 2000; i++) {
216 RsCommonHook::Instance().OnStartNewAnimation(componentName);
217 }
218 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().lastAnimationTimestamp_,
219 HgmCore::Instance().GetActualTimestamp() / NS_PER_MS);
220 }
221
222
223 /**
224 * @tc.name: GetAnimationIdleFpsTest1
225 * @tc.desc: test results of GetAnimationIdleFpsTest1
226 * @tc.type: FUNC
227 * @tc.require: issuesIA96Q3
228 */
229 HWTEST_F(HgmEnergyConsumptionPolicyTest, GetAnimationIdleFpsTest1, TestSize.Level0)
230 {
231 SetConfigEnable("false");
232 FrameRateRange rsRange = { DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DEFAULT_MAX_FPS };
233 HgmEnergyConsumptionPolicy::Instance().GetAnimationIdleFps(rsRange);
234 ASSERT_EQ(rsRange.max_, DEFAULT_MAX_FPS);
235 ASSERT_EQ(rsRange.min_, DEFAULT_MAX_FPS);
236 ASSERT_EQ(rsRange.preferred_, DEFAULT_MAX_FPS);
237 }
238
239 /**
240 * @tc.name: GetAnimationIdleFpsTest2
241 * @tc.desc: test results of GetAnimationIdleFpsTest2
242 * @tc.type: FUNC
243 * @tc.require: issuesIA96Q3
244 */
245 HWTEST_F(HgmEnergyConsumptionPolicyTest, GetAnimationIdleFpsTest2, TestSize.Level0)
246 {
247 SetConfigEnable("true");
248 HgmEnergyConsumptionPolicy::Instance().lastAnimationTimestamp_ = 1719544264071;
249 HgmEnergyConsumptionPolicy::Instance().firstAnimationTimestamp_ = 1719544263071;
250 FrameRateRange rsRange = { DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DEFAULT_MAX_FPS };
251 HgmEnergyConsumptionPolicy::Instance().GetAnimationIdleFps(rsRange);
252 ASSERT_EQ(rsRange.max_, DEFAULT_MAX_FPS);
253 ASSERT_EQ(rsRange.min_, DEFAULT_MAX_FPS);
254 ASSERT_EQ(rsRange.preferred_, DEFAULT_MAX_FPS);
255 }
256
257 /**
258 * @tc.name: GetAnimationIdleFpsTest3
259 * @tc.desc: test results of GetAnimationIdleFpsTest3
260 * @tc.type: FUNC
261 * @tc.require: issuesIA96Q3
262 */
263 HWTEST_F(HgmEnergyConsumptionPolicyTest, GetAnimationIdleFpsTest3, TestSize.Level0)
264 {
265 SetConfigEnable("true");
266 HgmEnergyConsumptionPolicy::Instance().lastAnimationTimestamp_ = 1719544264071;
267 HgmEnergyConsumptionPolicy::Instance().firstAnimationTimestamp_ = 1719544261071;
268 FrameRateRange rsRange = { DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DEFAULT_MAX_FPS };
269 HgmEnergyConsumptionPolicy::Instance().GetAnimationIdleFps(rsRange);
270 ASSERT_EQ(rsRange.max_, IDLE_FPS);
271 ASSERT_EQ(rsRange.min_, IDLE_FPS);
272 ASSERT_EQ(rsRange.preferred_, IDLE_FPS);
273 }
274
275 /**
276 * @tc.name: GetUiAnimationIdleFpsTest1
277 * @tc.desc: test results of GetUiAnimationIdleFpsTest1
278 * @tc.type: FUNC
279 * @tc.require: issuesIA96Q3
280 */
281 HWTEST_F(HgmEnergyConsumptionPolicyTest, GetUiAnimationIdleFpsTest1, TestSize.Level0)
282 {
283 FrameRateRange rsRange = { DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, UI_ANIMATION_FRAME_RATE_TYPE };
284 SetConfigEnable("false");
285 ASSERT_FALSE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange));
286 ASSERT_EQ(rsRange.max_, DEFAULT_MAX_FPS);
287 ASSERT_EQ(rsRange.min_, DEFAULT_MAX_FPS);
288 ASSERT_EQ(rsRange.preferred_, DEFAULT_MAX_FPS);
289
290 SetConfigEnable("true");
291 ASSERT_TRUE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange));
292 ASSERT_EQ(rsRange.max_, 30);
293 ASSERT_EQ(rsRange.min_, 30);
294 ASSERT_EQ(rsRange.preferred_, 30);
295 HgmEnergyConsumptionPolicy::Instance().isTouchIdle_ = true;
296 ASSERT_TRUE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange));
297 }
298
299 /**
300 * @tc.name: GetDisplaySyncIdleFpsTest1
301 * @tc.desc: test results of GetDisplaySyncIdleFpsTest1
302 * @tc.type: FUNC
303 * @tc.require: issuesIA96Q3
304 */
305 HWTEST_F(HgmEnergyConsumptionPolicyTest, GetDisplaySyncIdleFpsTest1, TestSize.Level0)
306 {
307 FrameRateRange rsRange = { DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DISPLAY_SYNC_FRAME_RATE_TYPE };
308 SetConfigEnable("false");
309 ASSERT_FALSE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange));
310 ASSERT_EQ(rsRange.max_, DEFAULT_MAX_FPS);
311 ASSERT_EQ(rsRange.min_, DEFAULT_MAX_FPS);
312 ASSERT_EQ(rsRange.preferred_, DEFAULT_MAX_FPS);
313
314 SetConfigEnable("true");
315 ASSERT_TRUE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange));
316 ASSERT_EQ(rsRange.max_, 31);
317 ASSERT_EQ(rsRange.min_, 31);
318 ASSERT_EQ(rsRange.preferred_, 31);
319 }
320
321 /**
322 * @tc.name: GetAceComponentIdleFpsTest1
323 * @tc.desc: test results of GetAceComponentIdleFpsTest1
324 * @tc.type: FUNC
325 * @tc.require: issuesIA96Q3
326 */
327 HWTEST_F(HgmEnergyConsumptionPolicyTest, GetAceComponentIdleFpsTest1, TestSize.Level0)
328 {
329 FrameRateRange rsRange = { DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, ACE_COMPONENT_FRAME_RATE_TYPE };
330 SetConfigEnable("false");
331 ASSERT_FALSE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange));
332 ASSERT_EQ(rsRange.max_, DEFAULT_MAX_FPS);
333 ASSERT_EQ(rsRange.min_, DEFAULT_MAX_FPS);
334 ASSERT_EQ(rsRange.preferred_, DEFAULT_MAX_FPS);
335
336 SetConfigEnable("true");
337 ASSERT_TRUE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange));
338 ASSERT_EQ(rsRange.max_, 32);
339 ASSERT_EQ(rsRange.min_, 32);
340 ASSERT_EQ(rsRange.preferred_, 32);
341 }
342
343 /**
344 * @tc.name: GetDisplaySoloistIdleFpsTest1
345 * @tc.desc: test results of GetDisplaySoloistIdleFpsTest1
346 * @tc.type: FUNC
347 * @tc.require: issuesIA96Q3
348 */
349 HWTEST_F(HgmEnergyConsumptionPolicyTest, GetDisplaySoloistIdleFpsTest1, TestSize.Level0)
350 {
351 FrameRateRange rsRange = { DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DISPLAY_SOLOIST_FRAME_RATE_TYPE };
352 SetConfigEnable("false");
353 ASSERT_FALSE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange));
354 ASSERT_EQ(rsRange.max_, DEFAULT_MAX_FPS);
355 ASSERT_EQ(rsRange.min_, DEFAULT_MAX_FPS);
356 ASSERT_EQ(rsRange.preferred_, DEFAULT_MAX_FPS);
357
358 SetConfigEnable("true");
359 ASSERT_TRUE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange));
360 ASSERT_EQ(rsRange.max_, 33);
361 ASSERT_EQ(rsRange.min_, 33);
362 ASSERT_EQ(rsRange.preferred_, 33);
363 }
364
365 /**
366 * @tc.name: EnergyConsumptionAssureanceTest
367 * @tc.desc: test drag scene
368 * @tc.type: FUNC
369 * @tc.require: issuesICH496
370 */
371 HWTEST_F(HgmEnergyConsumptionPolicyTest, EnergyConsumptionAssureanceTest, TestSize.Level0)
372 {
373 SetConfigEnable("true");
374 FrameRateRange rsRange = { DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DRAG_SCENE_FRAME_RATE_TYPE };
375 EventInfo eventInfo = { .eventName = "ENERGY_CONSUMPTION_ASSURANCE", .eventStatus = false,
376 .description = "DRAG_SCENE:1000" };
377 HgmEnergyConsumptionPolicy::Instance().SetEnergyConsumptionAssuranceSceneInfo(eventInfo);
378 ASSERT_FALSE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange, 1000));
379 eventInfo = { .eventName = "ENERGY_CONSUMPTION_ASSURANCE", .eventStatus = true,
380 .description = "TEST" };
381 HgmEnergyConsumptionPolicy::Instance().SetEnergyConsumptionAssuranceSceneInfo(eventInfo);
382 ASSERT_FALSE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange, 1000));
383 eventInfo = { .eventName = "ENERGY_CONSUMPTION_ASSURANCE", .eventStatus = true,
384 .description = "DRAG_SCENE:1000" };
385 HgmEnergyConsumptionPolicy::Instance().SetEnergyConsumptionAssuranceSceneInfo(eventInfo);
386 ASSERT_TRUE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange, 1000));
387 eventInfo = { .eventName = "ENERGY_CONSUMPTION_ASSURANCE", .eventStatus = false,
388 .description = "DRAG_SCENE:2000" };
389 HgmEnergyConsumptionPolicy::Instance().SetEnergyConsumptionAssuranceSceneInfo(eventInfo);
390 ASSERT_TRUE(HgmEnergyConsumptionPolicy::Instance().GetUiIdleFps(rsRange, 1000));
391 }
392
393 /**
394 * @tc.name: GetCommponentFpsTest1
395 * @tc.desc: test results of GetCommponentFpsTest1
396 * @tc.type: FUNC
397 * @tc.require: issuesIA96Q3
398 */
399 HWTEST_F(HgmEnergyConsumptionPolicyTest, GetCommponentFpsTest1, TestSize.Level0)
400 {
401 auto& hgmEnergyConsumptionPolicy = HgmEnergyConsumptionPolicy::Instance();
402 hgmEnergyConsumptionPolicy.isTouchIdle_ = true;
403 FrameRateRange rsRange = { DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DISPLAY_SOLOIST_FRAME_RATE_TYPE };
404 hgmEnergyConsumptionPolicy.GetComponentFps(rsRange);
405 ASSERT_EQ(rsRange.max_, DEFAULT_MAX_FPS);
406 ASSERT_EQ(rsRange.min_, DEFAULT_MAX_FPS);
407 ASSERT_EQ(rsRange.preferred_, DEFAULT_MAX_FPS);
408 }
409
410 /**
411 * @tc.name: SetRefreshRateTest
412 * @tc.desc: test results of SetRefreshRateTest
413 * @tc.type: FUNC
414 * @tc.require: issuesIA96Q3
415 */
416 HWTEST_F(HgmEnergyConsumptionPolicyTest, SetRefreshRateTest, TestSize.Level0)
417 {
418 int32_t curRefreshRateMode = -1;
419 std::string curScreenStragyId = "LTPO-DEFAULT";
420 auto& hgmEnergyConsumptionPolicy = HgmEnergyConsumptionPolicy::Instance();
421 hgmEnergyConsumptionPolicy.SetRefreshRateMode(curRefreshRateMode, curScreenStragyId);
422 ASSERT_EQ(hgmEnergyConsumptionPolicy.curScreenStrategyId_, curScreenStragyId);
423 }
424
425 /**
426 * @tc.name: PrintEnergyConsumptionLogTest
427 * @tc.desc: test results of PrintEnergyConsumptionLogTest
428 * @tc.type: FUNC
429 * @tc.require: issuesIA96Q3
430 */
431 HWTEST_F(HgmEnergyConsumptionPolicyTest, PrintEnergyConsumptionLogTest, TestSize.Level0)
432 {
433 FrameRateRange rsRange = { DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DISPLAY_SOLOIST_FRAME_RATE_TYPE };
434 rsRange.isEnergyAssurance_ = true;
435 rsRange.componentScene_ = ComponentScene::SWIPER_FLING;
436 HgmEnergyConsumptionPolicy::Instance().PrintEnergyConsumptionLog(rsRange);
437 ASSERT_NE(HgmEnergyConsumptionPolicy::Instance().lastAssuranceLog_, "NO_CONSUMPTION_ASSURANCE");
438 rsRange.isEnergyAssurance_ = false;
439 HgmEnergyConsumptionPolicy::Instance().PrintEnergyConsumptionLog(rsRange);
440 }
441
442 /**
443 * @tc.name: SetTouchStateTest
444 * @tc.desc: test results of SetTouchStateTest
445 * @tc.type: FUNC
446 * @tc.require: issuesIA96Q3
447 */
448 HWTEST_F(HgmEnergyConsumptionPolicyTest, SetTouchStateTest, TestSize.Level0)
449 {
450 HgmEnergyConsumptionPolicy::Instance().SetTouchState(TouchState::DOWN_STATE);
451 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().isTouchIdle_, false);
452 }
453
454 /**
455 * @tc.name: SetVideoCallSceneInfoTest
456 * @tc.desc: test results of SetVideoCallSceneInfoTest
457 * @tc.type: FUNC
458 * @tc.require: issuesIA96Q3
459 */
460 HWTEST_F(HgmEnergyConsumptionPolicyTest, SetVideoCallSceneInfoTest, TestSize.Level0)
461 {
462 EventInfo eventInfo = {
463 .eventName = "VOTER_VIDEO_CALL",
464 .maxRefreshRate = 15,
465 .description = "flutterVsyncName:1234",
466 .eventStatus = true,
467
468 };
469 HgmEnergyConsumptionPolicy::Instance().SetVideoCallSceneInfo(eventInfo);
470 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().videoCallVsyncName_, "flutterVsyncName");
471 EventInfo eventInfo2 = {
472 .eventName = "VOTER_VIDEO_CALL",
473 .maxRefreshRate = 15,
474 .description = "flutterVsyncName:1234",
475 .eventStatus = false,
476 };
477 HgmEnergyConsumptionPolicy::Instance().SetVideoCallSceneInfo(eventInfo2);
478 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().videoCallVsyncName_, "");
479 }
480
481 /**
482 * @tc.name: StatisticsVideoCallBufferCountTest
483 * @tc.desc: test results of StatisticsVideoCallBufferCountTest
484 * @tc.type: FUNC
485 * @tc.require: issuesIA96Q3
486 */
487 HWTEST_F(HgmEnergyConsumptionPolicyTest, StatisticsVideoCallBufferCountTest, TestSize.Level0)
488 {
489 EventInfo eventInfo = {
490 .eventName = "VOTER_VIDEO_CALL",
491 .maxRefreshRate = 15,
492 .description = "flutterVsyncName:1234",
493 .eventStatus = true,
494
495 };
496 HgmEnergyConsumptionPolicy::Instance().SetVideoCallSceneInfo(eventInfo);
497 std::string bufferNamePrefix = "buffer";
498 HgmEnergyConsumptionPolicy::Instance().videoCallLayerName_ = bufferNamePrefix;
499 pid_t pid = 1234;
500 for (int i = 0; i < 100; i++) {
501 HgmEnergyConsumptionPolicy::Instance().StatisticsVideoCallBufferCount(
502 pid, std::string(bufferNamePrefix) + std::to_string(i));
503 }
504 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().videoBufferCount_.load(), 100);
505 }
506
507 /**
508 * @tc.name: CheckOnlyVideoCallExistTest
509 * @tc.desc: test results of CheckOnlyVideoCallExistTest
510 * @tc.type: FUNC
511 * @tc.require: issuesIA96Q3
512 */
513 HWTEST_F(HgmEnergyConsumptionPolicyTest, CheckOnlyVideoCallExistTest, TestSize.Level0)
514 {
515 auto& hgmEnergyConsumptionPolicy = HgmEnergyConsumptionPolicy::Instance();
516 hgmEnergyConsumptionPolicy.isEnableVideoCall_.store(true);
517 hgmEnergyConsumptionPolicy.videoBufferCount_.store(1);
518 hgmEnergyConsumptionPolicy.CheckOnlyVideoCallExist();
519 ASSERT_EQ(hgmEnergyConsumptionPolicy.isSubmitDecisionTask_.load(), true);
520 }
521
522 /**
523 * @tc.name: GetVideoCallVsyncChangeTest
524 * @tc.desc: test results of GetVideoCallVsyncChangeTest
525 * @tc.type: FUNC
526 * @tc.require: issuesIA96Q3
527 */
528 HWTEST_F(HgmEnergyConsumptionPolicyTest, GetVideoCallVsyncChangeTest, TestSize.Level0)
529 {
530 auto& hgmEnergyConsumptionPolicy = HgmEnergyConsumptionPolicy::Instance();
531 hgmEnergyConsumptionPolicy.isVideoCallVsyncChange_.store(true);
532 auto result = hgmEnergyConsumptionPolicy.GetVideoCallVsyncChange();
533 ASSERT_EQ(result, true);
534 ASSERT_EQ(hgmEnergyConsumptionPolicy.isVideoCallVsyncChange_.load(), false);
535 }
536
537 /**
538 * @tc.name: GetVideoCallFrameRateTest
539 * @tc.desc: test results of GetVideoCallFrameRateTest
540 * @tc.type: FUNC
541 * @tc.require: issuesIA96Q3
542 */
543 HWTEST_F(HgmEnergyConsumptionPolicyTest, GetVideoCallFrameRateTest, TestSize.Level0)
544 {
545 auto& hgmEnergyConsumptionPolicy = HgmEnergyConsumptionPolicy::Instance();
546 EventInfo eventInfo = {
547 .eventName = "VOTER_VIDEO_CALL",
548 .maxRefreshRate = 15,
549 .description = "flutterVsyncName:1234",
550 .eventStatus = true,
551
552 };
553 hgmEnergyConsumptionPolicy.SetVideoCallSceneInfo(eventInfo);
554 std::string vsyncName = "flutterVsyncName";
555 pid_t pid = 1234;
556 FrameRateRange frameRateRange;
557 hgmEnergyConsumptionPolicy.GetVideoCallFrameRate(pid, vsyncName, frameRateRange);
558 ASSERT_EQ(frameRateRange.preferred_, 0);
559 }
560
561 /**
562 * @tc.name: SetCurrentPkgNameTest
563 * @tc.desc: test results of SetCurrentPkgNameTest
564 * @tc.type: FUNC
565 * @tc.require: issuesIA96Q3
566 */
567 HWTEST_F(HgmEnergyConsumptionPolicyTest, SetCurrentPkgNameTest, TestSize.Level0)
568 {
569 std::vector<std::string> pkgNames;
570 HgmEnergyConsumptionPolicy::Instance().SetCurrentPkgName(pkgNames);
571 ASSERT_EQ(HgmEnergyConsumptionPolicy::Instance().videoCallLayerName_, "");
572 }
573
574 /**
575 * @tc.name: HgmFrameRateManager
576 * @tc.desc: test results of HgmFrameRateManager
577 * @tc.type: FUNC
578 * @tc.require:issuesIA96Q3
579 */
580 HWTEST_F(HgmEnergyConsumptionPolicyTest, HgmFrameRateManager, TestSize.Level1)
581 {
582 HgmFrameRateManager mgr;
583 mgr.rsFrameRateLinker_ = std::make_shared<RSRenderFrameRateLinker>();
584 std::shared_ptr<RSRenderFrameRateLinker> linker = std::make_shared<RSRenderFrameRateLinker>();
585 FrameRateLinkerMap appFrameRateLinkers_;
586 mgr.currRefreshRate_ = DEFAULT_MAX_FPS;
587 appFrameRateLinkers_[((NodeId)1000) << 32] = linker;
588 mgr.appFrameRateLinkers_ = appFrameRateLinkers_;
589 linker->SetExpectedRange(FrameRateRange(0, 0, 0,
590 ACE_COMPONENT_FRAME_RATE_TYPE));
591 HgmEnergyConsumptionPolicy::Instance().SetTouchState(TouchState::IDLE_STATE);
592 mgr.UpdateSoftVSync(true);
593 EventInfo eventInfo = { .eventName = "ENERGY_CONSUMPTION_ASSURANCE", .eventStatus = false,
594 .description = "DRAG_SCENE:1000" };
595 HgmEnergyConsumptionPolicy::Instance().SetEnergyConsumptionAssuranceSceneInfo(eventInfo);
596 linker->SetExpectedRange(FrameRateRange(0, 0, 0,
597 DRAG_SCENE_FRAME_RATE_TYPE));
598 mgr.UpdateSoftVSync(true);
599 HgmEnergyConsumptionPolicy::Instance().SetTouchState(TouchState::DOWN_STATE);
600 linker->SetExpectedRange(FrameRateRange(0, 0, 0,
601 ANIMATION_STATE_FIRST_FRAME));
602 mgr.UpdateSoftVSync(true);
603 linker->SetExpectedRange(FrameRateRange(DEFAULT_MAX_FPS, DEFAULT_MAX_FPS, DEFAULT_MAX_FPS,
604 ANIMATION_STATE_FIRST_FRAME));
605 mgr.UpdateSoftVSync(true);
606 EXPECT_EQ(mgr.currRefreshRate_, DEFAULT_MAX_FPS);
607 }
608 } // namespace Rosen
609 } // namespace OHOS