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