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
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 class HyperGraphicManagerTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp();
33 void TearDown();
34 };
35
SetUpTestCase()36 void HyperGraphicManagerTest::SetUpTestCase() {}
TearDownTestCase()37 void HyperGraphicManagerTest::TearDownTestCase() {}
SetUp()38 void HyperGraphicManagerTest::SetUp() {}
TearDown()39 void HyperGraphicManagerTest::TearDown() {}
40
41 /**
42 * @tc.name: Instance
43 * @tc.desc: Verify the independency of HgmCore instance
44 * @tc.type: FUNC
45 * @tc.require: I7DMS1
46 */
47 HWTEST_F(HyperGraphicManagerTest, Instance, Function | SmallTest | Level4)
48 {
49 PART("CaseDescription") {
50 STEP("1. call GetInstance twice") {
51 auto &instance1 = HgmCore::Instance();
52 auto &instance2 = HgmCore::Instance();
53 STEP("2. check the result of configuration") {
54 STEP_ASSERT_EQ(&instance1, &instance2);
55 }
56 }
57 }
58 }
59
60 /**
61 * @tc.name: IsInit
62 * @tc.desc: Verify the result of initialization
63 * @tc.type: FUNC
64 * @tc.require: I7DMS1
65 */
66 HWTEST_F(HyperGraphicManagerTest, IsInit, Function | SmallTest | Level2)
67 {
68 auto &instance = HgmCore::Instance();
69
70 PART("CaseDescription") {
71 STEP("1. check if IsInit() is true") {
72 bool init = instance.IsInit();
73 STEP_ASSERT_EQ(init, true);
74 }
75 }
76 }
77
78 /**
79 * @tc.name: AddScreen
80 * @tc.desc: Verify the result of AddScreen function
81 * @tc.type: FUNC
82 * @tc.require: I7DMS1
83 */
84 HWTEST_F(HyperGraphicManagerTest, AddScreen, Function | MediumTest | Level2)
85 {
86 auto &instance = HgmCore::Instance();
87 int sizeListBefore = 0;
88 int sizeListAfter = 0;
89
90 PART("EnvConditions") {
91 STEP("get Instance") {
92 bool init = instance.IsInit();
93 STEP_ASSERT_EQ(init, true);
94 }
95 }
96
97 PART("CaseDescription") {
98 STEP("1. mark screenList_ size before add") {
99 sizeListBefore = instance.GetScreenListSize();
100 STEP_ASSERT_GE(sizeListBefore, 0);
101 }
102
103 STEP("2. add new screen") {
104 ScreenId screenId = 2;
105 auto addScreen = instance.AddScreen(screenId, 0);
106 STEP_ASSERT_EQ(addScreen, 0);
107 }
108
109 STEP("3. mark screenList_ size after add") {
110 sizeListAfter = instance.GetScreenListSize();
111 }
112
113 STEP("3. check screenList_ size") {
114 STEP_ASSERT_EQ(sizeListAfter, sizeListBefore + 1);
115 }
116 }
117 }
118
119 /**
120 * @tc.name: GetScreen
121 * @tc.desc: Verify the result of GetScreen function
122 * @tc.type: FUNC
123 * @tc.require: I7DMS1
124 */
125 HWTEST_F(HyperGraphicManagerTest, GetScreen, Function | SmallTest | Level2)
126 {
127 auto &instance5 = HgmCore::Instance();
128 sptr<HgmScreen> screen = nullptr;
129 ScreenId screenId = 3;
130
131 PART("EnvConditions") {
132 STEP("get Instance and call Init and add a screen") {
133 auto addScreen = instance5.AddScreen(screenId, 0);
134 STEP_ASSERT_GE(addScreen, 0);
135 }
136 }
137
138 PART("CaseDescription") {
139 STEP("1. try get the previously added screen") {
140 screen = instance5.GetScreen(screenId);
141 }
142
143 STEP("2. check the pointer") {
144 STEP_ASSERT_NE(screen, nullptr);
145 }
146 }
147 }
148
149 /**
150 * @tc.name: AddScreenModeInfo
151 * @tc.desc: Verify the result of AddScreenModeInfo function
152 * @tc.type: FUNC
153 * @tc.require: I7DMS1
154 */
155 HWTEST_F(HyperGraphicManagerTest, AddScreenModeInfo, Function | SmallTest | Level3)
156 {
157 auto &instance6 = HgmCore::Instance();
158 int addMode = 0;
159 ScreenId screenId = 4;
160
161 PART("EnvConditions") {
162 STEP("get Instance and add a screen") {
163 auto addScreen = instance6.AddScreen(screenId, 0);
164 STEP_ASSERT_GE(addScreen, 0);
165 }
166 }
167
168 PART("CaseDescription") {
169 STEP("1. try get the previously added screen") {
170 auto screen = instance6.GetScreen(screenId);
171 STEP_ASSERT_NE(screen, nullptr);
172 }
173
174 STEP("2. add a supported config to the new screen") {
175 addMode = instance6.AddScreen(screenId, addMode);
176 }
177
178 STEP("3. verify adding result") {
179 STEP_ASSERT_EQ(addMode, 0);
180 }
181 }
182 }
183
184 /**
185 * @tc.name: RemoveScreen
186 * @tc.desc: Verify the result of RemoveScreen function
187 * @tc.type: FUNC
188 * @tc.require: I7DMS1
189 */
190 HWTEST_F(HyperGraphicManagerTest, RemoveScreen, Function | MediumTest | Level2)
191 {
192 auto &instance7 = HgmCore::Instance();
193 int sizeListBefore = 0;
194 int sizeListAfter = 0;
195 ScreenId screenId = 6;
196
197 PART("EnvConditions") {
198 STEP("get Instance and call Init and add a screen") {
199 bool init = instance7.IsInit();
200 STEP_ASSERT_EQ(init, true);
201 auto addScreen = instance7.AddScreen(screenId, 0);
202 STEP_ASSERT_EQ(addScreen, 0);
203 }
204 }
205
206 PART("CaseDescription") {
207 STEP("1. mark screenList_ size before remove") {
208 sizeListBefore = instance7.GetScreenListSize();
209 STEP_ASSERT_GE(sizeListBefore, 1);
210 }
211
212 STEP("2. add new screen") {
213 ScreenId screenId = 2;
214 auto removeScreen = instance7.RemoveScreen(screenId);
215 STEP_ASSERT_EQ(removeScreen, 0);
216 }
217
218 STEP("3. mark screenList_ size after remove") {
219 sizeListAfter = instance7.GetScreenListSize();
220 }
221
222 STEP("3. check screenList_ size") {
223 STEP_ASSERT_EQ(sizeListAfter, sizeListBefore - 1);
224 }
225 }
226 }
227
228 /**
229 * @tc.name: SetScreenRefreshRate
230 * @tc.desc: Verify the result of SetScreenRefreshRate function
231 * @tc.type: FUNC
232 * @tc.require: I7DMS1
233 */
234 HWTEST_F(HyperGraphicManagerTest, SetScreenRefreshRate, Function | MediumTest | Level2)
235 {
236 auto &instance8 = HgmCore::Instance();
237 ScreenId screenId = 7;
238 sptr<HgmScreen> screen = nullptr;
239 int32_t width = 1344;
240 int32_t height = 2772;
241 uint32_t rate = 120;
242 int32_t mode = 1;
243 int32_t width0 = 1344;
244 int32_t height0 = 2772;
245 uint32_t rate0 = 60;
246 int32_t mode0 = 0;
247
248 PART("EnvConditions") {
249 STEP("get Instance") {
250 bool init = instance8.IsInit();
251 STEP_ASSERT_EQ(init, true);
252 }
253 }
254
255 PART("CaseDescription") {
256 STEP("1. add a new screen") {
257 auto addScreen = instance8.AddScreen(screenId, 0);
258 STEP_ASSERT_EQ(addScreen, 0);
259 }
260
261 STEP("2. add a config mode - rate : 1, 120 to the new screen") {
262 auto addScreenProfile = instance8.AddScreenInfo(screenId, width, height, rate, mode);
263 STEP_ASSERT_EQ(addScreenProfile, 0);
264 auto addScreenProfile0 = instance8.AddScreenInfo(screenId, width0, height0, rate0, mode0);
265 STEP_ASSERT_EQ(addScreenProfile0, 0);
266 }
267
268 STEP("3. set the rate of default screen to 500") {
269 auto setRate500 = instance8.SetScreenRefreshRate(screenId, 0, 500);
270 STEP_ASSERT_EQ(setRate500, -1);
271 }
272
273 STEP("4. chech that the result is fail") {
274 screen = instance8.GetScreen(screenId);
275 STEP_ASSERT_NE(screen->GetActiveRefreshRate(), 500);
276 }
277
278 STEP("5. set the rate of default screen to 120") {
279 auto setRate120 = instance8.SetScreenRefreshRate(screenId, 0, 120);
280 STEP_ASSERT_NE(setRate120, -1);
281 }
282
283 STEP("6. check that the result is success") {
284 screen = instance8.GetScreen(screenId);
285 STEP_ASSERT_EQ(screen->GetActiveRefreshRate(), 120);
286 }
287 }
288 }
289
290 /**
291 * @tc.name: SetRefreshRateMode
292 * @tc.desc: Verify the result of SetRefreshRateMode function
293 * @tc.type: FUNC
294 * @tc.require: I7DMS1
295 */
296 HWTEST_F(HyperGraphicManagerTest, SetRefreshRateMode, Function | SmallTest | Level2)
297 {
298 auto &instance = HgmCore::Instance();
299 ScreenId screenId = 7;
300 sptr<HgmScreen> screen = nullptr;
301 int32_t width = 1344;
302 int32_t height = 2772;
303 uint32_t rate = 120;
304 int32_t mode = 1;
305 RefreshRateMode modeToSet = HGM_REFRESHRATE_MODE_MEDIUM;
306
307 PART("EnvConditions") {
308 STEP("get Instance") {
309 bool init = instance.IsInit();
310 STEP_ASSERT_EQ(init, true);
311 }
312 }
313
314 PART("CaseDescription") {
315 STEP("1. add a new screen") {
316 auto addScreen = instance.AddScreen(screenId, 0);
317 STEP_ASSERT_GE(addScreen, 0);
318 }
319
320 STEP("2. add a a supported config to the new screen") {
321 auto addScreenProfile = instance.AddScreenInfo(screenId, width, height, rate, mode);
322 STEP_ASSERT_EQ(addScreenProfile, 0);
323 }
324
325 STEP("3. set the refreshrate mode") {
326 auto setMode2 = instance.SetRefreshRateMode(modeToSet);
327 STEP_ASSERT_EQ(setMode2, -1);
328 }
329 }
330 }
331
332 /**
333 * @tc.name: HgmScreenTests
334 * @tc.desc: Others functions in HgmScreen
335 * @tc.type: FUNC
336 * @tc.require: I7NJ2G
337 */
338 HWTEST_F(HyperGraphicManagerTest, HgmScreenTests, Function | MediumTest | Level2)
339 {
340 auto &instance = HgmCore::Instance();
341 ScreenId screenId1 = 7;
342 ScreenId screenId2 = 8;
343 sptr<HgmScreen> screen = nullptr;
344 int32_t width = 1344;
345 int32_t height = 2772;
346 uint32_t rate = 120;
347 uint32_t rate2 = 60;
348 int32_t mode = 1;
349 int32_t mode2 = 2;
350 instance.AddScreen(screenId2, 1);
351 instance.AddScreenInfo(screenId2, width, height, rate, mode);
352 instance.AddScreenInfo(screenId2, width, height, rate2, mode2);
353 sptr<HgmScreen> screen2 = instance.GetScreen(screenId2);
354
355 PART("Prepare") {
356 STEP("screen tests") {
357 sptr<HgmScreen> screen1 = new HgmScreen();
358 delete screen1;
359 screen1 = nullptr;
360 STEP_ASSERT_EQ(screen1, nullptr);
361 }
362 }
363
364 PART("HgmScreen") {
365 STEP("1. add a new screen") {
366 instance.AddScreen(screenId1, 0);
367 screen = instance.GetScreen(screenId1);
368 uint32_t modeGot = screen->GetActiveRefreshRate();
369 STEP_ASSERT_NE(modeGot, rate);
370 }
371
372 STEP("2. set rate and resolution") {
373 int32_t setResult = screen2->SetActiveRefreshRate(screenId2, rate2);
374 STEP_ASSERT_EQ(setResult, 2);
375 }
376
377 STEP("3. set the refreshrate mode") {
378 int32_t setResult = screen2->SetRateAndResolution(screenId2, rate2, width, height);
379 STEP_ASSERT_NE(setResult, mode2);
380 setResult = screen2->SetRateAndResolution(screenId2, rate, width, height);
381 STEP_ASSERT_EQ(setResult, mode);
382 }
383
384 STEP("4. mode already exists") {
385 int32_t addResult = screen2->AddScreenModeInfo(width, height, rate, mode);
386 STEP_ASSERT_NE(addResult, 0);
387 }
388
389 STEP("5. setrange") {
390 int32_t setResult = screen2->SetRefreshRateRange(rate2, rate);
391 STEP_ASSERT_EQ(setResult, 0);
392 }
393 }
394 }
395
396 /**
397 * @tc.name: HgmCoreTests
398 * @tc.desc: Others functions in HgmCore
399 * @tc.type: FUNC
400 * @tc.require: I7NJ2G
401 */
402 HWTEST_F(HyperGraphicManagerTest, HgmCoreTests, Function | MediumTest | Level2)
403 {
404 auto &instance = HgmCore::Instance();
405 ScreenId screenId2 = 8;
406 ScreenId screenId3 = 9;
407 sptr<HgmScreen> screen = nullptr;
408 int32_t width = 1344;
409 int32_t height = 2772;
410 uint32_t rate = 120;
411 uint32_t rate2 = 60;
412 uint32_t rate3 = -1;
413 int32_t mode = 1;
414 int32_t mode2 = 2;
415 instance.AddScreen(screenId2, 1);
416 instance.AddScreenInfo(screenId2, width, height, rate, mode);
417 instance.AddScreenInfo(screenId2, width, height, rate2, mode2);
418
419 PART("HgmCore") {
420 STEP("1. set active mode") {
421 int32_t setResult = instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_HIGH);
422 setResult = instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_LOW);
423 setResult = instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_HIGH);
424 setResult = instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_HIGH);
425 STEP_ASSERT_NE(setResult, 0);
426 }
427
428 STEP("2. set refresh rate via core") {
429 int32_t setResult = instance.SetScreenRefreshRate(screenId3, 0, rate);
430 setResult = instance.SetScreenRefreshRate(screenId2, 0, rate3);
431 setResult = instance.SetScreenRefreshRate(screenId2, 0, rate2);
432 setResult = instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_HIGH);
433 setResult = instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_HIGH);
434 STEP_ASSERT_GE(setResult, -1);
435 }
436
437 STEP("3. set rate and resolution") {
438 int32_t setResult = instance.SetRateAndResolution(screenId2, 0, 0, 0, 0);
439 STEP_ASSERT_EQ(setResult, -1);
440 int32_t addResult = instance.AddScreen(screenId2, 1);
441 STEP_ASSERT_GE(addResult, -1);
442 }
443
444 STEP("4. add screen info, screen does not exist") {
445 int32_t setResult = instance.AddScreenInfo(screenId3, 0, 0, 0, 0);
446 STEP_ASSERT_NE(setResult, 0);
447 uint32_t getResult = instance.GetScreenCurrentRefreshRate(screenId3);
448 STEP_ASSERT_EQ(getResult, 0);
449 std::vector<uint32_t> getVResult = instance.GetScreenSupportedRefreshRates(screenId3);
450 STEP_ASSERT_EQ(getVResult.size(), 0);
451 }
452 }
453 }
454
455 /**
456 * @tc.name: HgmFrameRateToolTest
457 * @tc.desc: Verify the result of HgmFrameRateToolTest
458 * @tc.type: FUNC
459 * @tc.require: I7DMS1
460 */
461 HWTEST_F(HyperGraphicManagerTest, HgmFrameRateToolTest, Function | SmallTest | Level2)
462 {
463 auto &hgm_core = HgmCore::Instance();
464 ScreenId id = 1;
465 int32_t phyWidth = 685; // 685 means dayu200 phyWidth
466 int32_t phyHeight = 1218; // 1218 means dayu200 phyHeight
467 int32_t width = 720; // 720 means dayu200 weight
468 int32_t height = 1080; // 1080 means dayu200 height
469
470 PART("CaseDescription") {
471 STEP("1. call GetInstance twice") {
472 auto instance1 = HgmFrameRateTool::GetInstance();
473 auto instance2 = HgmFrameRateTool::GetInstance();
474 STEP_ASSERT_EQ(instance1, instance2);
475 }
476
477 STEP("2. add screenProfile ") {
478 auto res = hgm_core.AddScreenProfile(id, width, height, phyWidth, phyHeight);
479 STEP_ASSERT_EQ(res, 0);
480 }
481
482 STEP("3. set activeScreenProfile") {
483 hgm_core.SetActiveScreenId(id);
484 STEP_ASSERT_EQ(hgm_core.GetActiveScreenId(), id);
485 }
486
487 STEP("4. cal translate modifier preferred") {
488 HgmModifierProfile hgmModifierProfile = {0, 0, HgmModifierType::TRANSLATE};
489 auto preferred = hgm_core.CalModifierPreferred(hgmModifierProfile);
490 STEP_ASSERT_GT(preferred, 0);
491 }
492
493 STEP("5. cal scale modifier preferred") {
494 HgmModifierProfile hgmModifierProfile = {0, 0, HgmModifierType::SCALE};
495 auto preferred = hgm_core.CalModifierPreferred(hgmModifierProfile);
496 STEP_ASSERT_GT(preferred, 0);
497 }
498
499 STEP("6. cal rotation modifier preferred") {
500 HgmModifierProfile hgmModifierProfile = {0, 0, HgmModifierType::TRANSLATE};
501 auto preferred = hgm_core.CalModifierPreferred(hgmModifierProfile);
502 STEP_ASSERT_GT(preferred, 0);
503 }
504 }
505 }
506 } // namespace Rosen
507 } // namespace OHOS