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