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
22using namespace testing;
23using namespace testing::ext;
24
25namespace OHOS {
26namespace Rosen {
27class AbstractScreenTest : public testing::Test {
28public:
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
40sptr<AbstractScreen> AbstractScreenTest::absScreen_ = nullptr;
41sptr<AbstractScreenGroup> AbstractScreenTest::absScreenGroup_ = nullptr;
42std::recursive_mutex AbstractScreenTest::mutex_;
43std::string AbstractScreenTest::name_ = "AbstractScreenTest";
44
45void 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
55void AbstractScreenTest::TearDownTestCase()
56{
57}
58
59void AbstractScreenTest::SetUp()
60{
61}
62
63void AbstractScreenTest::TearDown()
64{
65}
66
67namespace {
68/**
69 * @tc.name: GetScreenMode
70 * @tc.desc: Get screen mode
71 * @tc.type: FUNC
72 */
73HWTEST_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 */
96HWTEST_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 */
105HWTEST_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 */
144HWTEST_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 */
161HWTEST_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 */
178HWTEST_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 */
190HWTEST_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 */
212HWTEST_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 */
231HWTEST_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 */
256HWTEST_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 */
270HWTEST_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 */
286HWTEST_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 */
297HWTEST_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 */
308HWTEST_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 */
337HWTEST_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 */
351HWTEST_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 */
378HWTEST_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 */
407HWTEST_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 */
424HWTEST_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 */
454HWTEST_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 */
479HWTEST_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 */
497HWTEST_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 */
514HWTEST_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 */
530HWTEST_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 */
551HWTEST_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 */
565HWTEST_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 */
580HWTEST_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 */
593HWTEST_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 */
627HWTEST_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 */
654HWTEST_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 */
678HWTEST_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 */
703HWTEST_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 */
728HWTEST_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 */
749HWTEST_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 */
765HWTEST_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 */
783HWTEST_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 */
801HWTEST_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 */
819HWTEST_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 */
837HWTEST_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 */
857HWTEST_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 */
877HWTEST_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 */
897HWTEST_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 */
917HWTEST_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 */
932HWTEST_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 */
950HWTEST_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 */
970HWTEST_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 */
990HWTEST_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