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: IsInit
77  * @tc.desc: Verify the result of initialization
78  * @tc.type: FUNC
79  * @tc.require: I7DMS1
80  */
81 HWTEST_F(HyperGraphicManagerTest, IsInit, Function | SmallTest | Level2)
82 {
83     auto &instance = HgmCore::Instance();
84 
85     PART("CaseDescription") {
86         STEP("1. check if IsInit() is true") {
87             bool init = instance.IsInit();
88             STEP_ASSERT_EQ(init, true);
89             bool enabled = instance.IsEnabled();
90             STEP_ASSERT_EQ(enabled, true);
91             instance.GetPolicyConfigData();
92             auto hgmFrameRateMgr_ = instance.GetFrameRateMgr();
93             STEP_ASSERT_NE(hgmFrameRateMgr_, nullptr);
94         }
95     }
96 }
97 
98 /**
99  * @tc.name: AddScreen
100  * @tc.desc: Verify the result of AddScreen function
101  * @tc.type: FUNC
102  * @tc.require: I7DMS1
103  */
104 HWTEST_F(HyperGraphicManagerTest, AddScreen, Function | MediumTest | Level2)
105 {
106     auto &instance = HgmCore::Instance();
107     int sizeListBefore = 0;
108     int sizeListAfter = 0;
109     int sizeScreenIds = 0;
110 
111     PART("EnvConditions") {
112         STEP("get Instance") {
113             bool init = instance.IsInit();
114             STEP_ASSERT_EQ(init, true);
115         }
116     }
117 
118     PART("CaseDescription") {
119         STEP("1. mark screenList_ size before add") {
120             sizeListBefore = instance.GetScreenListSize();
121             STEP_ASSERT_GE(sizeListBefore, 0);
122         }
123 
124         STEP("2. add new screen") {
125             ScreenId screenId = 2;
126             auto addScreen = instance.AddScreen(screenId, 0, screenSize);
127             STEP_ASSERT_EQ(addScreen, 0);
128         }
129 
130         STEP("3. mark screenList_ size after add") {
131             sizeListAfter = instance.GetScreenListSize();
132         }
133 
134         STEP("4. check screenList_ size") {
135             STEP_ASSERT_EQ(sizeListAfter, sizeListBefore + 1);
136         }
137 
138         STEP("5. mark screenIds Size") {
139             sizeScreenIds  = instance.GetScreenIds().size();
140             STEP_ASSERT_EQ(sizeScreenIds, sizeListAfter);
141         }
142     }
143 }
144 
145 /**
146  * @tc.name: GetScreen
147  * @tc.desc: Verify the result of GetScreen function
148  * @tc.type: FUNC
149  * @tc.require: I7DMS1
150  */
151 HWTEST_F(HyperGraphicManagerTest, GetScreen, Function | SmallTest | Level2)
152 {
153     auto &instance5 = HgmCore::Instance();
154     sptr<HgmScreen> screen = nullptr;
155     ScreenId screenId = 3;
156     ScreenId screenId2 = 4;
157 
158 
159     PART("EnvConditions") {
160         STEP("get Instance and call Init and add a screen") {
161             auto addScreen = instance5.AddScreen(screenId, 0, screenSize);
162             auto activeScreen = instance5.GetActiveScreen();
163 
164             instance5.SetActiveScreenId(screenId);
165             activeScreen = instance5.GetActiveScreen();
166             STEP_ASSERT_NE(activeScreen, nullptr);
167             STEP_ASSERT_GE(addScreen, 0);
168             STEP_ASSERT_GE(instance5.GetActiveScreenId(), screenId);
169         }
170     }
171 
172     PART("CaseDescription") {
173         STEP("1. try get the previously added screen") {
174             screen = instance5.GetScreen(screenId);
175         }
176 
177         STEP("2. check the pointer") {
178             STEP_ASSERT_NE(screen, nullptr);
179         }
180 
181         STEP("3. try get the non-existence screen") {
182             screen = instance5.GetScreen(screenId2);
183             STEP_ASSERT_EQ(screen, nullptr);
184         }
185     }
186 }
187 
188 /**
189  * @tc.name: AddScreenModeInfo
190  * @tc.desc: Verify the result of AddScreenModeInfo function
191  * @tc.type: FUNC
192  * @tc.require: I7DMS1
193  */
194 HWTEST_F(HyperGraphicManagerTest, AddScreenModeInfo, Function | SmallTest | Level3)
195 {
196     auto &instance6 = HgmCore::Instance();
197     int addMode = 0;
198     ScreenId screenId = 4;
199 
200     PART("EnvConditions") {
201         STEP("get Instance and add a screen") {
202             auto addScreen = instance6.AddScreen(screenId, 0, screenSize);
203             STEP_ASSERT_GE(addScreen, 0);
204         }
205     }
206 
207     PART("CaseDescription") {
208         STEP("1. try get the previously added screen") {
209             auto screen = instance6.GetScreen(screenId);
210             STEP_ASSERT_NE(screen, nullptr);
211         }
212 
213         STEP("2. add a supported config to the new screen") {
214             addMode = instance6.AddScreen(screenId, addMode, screenSize);
215         }
216 
217         STEP("3. verify adding result") {
218             STEP_ASSERT_EQ(addMode, 0);
219         }
220     }
221 }
222 
223 /**
224  * @tc.name: RemoveScreen
225  * @tc.desc: Verify the result of RemoveScreen function
226  * @tc.type: FUNC
227  * @tc.require: I7DMS1
228  */
229 HWTEST_F(HyperGraphicManagerTest, RemoveScreen, Function | MediumTest | Level2)
230 {
231     auto &instance7 = HgmCore::Instance();
232     int sizeListBefore = 0;
233     int sizeListAfter = 0;
234     ScreenId screenId = 6;
235 
236     PART("EnvConditions") {
237         STEP("get Instance and call Init and add a screen") {
238             bool init = instance7.IsInit();
239             STEP_ASSERT_EQ(init, true);
240             auto addScreen = instance7.AddScreen(screenId, 0, screenSize);
241             STEP_ASSERT_EQ(addScreen, 0);
242         }
243     }
244 
245     PART("CaseDescription") {
246         STEP("1. mark screenList_ size before remove") {
247             sizeListBefore = instance7.GetScreenListSize();
248             STEP_ASSERT_GE(sizeListBefore, 1);
249         }
250 
251         STEP("2. add new screen") {
252             ScreenId screenId = 2;
253             auto removeScreen = instance7.RemoveScreen(screenId);
254             STEP_ASSERT_EQ(removeScreen, 0);
255         }
256 
257         STEP("3. mark screenList_ size after remove") {
258             sizeListAfter = instance7.GetScreenListSize();
259         }
260 
261         STEP("3. check screenList_ size") {
262             STEP_ASSERT_EQ(sizeListAfter, sizeListBefore - 1);
263         }
264     }
265 }
266 
267 /**
268  * @tc.name: SetScreenRefreshRate
269  * @tc.desc: Verify the result of SetScreenRefreshRate function
270  * @tc.type: FUNC
271  * @tc.require: I7DMS1
272  */
273 HWTEST_F(HyperGraphicManagerTest, SetScreenRefreshRate, Function | MediumTest | Level2)
274 {
275     auto &instance8 = HgmCore::Instance();
276     ScreenId screenId = 7;
277     ScreenId screenId2 = 1;
278     sptr<HgmScreen> screen = nullptr;
279     int32_t width = 1344;
280     int32_t height = 2772;
281     uint32_t rate = 120;
282     int32_t mode = 1;
283     int32_t width0 = 1344;
284     int32_t height0 = 2772;
285     uint32_t rate0 = 60;
286     int32_t mode0 = 0;
287     int32_t timestamp = 1704038400; // 2024-01-01 00:00:00
288 
289     PART("CaseDescription") {
290         STEP("1. add a new screen") {
291             auto addScreen = instance8.AddScreen(screenId, 0, screenSize);
292             STEP_ASSERT_EQ(addScreen, 0);
293             auto addScreenProfile = instance8.AddScreenInfo(screenId, width, height, rate, mode);
294             STEP_ASSERT_EQ(addScreenProfile, 0);
295             auto addScreenProfile0 = instance8.AddScreenInfo(screenId, width0, height0, rate0, mode0);
296             STEP_ASSERT_EQ(addScreenProfile0, 0);
297             addScreenProfile0 = instance8.AddScreenInfo(screenId2, width0, height0, rate0, mode0);
298             STEP_ASSERT_EQ(addScreenProfile0, 100);
299             auto setRate500 = instance8.SetScreenRefreshRate(screenId, 0, 500);
300             STEP_ASSERT_EQ(setRate500, -1);
301             screen = instance8.GetScreen(screenId);
302             STEP_ASSERT_NE(screen->GetActiveRefreshRate(), 500);
303             auto setRate120 = instance8.SetScreenRefreshRate(screenId, 0, 120);
304             STEP_ASSERT_NE(setRate120, -1);
305             auto setRate60 = instance8.SetScreenRefreshRate(screenId2, 0, 60);
306             STEP_ASSERT_EQ(setRate60, -1);
307             auto setRateNegative = instance8.SetScreenRefreshRate(screenId, 0, -1);
308             STEP_ASSERT_EQ(setRateNegative, -1);
309             screen = instance8.GetScreen(screenId);
310             STEP_ASSERT_EQ(screen->GetActiveRefreshRate(), 120);
311             auto modeListToApply = instance8.GetModesToApply();
312             STEP_ASSERT_NE(modeListToApply->size(), 0);
313             instance8.SetPendingScreenRefreshRate(rate0);
314             STEP_ASSERT_EQ(instance8.GetPendingScreenRefreshRate(), rate0);
315             instance8.SetTimestamp(timestamp);
316             STEP_ASSERT_EQ(instance8.GetCurrentTimestamp(), timestamp);
317         }
318     }
319 }
320 
321 /**
322  * @tc.name: SetRefreshRateMode
323  * @tc.desc: Verify the result of SetRefreshRateMode function
324  * @tc.type: FUNC
325  * @tc.require: I7DMS1
326  */
327 HWTEST_F(HyperGraphicManagerTest, SetRefreshRateMode, Function | SmallTest | Level2)
328 {
329     auto &instance = HgmCore::Instance();
330     ScreenId screenId = 7;
331     sptr<HgmScreen> screen = nullptr;
332     int32_t width = 1344;
333     int32_t height = 2772;
334     uint32_t rate = 120;
335     int32_t mode = 1;
336     int32_t modeToSet = 2;
337 
338     PART("EnvConditions") {
339         STEP("get Instance") {
340             bool init = instance.IsInit();
341             STEP_ASSERT_EQ(init, true);
342         }
343     }
344 
345     PART("CaseDescription") {
346         STEP("1. add a new screen") {
347             auto addScreen = instance.AddScreen(screenId, 0, screenSize);
348             STEP_ASSERT_GE(addScreen, 0);
349         }
350 
351         STEP("2. add a a supported config to the new screen") {
352             auto addScreenProfile = instance.AddScreenInfo(screenId, width, height, rate, mode);
353             STEP_ASSERT_EQ(addScreenProfile, 0);
354         }
355 
356         STEP("3. set the refreshrate mode") {
357             auto setMode2 = instance.SetRefreshRateMode(modeToSet);
358             STEP_ASSERT_EQ(setMode2, 0);
359         }
360     }
361 }
362 
363 /**
364  * @tc.name: HgmScreenTests
365  * @tc.desc: Others functions in HgmScreen
366  * @tc.type: FUNC
367  * @tc.require: I7NJ2G
368  */
369 HWTEST_F(HyperGraphicManagerTest, HgmScreenTests, Function | MediumTest | Level2)
370 {
371     auto &instance = HgmCore::Instance();
372     ScreenId screenId1 = 7;
373     ScreenId screenId2 = 8;
374     int32_t width = 1344;
375     int32_t height = 2772;
376     int32_t width2 = 640;
377     int32_t height2 = 1320;
378     uint32_t rate = 120;
379     uint32_t rate2 = 60;
380     uint32_t rate3 = 150;
381     uint32_t rate4 = 0;
382     uint32_t rate5 = 80;
383     int32_t mode = 1;
384     int32_t mode2 = 2;
385     instance.AddScreen(screenId2, 1, screenSize);
386     instance.AddScreenInfo(screenId2, width, height, rate, mode);
387     instance.AddScreenInfo(screenId2, width, height, rate2, mode2);
388     sptr<HgmScreen> screen = instance.GetScreen(screenId1);
389     sptr<HgmScreen> screen2 = instance.GetScreen(screenId2);
390 
391     instance.AddScreen(screenId1, 0, screenSize);
392     EXPECT_GE(screen->GetActiveRefreshRate(), 0);
393     EXPECT_EQ(screen2->SetActiveRefreshRate(screenId2, rate2), 2);
394     EXPECT_EQ(screen2->SetActiveRefreshRate(screenId2, rate3), -1);
395     screen2->SetRateAndResolution(screenId2, rate2, width, height);
396     EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate, width, height), mode);
397     EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate3, width, height), -1);
398     EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate4, width, height), -1);
399     EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate5, width, height), -1);
400     EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate5, width2, height2), -1);
401     EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate5, width, height2), -1);
402     EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate5, width2, height), -1);
403     EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate, width2, height2), -1);
404     EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate, width, height2), -1);
405     EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate, width2, height), -1);
406     screen2->AddScreenModeInfo(width, height, rate, mode);
407     EXPECT_EQ(screen2->SetRefreshRateRange(rate2, rate), 0);
408 }
409 
410 /**
411  * @tc.name: HgmScreenTests2
412  * @tc.desc: Others functions in HgmScreen
413  * @tc.type: FUNC
414  * @tc.require: I7NJ2G
415  */
416 HWTEST_F(HyperGraphicManagerTest, HgmScreenTests2, Function | MediumTest | Level2) {
417     PART("HgmScreen") {
418         STEP("screen tests") {
419             sptr<HgmScreen> screen1 = new HgmScreen();
420             STEP_ASSERT_EQ(screen1->GetId(), 0);
421             STEP_ASSERT_EQ(screen1->GetActiveMode(), 0);
422             STEP_ASSERT_EQ(screen1->GetSupportedRates().size(), 0);
423             STEP_ASSERT_EQ(screen1->IsSupportRate(OLED_30_HZ), false);
424             STEP_ASSERT_EQ(screen1->GetActiveRefreshRateMode(), -1);
425             STEP_ASSERT_EQ(screen1->GetWidth(), 0);
426             STEP_ASSERT_EQ(screen1->GetHeight(), 0);
427             STEP_ASSERT_EQ(screen1->GetPhyWidth(), 0);
428             STEP_ASSERT_EQ(screen1->GetPhyHeight(), 0);
429             STEP_ASSERT_EQ(screen1->GetPpi(), 0);
430             STEP_ASSERT_EQ(screen1->GetXDpi(), 0);
431             STEP_ASSERT_EQ(screen1->GetYDpi(), 0);
432 
433             delete screen1;
434             screen1 = nullptr;
435             STEP_ASSERT_EQ(screen1, nullptr);
436         }
437     }
438 }
439 
440 
441 /**
442  * @tc.name: HgmCoreTests
443  * @tc.desc: Others functions in HgmCore
444  * @tc.type: FUNC
445  * @tc.require: I7NJ2G
446  */
447 HWTEST_F(HyperGraphicManagerTest, HgmCoreTests, Function | MediumTest | Level2)
448 {
449     auto &instance = HgmCore::Instance();
450     ScreenId screenId2 = 8;
451     ScreenId screenId3 = 9;
452     sptr<HgmScreen> screen = nullptr;
453     int32_t width = 1344;
454     int32_t height = 2772;
455     uint32_t rate = 120;
456     uint32_t rate2 = 60;
457     uint32_t rate3 = -1;
458     int32_t mode = 1;
459     int32_t mode2 = 2;
460     instance.AddScreen(screenId2, 1, screenSize);
461     instance.AddScreenInfo(screenId2, width, height, rate, mode);
462     instance.AddScreenInfo(screenId2, width, height, rate2, mode2);
463 
464     PART("HgmCore") {
465         STEP("1. set active mode") {
466             int32_t setResult = instance.SetRefreshRateMode(settingMode1);
467             setResult = instance.SetRefreshRateMode(settingMode3);
468             setResult = instance.SetRefreshRateMode(settingMode1);
469             STEP_ASSERT_EQ(setResult, 0);
470         }
471 
472         STEP("2. set refresh rate via core") {
473             int32_t setResult = instance.SetScreenRefreshRate(screenId3, 0, rate);
474             setResult = instance.SetScreenRefreshRate(screenId2, 0, rate3);
475             setResult = instance.SetScreenRefreshRate(screenId2, 0, rate2);
476             setResult = instance.SetRefreshRateMode(settingMode1);
477             STEP_ASSERT_GE(setResult, -1);
478         }
479 
480         STEP("3. set rate and resolution") {
481             int32_t setResult = instance.SetRateAndResolution(screenId2, 0, 0, 0, 0);
482             STEP_ASSERT_EQ(setResult, -1);
483             int32_t addResult = instance.AddScreen(screenId2, 1, screenSize);
484             STEP_ASSERT_GE(addResult, -1);
485         }
486 
487         STEP("4. add screen info, screen does not exist") {
488             int32_t setResult = instance.AddScreenInfo(screenId3, 0, 0, 0, 0);
489             STEP_ASSERT_NE(setResult, 0);
490             uint32_t getResult = instance.GetScreenCurrentRefreshRate(screenId3);
491             STEP_ASSERT_EQ(getResult, 0);
492             std::vector<uint32_t> getVResult = instance.GetScreenSupportedRefreshRates(screenId3);
493             STEP_ASSERT_EQ(getVResult.size(), 0);
494         }
495 
496         STEP("5. add screen info, screen exist") {
497             instance.GetScreenCurrentRefreshRate(screenId2);
498             std::vector<uint32_t> getVResult = instance.GetScreenSupportedRefreshRates(screenId2);
499             auto screenComponentRefreshRates = instance.GetScreenComponentRefreshRates(screenId2);
500         }
501     }
502 }
503 
504 /**
505  * @tc.name: SetRefreshRateMode002
506  * @tc.desc: HgmCore.SetRefreshRateMode002
507  * @tc.type: FUNC
508  * @tc.require:
509  */
510 HWTEST_F(HyperGraphicManagerTest, SetRefreshRateMode002, Function | MediumTest | Level2)
511 {
512     auto &instance = HgmCore::Instance();
513     ScreenId screenId2 = 8;
514     sptr<HgmScreen> screen = nullptr;
515     int32_t width = 1344;
516     int32_t height = 2772;
517     uint32_t rate = 120;
518     uint32_t rate2 = 60;
519     int32_t mode = 1;
520     int32_t mode2 = 2;
521     instance.AddScreen(screenId2, 1, screenSize);
522     instance.AddScreenInfo(screenId2, width, height, rate, mode);
523     instance.AddScreenInfo(screenId2, width, height, rate2, mode2);
524 
525     PART("HgmCore") {
526         STEP("1. set active mode") {
527             int32_t setResult = instance.SetRefreshRateMode(settingMode1);
528             STEP_ASSERT_EQ(setResult, 0);
529             auto refreshRateMode = instance.GetCurrentRefreshRateMode();
530             STEP_ASSERT_EQ(refreshRateMode, settingMode1);
531 
532             setResult = instance.SetRefreshRateMode(settingMode2);
533             STEP_ASSERT_EQ(setResult, 0);
534             refreshRateMode = instance.GetCurrentRefreshRateMode();
535             STEP_ASSERT_EQ(refreshRateMode, settingMode2);
536 
537             setResult = instance.SetRefreshRateMode(settingMode1);
538             STEP_ASSERT_EQ(setResult, 0);
539             refreshRateMode = instance.GetCurrentRefreshRateMode();
540             STEP_ASSERT_EQ(refreshRateMode, settingMode1);
541         }
542     }
543 }
544 
545 /**
546  * @tc.name: RefreshBundleName
547  * @tc.desc: Verify the result of RefreshBundleName
548  * @tc.type: FUNC
549  * @tc.require: I7DMS1
550  */
551 HWTEST_F(HyperGraphicManagerTest, RefreshBundleName, Function | SmallTest | Level2)
552 {
553     auto &instance = HgmCore::Instance();
554 
555     PART("EnvConditions") {
556         STEP("get Instance") {
557             bool init = instance.IsInit();
558             STEP_ASSERT_EQ(init, true);
559         }
560     }
561 
562     PART("CaseConditions") {
563         STEP("1. test RefreshBundleName is true") {
564             auto setMode = instance.RefreshBundleName("test hgm_core");
565             STEP_ASSERT_EQ(setMode, 0);
566             instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_AUTO);
567             setMode = instance.RefreshBundleName("test hgm_core2");
568             STEP_ASSERT_EQ(setMode, 0);
569         }
570     }
571 }
572 
573 /**
574  * @tc.name: GetIdealPeriod
575  * @tc.desc: Test GetIdealPeriod
576  * @tc.type: FUNC
577  * @tc.require:
578  */
579 HWTEST_F(HyperGraphicManagerTest, GetIdealPeriod, Function | SmallTest | Level2)
580 {
581     auto &instance = HgmCore::Instance();
582     EXPECT_EQ(instance.GetIdealPeriod(30), IDEAL_30_PERIOD);
583     EXPECT_EQ(instance.GetIdealPeriod(60), IDEAL_60_PERIOD);
584 }
585 
586 /**
587  * @tc.name: GetLtpoEnabled
588  * @tc.desc: Test GetLtpoEnabled
589  * @tc.type: FUNC
590  * @tc.require:
591  */
592 HWTEST_F(HyperGraphicManagerTest, GetLtpoEnabled, Function | SmallTest | Level2)
593 {
594     auto &instance = HgmCore::Instance();
595     instance.SetLtpoEnabled(true);
596     instance.SetSupportedMaxTE(VSYNC_MAX_REFRESHRATE);
597     instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_AUTO);
598     EXPECT_EQ(instance.IsLTPOSwitchOn(), true);
599     EXPECT_EQ(instance.GetSupportedMaxTE(), VSYNC_MAX_REFRESHRATE);
600     EXPECT_EQ(instance.GetCurrentRefreshRateMode(), static_cast<int32_t>(HGM_REFRESHRATE_MODE_AUTO));
601     EXPECT_EQ(instance.GetLtpoEnabled(), true);
602 }
603 
604 /**
605  * @tc.name: NotifyScreenPowerStatus
606  * @tc.desc: Test NotifyScreenPowerStatus
607  * @tc.type: FUNC
608  * @tc.require:
609  */
610 HWTEST_F(HyperGraphicManagerTest, NotifyScreenPowerStatus, Function | SmallTest | Level2)
611 {
612     ScreenId screenId = 8;
613     auto &instance = HgmCore::Instance();
614     instance.NotifyScreenPowerStatus(screenId, POWER_STATUS_ON);
615 }
616 
617 
618 /**
619  * @tc.name: RefreshRateModeChangeCallback
620  * @tc.desc: Test RefreshRateModeChangeCallback
621  * @tc.type: FUNC
622  * @tc.require:
623  */
624 HWTEST_F(HyperGraphicManagerTest, RefreshRateModeChangeCallback, Function | SmallTest | Level2)
625 {
626     auto &instance = HgmCore::Instance();
__anon0246ba470202(int32_t num) 627     instance.RegisterRefreshRateModeChangeCallback([](int32_t num) {return;});
628     EXPECT_NE(instance.GetRefreshRateModeChangeCallback(), nullptr);
629 }
630 
631 /**
632  * @tc.name: SetEnableDynamicMode
633  * @tc.desc: Test SetEnableDynamicMode
634  * @tc.type: FUNC
635  * @tc.require:
636  */
637 HWTEST_F(HyperGraphicManagerTest, SetEnableDynamicMode, Function | SmallTest | Level1)
638 {
639     auto &instance = HgmCore::Instance();
640     EXPECT_EQ(instance.GetEnableDynamicMode(), true);
641     instance.SetEnableDynamicMode(false);
642     EXPECT_EQ(instance.GetEnableDynamicMode(), false);
643 }
644 
645 /**
646  * @tc.name: SetActualTimestamp
647  * @tc.desc: Verify the result of SetActualTimestamp function
648  * @tc.type: FUNC
649  * @tc.require:
650  */
651 HWTEST_F(HyperGraphicManagerTest, SetActualTimestamp, Function | SmallTest | Level2)
652 {
653     auto &hgmCore = HgmCore::Instance();
654     int64_t timestamp = 1700;
655     hgmCore.SetActualTimestamp(timestamp);
656     EXPECT_EQ(hgmCore.GetActualTimestamp() == timestamp, true);
657 }
658 
659 /**
660  * @tc.name: SetVsyncId
661  * @tc.desc: Verify the result of SetVsyncId function
662  * @tc.type: FUNC
663  * @tc.require:
664  */
665 HWTEST_F(HyperGraphicManagerTest, SetVsyncId, Function | SmallTest | Level2)
666 {
667     auto &hgmCore = HgmCore::Instance();
668     uint64_t vsyncId = 1800;
669     hgmCore.SetVsyncId(vsyncId);
670     EXPECT_EQ(hgmCore.GetVsyncId() == vsyncId, true);
671 }
672 
673 /**
674  * @tc.name: SetForceRefreshFlag
675  * @tc.desc: Verify the result of SetForceRefreshFlag function
676  * @tc.type: FUNC
677  * @tc.require:
678  */
679 HWTEST_F(HyperGraphicManagerTest, SetForceRefreshFlag, Function | SmallTest | Level2)
680 {
681     auto &hgmCore = HgmCore::Instance();
682     bool isForceRefresh = false;
683     hgmCore.SetForceRefreshFlag(isForceRefresh);
684     EXPECT_EQ(hgmCore.GetForceRefreshFlag() == isForceRefresh, true);
685 }
686 } // namespace Rosen
687 } // namespace OHOS