1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "abstract_screen.h"
19 #include "abstract_screen_controller.h"
20 #include "scene_board_judgement.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Rosen {
27 class AbstractScreenTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31 void SetUp() override;
32 void TearDown() override;
33
34 static sptr<AbstractScreen> absScreen_;
35 static sptr<AbstractScreenGroup> absScreenGroup_;
36 static std::recursive_mutex mutex_;
37 static std::string name_;
38 };
39
40 sptr<AbstractScreen> AbstractScreenTest::absScreen_ = nullptr;
41 sptr<AbstractScreenGroup> AbstractScreenTest::absScreenGroup_ = nullptr;
42 std::recursive_mutex AbstractScreenTest::mutex_;
43 std::string AbstractScreenTest::name_ = "AbstractScreenTest";
44
SetUpTestCase()45 void AbstractScreenTest::SetUpTestCase()
46 {
47 sptr<AbstractScreenController> absScreenController = new AbstractScreenController(mutex_);
48 absScreen_ = new AbstractScreen(absScreenController, name_, 0, 0);
49 absScreenGroup_ = new AbstractScreenGroup(absScreenController,
50 0, 0, name_, ScreenCombination::SCREEN_ALONE);
51 absScreen_->modes_.clear();
52 absScreen_->activeIdx_ = 0;
53 }
54
TearDownTestCase()55 void AbstractScreenTest::TearDownTestCase()
56 {
57 }
58
SetUp()59 void AbstractScreenTest::SetUp()
60 {
61 }
62
TearDown()63 void AbstractScreenTest::TearDown()
64 {
65 }
66
67 namespace {
68 /**
69 * @tc.name: GetScreenMode
70 * @tc.desc: Get screen mode
71 * @tc.type: FUNC
72 */
73 HWTEST_F(AbstractScreenTest, GetScreenMode, Function | SmallTest | Level3)
74 {
75 sptr<SupportedScreenModes> mode0 = new SupportedScreenModes();
76 sptr<SupportedScreenModes> mode1 = new SupportedScreenModes();
77 absScreen_->modes_ = {mode0, mode1};
78
79 absScreen_->activeIdx_ = -1;
80 ASSERT_EQ(nullptr, absScreen_->GetActiveScreenMode());
81 absScreen_->activeIdx_ = static_cast<int32_t>(absScreen_->modes_.size());
82 ASSERT_EQ(nullptr, absScreen_->GetActiveScreenMode());
83 absScreen_->activeIdx_ = 0;
84 ASSERT_EQ(mode0, absScreen_->GetActiveScreenMode());
85 absScreen_->activeIdx_ = 1;
86 ASSERT_EQ(mode1, absScreen_->GetActiveScreenMode());
87
88 ASSERT_EQ(mode0, (absScreen_->GetAbstractScreenModes())[0]);
89 ASSERT_EQ(mode1, (absScreen_->GetAbstractScreenModes())[1]);
90 }
91
92 /**
93 * @tc.name: ConvertToScreenInfo
94 * @tc.desc: Convert to screen info
95 * @tc.type: FUNC
96 */
97 HWTEST_F(AbstractScreenTest, ConvertToScreenInfo, Function | SmallTest | Level3)
98 {
99 ASSERT_NE(nullptr, absScreen_->ConvertToScreenInfo());
100 }
101
102 /**
103 * @tc.name: RSTree
104 * @tc.desc: RS tree
105 * @tc.type: FUNC
106 */
107 HWTEST_F(AbstractScreenTest, RSTree, Function | SmallTest | Level3)
108 {
109 std::shared_ptr<RSSurfaceNode> surfaceNode;
110 absScreen_->rsDisplayNode_ = nullptr;
111 absScreen_->UpdateRSTree(surfaceNode, true);
112 absScreen_->UpdateDisplayGroupRSTree(surfaceNode, 0, true);
113
114 struct RSDisplayNodeConfig config;
115 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
116 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
117 absScreen_->UpdateRSTree(surfaceNode, true);
118 absScreen_->UpdateDisplayGroupRSTree(surfaceNode, 0, true);
119
120 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
121 surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
122 absScreen_->UpdateRSTree(surfaceNode, true);
123 absScreen_->UpdateDisplayGroupRSTree(surfaceNode, 0, false);
124 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
125
126 absScreen_->UpdateRSTree(surfaceNode, false);
127 absScreen_->UpdateDisplayGroupRSTree(surfaceNode, 0, false);
128 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
129
130 absScreen_->UpdateRSTree(surfaceNode, false, false);
131 absScreen_->UpdateDisplayGroupRSTree(surfaceNode, 0, false);
132 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
133
134 absScreen_->UpdateRSTree(surfaceNode, false, false);
135 absScreen_->UpdateDisplayGroupRSTree(surfaceNode, 0, true);
136 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
137 absScreen_->rsDisplayNode_ = nullptr;
138 }
139
140 /**
141 * @tc.name: InitRSDisplayNode
142 * @tc.desc: InitRSDisplayNode
143 * @tc.type: FUNC
144 */
145 HWTEST_F(AbstractScreenTest, InitRSDisplayNode, Function | SmallTest | Level3)
146 {
147 struct RSDisplayNodeConfig config;
148 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
149 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
150
151 RSDisplayNodeConfig config_;
152 Point startPoint;
153 absScreen_->InitRSDisplayNode(config_, startPoint);
154 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
155 }
156
157 /**
158 * @tc.name: InitRSDefaultDisplayNode
159 * @tc.desc: InitRSDefaultDisplayNode
160 * @tc.type: FUNC
161 */
162 HWTEST_F(AbstractScreenTest, InitRSDefaultDisplayNode, Function | SmallTest | Level3)
163 {
164 struct RSDisplayNodeConfig config;
165 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
166 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
167
168 RSDisplayNodeConfig config_;
169 Point startPoint;
170 absScreen_->InitRSDefaultDisplayNode(config_, startPoint);
171 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
172 }
173
174 /**
175 * @tc.name: SetScreenColorGamut
176 * @tc.desc: SetScreenColorGamut
177 * @tc.type: FUNC
178 */
179 HWTEST_F(AbstractScreenTest, SetScreenColorGamut, Function | SmallTest | Level3)
180 {
181 int32_t colorGamutIdx = 0;
182 auto result = absScreen_->SetScreenColorGamut(colorGamutIdx);
183 ASSERT_EQ(result, DMError::DM_ERROR_RENDER_SERVICE_FAILED);
184 }
185
186 /**
187 * @tc.name: ColorGamut
188 * @tc.desc: Screen color gamut
189 * @tc.type: FUNC
190 */
191 HWTEST_F(AbstractScreenTest, ColorGamut, Function | SmallTest | Level3)
192 {
193 sptr<AbstractScreenController> absScreenController0 = new AbstractScreenController(mutex_);
194 sptr<AbstractScreen> absScreen0 = new AbstractScreen(absScreenController0, name_, 0, -1ULL);
195 std::vector<ScreenColorGamut> colorGamuts;
196 ASSERT_EQ(DMError::DM_ERROR_RENDER_SERVICE_FAILED, absScreen0->GetScreenSupportedColorGamuts(colorGamuts));
197 ScreenColorGamut colorGamut;
198 ASSERT_EQ(DMError::DM_ERROR_RENDER_SERVICE_FAILED, absScreen0->GetScreenColorGamut(colorGamut));
199
200 ASSERT_EQ(DMError::DM_ERROR_RENDER_SERVICE_FAILED, absScreen0->SetScreenColorGamut(0));
201
202 ScreenGamutMap gamutMap;
203 ASSERT_EQ(DMError::DM_ERROR_RENDER_SERVICE_FAILED, absScreen0->GetScreenGamutMap(gamutMap));
204
205 gamutMap = ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION;
206 ASSERT_EQ(DMError::DM_ERROR_RENDER_SERVICE_FAILED, absScreen0->GetScreenGamutMap(gamutMap));
207 }
208
209 /**
210 * @tc.name: FillScreenInfo
211 * @tc.desc: Fill screen info
212 * @tc.type: FUNC
213 */
214 HWTEST_F(AbstractScreenTest, FillScreenInfo, Function | SmallTest | Level3)
215 {
216 absScreen_->FillScreenInfo(nullptr);
217 sptr<ScreenInfo> info = new ScreenInfo();
218 ASSERT_NE(nullptr, info);
219
220 absScreen_->virtualPixelRatio_ = 0.f;
221 absScreen_->FillScreenInfo(info);
222 ASSERT_EQ(1.f, info->virtualPixelRatio_);
223
224 absScreen_->virtualPixelRatio_ = 2.f;
225 absScreen_->FillScreenInfo(info);
226 ASSERT_EQ(2.f, info->virtualPixelRatio_);
227 }
228
229 /**
230 * @tc.name: CalcRotation
231 * @tc.desc: Calc rotation
232 * @tc.type: FUNC
233 */
234 HWTEST_F(AbstractScreenTest, CalcRotation, Function | SmallTest | Level3)
235 {
236 absScreen_->modes_.clear();
237 absScreen_->activeIdx_ = 0;
238
239 ASSERT_EQ(Rotation::ROTATION_0, absScreen_->CalcRotation(Orientation::UNSPECIFIED));
240
241 sptr<SupportedScreenModes> mode = new SupportedScreenModes();
242 mode->width_ = 1;
243 mode->height_ = 1;
244 absScreen_->modes_ = {mode};
245
246 ASSERT_EQ(Rotation::ROTATION_0, absScreen_->CalcRotation(Orientation::UNSPECIFIED));
247 ASSERT_EQ(Rotation::ROTATION_90, absScreen_->CalcRotation(Orientation::VERTICAL));
248 ASSERT_EQ(Rotation::ROTATION_0, absScreen_->CalcRotation(Orientation::HORIZONTAL));
249 ASSERT_EQ(Rotation::ROTATION_270, absScreen_->CalcRotation(Orientation::REVERSE_VERTICAL));
250 ASSERT_EQ(Rotation::ROTATION_180, absScreen_->CalcRotation(Orientation::REVERSE_HORIZONTAL));
251 ASSERT_EQ(Rotation::ROTATION_0, absScreen_->CalcRotation(Orientation::LOCKED));
252 }
253
254 /**
255 * @tc.name: GetScreenGroupId
256 * @tc.desc: get screen groupId
257 * @tc.type: FUNC
258 */
259 HWTEST_F(AbstractScreenTest, GetScreenGroupId, Function | SmallTest | Level3)
260 {
261 ScreenId result = absScreen_->GetScreenGroupId();
262 EXPECT_EQ(result, SCREEN_ID_INVALID);
263 absScreen_->groupDmsId_ = 10086;
264 result = absScreen_->GetScreenGroupId();
265 EXPECT_EQ(result, 10086);
266 }
267
268 /**
269 * @tc.name: SetScreenGamutMap
270 * @tc.desc: set screen gamut map
271 * @tc.type: FUNC
272 */
273 HWTEST_F(AbstractScreenTest, SetScreenGamutMap, Function | SmallTest | Level3)
274 {
275 ScreenGamutMap gamutMap = ScreenGamutMap::GAMUT_MAP_HDR_CONSTANT;
276 DMError result = absScreen_->SetScreenGamutMap(gamutMap);
277 EXPECT_EQ(result, DMError::DM_ERROR_RENDER_SERVICE_FAILED);
278
279 gamutMap = static_cast<ScreenGamutMap>(static_cast<uint32_t>(ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION) + 1);
280 result = absScreen_->SetScreenGamutMap(gamutMap);
281 EXPECT_EQ(result, DMError::DM_ERROR_INVALID_PARAM);
282 }
283
284 /**
285 * @tc.name: SetScreenColorTransform
286 * @tc.desc: set screen color transform
287 * @tc.type: FUNC
288 */
289 HWTEST_F(AbstractScreenTest, SetScreenColorTransform, Function | SmallTest | Level3)
290 {
291 DMError result = absScreen_->SetScreenColorTransform();
292 EXPECT_EQ(result, DMError::DM_OK);
293 }
294
295 /**
296 * @tc.name: GetVirtualPixelRatio
297 * @tc.desc: get virtual pixel ratio
298 * @tc.type: FUNC
299 */
300 HWTEST_F(AbstractScreenTest, GetVirtualPixelRatio, Function | SmallTest | Level3)
301 {
302 float result = absScreen_->GetVirtualPixelRatio();
303 EXPECT_EQ(result, 2.0f);
304 }
305
306 /**
307 * @tc.name: GetSourceMode
308 * @tc.desc: get source mode
309 * @tc.type: FUNC
310 */
311 HWTEST_F(AbstractScreenTest, GetSourceMode, Function | SmallTest | Level3)
312 {
313 absScreenGroup_->combination_ = ScreenCombination::SCREEN_MIRROR;
314 absScreen_->screenController_->dmsScreenGroupMap_.insert({10086, absScreenGroup_});
315 absScreen_->groupDmsId_ = 10086;
316 ScreenSourceMode result = absScreen_->GetSourceMode();
317 EXPECT_EQ(result, ScreenSourceMode::SCREEN_MAIN);
318
319 absScreen_->screenController_->defaultRsScreenId_ = 144;
320 result = absScreen_->GetSourceMode();
321 EXPECT_EQ(result, ScreenSourceMode::SCREEN_MIRROR);
322 absScreenGroup_->combination_ = ScreenCombination::SCREEN_EXPAND;
323 result = absScreen_->GetSourceMode();
324 EXPECT_EQ(result, ScreenSourceMode::SCREEN_EXTEND);
325 absScreenGroup_->combination_ = ScreenCombination::SCREEN_ALONE;
326 result = absScreen_->GetSourceMode();
327 EXPECT_EQ(result, ScreenSourceMode::SCREEN_ALONE);
328
329 sptr<AbstractScreenController> absScreenController = new AbstractScreenController(mutex_);
330 sptr<AbstractScreen> absScreenTest = new AbstractScreen(absScreenController, name_, 0, 0);
331 result = absScreenTest->GetSourceMode();
332 EXPECT_EQ(result, ScreenSourceMode::SCREEN_ALONE);
333 }
334
335 /**
336 * @tc.name: ConvertToScreenGroupInfo
337 * @tc.desc: convert to screen group info
338 * @tc.type: FUNC
339 */
340 HWTEST_F(AbstractScreenTest, ConvertToScreenGroupInfo, Function | SmallTest | Level3)
341 {
342 Point point_(159, 357);
343 absScreen_->startPoint_ = point_;
344 (absScreenGroup_->screenMap_).insert({10086, absScreen_});
345 sptr<ScreenGroupInfo> result = absScreenGroup_->ConvertToScreenGroupInfo();
346 EXPECT_EQ(result->children_[0], 10086);
347 }
348
349 /**
350 * @tc.name: GetRSDisplayNodeConfig01
351 * @tc.desc: Get RSDisplay node config
352 * @tc.type: FUNC
353 */
354 HWTEST_F(AbstractScreenTest, GetRSDisplayNodeConfig01, Function | SmallTest | Level3)
355 {
356 sptr<AbstractScreen> absTest = nullptr;
357 RSDisplayNodeConfig config_;
358 bool result = absScreenGroup_->GetRSDisplayNodeConfig(absTest, config_);
359 EXPECT_FALSE(result);
360
361 absScreenGroup_->combination_ = ScreenCombination::SCREEN_ALONE;
362 result = absScreenGroup_->GetRSDisplayNodeConfig(absTest, config_);
363 EXPECT_FALSE(result);
364
365 absScreenGroup_->combination_ = ScreenCombination::SCREEN_MIRROR;
366 absScreenGroup_->mirrorScreenId_ = 0;
367 result = absScreenGroup_->GetRSDisplayNodeConfig(absTest, config_);
368 EXPECT_FALSE(result);
369 Point point_(159, 357);
370 absScreen_->startPoint_ = point_;
371 (absScreenGroup_->screenMap_).insert({10086, absScreen_});
372 absScreenGroup_->mirrorScreenId_ = 10086;
373 EXPECT_FALSE(result);
374 }
375
376 /**
377 * @tc.name: GetRSDisplayNodeConfig01
378 * @tc.desc: Get RSDisplay node config
379 * @tc.type: FUNC
380 */
381 HWTEST_F(AbstractScreenTest, GetRSDisplayNodeConfig02, Function | SmallTest | Level3)
382 {
383 sptr<AbstractScreen> absTest = absScreen_;
384 RSDisplayNodeConfig config_;
385
386 absScreenGroup_->combination_ = ScreenCombination::SCREEN_ALONE;
387 bool result = absScreenGroup_->GetRSDisplayNodeConfig(absTest, config_);
388 EXPECT_EQ(true, result);
389
390 absScreenGroup_->combination_ = ScreenCombination::SCREEN_EXPAND;
391 result = absScreenGroup_->GetRSDisplayNodeConfig(absTest, config_);
392 EXPECT_EQ(true, result);
393
394 absScreenGroup_->combination_ = ScreenCombination::SCREEN_MIRROR;
395 absScreenGroup_->mirrorScreenId_ = 0;
396 result = absScreenGroup_->GetRSDisplayNodeConfig(absTest, config_);
397 EXPECT_EQ(true, result);
398 Point point_(159, 357);
399 absScreen_->startPoint_ = point_;
400 (absScreenGroup_->screenMap_).insert({10086, absScreen_});
401 absScreenGroup_->mirrorScreenId_ = 10086;
402 EXPECT_EQ(true, result);
403 }
404
405 /**
406 * @tc.name: GetChildPosition
407 * @tc.desc: GetChildPosition
408 * @tc.type: FUNC
409 */
410 HWTEST_F(AbstractScreenTest, GetChildPosition, Function | SmallTest | Level3)
411 {
412 ScreenId screenId = -1;
413 absScreenGroup_->GetChildPosition(screenId);
414 ASSERT_EQ(screenId, -1);
415
416 screenId = 1;
417 absScreenGroup_->GetChildPosition(screenId);
418 ASSERT_EQ(screenId, 1);
419 }
420
421 /**
422 * @tc.name: AddChild01
423 * @tc.desc: Add child
424 * @tc.type: FUNC
425 */
426 HWTEST_F(AbstractScreenTest, AddChild01, Function | SmallTest | Level3)
427 {
428 absScreenGroup_->screenMap_.clear();
429 sptr<AbstractScreen> absTest = nullptr;
430 Point point_(159, 357);
431 bool result = absScreenGroup_->AddChild(absTest, point_);
432 EXPECT_FALSE(result);
433
434 absScreenGroup_->mirrorScreenId_ = 10086;
435 absScreenGroup_->combination_ = ScreenCombination::SCREEN_MIRROR;
436 result = absScreenGroup_->AddChild(absScreen_, point_);
437 ASSERT_TRUE(result);
438 absScreenGroup_->combination_ = ScreenCombination::SCREEN_EXPAND;
439 absScreen_->rsDisplayNode_ = nullptr;
440 result = absScreenGroup_->AddChild(absScreen_, point_);
441 EXPECT_FALSE(result);
442
443 struct RSDisplayNodeConfig config;
444 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
445 absScreen_->type_ = ScreenType::REAL;
446 absScreenGroup_->defaultScreenId_ = 0;
447 result = absScreenGroup_->AddChild(absScreen_, point_);
448 ASSERT_TRUE(result);
449 }
450
451 /**
452 * @tc.name: AddChild02
453 * @tc.desc: Add child
454 * @tc.type: FUNC
455 */
456 HWTEST_F(AbstractScreenTest, AddChild02, Function | SmallTest | Level3)
457 {
458 absScreenGroup_->screenMap_.clear();
459 Point point_(159, 357);
460 absScreenGroup_->mirrorScreenId_ = 10086;
461 absScreenGroup_->combination_ = ScreenCombination::SCREEN_MIRROR;
462 absScreen_->startPoint_ = point_;
463 (absScreenGroup_->screenMap_).insert({0, absScreen_});
464 absScreen_->rsDisplayNode_ = nullptr;
465 bool result = absScreenGroup_->AddChild(absScreen_, point_);
466 EXPECT_FALSE(result);
467
468 struct RSDisplayNodeConfig config;
469 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
470 absScreen_->type_ = ScreenType::REAL;
471 absScreenGroup_->defaultScreenId_ = 0;
472 result = absScreenGroup_->AddChild(absScreen_, point_);
473 ASSERT_TRUE(result);
474 }
475
476 /**
477 * @tc.name: AddChildren
478 * @tc.desc: Add children
479 * @tc.type: FUNC
480 */
481 HWTEST_F(AbstractScreenTest, AddChildren, Function | SmallTest | Level3)
482 {
483 Point point_(159, 357);
484 std::vector<Point> vecPoint({point_});
485 std::vector<sptr<AbstractScreen>> vecSptr;
486 bool result = absScreenGroup_->AddChildren(vecSptr, vecPoint);
487 EXPECT_FALSE(result);
488
489 vecSptr.push_back(absScreen_);
490 result = absScreenGroup_->AddChildren(vecSptr, vecPoint);
491 ASSERT_TRUE(result);
492 }
493
494 /**
495 * @tc.name: RemoveChild01
496 * @tc.desc: Remove child
497 * @tc.type: FUNC
498 */
499 HWTEST_F(AbstractScreenTest, RemoveChild01, Function | SmallTest | Level3)
500 {
501 sptr<AbstractScreen> absTest = nullptr;
502 bool result = absScreenGroup_->RemoveChild(absTest);
503 EXPECT_FALSE(result);
504
505 struct RSDisplayNodeConfig config;
506 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
507 result = absScreenGroup_->RemoveChild(absScreen_);
508 EXPECT_TRUE(result);
509 }
510
511 /**
512 * @tc.name: RemoveChild02
513 * @tc.desc: Remove child
514 * @tc.type: FUNC
515 */
516 HWTEST_F(AbstractScreenTest, RemoveChild02, Function | SmallTest | Level3)
517 {
518 Point point_(159, 357);
519 struct RSDisplayNodeConfig config;
520 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
521 absScreen_->startPoint_ = point_;
522 (absScreenGroup_->screenMap_).insert({0, absScreen_});
523 bool result = absScreenGroup_->RemoveChild(absScreen_);
524 ASSERT_TRUE(result);
525 }
526
527 /**
528 * @tc.name: RemoveDefaultScreen
529 * @tc.desc: Remove default screen
530 * @tc.type: FUNC
531 */
532 HWTEST_F(AbstractScreenTest, RemoveDefaultScreen, Function | SmallTest | Level3)
533 {
534 sptr<AbstractScreen> absTest = nullptr;
535 bool result = absScreenGroup_->RemoveDefaultScreen(absTest);
536 EXPECT_FALSE(result);
537
538 absScreen_->rsDisplayNode_ = nullptr;
539 result = absScreenGroup_->RemoveDefaultScreen(absScreen_);
540 EXPECT_TRUE(result);
541
542 struct RSDisplayNodeConfig config;
543 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
544 result = absScreenGroup_->RemoveDefaultScreen(absScreen_);
545 ASSERT_TRUE(result);
546 }
547
548 /**
549 * @tc.name: GetChildren
550 * @tc.desc: Get children
551 * @tc.type: FUNC
552 */
553 HWTEST_F(AbstractScreenTest, GetChildren, Function | SmallTest | Level3)
554 {
555 Point point_(159, 357);
556 absScreen_->startPoint_ = point_;
557 (absScreenGroup_->screenMap_).insert({10086, absScreen_});
558 std::vector<sptr<AbstractScreen>> result = absScreenGroup_->GetChildren();
559 ASSERT_EQ(result[0], absScreen_);
560 }
561
562 /**
563 * @tc.name: GetChildrenPosition
564 * @tc.desc: Get children position
565 * @tc.type: FUNC
566 */
567 HWTEST_F(AbstractScreenTest, GetChildrenPosition, Function | SmallTest | Level3)
568 {
569 Point point_(159, 357);
570 absScreen_->startPoint_ = point_;
571 (absScreenGroup_->screenMap_).insert({10086, absScreen_});
572 std::vector<Point> result = absScreenGroup_->GetChildrenPosition();
573 EXPECT_EQ(result[0].posX_, 159);
574 EXPECT_EQ(result[0].posY_, 357);
575 }
576
577 /**
578 * @tc.name: ~AbstractScreenGroup
579 * @tc.desc: Abstract screen group
580 * @tc.type: FUNC
581 */
582 HWTEST_F(AbstractScreenTest, AbstractScreenGroup, Function | SmallTest | Level3)
583 {
584 sptr<AbstractScreenController> absScreenController = new AbstractScreenController(mutex_);
585 absScreenGroup_ = new AbstractScreenGroup(absScreenController,
586 0, 0, name_, ScreenCombination::SCREEN_ALONE);
587 EXPECT_NE(absScreenController, nullptr);
588 }
589
590 /**
591 * @tc.name: AddSurfaceNode
592 * @tc.desc: AddSurfaceNode
593 * @tc.type: FUNC
594 */
595 HWTEST_F(AbstractScreenTest, AddSurfaceNode, Function | SmallTest | Level3)
596 {
597 struct RSDisplayNodeConfig config;
598 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
599 std::shared_ptr<RSSurfaceNode> surfaceNode;
600 DMError ret = absScreen_->AddSurfaceNode(surfaceNode, true);
601 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
602
603 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
604 surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
605
606 ret = absScreen_->AddSurfaceNode(surfaceNode, true);
607 ASSERT_EQ(ret, DMError::DM_OK);
608
609 ret = absScreen_->AddSurfaceNode(surfaceNode, true, false);
610 ASSERT_EQ(ret, DMError::DM_OK);
611
612 ret = absScreen_->AddSurfaceNode(surfaceNode, false);
613 ASSERT_EQ(ret, DMError::DM_OK);
614
615 absScreen_->rsDisplayNode_ = nullptr;
616 ret = absScreen_->AddSurfaceNode(surfaceNode, false);
617 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
618
619 surfaceNode = nullptr;
620 ret = absScreen_->AddSurfaceNode(surfaceNode, false);
621 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
622 }
623
624 /**
625 * @tc.name: RemoveSurfaceNode
626 * @tc.desc: RemoveSurfaceNode
627 * @tc.type: FUNC
628 */
629 HWTEST_F(AbstractScreenTest, RemoveSurfaceNode, Function | SmallTest | Level3)
630 {
631 struct RSDisplayNodeConfig config;
632 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
633 std::shared_ptr<RSSurfaceNode> surfaceNode;
634 DMError ret = absScreen_->RemoveSurfaceNode(surfaceNode);
635 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
636
637 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
638 surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
639 ret = absScreen_->RemoveSurfaceNode(surfaceNode);
640 ASSERT_EQ(ret, DMError::DM_ERROR_INVALID_PARAM);
641
642 absScreen_->rsDisplayNode_ = nullptr;
643 ret = absScreen_->RemoveSurfaceNode(surfaceNode);
644 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
645
646 surfaceNode = nullptr;
647 ret = absScreen_->RemoveSurfaceNode(surfaceNode);
648 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
649 }
650
651 /**
652 * @tc.name: GetScreenMode
653 * @tc.desc: Get screen mode
654 * @tc.type: FUNC
655 */
656 HWTEST_F(AbstractScreenTest, GetScreenMode01, Function | SmallTest | Level3)
657 {
658 sptr<SupportedScreenModes> mode0 = new SupportedScreenModes();
659 sptr<SupportedScreenModes> mode1 = new SupportedScreenModes();
660 absScreen_->modes_ = {mode0, mode1};
661
662 absScreen_->activeIdx_ = -1;
663 ASSERT_EQ(nullptr, absScreen_->GetActiveScreenMode());
664 absScreen_->activeIdx_ = static_cast<int32_t>(absScreen_->modes_.size());
665 ASSERT_EQ(nullptr, absScreen_->GetActiveScreenMode());
666 absScreen_->activeIdx_ = 0;
667 ASSERT_EQ(mode0, absScreen_->GetActiveScreenMode());
668 absScreen_->activeIdx_ = 1;
669 ASSERT_EQ(mode1, absScreen_->GetActiveScreenMode());
670
671 ASSERT_EQ(mode0, (absScreen_->GetAbstractScreenModes())[0]);
672 ASSERT_EQ(mode1, (absScreen_->GetAbstractScreenModes())[1]);
673 }
674
675 /**
676 * @tc.name: AddChild
677 * @tc.desc: Add child
678 * @tc.type: FUNC
679 */
680 HWTEST_F(AbstractScreenTest, AddChild03, Function | SmallTest | Level3)
681 {
682 absScreenGroup_->screenMap_.clear();
683 Point point_(159, 357);
684 absScreenGroup_->mirrorScreenId_ = 10086;
685 absScreenGroup_->combination_ = ScreenCombination::SCREEN_MIRROR;
686 absScreen_->startPoint_ = point_;
687 (absScreenGroup_->screenMap_).insert({0, absScreen_});
688 absScreen_->rsDisplayNode_ = nullptr;
689 bool result = absScreenGroup_->AddChild(absScreen_, point_);
690 EXPECT_FALSE(result);
691
692 struct RSDisplayNodeConfig config;
693 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
694 absScreen_->type_ = ScreenType::REAL;
695 absScreenGroup_->defaultScreenId_ = 0;
696 result = absScreenGroup_->AddChild(absScreen_, point_);
697 ASSERT_TRUE(result);
698 }
699
700 /**
701 * @tc.name: CalcRotation
702 * @tc.desc: Calc rotation
703 * @tc.type: FUNC
704 */
705 HWTEST_F(AbstractScreenTest, CalcRotation01, Function | SmallTest | Level3)
706 {
707 absScreen_->modes_.clear();
708 absScreen_->activeIdx_ = 0;
709
710 ASSERT_EQ(Rotation::ROTATION_0, absScreen_->CalcRotation(Orientation::UNSPECIFIED));
711
712 sptr<SupportedScreenModes> mode = new SupportedScreenModes();
713 mode->width_ = 1;
714 mode->height_ = 1;
715 absScreen_->modes_ = {mode};
716
717 ASSERT_EQ(Rotation::ROTATION_0, absScreen_->CalcRotation(Orientation::UNSPECIFIED));
718 ASSERT_EQ(Rotation::ROTATION_90, absScreen_->CalcRotation(Orientation::VERTICAL));
719 ASSERT_EQ(Rotation::ROTATION_0, absScreen_->CalcRotation(Orientation::HORIZONTAL));
720 ASSERT_EQ(Rotation::ROTATION_270, absScreen_->CalcRotation(Orientation::REVERSE_VERTICAL));
721 ASSERT_EQ(Rotation::ROTATION_180, absScreen_->CalcRotation(Orientation::REVERSE_HORIZONTAL));
722 ASSERT_EQ(Rotation::ROTATION_0, absScreen_->CalcRotation(Orientation::LOCKED));
723 }
724
725 /**
726 * @tc.name: RemoveDefaultScreen
727 * @tc.desc: Remove default screen
728 * @tc.type: FUNC
729 */
730 HWTEST_F(AbstractScreenTest, RemoveDefaultScreen02, Function | SmallTest | Level3)
731 {
732 sptr<AbstractScreen> absTest = nullptr;
733 bool result = absScreenGroup_->RemoveDefaultScreen(absTest);
734 EXPECT_FALSE(result);
735
736 absScreen_->rsDisplayNode_ = nullptr;
737 result = absScreenGroup_->RemoveDefaultScreen(absScreen_);
738 EXPECT_TRUE(result);
739
740 struct RSDisplayNodeConfig config;
741 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
742 result = absScreenGroup_->RemoveDefaultScreen(absScreen_);
743 ASSERT_TRUE(result);
744 }
745
746 /**
747 * @tc.name: UpdateRSTree01
748 * @tc.desc: UpdateRSTree
749 * @tc.type: FUNC
750 */
751 HWTEST_F(AbstractScreenTest, UpdateRSTree01, Function | SmallTest | Level3)
752 {
753 std::shared_ptr<RSSurfaceNode> surfaceNode;
754 absScreen_->rsDisplayNode_ = nullptr;
755 bool isAdd = true;
756 bool needToUpdate = true;
757
758 absScreen_->UpdateRSTree(surfaceNode, isAdd, needToUpdate);
759 ASSERT_EQ(nullptr, absScreen_->rsDisplayNode_);
760 }
761
762 /**
763 * @tc.name: UpdateRSTree02
764 * @tc.desc: UpdateRSTree
765 * @tc.type: FUNC
766 */
767 HWTEST_F(AbstractScreenTest, UpdateRSTree02, Function | SmallTest | Level3)
768 {
769 std::shared_ptr<RSSurfaceNode> surfaceNode;
770 struct RSDisplayNodeConfig config;
771 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
772 bool isAdd = true;
773 bool needToUpdate = true;
774
775 absScreen_->UpdateRSTree(surfaceNode, isAdd, needToUpdate);
776 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
777 absScreen_->rsDisplayNode_ = nullptr;
778 }
779
780 /**
781 * @tc.name: UpdateRSTree03
782 * @tc.desc: UpdateRSTree
783 * @tc.type: FUNC
784 */
785 HWTEST_F(AbstractScreenTest, UpdateRSTree03, Function | SmallTest | Level3)
786 {
787 std::shared_ptr<RSSurfaceNode> surfaceNode;
788 struct RSDisplayNodeConfig config;
789 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
790 bool isAdd = true;
791 bool needToUpdate = false;
792
793 absScreen_->UpdateRSTree(surfaceNode, isAdd, needToUpdate);
794 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
795 absScreen_->rsDisplayNode_ = nullptr;
796 }
797
798 /**
799 * @tc.name: UpdateRSTree04
800 * @tc.desc: UpdateRSTree
801 * @tc.type: FUNC
802 */
803 HWTEST_F(AbstractScreenTest, UpdateRSTree04, Function | SmallTest | Level3)
804 {
805 std::shared_ptr<RSSurfaceNode> surfaceNode;
806 struct RSDisplayNodeConfig config;
807 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
808 bool isAdd = false;
809 bool needToUpdate = false;
810
811 absScreen_->UpdateRSTree(surfaceNode, isAdd, needToUpdate);
812 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
813 absScreen_->rsDisplayNode_ = nullptr;
814 }
815
816 /**
817 * @tc.name: UpdateRSTree05
818 * @tc.desc: UpdateRSTree
819 * @tc.type: FUNC
820 */
821 HWTEST_F(AbstractScreenTest, UpdateRSTree05, Function | SmallTest | Level3)
822 {
823 std::shared_ptr<RSSurfaceNode> surfaceNode;
824 struct RSDisplayNodeConfig config;
825 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
826 bool isAdd = false;
827 bool needToUpdate = true;
828
829 absScreen_->UpdateRSTree(surfaceNode, isAdd, needToUpdate);
830 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
831 absScreen_->rsDisplayNode_ = nullptr;
832 }
833
834 /**
835 * @tc.name: UpdateRSTree06
836 * @tc.desc: UpdateRSTree
837 * @tc.type: FUNC
838 */
839 HWTEST_F(AbstractScreenTest, UpdateRSTree06, Function | SmallTest | Level3)
840 {
841 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
842 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig,
843 RSSurfaceNodeType::DEFAULT);
844 bool isAdd = false;
845 bool needToUpdate = true;
846 struct RSDisplayNodeConfig config;
847 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
848 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
849
850 absScreen_->UpdateRSTree(surfaceNode, isAdd, needToUpdate);
851 absScreen_->rsDisplayNode_ = nullptr;
852 }
853
854 /**
855 * @tc.name: UpdateRSTree07
856 * @tc.desc: UpdateRSTree
857 * @tc.type: FUNC
858 */
859 HWTEST_F(AbstractScreenTest, UpdateRSTree07, Function | SmallTest | Level3)
860 {
861 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
862 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig,
863 RSSurfaceNodeType::DEFAULT);
864 bool isAdd = true;
865 bool needToUpdate = false;
866 struct RSDisplayNodeConfig config;
867 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
868 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
869
870 absScreen_->UpdateRSTree(surfaceNode, isAdd, needToUpdate);
871 absScreen_->rsDisplayNode_ = nullptr;
872 }
873
874 /**
875 * @tc.name: UpdateRSTree08
876 * @tc.desc: UpdateRSTree
877 * @tc.type: FUNC
878 */
879 HWTEST_F(AbstractScreenTest, UpdateRSTree08, Function | SmallTest | Level3)
880 {
881 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
882 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig,
883 RSSurfaceNodeType::DEFAULT);
884 bool isAdd = false;
885 bool needToUpdate = false;
886 struct RSDisplayNodeConfig config;
887 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
888 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
889
890 absScreen_->UpdateRSTree(surfaceNode, isAdd, needToUpdate);
891 absScreen_->rsDisplayNode_ = nullptr;
892 }
893
894 /**
895 * @tc.name: UpdateRSTree09
896 * @tc.desc: UpdateRSTree
897 * @tc.type: FUNC
898 */
899 HWTEST_F(AbstractScreenTest, UpdateRSTree09, Function | SmallTest | Level3)
900 {
901 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
902 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig,
903 RSSurfaceNodeType::DEFAULT);
904 bool isAdd = false;
905 bool needToUpdate = true;
906 struct RSDisplayNodeConfig config;
907 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
908 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
909
910 absScreen_->UpdateRSTree(surfaceNode, isAdd, needToUpdate);
911 absScreen_->rsDisplayNode_ = nullptr;
912 }
913
914 /**
915 * @tc.name: UpdateDisplayGroupRSTree01
916 * @tc.desc: UpdateDisplayGroupRSTree
917 * @tc.type: FUNC
918 */
919 HWTEST_F(AbstractScreenTest, UpdateDisplayGroupRSTree01, Function | SmallTest | Level3)
920 {
921 std::shared_ptr<RSSurfaceNode> surfaceNode;
922 NodeId parentNodeId = 0;
923 bool isAdd = true;
924
925 absScreen_->UpdateDisplayGroupRSTree(surfaceNode, parentNodeId, isAdd);
926 ASSERT_EQ(nullptr, absScreen_->rsDisplayNode_);
927 }
928
929 /**
930 * @tc.name: UpdateDisplayGroupRSTree02
931 * @tc.desc: UpdateDisplayGroupRSTree
932 * @tc.type: FUNC
933 */
934 HWTEST_F(AbstractScreenTest, UpdateDisplayGroupRSTree02, Function | SmallTest | Level3)
935 {
936 std::shared_ptr<RSSurfaceNode> surfaceNode;
937 NodeId parentNodeId = 0;
938 bool isAdd = true;
939 struct RSDisplayNodeConfig config;
940 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
941 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
942
943 absScreen_->UpdateDisplayGroupRSTree(surfaceNode, parentNodeId, isAdd);
944 absScreen_->rsDisplayNode_ = nullptr;
945 }
946
947 /**
948 * @tc.name: UpdateDisplayGroupRSTree03
949 * @tc.desc: UpdateDisplayGroupRSTree
950 * @tc.type: FUNC
951 */
952 HWTEST_F(AbstractScreenTest, UpdateDisplayGroupRSTree03, Function | SmallTest | Level3)
953 {
954 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
955 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig,
956 RSSurfaceNodeType::DEFAULT);
957 NodeId parentNodeId = 0;
958 bool isAdd = false;
959 struct RSDisplayNodeConfig config;
960 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
961 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
962
963 absScreen_->UpdateDisplayGroupRSTree(surfaceNode, parentNodeId, isAdd);
964 absScreen_->rsDisplayNode_ = nullptr;
965 }
966
967 /**
968 * @tc.name: UpdateDisplayGroupRSTree04
969 * @tc.desc: UpdateDisplayGroupRSTree
970 * @tc.type: FUNC
971 */
972 HWTEST_F(AbstractScreenTest, UpdateDisplayGroupRSTree04, Function | SmallTest | Level3)
973 {
974 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
975 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig,
976 RSSurfaceNodeType::DEFAULT);
977 NodeId parentNodeId = 0;
978 bool isAdd = true;
979 struct RSDisplayNodeConfig config;
980 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
981 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
982
983 absScreen_->UpdateDisplayGroupRSTree(surfaceNode, parentNodeId, isAdd);
984 absScreen_->rsDisplayNode_ = nullptr;
985 }
986
987 /**
988 * @tc.name: UpdateDisplayGroupRSTree05
989 * @tc.desc: UpdateDisplayGroupRSTree
990 * @tc.type: FUNC
991 */
992 HWTEST_F(AbstractScreenTest, UpdateDisplayGroupRSTree05, Function | SmallTest | Level3)
993 {
994 std::shared_ptr<RSSurfaceNode> surfaceNode;
995 NodeId parentNodeId = 0;
996 bool isAdd = false;
997 struct RSDisplayNodeConfig config;
998 absScreen_->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
999 ASSERT_NE(nullptr, absScreen_->rsDisplayNode_);
1000
1001 absScreen_->UpdateDisplayGroupRSTree(surfaceNode, parentNodeId, isAdd);
1002 absScreen_->rsDisplayNode_ = nullptr;
1003 }
1004 }
1005 } // namespace Rosen
1006 } // namespace OHOS
1007