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