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_controller.h"
19 #include "iremote_object_mocker.h"
20 #include "modifier_render_thread/rs_modifiers_draw_thread.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Rosen {
27 class AbstractScreenControllerTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31 void SetUp() override;
32 void TearDown() override;
33
34 std::recursive_mutex mutex;
35 sptr<AbstractScreenController> absController_ = new AbstractScreenController(mutex);
36 std::string name = "AbstractScreenController";
37 std::vector<sptr<AbstractScreen>> screenVec;
38 std::vector<sptr<AbstractScreenGroup>> screenGroupVec;
39 };
40
SetUpTestCase()41 void AbstractScreenControllerTest::SetUpTestCase()
42 {
43 }
44
TearDownTestCase()45 void AbstractScreenControllerTest::TearDownTestCase()
46 {
47 #ifdef RS_ENABLE_VK
48 RSModifiersDrawThread::Destroy();
49 #endif
50 }
51
SetUp()52 void AbstractScreenControllerTest::SetUp()
53 {
54 uint64_t index = 5;
55 for (uint64_t i = 0; i < index; ++i) {
56 ScreenId dmsId = i;
57 ScreenId rsId = i;
58 sptr<AbstractScreen> absScreen = new AbstractScreen(absController_, name, dmsId, rsId);
59 sptr<AbstractScreenGroup> absScreenGroup = new AbstractScreenGroup(absController_,
60 dmsId, rsId, name, ScreenCombination::SCREEN_ALONE);
61 screenVec.emplace_back(absScreen);
62 screenGroupVec.emplace_back(absScreenGroup);
63 // init dmsScreenMap_
64 absController_->dmsScreenMap_.insert(std::make_pair(dmsId, absScreen));
65 // init screenIdManager_
66 absController_->screenIdManager_.rs2DmsScreenIdMap_.insert(std::make_pair(rsId, dmsId));
67 absController_->screenIdManager_.dms2RsScreenIdMap_.insert(std::make_pair(dmsId, rsId));
68 // init dmsScreenGroupMap_
69 absController_->dmsScreenGroupMap_.insert(std::make_pair(rsId, absScreenGroup));
70 }
71 screenVec[4]->type_ = ScreenType::UNDEFINED;
72 screenVec[3]->type_ = ScreenType::VIRTUAL;
73 absController_->dmsScreenMap_.insert(std::make_pair(index, nullptr));
74 absController_->screenIdManager_.dms2RsScreenIdMap_.insert(std::make_pair(index, SCREEN_ID_INVALID));
75 absController_->dmsScreenGroupMap_.insert(std::make_pair(index, nullptr));
76 }
77
TearDown()78 void AbstractScreenControllerTest::TearDown()
79 {
80 screenVec.clear();
81 }
82
83 namespace {
84 /**
85 * @tc.name: ProcessScreenDisconnected
86 * @tc.desc: ProcessScreenDisconnected test
87 * @tc.type: FUNC
88 */
89 HWTEST_F(AbstractScreenControllerTest, ProcessScreenDisconnected01, TestSize.Level1)
90 {
91 ScreenId rsId = 6;
92 ScreenId dmsId;
93 absController_->ProcessScreenDisconnected(rsId);
94 ASSERT_EQ(false, absController_->screenIdManager_.ConvertToDmsScreenId(rsId, dmsId));
95 }
96
97 /**
98 * @tc.name: ProcessScreenDisconnected
99 * @tc.desc: ProcessScreenDisconnected test
100 * @tc.type: FUNC
101 */
102 HWTEST_F(AbstractScreenControllerTest, ProcessScreenDisconnected02, TestSize.Level1)
103 {
104 ScreenId rsId = 2;
105 ScreenId dmsId;
106 absController_->ProcessScreenDisconnected(rsId);
107 absController_->screenIdManager_.ConvertToDmsScreenId(rsId, dmsId);
108 absController_->dmsScreenMap_.erase(dmsId);
109 ASSERT_EQ(false, absController_->screenIdManager_.ConvertToDmsScreenId(rsId, dmsId));
110 ASSERT_EQ(absController_->dmsScreenMap_.end(), absController_->dmsScreenMap_.find(dmsId));
111 }
112
113 /**
114 * @tc.name: ProcessScreenDisconnected
115 * @tc.desc: ProcessScreenDisconnected test
116 * @tc.type: FUNC
117 */
118 HWTEST_F(AbstractScreenControllerTest, ProcessScreenDisconnected03, TestSize.Level1)
119 {
120 ScreenId rsId = 2;
121 ScreenId dmsId;
122 absController_->abstractScreenCallback_ = nullptr;
123 absController_->ProcessScreenDisconnected(rsId);
124 ASSERT_EQ(false, absController_->screenIdManager_.ConvertToDmsScreenId(rsId, dmsId));
125 ASSERT_NE(absController_->dmsScreenMap_.end(), absController_->dmsScreenMap_.find(dmsId));
126 }
127
128 /**
129 * @tc.name: SetScreenRotateAnimation
130 * @tc.desc: SetScreenRotateAnimation test
131 * @tc.type: FUNC
132 */
133 HWTEST_F(AbstractScreenControllerTest, SetScreenRotateAnimation01, TestSize.Level1)
134 {
135 RSDisplayNodeConfig config;
136 absController_->dmsScreenMap_[1]->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
137 sptr<AbstractScreen> screen = screenVec[0];
138 screen->rotation_ = Rotation::ROTATION_270;
139 absController_->SetScreenRotateAnimation(screen, 1, Rotation::ROTATION_0, true);
140 ASSERT_EQ(Rotation::ROTATION_270, screen->rotation_);
141 }
142
143 /**
144 * @tc.name: SetScreenRotateAnimation
145 * @tc.desc: SetScreenRotateAnimation test
146 * @tc.type: FUNC
147 */
148 HWTEST_F(AbstractScreenControllerTest, SetScreenRotateAnimation02, TestSize.Level1)
149 {
150 RSDisplayNodeConfig config;
151 absController_->dmsScreenMap_[1]->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
152 sptr<AbstractScreen> screen = screenVec[0];
153 screen->rotation_ = Rotation::ROTATION_0;
154 absController_->SetScreenRotateAnimation(screen, 1, Rotation::ROTATION_270, true);
155 ASSERT_EQ(Rotation::ROTATION_0, screen->rotation_);
156 }
157
158 /**
159 * @tc.name: SetScreenRotateAnimation
160 * @tc.desc: SetScreenRotateAnimation test
161 * @tc.type: FUNC
162 */
163 HWTEST_F(AbstractScreenControllerTest, SetScreenRotateAnimation03, TestSize.Level1)
164 {
165 RSDisplayNodeConfig config;
166 absController_->dmsScreenMap_[1]->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
167 sptr<AbstractScreen> screen = screenVec[0];
168 screen->rotation_ = Rotation::ROTATION_0;
169 absController_->SetScreenRotateAnimation(screen, 1, Rotation::ROTATION_270, false);
170 ASSERT_EQ(Rotation::ROTATION_0, screen->rotation_);
171 }
172
173 /**
174 * @tc.name: MakeMirror
175 * @tc.desc: MakeMirror test
176 * @tc.type: FUNC
177 */
178 HWTEST_F(AbstractScreenControllerTest, MakeMirror01, TestSize.Level1)
179 {
180 std::vector<ScreenId> screens;
181 ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(5, screens));
182 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
183 }
184
185 /**
186 * @tc.name: MakeMirror
187 * @tc.desc: MakeMirror test
188 * @tc.type: FUNC
189 */
190 HWTEST_F(AbstractScreenControllerTest, MakeMirror02, TestSize.Level1)
191 {
192 std::vector<ScreenId> screens;
193 absController_->dmsScreenMap_[2]->type_ = ScreenType::UNDEFINED;
194 ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(2, screens));
195 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
196 }
197
198 /**
199 * @tc.name: MakeMirror
200 * @tc.desc: MakeMirror test
201 * @tc.type: FUNC
202 */
203 HWTEST_F(AbstractScreenControllerTest, MakeMirror03, TestSize.Level1)
204 {
205 std::vector<ScreenId> screens;
206 absController_->dmsScreenMap_[2]->type_ = ScreenType::REAL;
207 absController_->dmsScreenMap_[2]->groupDmsId_ = 5;
208 absController_->abstractScreenCallback_ = nullptr;
209 ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(2, screens));
210 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
211 }
212
213 /**
214 * @tc.name: MakeMirror
215 * @tc.desc: MakeMirror test
216 * @tc.type: FUNC
217 */
218 HWTEST_F(AbstractScreenControllerTest, MakeMirror04, TestSize.Level1)
219 {
220 std::vector<ScreenId> screens;
221 absController_->dmsScreenMap_[2]->type_ = ScreenType::REAL;
222 absController_->dmsScreenMap_[2]->groupDmsId_ = 5;
223 absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
224 ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(2, screens));
225 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
226 }
227
228 /**
229 * @tc.name: MakeMirror
230 * @tc.desc: MakeMirror test
231 * @tc.type: FUNC
232 */
233 HWTEST_F(AbstractScreenControllerTest, MakeMirror05, TestSize.Level1)
234 {
235 std::vector<ScreenId> screens;
236 absController_->dmsScreenMap_[2]->type_ = ScreenType::REAL;
237 absController_->dmsScreenMap_[2]->groupDmsId_ = 2;
238 absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
239 ASSERT_TRUE(DMError::DM_OK == absController_->MakeMirror(2, screens));
240 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
241 }
242
243 /**
244 * @tc.name: ProcessScreenConnected
245 * @tc.desc: ProcessScreenConnected test
246 * @tc.type: FUNC
247 */
248 HWTEST_F(AbstractScreenControllerTest, ProcessScreenConnected01, TestSize.Level1)
249 {
250 ScreenId id = 0;
251 absController_->ProcessScreenConnected(id);
252 ASSERT_EQ(true, absController_->screenIdManager_.HasRsScreenId(id));
253 }
254
255 /**
256 * @tc.name: OnRsScreenConnectionChange
257 * @tc.desc: OnRsScreenConnectionChange test
258 * @tc.type: FUNC
259 */
260 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange01, TestSize.Level1)
261 {
262 ScreenEvent event = ScreenEvent::UNKNOWN;
263 ScreenId rsScreenId = 100;
264 absController_->OnRsScreenConnectionChange(rsScreenId, event);
265 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
266 }
267
268 /**
269 * @tc.name: OnRsScreenConnectionChange
270 * @tc.desc: OnRsScreenConnectionChange test
271 * @tc.type: FUNC
272 */
273 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange02, TestSize.Level1)
274 {
275 ScreenEvent event = ScreenEvent::UNKNOWN;
276 ScreenId rsScreenId = 1;
277 absController_->OnRsScreenConnectionChange(rsScreenId, event);
278 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
279 }
280
281 /**
282 * @tc.name: OnRsScreenConnectionChange
283 * @tc.desc: OnRsScreenConnectionChange test
284 * @tc.type: FUNC
285 */
286 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange03, TestSize.Level1)
287 {
288 ScreenEvent event = ScreenEvent::CONNECTED;
289 ScreenId rsScreenId = 1;
290 absController_->OnRsScreenConnectionChange(rsScreenId, event);
291 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
292 }
293
294 /**
295 * @tc.name: OnRsScreenConnectionChange
296 * @tc.desc: OnRsScreenConnectionChange test
297 * @tc.type: FUNC
298 */
299 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange04, TestSize.Level1)
300 {
301 ScreenEvent event = ScreenEvent::DISCONNECTED;
302 ScreenId rsScreenId = 1;
303 absController_->OnRsScreenConnectionChange(rsScreenId, event);
304 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
305 }
306
307 /**
308 * @tc.name: GetAllValidScreenIds
309 * @tc.desc: GetAllValidScreenIds test
310 * @tc.type: FUNC
311 */
312 HWTEST_F(AbstractScreenControllerTest, GetAllValidScreenIds, TestSize.Level1)
313 {
314 std::vector<ScreenId> screenIds {0, 1, 1, 2, 2, 3, 4};
315 std::vector<ScreenId> valid {0, 1, 2, 3};
316 ASSERT_EQ(valid, absController_->GetAllValidScreenIds(screenIds));
317 }
318
319 /**
320 * @tc.name: GetRSDisplayNodeByScreenId
321 * @tc.desc: GetRSDisplayNodeByScreenId test
322 * @tc.type: FUNC
323 */
324 HWTEST_F(AbstractScreenControllerTest, GetRSDisplayNodeByScreenId, TestSize.Level1)
325 {
326 ScreenId id = 6;
327 std::shared_ptr<RSDisplayNode> node = nullptr;
328 ASSERT_EQ(node, absController_->GetRSDisplayNodeByScreenId(id));
329 }
330
331 /**
332 * @tc.name: UpdateRSTree
333 * @tc.desc: UpdateRSTree test
334 * @tc.type: FUNC
335 */
336 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree01, TestSize.Level1)
337 {
338 ScreenId id = 8;
339 std::shared_ptr<RSSurfaceNode> node = nullptr;
340 absController_->UpdateRSTree(id, id, node, true, true);
341 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(id));
342 }
343
344 /**
345 * @tc.name: UpdateRSTree
346 * @tc.desc: UpdateRSTree test
347 * @tc.type: FUNC
348 */
349 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree02, TestSize.Level1)
350 {
351 ScreenId id = 1;
352 ScreenId parentId = 8;
353 std::shared_ptr<RSSurfaceNode> node = nullptr;
354 absController_->UpdateRSTree(id, parentId, node, true, true);
355 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
356 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(parentId));
357 }
358
359 /**
360 * @tc.name: UpdateRSTree
361 * @tc.desc: UpdateRSTree test
362 * @tc.type: FUNC
363 */
364 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree03, TestSize.Level1)
365 {
366 ScreenId id = 1;
367 ScreenId parentId = 2;
368 std::shared_ptr<RSSurfaceNode> node = nullptr;
369 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
370 sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
371 ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
372 parentScreen->rsDisplayNode_ = nullptr;
373 absController_->UpdateRSTree(id, parentId, node, true, true);
374 }
375
376 /**
377 * @tc.name: UpdateRSTree
378 * @tc.desc: UpdateRSTree test
379 * @tc.type: FUNC
380 */
381 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree04, TestSize.Level1)
382 {
383 ScreenId id = 1;
384 ScreenId parentId = 2;
385 std::shared_ptr<RSSurfaceNode> node = nullptr;
386 RSDisplayNodeConfig config;
387 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
388 sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
389 ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
390 parentScreen->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
391 absController_->UpdateRSTree(id, parentId, node, true, true);
392 }
393
394 /**
395 * @tc.name: UpdateRSTree
396 * @tc.desc: UpdateRSTree test
397 * @tc.type: FUNC
398 */
399 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree05, TestSize.Level1)
400 {
401 ScreenId id = 1;
402 ScreenId parentId = 2;
403 std::shared_ptr<RSSurfaceNode> node = nullptr;
404 RSDisplayNodeConfig config;
405 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
406 sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
407 ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
408 parentScreen->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
409 absController_->UpdateRSTree(id, parentId, node, true, false);
410 }
411
412 /**
413 * @tc.name: RegisterAbstractScreenCallback
414 * @tc.desc: RegisterAbstractScreenCallback test
415 * @tc.type: FUNC
416 */
417 HWTEST_F(AbstractScreenControllerTest, RegisterAbstractScreenCallback, TestSize.Level1)
418 {
419 sptr<AbstractScreenController::AbstractScreenCallback> cb = nullptr;
420 absController_->RegisterAbstractScreenCallback(cb);
421 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
422 }
423
424 /**
425 * @tc.name: AddToGroupLocked
426 * @tc.desc: AddToGroupLocked test
427 * @tc.type: FUNC
428 */
429 HWTEST_F(AbstractScreenControllerTest, AddToGroupLocked, TestSize.Level1)
430 {
431 ASSERT_EQ(false, absController_->dmsScreenGroupMap_.empty());
432 ASSERT_EQ(nullptr, absController_->AddToGroupLocked(screenVec[0]));
433 }
434
435 /**
436 * @tc.name: RemoveFromGroupLocked
437 * @tc.desc: RemoveFromGroupLocked test
438 * @tc.type: FUNC
439 */
440 HWTEST_F(AbstractScreenControllerTest, RemoveFromGroupLocked01, TestSize.Level1)
441 {
442 sptr<AbstractScreen> screen = screenVec[0];
443 screen->groupDmsId_ = 0;
444 ASSERT_EQ(nullptr, absController_->RemoveFromGroupLocked(screen));
445 }
446
447 /**
448 * @tc.name: RemoveChildFromGroup
449 * @tc.desc: RemoveChildFromGroup test
450 * @tc.type: FUNC
451 */
452 HWTEST_F(AbstractScreenControllerTest, RemoveChildFromGroup01, TestSize.Level1)
453 {
454 sptr<AbstractScreen> screen = screenVec[0];
455 ScreenId dmsId = screen->dmsId_;
456 sptr<AbstractScreenGroup> screenGroup = absController_->dmsScreenGroupMap_[0];
457 screenGroup->screenMap_.insert(std::make_pair(dmsId, screen));
458 ASSERT_EQ(true, absController_->RemoveChildFromGroup(screen, screenGroup));
459 }
460
461 /**
462 * @tc.name: AddAsSuccedentScreenLocked
463 * @tc.desc: AddAsSuccedentScreenLocked test
464 * @tc.type: FUNC
465 */
466 HWTEST_F(AbstractScreenControllerTest, AddAsSuccedentScreenLocked01, TestSize.Level1)
467 {
468 sptr<AbstractScreen> screen = screenVec[0];
469 absController_->dmsScreenMap_.erase(absController_->GetDefaultAbstractScreenId());
470 ASSERT_EQ(nullptr, absController_->AddAsSuccedentScreenLocked(screen));
471 }
472
473 /**
474 * @tc.name: AddAsSuccedentScreenLocked
475 * @tc.desc: AddAsSuccedentScreenLocked test
476 * @tc.type: FUNC
477 */
478 HWTEST_F(AbstractScreenControllerTest, AddAsSuccedentScreenLocked02, TestSize.Level1)
479 {
480 sptr<AbstractScreen> screen = screenVec[0];
481 ASSERT_EQ(nullptr, absController_->AddAsSuccedentScreenLocked(screen));
482 }
483
484 /**
485 * @tc.name: CreateVirtualScreen
486 * @tc.desc: CreateVirtualScreen test
487 * @tc.type: FUNC
488 */
489 HWTEST_F(AbstractScreenControllerTest, CreateVirtualScreen01, TestSize.Level1)
490 {
491 VirtualScreenOption option;
492 sptr<IRemoteObject> displayManagerAgent = new IRemoteObjectMocker();
493 auto ret = absController_->CreateVirtualScreen(option, displayManagerAgent);
494 if (ret != 0)
495 {
496 ASSERT_NE(0, ret);
497 }
498 }
499
500 /**
501 * @tc.name: InitVirtualScreen
502 * @tc.desc: InitVirtualScreen test
503 * @tc.type: FUNC
504 */
505 HWTEST_F(AbstractScreenControllerTest, InitVirtualScreen01, TestSize.Level1)
506 {
507 VirtualScreenOption option;
508 absController_->dmsScreenMap_.erase(absController_->GetDefaultAbstractScreenId());
509 sptr<AbstractScreen> screen = absController_->InitVirtualScreen(0, 0, option);
510 auto ret = screen->activeIdx_;
511 if (ret != 0) {
512 ASSERT_NE(0, ret);
513 }
514 }
515
516 /**
517 * @tc.name: InitVirtualScreen
518 * @tc.desc: InitVirtualScreen test
519 * @tc.type: FUNC
520 */
521 HWTEST_F(AbstractScreenControllerTest, InitVirtualScreen02, TestSize.Level1)
522 {
523 VirtualScreenOption option;
524 sptr<AbstractScreen> defaultScreen = absController_->dmsScreenMap_[absController_->GetDefaultAbstractScreenId()];
525 sptr<SupportedScreenModes> modes;
526 if (defaultScreen != nullptr) {
527 defaultScreen->modes_.emplace_back(modes);
528 defaultScreen->activeIdx_ = 0;
529 ASSERT_EQ(nullptr, defaultScreen->GetActiveScreenMode());
530 sptr<AbstractScreen> screen = absController_->InitVirtualScreen(0, 0, option);
531 ASSERT_EQ(ScreenType::VIRTUAL, screen->type_);
532 }
533 }
534
535 /**
536 * @tc.name: DestroyVirtualScreen
537 * @tc.desc: DestroyVirtualScreen test
538 * @tc.type: FUNC
539 */
540 HWTEST_F(AbstractScreenControllerTest, DestroyVirtualScreen01, TestSize.Level1)
541 {
542 ScreenId id = 5;
543 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, absController_->DestroyVirtualScreen(id));
544 }
545
546 /**
547 * @tc.name: DestroyVirtualScreen
548 * @tc.desc: DestroyVirtualScreen test
549 * @tc.type: FUNC
550 */
551 HWTEST_F(AbstractScreenControllerTest, DestroyVirtualScreen02, TestSize.Level1)
552 {
553 ScreenId id = 1;
554 ASSERT_EQ(DMError::DM_OK, absController_->DestroyVirtualScreen(id));
555 }
556
557 /**
558 * @tc.name: SetVirtualScreenSurface
559 * @tc.desc: SetVirtualScreenSurface test
560 * @tc.type: FUNC
561 */
562 HWTEST_F(AbstractScreenControllerTest, SetVirtualScreenSurface01, TestSize.Level1)
563 {
564 ScreenId id = 6;
565 sptr<Surface> surface = nullptr;
566 ASSERT_EQ(DMError::DM_ERROR_RENDER_SERVICE_FAILED, absController_->SetVirtualScreenSurface(id, surface));
567 }
568
569 /**
570 * @tc.name: SetBuildInDefaultOrientation
571 * @tc.desc: SetBuildInDefaultOrientation test
572 * @tc.type: FUNC
573 */
574 HWTEST_F(AbstractScreenControllerTest, SetBuildInDefaultOrientation, TestSize.Level1)
575 {
576 Orientation orientation = Orientation::BEGIN;
577 absController_->SetBuildInDefaultOrientation(orientation);
578 ASSERT_EQ(orientation, absController_->buildInDefaultOrientation_);
579 }
580
581 /**
582 * @tc.name: SetOrientation
583 * @tc.desc: SetOrientation test
584 * @tc.type: FUNC
585 */
586 HWTEST_F(AbstractScreenControllerTest, SetOrientation01, TestSize.Level1)
587 {
588 absController_->dmsScreenMap_[1]->isScreenGroup_ = true;
589 Orientation orientation = Orientation::BEGIN;
590 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, absController_->SetOrientation(1, orientation, true));
591 }
592
593 /**
594 * @tc.name: SetOrientation
595 * @tc.desc: SetOrientation test
596 * @tc.type: FUNC
597 */
598 HWTEST_F(AbstractScreenControllerTest, SetOrientation02, TestSize.Level1)
599 {
600 absController_->dmsScreenMap_[1]->isScreenGroup_ = false;
601
602 Orientation orientation = Orientation::BEGIN;
603 bool isFromWindow = true;
604 DMError ret = absController_->SetOrientation(1, orientation, isFromWindow);
605 ASSERT_EQ(DMError::DM_OK, ret);
606
607 orientation = Orientation::VERTICAL;
608 ret = absController_->SetOrientation(1, orientation, isFromWindow);
609 ASSERT_EQ(DMError::DM_OK, ret);
610
611 isFromWindow = false;
612 ret = absController_->SetOrientation(1, orientation, isFromWindow);
613 ASSERT_EQ(DMError::DM_OK, ret);
614
615 ret = absController_->SetOrientation(1, orientation, isFromWindow, false);
616 ASSERT_EQ(DMError::DM_OK, ret);
617 }
618
619 /**
620 * @tc.name: SetRotation
621 * @tc.desc: SetRotation test
622 * @tc.type: FUNC
623 */
624 HWTEST_F(AbstractScreenControllerTest, SetRotation01, TestSize.Level1)
625 {
626 absController_->dmsScreenMap_[1]->rotation_ = Rotation::ROTATION_180;
627 absController_->screenIdManager_.dms2RsScreenIdMap_.erase(1);
628 ASSERT_EQ(true, absController_->SetRotation(1, Rotation::ROTATION_0, true));
629 absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
630 ASSERT_EQ(false, absController_->SetRotation(1, Rotation::ROTATION_0, false));
631 ASSERT_EQ(false, absController_->SetRotation(1, Rotation::ROTATION_0, true));
632 }
633
634 /**
635 * @tc.name: SetScreenActiveMode
636 * @tc.desc: SetScreenActiveMode test
637 * @tc.type: FUNC
638 */
639 HWTEST_F(AbstractScreenControllerTest, SetScreenActiveMode01, TestSize.Level1)
640 {
641 ASSERT_TRUE(DMError::DM_OK != absController_->SetScreenActiveMode(5, 0));
642 }
643
644 /**
645 * @tc.name: SetScreenActiveMode
646 * @tc.desc: SetScreenActiveMode test
647 * @tc.type: FUNC
648 */
649 HWTEST_F(AbstractScreenControllerTest, SetScreenActiveMode02, TestSize.Level1)
650 {
651 absController_->screenIdManager_.dms2RsScreenIdMap_.erase(1);
652 ASSERT_TRUE(DMError::DM_OK != absController_->SetScreenActiveMode(1, 0));
653 }
654
655 /**
656 * @tc.name: ProcessScreenModeChanged
657 * @tc.desc: ProcessScreenModeChanged test
658 * @tc.type: FUNC
659 */
660 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged01, TestSize.Level1)
661 {
662 absController_->ProcessScreenModeChanged(7);
663 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
664 }
665
666 /**
667 * @tc.name: ProcessScreenModeChanged
668 * @tc.desc: ProcessScreenModeChanged test
669 * @tc.type: FUNC
670 */
671 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged02, TestSize.Level1)
672 {
673 absController_->ProcessScreenModeChanged(5);
674 ASSERT_EQ(nullptr, absController_->dmsScreenMap_[5]);
675 }
676
677 /**
678 * @tc.name: ProcessScreenModeChanged
679 * @tc.desc: ProcessScreenModeChanged test
680 * @tc.type: FUNC
681 */
682 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged03, TestSize.Level1)
683 {
684 absController_->ProcessScreenModeChanged(2);
685 ASSERT_NE(nullptr, absController_->dmsScreenMap_[2]);
686 }
687
688 /**
689 * @tc.name: ProcessScreenModeChanged
690 * @tc.desc: ProcessScreenModeChanged test
691 * @tc.type: FUNC
692 */
693 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged04, TestSize.Level1)
694 {
695 sptr<AbstractScreen> screen = absController_->GetAbstractScreen(2);
696 screen->activeIdx_ = 0;
697 absController_->abstractScreenCallback_ = nullptr;
698 absController_->ProcessScreenModeChanged(2);
699 ASSERT_NE(nullptr, absController_->dmsScreenMap_[2]);
700 }
701
702 /**
703 * @tc.name: ProcessScreenModeChanged
704 * @tc.desc: ProcessScreenModeChanged test
705 * @tc.type: FUNC
706 */
707 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged05, TestSize.Level1)
708 {
709 sptr<AbstractScreen> screen = absController_->GetAbstractScreen(2);
710 screen->activeIdx_ = 0;
711 absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
712 absController_->ProcessScreenModeChanged(2);
713 ASSERT_NE(nullptr, absController_->dmsScreenMap_[2]);
714 }
715
716 /**
717 * @tc.name: ChangeScreenGroup
718 * @tc.desc: ChangeScreenGroup test
719 * @tc.type: FUNC
720 */
721 HWTEST_F(AbstractScreenControllerTest, ChangeScreenGroup01, TestSize.Level1)
722 {
723 sptr<AbstractScreenGroup> group = screenGroupVec[0];
724 Point point;
725 group->screenMap_.insert(std::make_pair(0, screenVec[0]));
726 group->screenMap_.insert(std::make_pair(1, screenVec[0]));
727 std::vector<Point> startPoints;
728 std::vector<ScreenId> screens;
729 for (ScreenId i = 0; i < 7; ++i) {
730 screens.emplace_back(i);
731 startPoints.emplace_back(point);
732 if (i < absController_->dmsScreenMap_.size() && absController_->dmsScreenMap_[i] != nullptr) {
733 absController_->dmsScreenMap_[i]->groupDmsId_ = 1;
734 }
735 }
736 absController_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_ALONE);
737 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
738 }
739
740 /**
741 * @tc.name: ChangeScreenGroup
742 * @tc.desc: ChangeScreenGroup test
743 * @tc.type: FUNC
744 */
745 HWTEST_F(AbstractScreenControllerTest, ChangeScreenGroup02, TestSize.Level1)
746 {
747 sptr<AbstractScreenGroup> group = screenGroupVec[0];
748 Point point;
749 group->screenMap_.insert(std::make_pair(0, screenVec[0]));
750 group->screenMap_.insert(std::make_pair(1, screenVec[0]));
751 std::vector<Point> startPoints;
752 std::vector<ScreenId> screens;
753 for (ScreenId i = 0; i < 7; ++i) {
754 screens.emplace_back(i);
755 startPoints.emplace_back(point);
756 if (i < absController_->dmsScreenMap_.size() && absController_->dmsScreenMap_[i] != nullptr) {
757 absController_->dmsScreenMap_[i]->groupDmsId_ = 1;
758 }
759 }
760 absController_->abstractScreenCallback_ = nullptr;
761 absController_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_ALONE);
762 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
763 }
764
765 /**
766 * @tc.name: ChangeScreenGroup
767 * @tc.desc: ChangeScreenGroup test
768 * @tc.type: FUNC
769 */
770 HWTEST_F(AbstractScreenControllerTest, AddScreenToGroup01, TestSize.Level1)
771 {
772 sptr<AbstractScreenGroup> group = screenGroupVec[0];
773 std::vector<ScreenId> addScreens {0, 1, 2, 3, 4, 5};
774 Point point;
775 std::vector<Point> addChildPos(10, point);
776 std::map<ScreenId, bool> removeChildResMap;
777 absController_->AddScreenToGroup(group, addScreens, addChildPos, removeChildResMap);
778 absController_->abstractScreenCallback_ = nullptr;
779 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
780 }
781
782 /**
783 * @tc.name: MakeExpand
784 * @tc.desc: MakeExpand test
785 * @tc.type: FUNC
786 */
787 HWTEST_F(AbstractScreenControllerTest, MakeExpand01, TestSize.Level1)
788 {
789 std::vector<ScreenId> screenIds;
790 std::vector<Point> startPoints;
791 ScreenId defaultId = absController_->GetDefaultAbstractScreenId();
792 absController_->dmsScreenMap_[defaultId] = nullptr;
793 ASSERT_EQ(false, absController_->MakeExpand(screenIds, startPoints));
794 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screenIds, ScreenCombination::SCREEN_EXPAND));
795 }
796
797 /**
798 * @tc.name: MakeExpand
799 * @tc.desc: MakeExpand test
800 * @tc.type: FUNC
801 */
802 HWTEST_F(AbstractScreenControllerTest, MakeExpand02, TestSize.Level1)
803 {
804 std::vector<ScreenId> screenIds;
805 std::vector<Point> startPoints;
806 ScreenId defaultId = absController_->GetDefaultAbstractScreenId();
807 auto defaultScreen = absController_->GetAbstractScreen(defaultId);
808 if (defaultScreen != nullptr)
809 {
810 ScreenId groupDmsId = defaultScreen->groupDmsId_;
811 absController_->dmsScreenGroupMap_[groupDmsId] = nullptr;
812 ASSERT_EQ(false, absController_->MakeExpand(screenIds, startPoints));
813 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screenIds, ScreenCombination::SCREEN_EXPAND));
814 }
815 }
816
817 /**
818 * @tc.name: RemoveVirtualScreenFromGroup
819 * @tc.desc: RemoveVirtualScreenFromGroup test
820 * @tc.type: FUNC
821 */
822 HWTEST_F(AbstractScreenControllerTest, RemoveVirtualScreenFromGroup01, TestSize.Level1)
823 {
824 std::vector<ScreenId> screens {0, 1, 2, 3, 4, 5, 6, 7};
825 absController_->abstractScreenCallback_ = nullptr;
826 absController_->RemoveVirtualScreenFromGroup(screens);
827 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
828 }
829
830 /**
831 * @tc.name: OnRemoteDied
832 * @tc.desc: OnRemoteDied test
833 * @tc.type: FUNC
834 */
835 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied01, TestSize.Level1)
836 {
837 sptr<IRemoteObject> agent = nullptr;
838 ASSERT_EQ(false, absController_->OnRemoteDied(agent));
839 }
840
841 /**
842 * @tc.name: OnRemoteDied
843 * @tc.desc: OnRemoteDied test
844 * @tc.type: FUNC
845 */
846 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied02, TestSize.Level1)
847 {
848 sptr<IRemoteObject> agent = new IRemoteObjectMocker();
849 ASSERT_EQ(true, absController_->OnRemoteDied(agent));
850 }
851
852 /**
853 * @tc.name: OnRemoteDied
854 * @tc.desc: OnRemoteDied test
855 * @tc.type: FUNC
856 */
857 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied03, TestSize.Level1)
858 {
859 sptr<IRemoteObject> agent = new IRemoteObjectMocker();
860 std::vector<ScreenId> screens {5};
861 absController_->screenAgentMap_.insert(std::make_pair(agent, screens));
862 absController_->defaultRsScreenId_ = 0;
863 ASSERT_EQ(true, absController_->OnRemoteDied(agent));
864 ASSERT_EQ(0, absController_->screenAgentMap_.size());
865 absController_->defaultRsScreenId_ = SCREEN_ID_INVALID;
866 }
867
868 /**
869 * @tc.name: CreateAndGetNewScreenId
870 * @tc.desc: CreateAndGetNewScreenId test
871 * @tc.type: FUNC
872 */
873 HWTEST_F(AbstractScreenControllerTest, CreateAndGetNewScreenId01, TestSize.Level1)
874 {
875 ScreenId rsScreenId = 1;
876 ScreenId dmsScreenId = absController_->screenIdManager_.dmsScreenCount_;
877 ASSERT_EQ(dmsScreenId, absController_->screenIdManager_.CreateAndGetNewScreenId(rsScreenId));
878 ASSERT_EQ(++dmsScreenId, absController_->screenIdManager_.dmsScreenCount_);
879 }
880
881 /**
882 * @tc.name: ConvertToRsScreenId
883 * @tc.desc: ConvertToRsScreenId test
884 * @tc.type: FUNC
885 */
886 HWTEST_F(AbstractScreenControllerTest, ConvertToRsScreenId01, TestSize.Level1)
887 {
888 ScreenId rsScreenId;
889 ScreenId dmsScreenId = 8;
890 ASSERT_EQ(false, absController_->screenIdManager_.ConvertToRsScreenId(dmsScreenId, rsScreenId));
891 }
892
893 /**
894 * @tc.name: NotifyScreenConnected
895 * @tc.desc: NotifyScreenConnected test
896 * @tc.type: FUNC
897 */
898 HWTEST_F(AbstractScreenControllerTest, NotifyScreenConnected, TestSize.Level1)
899 {
900 sptr<ScreenInfo> screenInfo = nullptr;
901 absController_->NotifyScreenConnected(screenInfo);
902 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
903 }
904
905 /**
906 * @tc.name: NotifyScreenConnected
907 * @tc.desc: NotifyScreenConnected test
908 * @tc.type: FUNC
909 */
910 HWTEST_F(AbstractScreenControllerTest, NotifyScreenChanged, TestSize.Level1)
911 {
912 sptr<ScreenInfo> screenInfo = nullptr;
913 absController_->NotifyScreenChanged(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
914 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
915 }
916
917 /**
918 * @tc.name: NotifyScreenConnected
919 * @tc.desc: NotifyScreenConnected test
920 * @tc.type: FUNC
921 */
922 HWTEST_F(AbstractScreenControllerTest, NotifyScreenGroupChanged, TestSize.Level1)
923 {
924 sptr<ScreenInfo> screenInfo = nullptr;
925 absController_->NotifyScreenGroupChanged(screenInfo, ScreenGroupChangeEvent::ADD_TO_GROUP);
926 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
927 }
928
929 /**
930 * @tc.name: NotifyScreenConnected
931 * @tc.desc: NotifyScreenConnected test
932 * @tc.type: FUNC
933 */
934 HWTEST_F(AbstractScreenControllerTest, SetScreenPowerForAll, TestSize.Level1)
935 {
936 ASSERT_EQ(false, absController_->SetScreenPowerForAll(ScreenPowerState::POWER_ON,
937 PowerStateChangeReason::POWER_BUTTON));
938
939 for (uint32_t i = 0; i < screenVec.size(); ++i) {
940 if (screenVec[i] != nullptr && screenVec[i]->type_ == ScreenType::REAL) {
941 screenVec[i]->type_ = ScreenType::UNDEFINED;
942 }
943 }
944 ASSERT_EQ(false, absController_->SetScreenPowerForAll(ScreenPowerState::INVALID_STATE,
945 PowerStateChangeReason::POWER_BUTTON));
946
947 ASSERT_EQ(false, absController_->SetScreenPowerForAll(ScreenPowerState::POWER_OFF,
948 PowerStateChangeReason::POWER_BUTTON));
949 }
950
951 /**
952 * @tc.name: SetVirtualPixelRatio
953 * @tc.desc: SetVirtualPixelRatio test
954 * @tc.type: FUNC
955 */
956 HWTEST_F(AbstractScreenControllerTest, SetVirtualPixelRatio01, TestSize.Level1)
957 {
958 auto screen = screenVec[0];
959 ScreenId id = 0;
960 float ratio = 1.0;
961 screen->isScreenGroup_ = true;
962 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, absController_->SetVirtualPixelRatio(id, ratio));
963 }
964
965 /**
966 * @tc.name: SetVirtualPixelRatio
967 * @tc.desc: SetVirtualPixelRatio test
968 * @tc.type: FUNC
969 */
970 HWTEST_F(AbstractScreenControllerTest, SetVirtualPixelRatio02, TestSize.Level1)
971 {
972 ScreenId id = 0;
973 float ratio = 1.0;
974 absController_->abstractScreenCallback_ = nullptr;
975 ASSERT_EQ(DMError::DM_OK, absController_->SetVirtualPixelRatio(id, ratio));
976 }
977
978 /**
979 * @tc.name: RegisterRsScreenConnectionChangeListener
980 * @tc.desc: RegisterRsScreenConnectionChangeListener test
981 * @tc.type: FUNC
982 */
983 HWTEST_F(AbstractScreenControllerTest, RegisterRsScreenConnectionChangeListener, TestSize.Level1)
984 {
985 sptr<IRemoteObject> agent = new IRemoteObjectMocker();
986 absController_->Init();
987 ASSERT_EQ(true, absController_->OnRemoteDied(agent));
988 agent.clear();
989 }
990
991 /**
992 * @tc.name: RemoveSurfaceNodeFromScreen
993 * @tc.desc: RemoveSurfaceNodeFromScreen test
994 * @tc.type: FUNC
995 */
996 HWTEST_F(AbstractScreenControllerTest, RemoveSurfaceNodeFromScreen, TestSize.Level1)
997 {
998 ScreenId dmsScreenId = 8;
999 std::shared_ptr<RSSurfaceNode> surfaceNode = nullptr;
1000 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, absController_->RemoveSurfaceNodeFromScreen(dmsScreenId, surfaceNode));
1001 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(dmsScreenId));
1002 }
1003
1004 /**
1005 * @tc.name: ProcessDefaultScreenReconnected
1006 * @tc.desc: ProcessDefaultScreenReconnected test
1007 * @tc.type: FUNC
1008 */
1009 HWTEST_F(AbstractScreenControllerTest, ProcessDefaultScreenReconnected01, TestSize.Level1)
1010 {
1011 ScreenId rsScreenId = 8;
1012 absController_->ProcessDefaultScreenReconnected(rsScreenId);
1013 absController_->defaultRsScreenId_ = 8;
1014 rsScreenId = 1;
1015 absController_->ProcessDefaultScreenReconnected(rsScreenId);
1016 rsScreenId = 8;
1017 absController_->ProcessDefaultScreenReconnected(rsScreenId);
1018 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(rsScreenId));
1019 }
1020
1021 /**
1022 * @tc.name: ProcessDefaultScreenReconnected
1023 * @tc.desc: ProcessDefaultScreenReconnected test
1024 * @tc.type: FUNC
1025 */
1026 HWTEST_F(AbstractScreenControllerTest, ProcessDefaultScreenReconnected02, TestSize.Level1)
1027 {
1028 ScreenId rsScreenId = 8;
1029 absController_->defaultRsScreenId_ = 8;
1030 absController_->ProcessDefaultScreenReconnected(rsScreenId);
1031 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(rsScreenId));
1032 rsScreenId = 5;
1033 absController_->defaultRsScreenId_ = 5;
1034 absController_->ProcessDefaultScreenReconnected(rsScreenId);
1035 rsScreenId = 1;
1036 absController_->defaultRsScreenId_ = 1;
1037 absController_->ProcessDefaultScreenReconnected(rsScreenId);
1038 }
1039
1040 /**
1041 * @tc.name: ConvertToRsScreenId
1042 * @tc.desc: ConvertToRsScreenId test
1043 * @tc.type: FUNC
1044 */
1045 HWTEST_F(AbstractScreenControllerTest, ConvertToRsScreenId, TestSize.Level1)
1046 {
1047 ScreenId dmsScreenId = 6;
1048 ASSERT_TRUE(absController_->screenIdManager_.ConvertToRsScreenId(dmsScreenId));
1049 }
1050
1051 /**
1052 * @tc.name: ConvertToDmsScreenId
1053 * @tc.desc: ConvertToDmsScreenId test
1054 * @tc.type: FUNC
1055 */
1056 HWTEST_F(AbstractScreenControllerTest, ConvertToDmsScreenId, TestSize.Level1)
1057 {
1058 ScreenId rsScreenId = 7;
1059 ASSERT_TRUE(absController_->screenIdManager_.ConvertToDmsScreenId(rsScreenId));
1060 }
1061
1062 /**
1063 * @tc.name: AddSurfaceNodeToScreen
1064 * @tc.desc: AddSurfaceNodeToScreen test
1065 * @tc.type: FUNC
1066 */
1067 HWTEST_F(AbstractScreenControllerTest, AddSurfaceNodeToScreen, TestSize.Level1)
1068 {
1069 ScreenId dmsScreenId = 7;
1070 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
1071 std::shared_ptr<RSSurfaceNode> surfaceNode = std::make_shared<RSSurfaceNode>(rsSurfaceNodeConfig, true, 0);
1072 DMError ret = absController_->AddSurfaceNodeToScreen(dmsScreenId, surfaceNode, true);
1073 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1074
1075 dmsScreenId = 1;
1076 ret = absController_->AddSurfaceNodeToScreen(dmsScreenId, surfaceNode, true);
1077 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1078 }
1079
1080 /**
1081 * @tc.name: GetScreenSupportedColorGamuts
1082 * @tc.desc: GetScreenSupportedColorGamuts test
1083 * @tc.type: FUNC
1084 */
1085 HWTEST_F(AbstractScreenControllerTest, GetScreenSupportedColorGamuts, TestSize.Level1)
1086 {
1087 ScreenId screenId = 1;
1088 std::vector<ScreenColorGamut> colorGamuts;
1089 DMError ret = absController_->GetScreenSupportedColorGamuts(screenId, colorGamuts);
1090
1091 ASSERT_EQ(ret, DMError::DM_ERROR_RENDER_SERVICE_FAILED);
1092 }
1093
1094 /**
1095 * @tc.name: GetScreenColorGamut
1096 * @tc.desc: GetScreenColorGamut test
1097 * @tc.type: FUNC
1098 */
1099 HWTEST_F(AbstractScreenControllerTest, GetScreenColorGamut, TestSize.Level1)
1100 {
1101 ScreenId screenId = 1;
1102 ScreenColorGamut colorGamut;
1103 DMError ret = absController_->GetScreenColorGamut(screenId, colorGamut);
1104
1105 ASSERT_EQ(ret, DMError::DM_ERROR_RENDER_SERVICE_FAILED);
1106 }
1107
1108 /**
1109 * @tc.name: SetScreenColorGamut
1110 * @tc.desc: SetScreenColorGamut test
1111 * @tc.type: FUNC
1112 */
1113 HWTEST_F(AbstractScreenControllerTest, SetScreenColorGamut, TestSize.Level1)
1114 {
1115 ScreenId screenId = 1;
1116 int32_t colorGamutIdx = 1;
1117 DMError ret = absController_->SetScreenColorGamut(screenId, colorGamutIdx);
1118
1119 ASSERT_EQ(ret, DMError::DM_ERROR_RENDER_SERVICE_FAILED);
1120 }
1121
1122 /**
1123 * @tc.name: GetScreenGamutMap
1124 * @tc.desc: GetScreenGamutMap test
1125 * @tc.type: FUNC
1126 */
1127 HWTEST_F(AbstractScreenControllerTest, GetScreenGamutMap, TestSize.Level1)
1128 {
1129 ScreenId screenId = 1;
1130 ScreenGamutMap gamutMap;
1131 DMError ret = absController_->GetScreenGamutMap(screenId, gamutMap);
1132
1133 ASSERT_EQ(ret, DMError::DM_ERROR_RENDER_SERVICE_FAILED);
1134 }
1135
1136 /**
1137 * @tc.name: SetScreenGamutMap
1138 * @tc.desc: SetScreenGamutMap test
1139 * @tc.type: FUNC
1140 */
1141 HWTEST_F(AbstractScreenControllerTest, SetScreenGamutMap, TestSize.Level1)
1142 {
1143 ScreenId screenId = 1;
1144 ScreenGamutMap gamutMap = {};
1145 DMError ret = absController_->SetScreenGamutMap(screenId, gamutMap);
1146
1147 ASSERT_EQ(ret, DMError::DM_ERROR_RENDER_SERVICE_FAILED);
1148 }
1149
1150 /**
1151 * @tc.name: SetScreenColorTransform
1152 * @tc.desc: SetScreenColorTransform test
1153 * @tc.type: FUNC
1154 */
1155 HWTEST_F(AbstractScreenControllerTest, SetScreenColorTransform, TestSize.Level1)
1156 {
1157 ScreenId screenId = 1;
1158 DMError ret = absController_->SetScreenColorTransform(screenId);
1159
1160 ASSERT_EQ(ret, DMError::DM_OK);
1161 }
1162
1163 /**
1164 * @tc.name: StopScreens
1165 * @tc.desc: StopScreens test
1166 * @tc.type: FUNC
1167 */
1168 HWTEST_F(AbstractScreenControllerTest, StopScreens, TestSize.Level1)
1169 {
1170 std::vector<ScreenId> screenIds = {7};
1171 ScreenCombination stopCombination = ScreenCombination::SCREEN_ALONE;
1172 DMError ret = absController_->StopScreens(screenIds, stopCombination);
1173 ASSERT_EQ(ret, DMError::DM_OK);
1174
1175 screenIds[0] = 2;
1176 ret = absController_->StopScreens(screenIds, stopCombination);
1177 ASSERT_EQ(ret, DMError::DM_OK);
1178
1179 absController_->dmsScreenMap_[2]->groupDmsId_=2;
1180 ret = absController_->StopScreens(screenIds, stopCombination);
1181 ASSERT_EQ(ret, DMError::DM_OK);
1182
1183 absController_->dmsScreenMap_[2]->groupDmsId_=5;
1184 ret = absController_->StopScreens(screenIds, stopCombination);
1185 ASSERT_EQ(ret, DMError::DM_OK);
1186
1187 absController_->dmsScreenMap_[2]->groupDmsId_=2;
1188 stopCombination = ScreenCombination::SCREEN_MIRROR;
1189 ret = absController_->StopScreens(screenIds, stopCombination);
1190 ASSERT_EQ(ret, DMError::DM_OK);
1191 }
1192
1193 /**
1194 * @tc.name: ChangeScreenGroup
1195 * @tc.desc: ChangeScreenGroup test
1196 * @tc.type: FUNC
1197 */
1198 HWTEST_F(AbstractScreenControllerTest, ChangeScreenGroup03, TestSize.Level1)
1199 {
1200 sptr<AbstractScreenGroup> group = screenGroupVec[0];
1201 Point point;
1202 group->screenMap_.insert(std::make_pair(0, screenVec[0]));
1203 group->screenMap_.insert(std::make_pair(1, screenVec[0]));
1204 std::vector<Point> startPoints;
1205 std::vector<ScreenId> screens;
1206 for (ScreenId i = 0; i < 7; ++i) {
1207 screens.emplace_back(i);
1208 startPoints.emplace_back(point);
1209 if (i < absController_->dmsScreenMap_.size() && absController_->dmsScreenMap_[i] != nullptr) {
1210 absController_->dmsScreenMap_[i]->groupDmsId_ = 1;
1211 }
1212 }
1213 absController_->abstractScreenCallback_ = nullptr;
1214 absController_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_ALONE);
1215 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
1216 }
1217
1218 /**
1219 * @tc.name: UpdateRSTree
1220 * @tc.desc: UpdateRSTree test
1221 * @tc.type: FUNC
1222 */
1223 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree06, TestSize.Level1)
1224 {
1225 ScreenId id = 1;
1226 ScreenId parentId = 2;
1227 std::shared_ptr<RSSurfaceNode> node = nullptr;
1228 RSDisplayNodeConfig config;
1229 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
1230 sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
1231 ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
1232 parentScreen->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
1233 absController_->UpdateRSTree(id, parentId, node, true, false);
1234 }
1235
1236 /**
1237 * @tc.name: SetScreenRotateAnimation
1238 * @tc.desc: SetScreenRotateAnimation test
1239 * @tc.type: FUNC
1240 */
1241 HWTEST_F(AbstractScreenControllerTest, SetScreenRotateAnimation04, TestSize.Level1)
1242 {
1243 RSDisplayNodeConfig config;
1244 absController_->dmsScreenMap_[1]->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
1245 sptr<AbstractScreen> screen = screenVec[0];
1246 screen->rotation_ = Rotation::ROTATION_0;
1247 absController_->SetScreenRotateAnimation(screen, 1, Rotation::ROTATION_270, false);
1248 ASSERT_EQ(Rotation::ROTATION_0, screen->rotation_);
1249 }
1250
1251 /**
1252 * @tc.name: SetRotation
1253 * @tc.desc: SetRotation test
1254 * @tc.type: FUNC
1255 */
1256 HWTEST_F(AbstractScreenControllerTest, SetRotation02, TestSize.Level1)
1257 {
1258 absController_->dmsScreenMap_[1]->rotation_ = Rotation::ROTATION_180;
1259 absController_->screenIdManager_.dms2RsScreenIdMap_.erase(1);
1260 ASSERT_EQ(true, absController_->SetRotation(1, Rotation::ROTATION_0, true));
1261 absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
1262 ASSERT_EQ(false, absController_->SetRotation(1, Rotation::ROTATION_0, false));
1263 ASSERT_EQ(false, absController_->SetRotation(1, Rotation::ROTATION_0, true));
1264 }
1265
1266 /**
1267 * @tc.name: InitVirtualScreen
1268 * @tc.desc: InitVirtualScreen test
1269 * @tc.type: FUNC
1270 */
1271 HWTEST_F(AbstractScreenControllerTest, InitVirtualScreen03, TestSize.Level1)
1272 {
1273 VirtualScreenOption option;
1274 sptr<AbstractScreen> defaultScreen = absController_->dmsScreenMap_[absController_->GetDefaultAbstractScreenId()];
1275 sptr<SupportedScreenModes> modes;
1276 if (defaultScreen != nullptr) {
1277 defaultScreen->modes_.emplace_back(modes);
1278 defaultScreen->activeIdx_ = 0;
1279 ASSERT_EQ(nullptr, defaultScreen->GetActiveScreenMode());
1280 sptr<AbstractScreen> screen = absController_->InitVirtualScreen(0, 0, option);
1281 ASSERT_EQ(ScreenType::VIRTUAL, screen->type_);
1282 }
1283 }
1284
1285 /**
1286 * @tc.name: MakeMirror
1287 * @tc.desc: MakeMirror test
1288 * @tc.type: FUNC
1289 */
1290 HWTEST_F(AbstractScreenControllerTest, MakeMirror06, TestSize.Level1)
1291 {
1292 std::vector<ScreenId> screens;
1293 absController_->dmsScreenMap_[2]->type_ = ScreenType::REAL;
1294 absController_->dmsScreenMap_[2]->groupDmsId_ = 5;
1295 absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
1296 ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(2, screens));
1297 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
1298 }
1299
1300 /**
1301 * @tc.name: SetVirtualScreenAsDefault
1302 * @tc.desc: SetVirtualScreenAsDefault test
1303 * @tc.type: FUNC
1304 */
1305 HWTEST_F(AbstractScreenControllerTest, SetVirtualScreenAsDefault, TestSize.Level1)
1306 {
1307 ScreenId screenId = 0;
1308 auto res = absController_->SetVirtualScreenAsDefault(screenId);
1309 EXPECT_FALSE(res);
1310 VirtualScreenOption option;
1311 sptr<IRemoteObject> displayManagerAgent = new IRemoteObjectMocker();
1312 auto virtualScreenId = absController_->CreateVirtualScreen(option, displayManagerAgent);
1313 res = absController_->SetVirtualScreenAsDefault(virtualScreenId);
1314 EXPECT_FALSE(res);
1315 }
1316 }
1317 } // namespace Rosen
1318 } // namespace OHOS
1319