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 * @tc.name: ProcessScreenDisconnected
94 * @tc.desc: ProcessScreenDisconnected test
95 * @tc.type: FUNC
96 */
97 HWTEST_F(AbstractScreenControllerTest, ProcessScreenDisconnected02, Function | SmallTest | Level3)
98 {
99 ScreenId rsId = 2;
100 ScreenId dmsId;
101 absController_->ProcessScreenDisconnected(rsId);
102 absController_->screenIdManager_.ConvertToDmsScreenId(rsId, dmsId);
103 absController_->dmsScreenMap_.erase(dmsId);
104 ASSERT_EQ(false, absController_->screenIdManager_.ConvertToDmsScreenId(rsId, dmsId));
105 ASSERT_EQ(absController_->dmsScreenMap_.end(), absController_->dmsScreenMap_.find(dmsId));
106 }
107 /**
108 * @tc.name: ProcessScreenDisconnected
109 * @tc.desc: ProcessScreenDisconnected test
110 * @tc.type: FUNC
111 */
112 HWTEST_F(AbstractScreenControllerTest, ProcessScreenDisconnected03, Function | SmallTest | Level3)
113 {
114 ScreenId rsId = 2;
115 ScreenId dmsId;
116 absController_->abstractScreenCallback_ = nullptr;
117 absController_->ProcessScreenDisconnected(rsId);
118 ASSERT_EQ(false, absController_->screenIdManager_.ConvertToDmsScreenId(rsId, dmsId));
119 ASSERT_NE(absController_->dmsScreenMap_.end(), absController_->dmsScreenMap_.find(dmsId));
120 }
121 /**
122 * @tc.name: SetScreenRotateAnimation
123 * @tc.desc: SetScreenRotateAnimation test
124 * @tc.type: FUNC
125 */
126 HWTEST_F(AbstractScreenControllerTest, SetScreenRotateAnimation01, Function | SmallTest | Level3)
127 {
128 RSDisplayNodeConfig config;
129 absController_->dmsScreenMap_[1]->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
130 sptr<AbstractScreen> screen = screenVec[0];
131 screen->rotation_ = Rotation::ROTATION_270;
132 absController_->SetScreenRotateAnimation(screen, 1, Rotation::ROTATION_0, true);
133 ASSERT_EQ(Rotation::ROTATION_270, screen->rotation_);
134 }
135 /**
136 * @tc.name: SetScreenRotateAnimation
137 * @tc.desc: SetScreenRotateAnimation test
138 * @tc.type: FUNC
139 */
140 HWTEST_F(AbstractScreenControllerTest, SetScreenRotateAnimation02, Function | SmallTest | Level3)
141 {
142 RSDisplayNodeConfig config;
143 absController_->dmsScreenMap_[1]->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
144 sptr<AbstractScreen> screen = screenVec[0];
145 screen->rotation_ = Rotation::ROTATION_0;
146 absController_->SetScreenRotateAnimation(screen, 1, Rotation::ROTATION_270, true);
147 ASSERT_EQ(Rotation::ROTATION_0, screen->rotation_);
148 }
149 /**
150 * @tc.name: SetScreenRotateAnimation
151 * @tc.desc: SetScreenRotateAnimation test
152 * @tc.type: FUNC
153 */
154 HWTEST_F(AbstractScreenControllerTest, SetScreenRotateAnimation03, Function | SmallTest | Level3)
155 {
156 RSDisplayNodeConfig config;
157 absController_->dmsScreenMap_[1]->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
158 sptr<AbstractScreen> screen = screenVec[0];
159 screen->rotation_ = Rotation::ROTATION_0;
160 absController_->SetScreenRotateAnimation(screen, 1, Rotation::ROTATION_270, false);
161 ASSERT_EQ(Rotation::ROTATION_0, screen->rotation_);
162 }
163 /**
164 * @tc.name: MakeMirror
165 * @tc.desc: MakeMirror test
166 * @tc.type: FUNC
167 */
168 HWTEST_F(AbstractScreenControllerTest, MakeMirror01, Function | SmallTest | Level3)
169 {
170 std::vector<ScreenId> screens;
171 ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(5, screens));
172 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
173 }
174 /**
175 * @tc.name: MakeMirror
176 * @tc.desc: MakeMirror test
177 * @tc.type: FUNC
178 */
179 HWTEST_F(AbstractScreenControllerTest, MakeMirror02, Function | SmallTest | Level3)
180 {
181 std::vector<ScreenId> screens;
182 absController_->dmsScreenMap_[2]->type_ = ScreenType::UNDEFINED;
183 ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(2, screens));
184 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
185 }
186 /**
187 * @tc.name: MakeMirror
188 * @tc.desc: MakeMirror test
189 * @tc.type: FUNC
190 */
191 HWTEST_F(AbstractScreenControllerTest, MakeMirror03, Function | SmallTest | Level3)
192 {
193 std::vector<ScreenId> screens;
194 absController_->dmsScreenMap_[2]->type_ = ScreenType::REAL;
195 absController_->dmsScreenMap_[2]->groupDmsId_ = 5;
196 absController_->abstractScreenCallback_ = nullptr;
197 ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(2, screens));
198 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
199 }
200 /**
201 * @tc.name: MakeMirror
202 * @tc.desc: MakeMirror test
203 * @tc.type: FUNC
204 */
205 HWTEST_F(AbstractScreenControllerTest, MakeMirror04, Function | SmallTest | Level3)
206 {
207 std::vector<ScreenId> screens;
208 absController_->dmsScreenMap_[2]->type_ = ScreenType::REAL;
209 absController_->dmsScreenMap_[2]->groupDmsId_ = 5;
210 absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
211 ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(2, screens));
212 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
213 }
214 /**
215 * @tc.name: MakeMirror
216 * @tc.desc: MakeMirror test
217 * @tc.type: FUNC
218 */
219 HWTEST_F(AbstractScreenControllerTest, MakeMirror05, Function | SmallTest | Level3)
220 {
221 std::vector<ScreenId> screens;
222 absController_->dmsScreenMap_[2]->type_ = ScreenType::REAL;
223 absController_->dmsScreenMap_[2]->groupDmsId_ = 2;
224 absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
225 ASSERT_TRUE(DMError::DM_OK == absController_->MakeMirror(2, screens));
226 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
227 }
228 /**
229 * @tc.name: ProcessScreenConnected
230 * @tc.desc: ProcessScreenConnected test
231 * @tc.type: FUNC
232 */
233 HWTEST_F(AbstractScreenControllerTest, ProcessScreenConnected01, Function | SmallTest | Level3)
234 {
235 ScreenId id = 0;
236 absController_->ProcessScreenConnected(id);
237 ASSERT_EQ(true, absController_->screenIdManager_.HasRsScreenId(id));
238 }
239 /**
240 * @tc.name: OnRsScreenConnectionChange
241 * @tc.desc: OnRsScreenConnectionChange test
242 * @tc.type: FUNC
243 */
244 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange01, Function | SmallTest | Level3)
245 {
246 ScreenEvent event = ScreenEvent::UNKNOWN;
247 ScreenId rsScreenId = 100;
248 absController_->OnRsScreenConnectionChange(rsScreenId, event);
249 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
250 }
251 /**
252 * @tc.name: OnRsScreenConnectionChange
253 * @tc.desc: OnRsScreenConnectionChange test
254 * @tc.type: FUNC
255 */
256 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange02, Function | SmallTest | Level3)
257 {
258 ScreenEvent event = ScreenEvent::UNKNOWN;
259 ScreenId rsScreenId = 1;
260 absController_->OnRsScreenConnectionChange(rsScreenId, event);
261 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
262 }
263 /**
264 * @tc.name: OnRsScreenConnectionChange
265 * @tc.desc: OnRsScreenConnectionChange test
266 * @tc.type: FUNC
267 */
268 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange03, Function | SmallTest | Level3)
269 {
270 ScreenEvent event = ScreenEvent::CONNECTED;
271 ScreenId rsScreenId = 1;
272 absController_->OnRsScreenConnectionChange(rsScreenId, event);
273 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
274 }
275 /**
276 * @tc.name: OnRsScreenConnectionChange
277 * @tc.desc: OnRsScreenConnectionChange test
278 * @tc.type: FUNC
279 */
280 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange04, Function | SmallTest | Level3)
281 {
282 ScreenEvent event = ScreenEvent::DISCONNECTED;
283 ScreenId rsScreenId = 1;
284 absController_->OnRsScreenConnectionChange(rsScreenId, event);
285 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
286 }
287 /**
288 * @tc.name: GetAllValidScreenIds
289 * @tc.desc: GetAllValidScreenIds test
290 * @tc.type: FUNC
291 */
292 HWTEST_F(AbstractScreenControllerTest, GetAllValidScreenIds, Function | SmallTest | Level3)
293 {
294 std::vector<ScreenId> screenIds {0, 1, 1, 2, 2, 3, 4};
295 std::vector<ScreenId> valid {0, 1, 2, 3};
296 ASSERT_EQ(valid, absController_->GetAllValidScreenIds(screenIds));
297 }
298 /**
299 * @tc.name: GetRSDisplayNodeByScreenId
300 * @tc.desc: GetRSDisplayNodeByScreenId test
301 * @tc.type: FUNC
302 */
303 HWTEST_F(AbstractScreenControllerTest, GetRSDisplayNodeByScreenId, Function | SmallTest | Level3)
304 {
305 ScreenId id = 6;
306 std::shared_ptr<RSDisplayNode> node = nullptr;
307 ASSERT_EQ(node, absController_->GetRSDisplayNodeByScreenId(id));
308 }
309 /**
310 * @tc.name: UpdateRSTree
311 * @tc.desc: UpdateRSTree test
312 * @tc.type: FUNC
313 */
314 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree01, Function | SmallTest | Level3)
315 {
316 ScreenId id = 8;
317 std::shared_ptr<RSSurfaceNode> node = nullptr;
318 absController_->UpdateRSTree(id, id, node, true, true);
319 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(id));
320 }
321 /**
322 * @tc.name: UpdateRSTree
323 * @tc.desc: UpdateRSTree test
324 * @tc.type: FUNC
325 */
326 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree02, Function | SmallTest | Level3)
327 {
328 ScreenId id = 1;
329 ScreenId parentId = 8;
330 std::shared_ptr<RSSurfaceNode> node = nullptr;
331 absController_->UpdateRSTree(id, parentId, node, true, true);
332 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
333 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(parentId));
334 }
335 /**
336 * @tc.name: UpdateRSTree
337 * @tc.desc: UpdateRSTree test
338 * @tc.type: FUNC
339 */
340 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree03, Function | SmallTest | Level3)
341 {
342 ScreenId id = 1;
343 ScreenId parentId = 2;
344 std::shared_ptr<RSSurfaceNode> node = nullptr;
345 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
346 sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
347 ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
348 parentScreen->rsDisplayNode_ = nullptr;
349 absController_->UpdateRSTree(id, parentId, node, true, true);
350 }
351 /**
352 * @tc.name: UpdateRSTree
353 * @tc.desc: UpdateRSTree test
354 * @tc.type: FUNC
355 */
356 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree04, Function | SmallTest | Level3)
357 {
358 ScreenId id = 1;
359 ScreenId parentId = 2;
360 std::shared_ptr<RSSurfaceNode> node = nullptr;
361 RSDisplayNodeConfig config;
362 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
363 sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
364 ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
365 parentScreen->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);;
366 absController_->UpdateRSTree(id, parentId, node, true, true);
367 }
368 /**
369 * @tc.name: UpdateRSTree
370 * @tc.desc: UpdateRSTree test
371 * @tc.type: FUNC
372 */
373 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree05, Function | SmallTest | Level3)
374 {
375 ScreenId id = 1;
376 ScreenId parentId = 2;
377 std::shared_ptr<RSSurfaceNode> node = nullptr;
378 RSDisplayNodeConfig config;
379 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
380 sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
381 ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
382 parentScreen->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);;
383 absController_->UpdateRSTree(id, parentId, node, true, false);
384 }
385 /**
386 * @tc.name: RegisterAbstractScreenCallback
387 * @tc.desc: RegisterAbstractScreenCallback test
388 * @tc.type: FUNC
389 */
390 HWTEST_F(AbstractScreenControllerTest, RegisterAbstractScreenCallback, Function | SmallTest | Level3)
391 {
392 sptr<AbstractScreenController::AbstractScreenCallback> cb = nullptr;
393 absController_->RegisterAbstractScreenCallback(cb);
394 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
395 }
396 /**
397 * @tc.name: AddToGroupLocked
398 * @tc.desc: AddToGroupLocked test
399 * @tc.type: FUNC
400 */
401 HWTEST_F(AbstractScreenControllerTest, AddToGroupLocked, Function | SmallTest | Level3)
402 {
403 ASSERT_EQ(false, absController_->dmsScreenGroupMap_.empty());
404 ASSERT_EQ(nullptr, absController_->AddToGroupLocked(screenVec[0]));
405 }
406 /**
407 * @tc.name: RemoveFromGroupLocked
408 * @tc.desc: RemoveFromGroupLocked test
409 * @tc.type: FUNC
410 */
411 HWTEST_F(AbstractScreenControllerTest, RemoveFromGroupLocked01, Function | SmallTest | Level3)
412 {
413 sptr<AbstractScreen> screen = screenVec[0];
414 screen->groupDmsId_ = 0;
415 ASSERT_EQ(nullptr, absController_->RemoveFromGroupLocked(screen));
416 }
417 /**
418 * @tc.name: RemoveChildFromGroup
419 * @tc.desc: RemoveChildFromGroup test
420 * @tc.type: FUNC
421 */
422 HWTEST_F(AbstractScreenControllerTest, RemoveChildFromGroup01, Function | SmallTest | Level3)
423 {
424 sptr<AbstractScreen> screen = screenVec[0];
425 ScreenId dmsId = screen->dmsId_;
426 Point point;
427 auto p = std::make_pair(screen, point);
428 sptr<AbstractScreenGroup> screenGroup = absController_->dmsScreenGroupMap_[0];
429 screenGroup->abstractScreenMap_.insert(std::make_pair(dmsId, p));
430 ASSERT_EQ(true, absController_->RemoveChildFromGroup(screen, screenGroup));
431 }
432 /**
433 * @tc.name: AddAsSuccedentScreenLocked
434 * @tc.desc: AddAsSuccedentScreenLocked test
435 * @tc.type: FUNC
436 */
437 HWTEST_F(AbstractScreenControllerTest, AddAsSuccedentScreenLocked01, Function | SmallTest | Level3)
438 {
439 sptr<AbstractScreen> screen = screenVec[0];
440 absController_->dmsScreenMap_.erase(absController_->GetDefaultAbstractScreenId());
441 ASSERT_EQ(nullptr, absController_->AddAsSuccedentScreenLocked(screen));
442 }
443 /**
444 * @tc.name: AddAsSuccedentScreenLocked
445 * @tc.desc: AddAsSuccedentScreenLocked test
446 * @tc.type: FUNC
447 */
448 HWTEST_F(AbstractScreenControllerTest, AddAsSuccedentScreenLocked02, Function | SmallTest | Level3)
449 {
450 sptr<AbstractScreen> screen = screenVec[0];
451 ASSERT_EQ(nullptr, absController_->AddAsSuccedentScreenLocked(screen));
452 }
453 /**
454 * @tc.name: CreateVirtualScreen
455 * @tc.desc: CreateVirtualScreen test
456 * @tc.type: FUNC
457 */
458 HWTEST_F(AbstractScreenControllerTest, CreateVirtualScreen01, Function | SmallTest | Level3)
459 {
460 VirtualScreenOption option;
461 sptr<IRemoteObject> displayManagerAgent = new IRemoteObjectMocker();
462 auto ret = absController_->CreateVirtualScreen(option, displayManagerAgent);
463 if (ret != 0)
464 {
465 ASSERT_NE(0, ret);
466 }
467 }
468
469 /**
470 * @tc.name: InitVirtualScreen
471 * @tc.desc: InitVirtualScreen test
472 * @tc.type: FUNC
473 */
474 HWTEST_F(AbstractScreenControllerTest, InitVirtualScreen01, Function | SmallTest | Level3)
475 {
476 VirtualScreenOption option;
477 absController_->dmsScreenMap_.erase(absController_->GetDefaultAbstractScreenId());
478 sptr<AbstractScreen> screen = absController_->InitVirtualScreen(0, 0, option);
479 auto ret = screen->activeIdx_;
480 if (ret != 0) {
481 ASSERT_NE(0, ret);
482 }
483 }
484
485 /**
486 * @tc.name: InitVirtualScreen
487 * @tc.desc: InitVirtualScreen test
488 * @tc.type: FUNC
489 */
490 HWTEST_F(AbstractScreenControllerTest, InitVirtualScreen02, Function | SmallTest | Level3)
491 {
492 VirtualScreenOption option;
493 sptr<AbstractScreen> defaultScreen = absController_->dmsScreenMap_[absController_->GetDefaultAbstractScreenId()];
494 sptr<SupportedScreenModes> modes;
495 if (defaultScreen != nullptr) {
496 defaultScreen->modes_.emplace_back(modes);
497 defaultScreen->activeIdx_ = 0;
498 ASSERT_EQ(nullptr, defaultScreen->GetActiveScreenMode());
499 sptr<AbstractScreen> screen = absController_->InitVirtualScreen(0, 0, option);
500 ASSERT_EQ(ScreenType::VIRTUAL, screen->type_);
501 }
502 }
503
504 /**
505 * @tc.name: DestroyVirtualScreen
506 * @tc.desc: DestroyVirtualScreen test
507 * @tc.type: FUNC
508 */
509 HWTEST_F(AbstractScreenControllerTest, DestroyVirtualScreen01, Function | SmallTest | Level3)
510 {
511 ScreenId id = 5;
512 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, absController_->DestroyVirtualScreen(id));
513 }
514 /**
515 * @tc.name: DestroyVirtualScreen
516 * @tc.desc: DestroyVirtualScreen test
517 * @tc.type: FUNC
518 */
519 HWTEST_F(AbstractScreenControllerTest, DestroyVirtualScreen02, Function | SmallTest | Level3)
520 {
521 ScreenId id = 1;
522 ASSERT_EQ(DMError::DM_OK, absController_->DestroyVirtualScreen(id));
523 }
524 /**
525 * @tc.name: SetVirtualScreenSurface
526 * @tc.desc: SetVirtualScreenSurface test
527 * @tc.type: FUNC
528 */
529 HWTEST_F(AbstractScreenControllerTest, SetVirtualScreenSurface01, Function | SmallTest | Level3)
530 {
531 ScreenId id = 6;
532 sptr<Surface> surface = nullptr;
533 ASSERT_EQ(DMError::DM_ERROR_RENDER_SERVICE_FAILED, absController_->SetVirtualScreenSurface(id, surface));
534 }
535 /**
536 * @tc.name: SetBuildInDefaultOrientation
537 * @tc.desc: SetBuildInDefaultOrientation test
538 * @tc.type: FUNC
539 */
540 HWTEST_F(AbstractScreenControllerTest, SetBuildInDefaultOrientation, Function | SmallTest | Level3)
541 {
542 Orientation orientation = Orientation::BEGIN;
543 absController_->SetBuildInDefaultOrientation(orientation);
544 ASSERT_EQ(orientation, absController_->buildInDefaultOrientation_);
545 }
546 /**
547 * @tc.name: SetOrientation
548 * @tc.desc: SetOrientation test
549 * @tc.type: FUNC
550 */
551 HWTEST_F(AbstractScreenControllerTest, SetOrientation01, Function | SmallTest | Level3)
552 {
553 absController_->dmsScreenMap_[1]->isScreenGroup_ = true;
554 Orientation orientation = Orientation::BEGIN;
555 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, absController_->SetOrientation(1, orientation, true));
556 }
557 /**
558 * @tc.name: SetRotation
559 * @tc.desc: SetRotation test
560 * @tc.type: FUNC
561 */
562 HWTEST_F(AbstractScreenControllerTest, SetRotation01, Function | SmallTest | Level3)
563 {
564 absController_->dmsScreenMap_[1]->rotation_ = Rotation::ROTATION_180;
565 absController_->screenIdManager_.dms2RsScreenIdMap_.erase(1);
566 ASSERT_EQ(true, absController_->SetRotation(1, Rotation::ROTATION_0, true));
567 absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
568 ASSERT_EQ(false, absController_->SetRotation(1, Rotation::ROTATION_0, false));
569 ASSERT_EQ(false, absController_->SetRotation(1, Rotation::ROTATION_0, true));
570 }
571 /**
572 * @tc.name: SetScreenActiveMode
573 * @tc.desc: SetScreenActiveMode test
574 * @tc.type: FUNC
575 */
576 HWTEST_F(AbstractScreenControllerTest, SetScreenActiveMode01, Function | SmallTest | Level3)
577 {
578 ASSERT_TRUE(DMError::DM_OK != absController_->SetScreenActiveMode(5, 0));
579 }
580 /**
581 * @tc.name: SetScreenActiveMode
582 * @tc.desc: SetScreenActiveMode test
583 * @tc.type: FUNC
584 */
585 HWTEST_F(AbstractScreenControllerTest, SetScreenActiveMode02, Function | SmallTest | Level3)
586 {
587 absController_->screenIdManager_.dms2RsScreenIdMap_.erase(1);
588 ASSERT_TRUE(DMError::DM_OK != absController_->SetScreenActiveMode(1, 0));
589 }
590 /**
591 * @tc.name: ProcessScreenModeChanged
592 * @tc.desc: ProcessScreenModeChanged test
593 * @tc.type: FUNC
594 */
595 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged01, Function | SmallTest | Level3)
596 {
597 absController_->ProcessScreenModeChanged(7);
598 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
599 }
600 /**
601 * @tc.name: ProcessScreenModeChanged
602 * @tc.desc: ProcessScreenModeChanged test
603 * @tc.type: FUNC
604 */
605 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged02, Function | SmallTest | Level3)
606 {
607 absController_->ProcessScreenModeChanged(5);
608 ASSERT_EQ(nullptr, absController_->dmsScreenMap_[5]);
609 }
610 /**
611 * @tc.name: ProcessScreenModeChanged
612 * @tc.desc: ProcessScreenModeChanged test
613 * @tc.type: FUNC
614 */
615 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged03, Function | SmallTest | Level3)
616 {
617 absController_->ProcessScreenModeChanged(2);
618 ASSERT_NE(nullptr, absController_->dmsScreenMap_[2]);
619 }
620 /**
621 * @tc.name: ProcessScreenModeChanged
622 * @tc.desc: ProcessScreenModeChanged test
623 * @tc.type: FUNC
624 */
625 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged04, Function | SmallTest | Level3)
626 {
627 sptr<AbstractScreen> screen = absController_->GetAbstractScreen(2);
628 screen->activeIdx_ = 0;
629 absController_->abstractScreenCallback_ = nullptr;
630 absController_->ProcessScreenModeChanged(2);
631 ASSERT_NE(nullptr, absController_->dmsScreenMap_[2]);
632 }
633 /**
634 * @tc.name: ProcessScreenModeChanged
635 * @tc.desc: ProcessScreenModeChanged test
636 * @tc.type: FUNC
637 */
638 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged05, Function | SmallTest | Level3)
639 {
640 sptr<AbstractScreen> screen = absController_->GetAbstractScreen(2);
641 screen->activeIdx_ = 0;
642 absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
643 absController_->ProcessScreenModeChanged(2);
644 ASSERT_NE(nullptr, absController_->dmsScreenMap_[2]);
645 }
646 /**
647 * @tc.name: ChangeScreenGroup
648 * @tc.desc: ChangeScreenGroup test
649 * @tc.type: FUNC
650 */
651 HWTEST_F(AbstractScreenControllerTest, ChangeScreenGroup01, Function | SmallTest | Level3)
652 {
653 sptr<AbstractScreenGroup> group = screenGroupVec[0];
654 Point point;
655 auto abs2pointPair = std::make_pair(screenVec[0], point);
656 group->abstractScreenMap_.insert(std::make_pair(0, abs2pointPair));
657 group->abstractScreenMap_.insert(std::make_pair(1, abs2pointPair));
658 std::vector<Point> startPoints;
659 std::vector<ScreenId> screens;
660 for (ScreenId i = 0; i < 7; ++i) {
661 screens.emplace_back(i);
662 startPoints.emplace_back(point);
663 if (i < absController_->dmsScreenMap_.size() && absController_->dmsScreenMap_[i] != nullptr) {
664 absController_->dmsScreenMap_[i]->groupDmsId_ = 1;
665 }
666 }
667 absController_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_ALONE);
668 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
669 }
670 /**
671 * @tc.name: ChangeScreenGroup
672 * @tc.desc: ChangeScreenGroup test
673 * @tc.type: FUNC
674 */
675 HWTEST_F(AbstractScreenControllerTest, ChangeScreenGroup02, Function | SmallTest | Level3)
676 {
677 sptr<AbstractScreenGroup> group = screenGroupVec[0];
678 Point point;
679 auto abs2pointPair = std::make_pair(screenVec[0], point);
680 group->abstractScreenMap_.insert(std::make_pair(0, abs2pointPair));
681 group->abstractScreenMap_.insert(std::make_pair(1, abs2pointPair));
682 std::vector<Point> startPoints;
683 std::vector<ScreenId> screens;
684 for (ScreenId i = 0; i < 7; ++i) {
685 screens.emplace_back(i);
686 startPoints.emplace_back(point);
687 if (i < absController_->dmsScreenMap_.size() && absController_->dmsScreenMap_[i] != nullptr) {
688 absController_->dmsScreenMap_[i]->groupDmsId_ = 1;
689 }
690 }
691 absController_->abstractScreenCallback_ = nullptr;
692 absController_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_ALONE);
693 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
694 }
695 /**
696 * @tc.name: ChangeScreenGroup
697 * @tc.desc: ChangeScreenGroup test
698 * @tc.type: FUNC
699 */
700 HWTEST_F(AbstractScreenControllerTest, AddScreenToGroup01, Function | SmallTest | Level3)
701 {
702 sptr<AbstractScreenGroup> group = screenGroupVec[0];
703 std::vector<ScreenId> addScreens {0, 1, 2, 3, 4, 5};
704 Point point;
705 std::vector<Point> addChildPos(10, point);
706 std::map<ScreenId, bool> removeChildResMap;
707 absController_->AddScreenToGroup(group, addScreens, addChildPos, removeChildResMap);
708 absController_->abstractScreenCallback_ = nullptr;
709 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
710 }
711
712 /**
713 * @tc.name: MakeExpand
714 * @tc.desc: MakeExpand test
715 * @tc.type: FUNC
716 */
717 HWTEST_F(AbstractScreenControllerTest, MakeExpand01, Function | SmallTest | Level3)
718 {
719 std::vector<ScreenId> screenIds;
720 std::vector<Point> startPoints;
721 ScreenId defaultId = absController_->GetDefaultAbstractScreenId();
722 absController_->dmsScreenMap_[defaultId] = nullptr;
723 ASSERT_EQ(false, absController_->MakeExpand(screenIds, startPoints));
724 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screenIds, ScreenCombination::SCREEN_EXPAND));
725 }
726
727 /**
728 * @tc.name: MakeExpand
729 * @tc.desc: MakeExpand test
730 * @tc.type: FUNC
731 */
732 HWTEST_F(AbstractScreenControllerTest, MakeExpand02, Function | SmallTest | Level3)
733 {
734 std::vector<ScreenId> screenIds;
735 std::vector<Point> startPoints;
736 ScreenId defaultId = absController_->GetDefaultAbstractScreenId();
737 auto defaultScreen = absController_->GetAbstractScreen(defaultId);
738 if (defaultScreen != nullptr)
739 {
740 ScreenId groupDmsId = defaultScreen->groupDmsId_;
741 absController_->dmsScreenGroupMap_[groupDmsId] = nullptr;
742 ASSERT_EQ(false, absController_->MakeExpand(screenIds, startPoints));
743 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screenIds, ScreenCombination::SCREEN_EXPAND));
744 }
745 }
746
747 /**
748 * @tc.name: RemoveVirtualScreenFromGroup
749 * @tc.desc: RemoveVirtualScreenFromGroup test
750 * @tc.type: FUNC
751 */
752 HWTEST_F(AbstractScreenControllerTest, RemoveVirtualScreenFromGroup01, Function | SmallTest | Level3)
753 {
754 std::vector<ScreenId> screens {0, 1, 2, 3, 4, 5, 6, 7};
755 absController_->abstractScreenCallback_ = nullptr;
756 absController_->RemoveVirtualScreenFromGroup(screens);
757 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
758 }
759
760 /**
761 * @tc.name: OnRemoteDied
762 * @tc.desc: OnRemoteDied test
763 * @tc.type: FUNC
764 */
765 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied01, Function | SmallTest | Level3)
766 {
767 sptr<IRemoteObject> agent = nullptr;
768 ASSERT_EQ(false, absController_->OnRemoteDied(agent));
769 }
770
771 /**
772 * @tc.name: OnRemoteDied
773 * @tc.desc: OnRemoteDied test
774 * @tc.type: FUNC
775 */
776 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied02, Function | SmallTest | Level3)
777 {
778 sptr<IRemoteObject> agent = new IRemoteObjectMocker();
779 ASSERT_EQ(true, absController_->OnRemoteDied(agent));
780 }
781
782 /**
783 * @tc.name: OnRemoteDied
784 * @tc.desc: OnRemoteDied test
785 * @tc.type: FUNC
786 */
787 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied03, Function | SmallTest | Level3)
788 {
789 sptr<IRemoteObject> agent = new IRemoteObjectMocker();
790 std::vector<ScreenId> screens {5};
791 absController_->screenAgentMap_.insert(std::make_pair(agent, screens));
792 ASSERT_EQ(true, absController_->OnRemoteDied(agent));
793 ASSERT_EQ(0, absController_->screenAgentMap_.size());
794 }
795
796 /**
797 * @tc.name: CreateAndGetNewScreenId
798 * @tc.desc: CreateAndGetNewScreenId test
799 * @tc.type: FUNC
800 */
801 HWTEST_F(AbstractScreenControllerTest, CreateAndGetNewScreenId01, Function | SmallTest | Level3)
802 {
803 ScreenId rsScreenId = 1;
804 ScreenId dmsScreenId = absController_->screenIdManager_.dmsScreenCount_;
805 ASSERT_EQ(dmsScreenId, absController_->screenIdManager_.CreateAndGetNewScreenId(rsScreenId));
806 ASSERT_EQ(++dmsScreenId, absController_->screenIdManager_.dmsScreenCount_);
807 }
808
809 /**
810 * @tc.name: ConvertToRsScreenId
811 * @tc.desc: ConvertToRsScreenId test
812 * @tc.type: FUNC
813 */
814 HWTEST_F(AbstractScreenControllerTest, ConvertToRsScreenId01, Function | SmallTest | Level3)
815 {
816 ScreenId rsScreenId;
817 ScreenId dmsScreenId = 8;
818 ASSERT_EQ(false, absController_->screenIdManager_.ConvertToRsScreenId(dmsScreenId, rsScreenId));
819 }
820
821 /**
822 * @tc.name: NotifyScreenConnected
823 * @tc.desc: NotifyScreenConnected test
824 * @tc.type: FUNC
825 */
826 HWTEST_F(AbstractScreenControllerTest, NotifyScreenConnected, Function | SmallTest | Level3)
827 {
828 sptr<ScreenInfo> screenInfo = nullptr;
829 absController_->NotifyScreenConnected(screenInfo);
830 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
831 }
832
833 /**
834 * @tc.name: NotifyScreenConnected
835 * @tc.desc: NotifyScreenConnected test
836 * @tc.type: FUNC
837 */
838 HWTEST_F(AbstractScreenControllerTest, NotifyScreenChanged, Function | SmallTest | Level3)
839 {
840 sptr<ScreenInfo> screenInfo = nullptr;
841 absController_->NotifyScreenChanged(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
842 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
843 }
844
845 /**
846 * @tc.name: NotifyScreenConnected
847 * @tc.desc: NotifyScreenConnected test
848 * @tc.type: FUNC
849 */
850 HWTEST_F(AbstractScreenControllerTest, NotifyScreenGroupChanged, Function | SmallTest | Level3)
851 {
852 sptr<ScreenInfo> screenInfo = nullptr;
853 absController_->NotifyScreenGroupChanged(screenInfo, ScreenGroupChangeEvent::ADD_TO_GROUP);
854 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
855 }
856
857 /**
858 * @tc.name: NotifyScreenConnected
859 * @tc.desc: NotifyScreenConnected test
860 * @tc.type: FUNC
861 */
862 HWTEST_F(AbstractScreenControllerTest, SetScreenPowerForAll, Function | SmallTest | Level3)
863 {
864 for (uint32_t i = 0; i < screenVec.size(); ++i) {
865 if (screenVec[i] != nullptr && screenVec[i]->type_ == ScreenType::REAL) {
866 screenVec[i]->type_ = ScreenType::UNDEFINED;
867 }
868 }
869 ASSERT_EQ(false, absController_->SetScreenPowerForAll(ScreenPowerState::INVALID_STATE,
870 PowerStateChangeReason::POWER_BUTTON));
871 }
872 /**
873 * @tc.name: SetVirtualPixelRatio
874 * @tc.desc: SetVirtualPixelRatio test
875 * @tc.type: FUNC
876 */
877 HWTEST_F(AbstractScreenControllerTest, SetVirtualPixelRatio01, Function | SmallTest | Level3)
878 {
879 auto screen = screenVec[0];
880 ScreenId id = 0;
881 float ratio = 1.0;
882 screen->isScreenGroup_ = true;
883 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, absController_->SetVirtualPixelRatio(id, ratio));
884 }
885 /**
886 * @tc.name: SetVirtualPixelRatio
887 * @tc.desc: SetVirtualPixelRatio test
888 * @tc.type: FUNC
889 */
890 HWTEST_F(AbstractScreenControllerTest, SetVirtualPixelRatio02, Function | SmallTest | Level3)
891 {
892 ScreenId id = 0;
893 float ratio = 1.0;
894 absController_->abstractScreenCallback_ = nullptr;
895 ASSERT_EQ(DMError::DM_OK, absController_->SetVirtualPixelRatio(id, ratio));
896 }
897 /**
898 * @tc.name: RegisterRsScreenConnectionChangeListener
899 * @tc.desc: RegisterRsScreenConnectionChangeListener test
900 * @tc.type: FUNC
901 */
902 HWTEST_F(AbstractScreenControllerTest, RegisterRsScreenConnectionChangeListener, Function | SmallTest | Level3)
903 {
904 sptr<IRemoteObject> agent = new IRemoteObjectMocker();
905 absController_->Init();
906 ASSERT_EQ(true, absController_->OnRemoteDied(agent));
907 agent.clear();
908 }
909 /**
910 * @tc.name: RemoveSurfaceNodeFromScreen
911 * @tc.desc: RemoveSurfaceNodeFromScreen test
912 * @tc.type: FUNC
913 */
914 HWTEST_F(AbstractScreenControllerTest, RemoveSurfaceNodeFromScreen, Function | SmallTest | Level3)
915 {
916 ScreenId dmsScreenId = 8;
917 std::shared_ptr<RSSurfaceNode> surfaceNode = nullptr;
918 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, absController_->RemoveSurfaceNodeFromScreen(dmsScreenId, surfaceNode));
919 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(dmsScreenId));
920 }
921 /**
922 * @tc.name: ProcessDefaultScreenReconnected
923 * @tc.desc: ProcessDefaultScreenReconnected test
924 * @tc.type: FUNC
925 */
926 HWTEST_F(AbstractScreenControllerTest, ProcessDefaultScreenReconnected01, Function | SmallTest | Level3)
927 {
928 ScreenId rsScreenId = 8;
929 absController_->ProcessDefaultScreenReconnected(rsScreenId);
930 absController_->defaultRsScreenId_ = 8;
931 rsScreenId = 1;
932 absController_->ProcessDefaultScreenReconnected(rsScreenId);
933 rsScreenId = 8;
934 absController_->ProcessDefaultScreenReconnected(rsScreenId);
935 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(rsScreenId));
936 }
937 /**
938 * @tc.name: ProcessDefaultScreenReconnected
939 * @tc.desc: ProcessDefaultScreenReconnected test
940 * @tc.type: FUNC
941 */
942 HWTEST_F(AbstractScreenControllerTest, ProcessDefaultScreenReconnected02, Function | SmallTest | Level3)
943 {
944 ScreenId rsScreenId = 8;
945 absController_->defaultRsScreenId_ = 8;
946 absController_->ProcessDefaultScreenReconnected(rsScreenId);
947 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(rsScreenId));
948 rsScreenId = 5;
949 absController_->defaultRsScreenId_ = 5;
950 absController_->ProcessDefaultScreenReconnected(rsScreenId);
951 rsScreenId = 1;
952 absController_->defaultRsScreenId_ = 1;
953 absController_->ProcessDefaultScreenReconnected(rsScreenId);
954 }
955
956 /**
957 * @tc.name: ConvertToRsScreenId
958 * @tc.desc: ConvertToRsScreenId test
959 * @tc.type: FUNC
960 */
961 HWTEST_F(AbstractScreenControllerTest, ConvertToRsScreenId, Function | SmallTest | Level3)
962 {
963 ScreenId dmsScreenId = 6;
964 ASSERT_TRUE(absController_->screenIdManager_.ConvertToRsScreenId(dmsScreenId));
965 }
966
967 /**
968 * @tc.name: ConvertToDmsScreenId
969 * @tc.desc: ConvertToDmsScreenId test
970 * @tc.type: FUNC
971 */
972 HWTEST_F(AbstractScreenControllerTest, ConvertToDmsScreenId, Function | SmallTest | Level3)
973 {
974 ScreenId rsScreenId = 7;
975 ASSERT_TRUE(absController_->screenIdManager_.ConvertToDmsScreenId(rsScreenId));
976 }
977 }
978 } // namespace Rosen
979 } // namespace OHOS
980