1 /*
2 * Copyright (c) 2023 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_core.h"
20 #include "hgm_frame_rate_manager.h"
21
22 #include "screen_manager/screen_types.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 namespace {
30 int32_t width = 720;
31 int32_t height = 1080;
32 int32_t phyWidth = 685;
33 int32_t phyHeight = 1218;
34 ScreenSize screenSize = {width, height, phyWidth, phyHeight};
35
36 constexpr int32_t settingMode1 = 1;
37 constexpr int32_t settingMode2 = 2;
38 constexpr int32_t settingMode3 = 3;
39 constexpr int32_t IDEAL_30_PERIOD = 33333333;
40 constexpr int32_t IDEAL_60_PERIOD = 16666666;
41
42 }
43 class HyperGraphicManagerTest : public testing::Test {
44 public:
45 static void SetUpTestCase();
46 static void TearDownTestCase();
47 void SetUp();
48 void TearDown();
49 };
50
SetUpTestCase()51 void HyperGraphicManagerTest::SetUpTestCase() {}
TearDownTestCase()52 void HyperGraphicManagerTest::TearDownTestCase() {}
SetUp()53 void HyperGraphicManagerTest::SetUp() {}
TearDown()54 void HyperGraphicManagerTest::TearDown() {}
55
56 /**
57 * @tc.name: Instance
58 * @tc.desc: Verify the independency of HgmCore instance
59 * @tc.type: FUNC
60 * @tc.require: I7DMS1
61 */
62 HWTEST_F(HyperGraphicManagerTest, Instance, Function | SmallTest | Level4)
63 {
64 PART("CaseDescription") {
65 STEP("1. call GetInstance twice") {
66 auto &instance1 = HgmCore::Instance();
67 auto &instance2 = HgmCore::Instance();
68 STEP("2. check the result of configuration") {
69 STEP_ASSERT_EQ(&instance1, &instance2);
70 }
71 }
72 }
73 }
74
75 /**
76 * @tc.name: Instance2
77 * @tc.desc: Verify the independency of HgmCore instance2
78 * @tc.type: FUNC
79 * @tc.require: I7DMS1
80 */
81 HWTEST_F(HyperGraphicManagerTest, Instance2, Function | SmallTest | Level4)
82 {
83 PART("CaseDescription") {
84 STEP("1. call GetInstance twice") {
85 auto defaultRateMode = "0";
86 auto newRateMode = "1";
87 RSSystemProperties::SetHgmRefreshRateModesEnabled(newRateMode);
88 auto &instance1 = HgmCore::Instance();
89 RSSystemProperties::SetHgmRefreshRateModesEnabled(defaultRateMode);
90 auto &instance2 = HgmCore::Instance();
91 STEP_ASSERT_EQ(&instance1, &instance2);
92 }
93 }
94 }
95
96 /**
97 * @tc.name: SetAsConfigTest
98 * @tc.desc: Verify the independency of HgmCore SetAsConfigTest
99 * @tc.type: FUNC
100 * @tc.require: I7DMS1
101 */
102 HWTEST_F(HyperGraphicManagerTest, SetAsConfigTest, Function | SmallTest | Level4)
103 {
104 PART("CaseDescription") {
105 STEP("1. call GetInstance twice") {
106 auto &instance1 = HgmCore::Instance();
107 if (instance1.hgmFrameRateMgr_ == nullptr) {
108 return;
109 }
110 auto curScreenStrategyId = instance1.hgmFrameRateMgr_->GetCurScreenStrategyId();
111 if (instance1.mPolicyConfigData_ == nullptr) {
112 return;
113 }
114 auto& curScreenSetting = instance1.mPolicyConfigData_->screenConfigs_[
115 curScreenStrategyId][std::to_string(instance1.customFrameRateMode_)];
116 instance1.SetASConfig(curScreenSetting);
117 STEP_ASSERT_EQ(instance1.adaptiveSync_, 0);
118 curScreenSetting.ltpoConfig["adaptiveSync"] = "1";
119 instance1.SetASConfig(curScreenSetting);
120 STEP_ASSERT_EQ(instance1.adaptiveSync_, 1);
121 curScreenSetting.ltpoConfig["adaptiveSync"] = "2";
122 instance1.SetASConfig(curScreenSetting);
123 STEP_ASSERT_EQ(instance1.adaptiveSync_, 0);
124 }
125 }
126 }
127
128
129 /**
130 * @tc.name: GetActiveScreenTest
131 * @tc.desc: Verify the independency of HgmCore GetActiveScreenTest
132 * @tc.type: FUNC
133 * @tc.require: I7DMS1
134 */
135 HWTEST_F(HyperGraphicManagerTest, GetActiveScreenTest, Function | SmallTest | Level4)
136 {
137 PART("CaseDescription") {
138 STEP("1. call GetInstance twice") {
139 auto &instance1 = HgmCore::Instance();
140 if (instance1.GetActiveScreen() == nullptr) {
141 return;
142 }
143 STEP_ASSERT_NE(instance1.GetActiveScreen(), nullptr);
144 instance1.hgmFrameRateMgr_->curScreenId_.store(INVALID_SCREEN_ID);
145 STEP_ASSERT_EQ(instance1.GetActiveScreen(), nullptr);
146 }
147 }
148 }
149
150
151 /**
152 * @tc.name: IsInit
153 * @tc.desc: Verify the result of initialization
154 * @tc.type: FUNC
155 * @tc.require: I7DMS1
156 */
157 HWTEST_F(HyperGraphicManagerTest, IsInit, Function | SmallTest | Level2)
158 {
159 auto &instance = HgmCore::Instance();
160
161 PART("CaseDescription") {
162 STEP("1. check if IsInit() is true") {
163 bool enabled = instance.IsEnabled();
164 if (enabled == false) {
165 return;
166 }
167 STEP_ASSERT_EQ(enabled, true);
168 instance.GetPolicyConfigData();
169 auto hgmFrameRateMgr_ = instance.GetFrameRateMgr();
170 STEP_ASSERT_NE(hgmFrameRateMgr_, nullptr);
171 }
172 }
173 }
174
175 /**
176 * @tc.name: AddScreen
177 * @tc.desc: Verify the result of AddScreen function
178 * @tc.type: FUNC
179 * @tc.require: I7DMS1
180 */
181 HWTEST_F(HyperGraphicManagerTest, AddScreen, Function | MediumTest | Level2)
182 {
183 auto &instance = HgmCore::Instance();
184 int sizeListBefore = 0;
185 int sizeListAfter = 0;
186 int sizeScreenIds = 0;
187
188 PART("CaseDescription") {
189 STEP("1. mark screenList_ size before add") {
190 sizeListBefore = instance.GetScreenListSize();
191 STEP_ASSERT_GE(sizeListBefore, 0);
192 }
193
194 STEP("2. add new screen") {
195 ScreenId screenId = 2;
196 auto addScreen = instance.AddScreen(screenId, 0, screenSize);
197 STEP_ASSERT_EQ(addScreen, 0);
198 }
199
200 STEP("3. mark screenList_ size after add") {
201 sizeListAfter = instance.GetScreenListSize();
202 }
203
204 STEP("4. check screenList_ size") {
205 STEP_ASSERT_EQ(sizeListAfter, sizeListBefore + 1);
206 }
207
208 STEP("5. mark screenIds Size") {
209 sizeScreenIds = instance.GetScreenIds().size();
210 STEP_ASSERT_EQ(sizeScreenIds, sizeListAfter);
211 }
212 }
213 }
214
215 /**
216 * @tc.name: GetScreen
217 * @tc.desc: Verify the result of GetScreen function
218 * @tc.type: FUNC
219 * @tc.require: I7DMS1
220 */
221 HWTEST_F(HyperGraphicManagerTest, GetScreen, Function | SmallTest | Level2)
222 {
223 auto &instance5 = HgmCore::Instance();
224 sptr<HgmScreen> screen = nullptr;
225 ScreenId screenId = 3;
226
227 PART("EnvConditions") {
228 STEP("get Instance and call Init and add a screen") {
229 auto addScreen = instance5.AddScreen(screenId, 0, screenSize);
230 auto activeScreen = instance5.GetActiveScreen();
231
232 instance5.SetActiveScreenId(screenId);
233 activeScreen = instance5.GetActiveScreen();
234 STEP_ASSERT_GE(addScreen, 0);
235 STEP_ASSERT_GE(instance5.GetActiveScreenId(), 0);
236 }
237 }
238
239 PART("CaseDescription") {
240 STEP("1. try get the previously added screen") {
241 screen = instance5.GetScreen(screenId);
242 }
243
244 STEP("2. check the pointer") {
245 STEP_ASSERT_NE(screen, nullptr);
246 }
247 }
248 }
249
250 /**
251 * @tc.name: AddScreenModeInfo
252 * @tc.desc: Verify the result of AddScreenModeInfo function
253 * @tc.type: FUNC
254 * @tc.require: I7DMS1
255 */
256 HWTEST_F(HyperGraphicManagerTest, AddScreenModeInfo, Function | SmallTest | Level3)
257 {
258 auto &instance6 = HgmCore::Instance();
259 int addMode = 0;
260 ScreenId screenId = 4;
261
262 PART("EnvConditions") {
263 STEP("get Instance and add a screen") {
264 auto addScreen = instance6.AddScreen(screenId, 0, screenSize);
265 STEP_ASSERT_GE(addScreen, 0);
266 }
267 }
268
269 PART("CaseDescription") {
270 STEP("1. try get the previously added screen") {
271 auto screen = instance6.GetScreen(screenId);
272 STEP_ASSERT_NE(screen, nullptr);
273 }
274
275 STEP("2. add a supported config to the new screen") {
276 addMode = instance6.AddScreen(screenId, addMode, screenSize);
277 }
278
279 STEP("3. verify adding result") {
280 STEP_ASSERT_EQ(addMode, 0);
281 }
282 }
283 }
284
285 /**
286 * @tc.name: RemoveScreen
287 * @tc.desc: Verify the result of RemoveScreen function
288 * @tc.type: FUNC
289 * @tc.require: I7DMS1
290 */
291 HWTEST_F(HyperGraphicManagerTest, RemoveScreen, Function | MediumTest | Level2)
292 {
293 auto &instance7 = HgmCore::Instance();
294 int sizeListBefore = 0;
295 int sizeListAfter = 0;
296 ScreenId screenId = 6;
297
298 PART("EnvConditions") {
299 STEP("get Instance and call Init and add a screen") {
300 auto addScreen = instance7.AddScreen(screenId, 0, screenSize);
301 STEP_ASSERT_EQ(addScreen, 0);
302 }
303 }
304
305 PART("CaseDescription") {
306 STEP("1. mark screenList_ size before remove") {
307 sizeListBefore = instance7.GetScreenListSize();
308 STEP_ASSERT_GE(sizeListBefore, 1);
309 }
310
311 STEP("2. add new screen") {
312 ScreenId screenId = 2;
313 auto removeScreen = instance7.RemoveScreen(screenId);
314 STEP_ASSERT_EQ(removeScreen, 0);
315 }
316
317 STEP("3. mark screenList_ size after remove") {
318 sizeListAfter = instance7.GetScreenListSize();
319 }
320
321 STEP("3. check screenList_ size") {
322 STEP_ASSERT_EQ(sizeListAfter, sizeListBefore - 1);
323 }
324 }
325 }
326
327 /**
328 * @tc.name: SetScreenRefreshRate
329 * @tc.desc: Verify the result of SetScreenRefreshRate function
330 * @tc.type: FUNC
331 * @tc.require: I7DMS1
332 */
333 HWTEST_F(HyperGraphicManagerTest, SetScreenRefreshRate, Function | MediumTest | Level2)
334 {
335 auto &instance8 = HgmCore::Instance();
336 ScreenId screenId = 7;
337 sptr<HgmScreen> screen = nullptr;
338 int32_t width = 1344;
339 int32_t height = 2772;
340 uint32_t rate = 120;
341 int32_t mode = 1;
342 int32_t width0 = 1344;
343 int32_t height0 = 2772;
344 uint32_t rate0 = 60;
345 int32_t mode0 = 0;
346 int32_t timestamp = 1704038400; // 2024-01-01 00:00:00
347
348 PART("CaseDescription") {
349 STEP("1. add a new screen") {
350 auto addScreen = instance8.AddScreen(screenId, 0, screenSize);
351 STEP_ASSERT_EQ(addScreen, 0);
352 auto addScreenProfile = instance8.AddScreenInfo(screenId, width, height, rate, mode);
353 STEP_ASSERT_EQ(addScreenProfile, 0);
354 auto addScreenProfile0 = instance8.AddScreenInfo(screenId, width0, height0, rate0, mode0);
355 STEP_ASSERT_EQ(addScreenProfile0, 0);
356 auto setRate500 = instance8.SetScreenRefreshRate(screenId, 0, 500);
357 STEP_ASSERT_EQ(setRate500, -1);
358 screen = instance8.GetScreen(screenId);
359 STEP_ASSERT_NE(screen->GetActiveRefreshRate(), 500);
360 auto setRate120 = instance8.SetScreenRefreshRate(screenId, 0, 120);
361 if (setRate120 == -1) {
362 return;
363 }
364 STEP_ASSERT_NE(setRate120, -1);
365 screen = instance8.GetScreen(screenId);
366 STEP_ASSERT_EQ(screen->GetActiveRefreshRate(), 120);
367 auto modeListToApply = instance8.GetModesToApply();
368 STEP_ASSERT_NE(modeListToApply->size(), 0);
369 instance8.SetPendingScreenRefreshRate(rate0);
370 STEP_ASSERT_EQ(instance8.GetPendingScreenRefreshRate(), rate0);
371 instance8.SetTimestamp(timestamp);
372 STEP_ASSERT_EQ(instance8.GetCurrentTimestamp(), timestamp);
373 }
374 }
375 }
376
377 /**
378 * @tc.name: SetRefreshRateMode
379 * @tc.desc: Verify the result of SetRefreshRateMode function
380 * @tc.type: FUNC
381 * @tc.require: I7DMS1
382 */
383 HWTEST_F(HyperGraphicManagerTest, SetRefreshRateMode, Function | SmallTest | Level2)
384 {
385 auto &instance = HgmCore::Instance();
386 ScreenId screenId = 7;
387 sptr<HgmScreen> screen = nullptr;
388 int32_t width = 1344;
389 int32_t height = 2772;
390 uint32_t rate = 120;
391 int32_t mode = 1;
392 int32_t modeToSet = 2;
393
394 PART("CaseDescription") {
395 STEP("1. add a new screen") {
396 auto addScreen = instance.AddScreen(screenId, 0, screenSize);
397 STEP_ASSERT_GE(addScreen, 0);
398 }
399
400 STEP("2. add a a supported config to the new screen") {
401 auto addScreenProfile = instance.AddScreenInfo(screenId, width, height, rate, mode);
402 STEP_ASSERT_EQ(addScreenProfile, 0);
403 }
404
405 STEP("3. set the refreshrate mode") {
406 auto setMode2 = instance.SetRefreshRateMode(modeToSet);
407 STEP_ASSERT_EQ(setMode2, 0);
408 }
409 }
410 }
411
412 /**
413 * @tc.name: HgmScreenTests
414 * @tc.desc: Others functions in HgmScreen
415 * @tc.type: FUNC
416 * @tc.require: I7NJ2G
417 */
418 HWTEST_F(HyperGraphicManagerTest, HgmScreenTests, Function | MediumTest | Level2)
419 {
420 auto &instance = HgmCore::Instance();
421 ScreenId screenId1 = 7;
422 ScreenId screenId2 = 8;
423 int32_t width = 1344;
424 int32_t height = 2772;
425 int32_t width2 = 640;
426 int32_t height2 = 1320;
427 uint32_t rate = 120;
428 uint32_t rate2 = 60;
429 uint32_t rate3 = 150;
430 uint32_t rate4 = 0;
431 uint32_t rate5 = 80;
432 int32_t mode = 1;
433 int32_t mode2 = 2;
434 instance.AddScreen(screenId2, 1, screenSize);
435 instance.AddScreenInfo(screenId2, width, height, rate, mode);
436 EXPECT_EQ(instance.AddScreenInfo(screenId2, width, height, rate, mode), HgmErrCode::HGM_SCREEN_PARAM_ERROR);
437 instance.AddScreenInfo(screenId2, width, height, rate2, mode2);
438 sptr<HgmScreen> screen = instance.GetScreen(screenId1);
439 sptr<HgmScreen> screen2 = instance.GetScreen(screenId2);
440
441 instance.AddScreen(screenId1, 0, screenSize);
442 EXPECT_GE(screen->GetActiveRefreshRate(), 0);
443 EXPECT_EQ(screen2->SetActiveRefreshRate(screenId2, rate2), 2);
444 EXPECT_EQ(screen2->SetActiveRefreshRate(screenId2, rate2), -1);
445 EXPECT_EQ(screen2->SetActiveRefreshRate(screenId2, rate3), -1);
446 EXPECT_EQ(screen2->SetActiveRefreshRate(screenId2, rate3), -1);
447 EXPECT_EQ(screen2->SetActiveRefreshRate(SWITCH_SCREEN_SCENE, rate2), 2);
448 screen2->SetRateAndResolution(screenId2, rate2, width, height);
449 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate, width, height), mode);
450 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate3, width, height), -1);
451 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate4, width, height), -1);
452 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate5, width, height), -1);
453 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate5, width2, height2), -1);
454 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate5, width, height2), -1);
455 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate5, width2, height), -1);
456 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate, width2, height2), -1);
457 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate, width, height2), -1);
458 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate, width2, height), -1);
459 screen2->AddScreenModeInfo(width, height, rate, mode);
460 EXPECT_EQ(screen2->SetRefreshRateRange(rate2, rate), 0);
461 }
462
463 /**
464 * @tc.name: HgmScreenTests2
465 * @tc.desc: Others functions in HgmScreen
466 * @tc.type: FUNC
467 * @tc.require: I7NJ2G
468 */
469 HWTEST_F(HyperGraphicManagerTest, HgmScreenTests2, Function | MediumTest | Level2) {
470 PART("HgmScreen") {
471 STEP("screen tests") {
472 sptr<HgmScreen> screen1 = new HgmScreen();
473 STEP_ASSERT_EQ(screen1->GetId(), 0);
474 STEP_ASSERT_EQ(screen1->GetActiveMode(), 0);
475 STEP_ASSERT_EQ(screen1->GetSupportedRates().size(), 0);
476 STEP_ASSERT_EQ(screen1->IsSupportRate(OLED_30_HZ), false);
477 STEP_ASSERT_EQ(screen1->GetActiveRefreshRateMode(), -1);
478 STEP_ASSERT_EQ(screen1->GetWidth(), 0);
479 STEP_ASSERT_EQ(screen1->GetHeight(), 0);
480 STEP_ASSERT_EQ(screen1->GetPhyWidth(), 0);
481 STEP_ASSERT_EQ(screen1->GetPhyHeight(), 0);
482 STEP_ASSERT_EQ(screen1->GetPpi(), 0);
483 STEP_ASSERT_EQ(screen1->GetXDpi(), 0);
484 STEP_ASSERT_EQ(screen1->GetYDpi(), 0);
485
486 int32_t invalidValue = 66;
487 STEP_ASSERT_EQ(screen1->GetModeIdViaRate(invalidValue), -1); // invalid mode id
488 uint32_t savedActiveMode = screen1->GetActiveMode();
489 STEP_ASSERT_NE(screen1->GetModeIdViaRate(0), -2);
490 screen1->activeModeId_ = invalidValue; // invalid active mode
491 STEP_ASSERT_EQ(screen1->IfSwitchToRate(screen1->GetActiveMode(), OLED_30_HZ), false);
492 STEP_ASSERT_EQ(screen1->GetModeIdViaRate(0), -1);
493 screen1->activeModeId_ = savedActiveMode;
494
495 screen1 = nullptr;
496 STEP_ASSERT_EQ(screen1, nullptr);
497 }
498 STEP("screen constructor tests") {
499 // format<width, height, phyWidth, phyHeight>
500 ScreenSize screenSize1 = {0, 0, 0, 0};
501 sptr<HgmScreen> screen1 = new HgmScreen(0, 0, screenSize1);
502 screen1 = nullptr;
503 STEP_ASSERT_EQ(screen1, nullptr);
504
505 ScreenSize screenSize2 = {720, 1080, 685, 1218};
506 sptr<HgmScreen> screen2 = new HgmScreen(0, 0, screenSize2);
507 screen2 = nullptr;
508 STEP_ASSERT_EQ(screen2, nullptr);
509 }
510 }
511 }
512
513 /**
514 * @tc.name: HgmCoreTests
515 * @tc.desc: Others functions in HgmCore
516 * @tc.type: FUNC
517 * @tc.require: I7NJ2G
518 */
519 HWTEST_F(HyperGraphicManagerTest, HgmCoreTests, Function | MediumTest | Level2)
520 {
521 auto &instance = HgmCore::Instance();
522 ScreenId screenId2 = 8;
523 ScreenId screenId3 = 9;
524 sptr<HgmScreen> screen = nullptr;
525 int32_t width = 1344;
526 int32_t height = 2772;
527 uint32_t rate = 120;
528 uint32_t rate2 = 60;
529 uint32_t rate3 = -1;
530 int32_t mode = 1;
531 int32_t mode2 = 2;
532 instance.AddScreen(screenId2, 1, screenSize);
533 instance.AddScreenInfo(screenId2, width, height, rate, mode);
534 instance.AddScreenInfo(screenId2, width, height, rate2, mode2);
535
536 PART("HgmCore") {
537 STEP("1. set active mode") {
538 int32_t setResult = instance.SetRefreshRateMode(settingMode1);
539 setResult = instance.SetRefreshRateMode(settingMode3);
540 setResult = instance.SetRefreshRateMode(settingMode1);
541 STEP_ASSERT_EQ(setResult, 0);
542 }
543
544 STEP("2. set refresh rate via core") {
545 int32_t setResult = instance.SetScreenRefreshRate(screenId3, 0, rate);
546 setResult = instance.SetScreenRefreshRate(screenId2, 0, rate3);
547 setResult = instance.SetScreenRefreshRate(screenId2, 0, rate2);
548 setResult = instance.SetRefreshRateMode(settingMode1);
549 STEP_ASSERT_GE(setResult, -1);
550 }
551
552 STEP("3. set rate and resolution") {
553 int32_t setResult = instance.SetRateAndResolution(screenId2, 0, 0, 0, 0);
554 STEP_ASSERT_EQ(setResult, -1);
555 int32_t addResult = instance.AddScreen(screenId2, 1, screenSize);
556 STEP_ASSERT_GE(addResult, -1);
557 }
558
559 STEP("4. add screen info, screen does not exist") {
560 int32_t setResult = instance.AddScreenInfo(screenId3, 0, 0, 0, 0);
561 STEP_ASSERT_NE(setResult, 0);
562 uint32_t getResult = instance.GetScreenCurrentRefreshRate(screenId3);
563 STEP_ASSERT_EQ(getResult, 0);
564 std::vector<uint32_t> getVResult = instance.GetScreenSupportedRefreshRates(screenId3);
565 STEP_ASSERT_EQ(getVResult.size(), 0);
566 }
567
568 STEP("5. add screen info, screen exist") {
569 instance.GetScreenCurrentRefreshRate(screenId2);
570 std::vector<uint32_t> getVResult = instance.GetScreenSupportedRefreshRates(screenId2);
571 auto screenComponentRefreshRates = instance.GetScreenComponentRefreshRates(screenId2);
572 }
573 }
574 }
575
576 /**
577 * @tc.name: SetRefreshRateMode002
578 * @tc.desc: HgmCore.SetRefreshRateMode002
579 * @tc.type: FUNC
580 * @tc.require:
581 */
582 HWTEST_F(HyperGraphicManagerTest, SetRefreshRateMode002, Function | MediumTest | Level2)
583 {
584 auto &instance = HgmCore::Instance();
585 ScreenId screenId2 = 8;
586 sptr<HgmScreen> screen = nullptr;
587 int32_t width = 1344;
588 int32_t height = 2772;
589 uint32_t rate = 120;
590 uint32_t rate2 = 60;
591 int32_t mode = 1;
592 int32_t mode2 = 2;
593 instance.AddScreen(screenId2, 1, screenSize);
594 instance.AddScreenInfo(screenId2, width, height, rate, mode);
595 instance.AddScreenInfo(screenId2, width, height, rate2, mode2);
596
597 PART("HgmCore") {
598 STEP("1. set active mode") {
599 int32_t setResult = instance.SetRefreshRateMode(settingMode1);
600 STEP_ASSERT_EQ(setResult, 0);
601 auto refreshRateMode = instance.GetCurrentRefreshRateMode();
602 STEP_ASSERT_EQ(refreshRateMode, settingMode1);
603
604 setResult = instance.SetRefreshRateMode(settingMode2);
605 STEP_ASSERT_EQ(setResult, 0);
606 refreshRateMode = instance.GetCurrentRefreshRateMode();
607 STEP_ASSERT_EQ(refreshRateMode, settingMode2);
608
609 setResult = instance.SetRefreshRateMode(settingMode1);
610 STEP_ASSERT_EQ(setResult, 0);
611 refreshRateMode = instance.GetCurrentRefreshRateMode();
612 STEP_ASSERT_EQ(refreshRateMode, settingMode1);
613 }
614 }
615 }
616
617 /**
618 * @tc.name: GetIdealPeriod
619 * @tc.desc: Test GetIdealPeriod
620 * @tc.type: FUNC
621 * @tc.require:
622 */
623 HWTEST_F(HyperGraphicManagerTest, GetIdealPeriod, Function | SmallTest | Level2)
624 {
625 auto &instance = HgmCore::Instance();
626 EXPECT_EQ(instance.GetIdealPeriod(30), IDEAL_30_PERIOD);
627 EXPECT_EQ(instance.GetIdealPeriod(60), IDEAL_60_PERIOD);
628 int32_t invalidValue = 0;
629 EXPECT_EQ(instance.GetIdealPeriod(invalidValue), 0);
630 }
631
632 /**
633 * @tc.name: GetLtpoEnabled
634 * @tc.desc: Test GetLtpoEnabled
635 * @tc.type: FUNC
636 * @tc.require:
637 */
638 HWTEST_F(HyperGraphicManagerTest, GetLtpoEnabled, Function | SmallTest | Level2)
639 {
640 auto &instance = HgmCore::Instance();
641 instance.SetLtpoEnabled(true);
642 instance.SetSupportedMaxTE(360);
643 instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_AUTO);
644 if (instance.IsLTPOSwitchOn() != true) {
645 return;
646 }
647 EXPECT_EQ(instance.IsLTPOSwitchOn(), true);
648 EXPECT_EQ(instance.GetSupportedMaxTE(), 360);
649 EXPECT_EQ(instance.GetCurrentRefreshRateMode(), static_cast<int32_t>(HGM_REFRESHRATE_MODE_AUTO));
650 EXPECT_EQ(instance.GetLtpoEnabled(), true);
651 }
652
653 /**
654 * @tc.name: NotifyScreenPowerStatus
655 * @tc.desc: Test NotifyScreenPowerStatus
656 * @tc.type: FUNC
657 * @tc.require:
658 */
659 HWTEST_F(HyperGraphicManagerTest, NotifyScreenPowerStatus, Function | SmallTest | Level2)
660 {
661 ScreenId screenId = 8;
662 auto &instance = HgmCore::Instance();
663 instance.NotifyScreenPowerStatus(screenId, POWER_STATUS_ON);
664 if (instance.hgmFrameRateMgr_ != nullptr) {
665 EXPECT_NE(instance.hgmFrameRateMgr_->curScreenId_, screenId);
666 }
667 }
668
669
670 /**
671 * @tc.name: RefreshRateModeChangeCallback
672 * @tc.desc: Test RefreshRateModeChangeCallback
673 * @tc.type: FUNC
674 * @tc.require:
675 */
676 HWTEST_F(HyperGraphicManagerTest, RefreshRateModeChangeCallback, Function | SmallTest | Level2)
677 {
678 auto &instance = HgmCore::Instance();
__anon2e0b4c4f0202(int32_t num) 679 instance.RegisterRefreshRateModeChangeCallback([](int32_t num) {return;});
680 EXPECT_NE(instance.GetRefreshRateModeChangeCallback(), nullptr);
681 }
682
683 /**
684 * @tc.name: SetEnableDynamicMode
685 * @tc.desc: Test SetEnableDynamicMode
686 * @tc.type: FUNC
687 * @tc.require:
688 */
689 HWTEST_F(HyperGraphicManagerTest, SetEnableDynamicMode, Function | SmallTest | Level1)
690 {
691 auto &instance = HgmCore::Instance();
692 EXPECT_EQ(instance.GetEnableDynamicMode(), true);
693 instance.SetEnableDynamicMode(false);
694 EXPECT_EQ(instance.GetEnableDynamicMode(), false);
695 }
696
697 /**
698 * @tc.name: SetHfbcConfigMap
699 * @tc.desc: Verify the result of SetHfbcConfigMap function
700 * @tc.type: FUNC
701 * @tc.require:
702 */
703 HWTEST_F(HyperGraphicManagerTest, SetHfbcConfigMap, Function | SmallTest | Level2)
704 {
705 auto &hgmCore = HgmCore::Instance();
706 if (hgmCore.mPolicyConfigData_ == nullptr) {
707 return;
708 }
709 EXPECT_EQ(hgmCore.mPolicyConfigData_->hfbcConfig_.size(), 0);
710 std::unordered_map<std::string, std::string> hfbcConfig = {
711 { "com.test.allowapp", "1" }, { "com.test.allowapp2", "1" }
712 };
713 hgmCore.SetHfbcConfigMap(hfbcConfig);
714 EXPECT_EQ(hgmCore.mPolicyConfigData_->hfbcConfig_.size(), hfbcConfig.size());
715 for (const auto& pkg : hfbcConfig) {
716 EXPECT_EQ(hgmCore.mPolicyConfigData_->hfbcConfig_.find(pkg.first) !=
717 hgmCore.mPolicyConfigData_->hfbcConfig_.end(), true);
718 }
719 }
720
721 /**
722 * @tc.name: TestAbnormalCase
723 * @tc.desc: Verify the abnormal case of HgmCore
724 * @tc.type: FUNC
725 * @tc.require:
726 */
727 HWTEST_F(HyperGraphicManagerTest, TestAbnormalCase, Function | SmallTest | Level4)
728 {
729 auto &hgm = HgmCore::Instance();
730 hgm.Init();
731
732 auto mgr = hgm.GetFrameRateMgr();
733 std::string savedScreenStrategyId = mgr->curScreenStrategyId_;
734 EXPECT_EQ(savedScreenStrategyId, "LTPO-DEFAULT");
735 std::string invalidScreenStrategyId = "DEFAULT-INVALID";
736 mgr->curScreenStrategyId_ = invalidScreenStrategyId;
737 hgm.CheckCustomFrameRateModeValid();
738 mgr->curScreenStrategyId_ = savedScreenStrategyId;
739
740 int32_t savedFrameRateMode = hgm.customFrameRateMode_;
741 EXPECT_EQ(savedFrameRateMode, -1);
742 int32_t invalidValue = 66;
743 hgm.customFrameRateMode_ = invalidValue;
744 hgm.CheckCustomFrameRateModeValid();
745 hgm.GetCurrentRefreshRateModeName();
746
747 if (hgm.mPolicyConfigData_ == nullptr) {
748 return;
749 }
750 EXPECT_NE(hgm.mPolicyConfigData_, nullptr);
751 std::shared_ptr<PolicyConfigData> cachedPolicyConfigData = nullptr;
752 std::swap(hgm.mPolicyConfigData_, cachedPolicyConfigData);
753 EXPECT_EQ(hgm.mPolicyConfigData_, nullptr);
754 hgm.customFrameRateMode_ = invalidValue;
755 EXPECT_EQ(hgm.GetCurrentRefreshRateModeName(), invalidValue);
756 hgm.customFrameRateMode_ = 1;
757 EXPECT_EQ(hgm.GetCurrentRefreshRateModeName(), 60);
758 ScreenId screenId = 8;
759 hgm.GetScreenComponentRefreshRates(screenId);
760 hgm.customFrameRateMode_ = savedFrameRateMode;
761 std::swap(hgm.mPolicyConfigData_, cachedPolicyConfigData);
762 EXPECT_NE(hgm.mPolicyConfigData_, nullptr);
763 }
764
765 /**
766 * @tc.name: SetActualTimestamp
767 * @tc.desc: Verify the result of SetActualTimestamp function
768 * @tc.type: FUNC
769 * @tc.require:
770 */
771 HWTEST_F(HyperGraphicManagerTest, SetActualTimestamp, Function | SmallTest | Level2)
772 {
773 auto &hgmCore = HgmCore::Instance();
774 int64_t timestamp = 1700;
775 hgmCore.SetActualTimestamp(timestamp);
776 EXPECT_EQ(hgmCore.GetActualTimestamp() == timestamp, true);
777 }
778
779 /**
780 * @tc.name: SetVsyncId
781 * @tc.desc: Verify the result of SetVsyncId function
782 * @tc.type: FUNC
783 * @tc.require:
784 */
785 HWTEST_F(HyperGraphicManagerTest, SetVsyncId, Function | SmallTest | Level2)
786 {
787 auto &hgmCore = HgmCore::Instance();
788 uint64_t vsyncId = 1800;
789 hgmCore.SetVsyncId(vsyncId);
790 EXPECT_EQ(hgmCore.GetVsyncId() == vsyncId, true);
791 }
792
793 /**
794 * @tc.name: SetForceRefreshFlag
795 * @tc.desc: Verify the result of SetForceRefreshFlag function
796 * @tc.type: FUNC
797 * @tc.require:
798 */
799 HWTEST_F(HyperGraphicManagerTest, SetForceRefreshFlag, Function | SmallTest | Level2)
800 {
801 auto &hgmCore = HgmCore::Instance();
802 bool isForceRefresh = false;
803 hgmCore.SetForceRefreshFlag(isForceRefresh);
804 EXPECT_EQ(hgmCore.GetForceRefreshFlag() == isForceRefresh, true);
805 }
806
807 /**
808 * @tc.name: SetFastComposeTimeStampDiff
809 * @tc.desc: Verify the result of SetFastComposeTimeStampDiff function
810 * @tc.type: FUNC
811 * @tc.require:
812 */
813 HWTEST_F(HyperGraphicManagerTest, SetFastComposeTimeStampDiff, Function | SmallTest | Level2)
814 {
815 auto &hgmCore = HgmCore::Instance();
816 bool fastComposeTimeStampDiff = false;
817 hgmCore.SetFastComposeTimeStampDiff(fastComposeTimeStampDiff);
818 EXPECT_EQ(hgmCore.GetFastComposeTimeStampDiff() == fastComposeTimeStampDiff, true);
819 }
820
821 /**
822 * @tc.name: SetIdealPipelineOffset
823 * @tc.desc: Verify the result of SetIdealPipelineOffset function
824 * @tc.type: FUNC
825 * @tc.require:
826 */
827 HWTEST_F(HyperGraphicManagerTest, SetIdealPipelineOffset, Function | SmallTest | Level2)
828 {
829 auto &hgmCore = HgmCore::Instance();
830 int32_t pipelineOffsetPulseNum = 6;
831 int64_t idealPipelineOffset = pipelineOffsetPulseNum * IDEAL_PULSE;
832 hgmCore.SetIdealPipelineOffset(pipelineOffsetPulseNum);
833 EXPECT_EQ(hgmCore.GetIdealPipelineOffset(), idealPipelineOffset);
834 }
835
836 /**
837 * @tc.name: IsSwitchDssEnable
838 * @tc.desc: Verify the result of IsSwitchDssEnable function
839 * @tc.type: FUNC
840 * @tc.require:
841 */
842 HWTEST_F(HyperGraphicManagerTest, IsSwitchDssEnable, Function | SmallTest | Level2)
843 {
844 auto &hgmCore = HgmCore::Instance();
845 ScreenId screenId = 2;
846 EXPECT_EQ(hgmCore.IsSwitchDssEnable(screenId), false);
847 hgmCore.SetScreenSwitchDssEnable(screenId, true);
848 EXPECT_EQ(hgmCore.IsSwitchDssEnable(screenId), true);
849 hgmCore.SetScreenSwitchDssEnable(screenId, false);
850 EXPECT_EQ(hgmCore.IsSwitchDssEnable(screenId), false);
851 }
852 } // namespace Rosen
853 } // namespace OHOS
854