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