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: MakeMirror
137 * @tc.desc: MakeMirror test
138 * @tc.type: FUNC
139 */
140 HWTEST_F(AbstractScreenControllerTest, MakeMirror01, Function | SmallTest | Level3)
141 {
142 std::vector<ScreenId> screens;
143 ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(5, screens));
144 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
145 }
146 /**
147 * @tc.name: MakeMirror
148 * @tc.desc: MakeMirror test
149 * @tc.type: FUNC
150 */
151 HWTEST_F(AbstractScreenControllerTest, MakeMirror02, Function | SmallTest | Level3)
152 {
153 std::vector<ScreenId> screens;
154 absController_->dmsScreenMap_[2]->type_ = ScreenType::UNDEFINED;
155 ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(2, screens));
156 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
157 }
158 /**
159 * @tc.name: MakeMirror
160 * @tc.desc: MakeMirror test
161 * @tc.type: FUNC
162 */
163 HWTEST_F(AbstractScreenControllerTest, MakeMirror03, Function | SmallTest | Level3)
164 {
165 std::vector<ScreenId> screens;
166 absController_->dmsScreenMap_[2]->type_ = ScreenType::REAL;
167 absController_->dmsScreenMap_[2]->groupDmsId_ = 5;
168 absController_->abstractScreenCallback_ = nullptr;
169 ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(2, screens));
170 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
171 }
172 /**
173 * @tc.name: MakeMirror
174 * @tc.desc: MakeMirror test
175 * @tc.type: FUNC
176 */
177 HWTEST_F(AbstractScreenControllerTest, MakeMirror04, Function | SmallTest | Level3)
178 {
179 std::vector<ScreenId> screens;
180 absController_->dmsScreenMap_[2]->type_ = ScreenType::REAL;
181 absController_->dmsScreenMap_[2]->groupDmsId_ = 5;
182 absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
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: ProcessScreenConnected
188 * @tc.desc: ProcessScreenConnected test
189 * @tc.type: FUNC
190 */
191 HWTEST_F(AbstractScreenControllerTest, ProcessScreenConnected01, Function | SmallTest | Level3)
192 {
193 ScreenId id = 0;
194 absController_->ProcessScreenConnected(id);
195 ASSERT_EQ(true, absController_->screenIdManager_.HasRsScreenId(id));
196 }
197 /**
198 * @tc.name: OnRsScreenConnectionChange
199 * @tc.desc: OnRsScreenConnectionChange test
200 * @tc.type: FUNC
201 */
202 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange01, Function | SmallTest | Level3)
203 {
204 ScreenEvent event = ScreenEvent::UNKNOWN;
205 ScreenId rsScreenId = 100;
206 absController_->OnRsScreenConnectionChange(rsScreenId, event);
207 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
208 }
209 /**
210 * @tc.name: OnRsScreenConnectionChange
211 * @tc.desc: OnRsScreenConnectionChange test
212 * @tc.type: FUNC
213 */
214 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange02, Function | SmallTest | Level3)
215 {
216 ScreenEvent event = ScreenEvent::UNKNOWN;
217 ScreenId rsScreenId = 1;
218 absController_->OnRsScreenConnectionChange(rsScreenId, event);
219 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
220 }
221 /**
222 * @tc.name: GetAllValidScreenIds
223 * @tc.desc: GetAllValidScreenIds test
224 * @tc.type: FUNC
225 */
226 HWTEST_F(AbstractScreenControllerTest, GetAllValidScreenIds, Function | SmallTest | Level3)
227 {
228 std::vector<ScreenId> screenIds {0, 1, 1, 2, 2, 3, 4};
229 std::vector<ScreenId> valid {0, 1, 2, 3};
230 ASSERT_EQ(valid, absController_->GetAllValidScreenIds(screenIds));
231 }
232 /**
233 * @tc.name: GetRSDisplayNodeByScreenId
234 * @tc.desc: GetRSDisplayNodeByScreenId test
235 * @tc.type: FUNC
236 */
237 HWTEST_F(AbstractScreenControllerTest, GetRSDisplayNodeByScreenId, Function | SmallTest | Level3)
238 {
239 ScreenId id = 6;
240 std::shared_ptr<RSDisplayNode> node = nullptr;
241 ASSERT_EQ(node, absController_->GetRSDisplayNodeByScreenId(id));
242 }
243 /**
244 * @tc.name: UpdateRSTree
245 * @tc.desc: UpdateRSTree test
246 * @tc.type: FUNC
247 */
248 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree01, Function | SmallTest | Level3)
249 {
250 ScreenId id = 8;
251 std::shared_ptr<RSSurfaceNode> node = nullptr;
252 absController_->UpdateRSTree(id, id, node, true, true);
253 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(id));
254 }
255 /**
256 * @tc.name: UpdateRSTree
257 * @tc.desc: UpdateRSTree test
258 * @tc.type: FUNC
259 */
260 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree02, Function | SmallTest | Level3)
261 {
262 ScreenId id = 1;
263 ScreenId parentId = 8;
264 std::shared_ptr<RSSurfaceNode> node = nullptr;
265 absController_->UpdateRSTree(id, parentId, node, true, true);
266 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
267 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(parentId));
268 }
269 /**
270 * @tc.name: UpdateRSTree
271 * @tc.desc: UpdateRSTree test
272 * @tc.type: FUNC
273 */
274 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree03, Function | SmallTest | Level3)
275 {
276 ScreenId id = 1;
277 ScreenId parentId = 2;
278 std::shared_ptr<RSSurfaceNode> node = nullptr;
279 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
280 sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
281 ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
282 parentScreen->rsDisplayNode_ = nullptr;
283 absController_->UpdateRSTree(id, parentId, node, true, true);
284 }
285 /**
286 * @tc.name: RegisterAbstractScreenCallback
287 * @tc.desc: RegisterAbstractScreenCallback test
288 * @tc.type: FUNC
289 */
290 HWTEST_F(AbstractScreenControllerTest, RegisterAbstractScreenCallback, Function | SmallTest | Level3)
291 {
292 sptr<AbstractScreenController::AbstractScreenCallback> cb = nullptr;
293 absController_->RegisterAbstractScreenCallback(cb);
294 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
295 }
296 /**
297 * @tc.name: AddToGroupLocked
298 * @tc.desc: AddToGroupLocked test
299 * @tc.type: FUNC
300 */
301 HWTEST_F(AbstractScreenControllerTest, AddToGroupLocked, Function | SmallTest | Level3)
302 {
303 ASSERT_EQ(false, absController_->dmsScreenGroupMap_.empty());
304 ASSERT_EQ(nullptr, absController_->AddToGroupLocked(screenVec[0]));
305 }
306 /**
307 * @tc.name: RemoveFromGroupLocked
308 * @tc.desc: RemoveFromGroupLocked test
309 * @tc.type: FUNC
310 */
311 HWTEST_F(AbstractScreenControllerTest, RemoveFromGroupLocked01, Function | SmallTest | Level3)
312 {
313 sptr<AbstractScreen> screen = screenVec[0];
314 screen->groupDmsId_ = 0;
315 ASSERT_EQ(nullptr, absController_->RemoveFromGroupLocked(screen));
316 }
317 /**
318 * @tc.name: RemoveChildFromGroup
319 * @tc.desc: RemoveChildFromGroup test
320 * @tc.type: FUNC
321 */
322 HWTEST_F(AbstractScreenControllerTest, RemoveChildFromGroup01, Function | SmallTest | Level3)
323 {
324 sptr<AbstractScreen> screen = screenVec[0];
325 ScreenId dmsId = screen->dmsId_;
326 Point point;
327 auto p = std::make_pair(screen, point);
328 sptr<AbstractScreenGroup> screenGroup = absController_->dmsScreenGroupMap_[0];
329 screenGroup->abstractScreenMap_.insert(std::make_pair(dmsId, p));
330 ASSERT_EQ(true, absController_->RemoveChildFromGroup(screen, screenGroup));
331 }
332 /**
333 * @tc.name: AddAsSuccedentScreenLocked
334 * @tc.desc: AddAsSuccedentScreenLocked test
335 * @tc.type: FUNC
336 */
337 HWTEST_F(AbstractScreenControllerTest, AddAsSuccedentScreenLocked01, Function | SmallTest | Level3)
338 {
339 sptr<AbstractScreen> screen = screenVec[0];
340 absController_->dmsScreenMap_.erase(absController_->GetDefaultAbstractScreenId());
341 ASSERT_EQ(nullptr, absController_->AddAsSuccedentScreenLocked(screen));
342 }
343 /**
344 * @tc.name: AddAsSuccedentScreenLocked
345 * @tc.desc: AddAsSuccedentScreenLocked test
346 * @tc.type: FUNC
347 */
348 HWTEST_F(AbstractScreenControllerTest, AddAsSuccedentScreenLocked02, Function | SmallTest | Level3)
349 {
350 sptr<AbstractScreen> screen = screenVec[0];
351 ASSERT_EQ(nullptr, absController_->AddAsSuccedentScreenLocked(screen));
352 }
353 /**
354 * @tc.name: CreateVirtualScreen
355 * @tc.desc: CreateVirtualScreen test
356 * @tc.type: FUNC
357 */
358 HWTEST_F(AbstractScreenControllerTest, CreateVirtualScreen01, Function | SmallTest | Level3)
359 {
360 VirtualScreenOption option;
361 sptr<IRemoteObject> displayManagerAgent = new IRemoteObjectMocker();
362 auto ret = absController_->CreateVirtualScreen(option, displayManagerAgent);
363 if (ret != 0)
364 {
365 ASSERT_NE(0, ret);
366 }
367 }
368
369 /**
370 * @tc.name: InitVirtualScreen
371 * @tc.desc: InitVirtualScreen test
372 * @tc.type: FUNC
373 */
374 HWTEST_F(AbstractScreenControllerTest, InitVirtualScreen01, Function | SmallTest | Level3)
375 {
376 VirtualScreenOption option;
377 absController_->dmsScreenMap_.erase(absController_->GetDefaultAbstractScreenId());
378 sptr<AbstractScreen> screen = absController_->InitVirtualScreen(0, 0, option);
379 auto ret = screen->activeIdx_;
380 if (ret != 0) {
381 ASSERT_NE(0, ret);
382 }
383 }
384
385 /**
386 * @tc.name: InitVirtualScreen
387 * @tc.desc: InitVirtualScreen test
388 * @tc.type: FUNC
389 */
390 HWTEST_F(AbstractScreenControllerTest, InitVirtualScreen02, Function | SmallTest | Level3)
391 {
392 VirtualScreenOption option;
393 sptr<AbstractScreen> defaultScreen = absController_->dmsScreenMap_[absController_->GetDefaultAbstractScreenId()];
394 sptr<SupportedScreenModes> modes;
395 if (defaultScreen != nullptr) {
396 defaultScreen->modes_.emplace_back(modes);
397 defaultScreen->activeIdx_ = 0;
398 ASSERT_EQ(nullptr, defaultScreen->GetActiveScreenMode());
399 sptr<AbstractScreen> screen = absController_->InitVirtualScreen(0, 0, option);
400 ASSERT_EQ(ScreenType::VIRTUAL, screen->type_);
401 }
402 }
403
404 /**
405 * @tc.name: DestroyVirtualScreen
406 * @tc.desc: DestroyVirtualScreen test
407 * @tc.type: FUNC
408 */
409 HWTEST_F(AbstractScreenControllerTest, DestroyVirtualScreen01, Function | SmallTest | Level3)
410 {
411 ScreenId id = 5;
412 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, absController_->DestroyVirtualScreen(id));
413 }
414 /**
415 * @tc.name: DestroyVirtualScreen
416 * @tc.desc: DestroyVirtualScreen test
417 * @tc.type: FUNC
418 */
419 HWTEST_F(AbstractScreenControllerTest, DestroyVirtualScreen02, Function | SmallTest | Level3)
420 {
421 ScreenId id = 1;
422 ASSERT_EQ(DMError::DM_OK, absController_->DestroyVirtualScreen(id));
423 }
424 /**
425 * @tc.name: SetVirtualScreenSurface
426 * @tc.desc: SetVirtualScreenSurface test
427 * @tc.type: FUNC
428 */
429 HWTEST_F(AbstractScreenControllerTest, SetVirtualScreenSurface01, Function | SmallTest | Level3)
430 {
431 ScreenId id = 6;
432 sptr<Surface> surface = nullptr;
433 ASSERT_EQ(DMError::DM_ERROR_RENDER_SERVICE_FAILED, absController_->SetVirtualScreenSurface(id, surface));
434 }
435 /**
436 * @tc.name: SetBuildInDefaultOrientation
437 * @tc.desc: SetBuildInDefaultOrientation test
438 * @tc.type: FUNC
439 */
440 HWTEST_F(AbstractScreenControllerTest, SetBuildInDefaultOrientation, Function | SmallTest | Level3)
441 {
442 Orientation orientation = Orientation::BEGIN;
443 absController_->SetBuildInDefaultOrientation(orientation);
444 ASSERT_EQ(orientation, absController_->buildInDefaultOrientation_);
445 }
446 /**
447 * @tc.name: SetOrientation
448 * @tc.desc: SetOrientation test
449 * @tc.type: FUNC
450 */
451 HWTEST_F(AbstractScreenControllerTest, SetOrientation01, Function | SmallTest | Level3)
452 {
453 absController_->dmsScreenMap_[1]->isScreenGroup_ = true;
454 Orientation orientation = Orientation::BEGIN;
455 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, absController_->SetOrientation(1, orientation, true));
456 }
457 /**
458 * @tc.name: SetRotation
459 * @tc.desc: SetRotation test
460 * @tc.type: FUNC
461 */
462 HWTEST_F(AbstractScreenControllerTest, SetRotation01, Function | SmallTest | Level3)
463 {
464 absController_->dmsScreenMap_[1]->rotation_ = Rotation::ROTATION_180;
465 absController_->screenIdManager_.dms2RsScreenIdMap_.erase(1);
466 ASSERT_EQ(true, absController_->SetRotation(1, Rotation::ROTATION_0, true));
467 }
468 /**
469 * @tc.name: SetScreenActiveMode
470 * @tc.desc: SetScreenActiveMode test
471 * @tc.type: FUNC
472 */
473 HWTEST_F(AbstractScreenControllerTest, SetScreenActiveMode01, Function | SmallTest | Level3)
474 {
475 ASSERT_TRUE(DMError::DM_OK != absController_->SetScreenActiveMode(5, 0));
476 }
477 /**
478 * @tc.name: SetScreenActiveMode
479 * @tc.desc: SetScreenActiveMode test
480 * @tc.type: FUNC
481 */
482 HWTEST_F(AbstractScreenControllerTest, SetScreenActiveMode02, Function | SmallTest | Level3)
483 {
484 absController_->screenIdManager_.dms2RsScreenIdMap_.erase(1);
485 ASSERT_TRUE(DMError::DM_OK != absController_->SetScreenActiveMode(1, 0));
486 }
487 /**
488 * @tc.name: ProcessScreenModeChanged
489 * @tc.desc: ProcessScreenModeChanged test
490 * @tc.type: FUNC
491 */
492 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged01, Function | SmallTest | Level3)
493 {
494 absController_->ProcessScreenModeChanged(7);
495 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
496 }
497 /**
498 * @tc.name: ProcessScreenModeChanged
499 * @tc.desc: ProcessScreenModeChanged test
500 * @tc.type: FUNC
501 */
502 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged02, Function | SmallTest | Level3)
503 {
504 absController_->ProcessScreenModeChanged(5);
505 ASSERT_EQ(nullptr, absController_->dmsScreenMap_[5]);
506 }
507 /**
508 * @tc.name: ProcessScreenModeChanged
509 * @tc.desc: ProcessScreenModeChanged test
510 * @tc.type: FUNC
511 */
512 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged03, Function | SmallTest | Level3)
513 {
514 absController_->ProcessScreenModeChanged(2);
515 ASSERT_NE(nullptr, absController_->dmsScreenMap_[2]);
516 }
517 /**
518 * @tc.name: ChangeScreenGroup
519 * @tc.desc: ChangeScreenGroup test
520 * @tc.type: FUNC
521 */
522 HWTEST_F(AbstractScreenControllerTest, ChangeScreenGroup01, Function | SmallTest | Level3)
523 {
524 sptr<AbstractScreenGroup> group = screenGroupVec[0];
525 Point point;
526 auto abs2pointPair = std::make_pair(screenVec[0], point);
527 group->abstractScreenMap_.insert(std::make_pair(0, abs2pointPair));
528 group->abstractScreenMap_.insert(std::make_pair(1, abs2pointPair));
529 std::vector<Point> startPoints;
530 std::vector<ScreenId> screens;
531 for (ScreenId i = 0; i < 7; ++i) {
532 screens.emplace_back(i);
533 startPoints.emplace_back(point);
534 if (i < absController_->dmsScreenMap_.size() && absController_->dmsScreenMap_[i] != nullptr) {
535 absController_->dmsScreenMap_[i]->groupDmsId_ = 1;
536 }
537 }
538 absController_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_ALONE);
539 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
540 }
541 /**
542 * @tc.name: ChangeScreenGroup
543 * @tc.desc: ChangeScreenGroup test
544 * @tc.type: FUNC
545 */
546 HWTEST_F(AbstractScreenControllerTest, ChangeScreenGroup02, Function | SmallTest | Level3)
547 {
548 sptr<AbstractScreenGroup> group = screenGroupVec[0];
549 Point point;
550 auto abs2pointPair = std::make_pair(screenVec[0], point);
551 group->abstractScreenMap_.insert(std::make_pair(0, abs2pointPair));
552 group->abstractScreenMap_.insert(std::make_pair(1, abs2pointPair));
553 std::vector<Point> startPoints;
554 std::vector<ScreenId> screens;
555 for (ScreenId i = 0; i < 7; ++i) {
556 screens.emplace_back(i);
557 startPoints.emplace_back(point);
558 if (i < absController_->dmsScreenMap_.size() && absController_->dmsScreenMap_[i] != nullptr) {
559 absController_->dmsScreenMap_[i]->groupDmsId_ = 1;
560 }
561 }
562 absController_->abstractScreenCallback_ = nullptr;
563 absController_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_ALONE);
564 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
565 }
566 /**
567 * @tc.name: ChangeScreenGroup
568 * @tc.desc: ChangeScreenGroup test
569 * @tc.type: FUNC
570 */
571 HWTEST_F(AbstractScreenControllerTest, AddScreenToGroup01, Function | SmallTest | Level3)
572 {
573 sptr<AbstractScreenGroup> group = screenGroupVec[0];
574 std::vector<ScreenId> addScreens {0, 1, 2, 3, 4, 5};
575 Point point;
576 std::vector<Point> addChildPos(10, point);
577 std::map<ScreenId, bool> removeChildResMap;
578 absController_->AddScreenToGroup(group, addScreens, addChildPos, removeChildResMap);
579 absController_->abstractScreenCallback_ = nullptr;
580 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
581 }
582
583 /**
584 * @tc.name: MakeExpand
585 * @tc.desc: MakeExpand test
586 * @tc.type: FUNC
587 */
588 HWTEST_F(AbstractScreenControllerTest, MakeExpand01, Function | SmallTest | Level3)
589 {
590 std::vector<ScreenId> screenIds;
591 std::vector<Point> startPoints;
592 ScreenId defaultId = absController_->GetDefaultAbstractScreenId();
593 absController_->dmsScreenMap_[defaultId] = nullptr;
594 ASSERT_EQ(false, absController_->MakeExpand(screenIds, startPoints));
595 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screenIds, ScreenCombination::SCREEN_EXPAND));
596 }
597
598 /**
599 * @tc.name: MakeExpand
600 * @tc.desc: MakeExpand test
601 * @tc.type: FUNC
602 */
603 HWTEST_F(AbstractScreenControllerTest, MakeExpand02, Function | SmallTest | Level3)
604 {
605 std::vector<ScreenId> screenIds;
606 std::vector<Point> startPoints;
607 ScreenId defaultId = absController_->GetDefaultAbstractScreenId();
608 auto defaultScreen = absController_->GetAbstractScreen(defaultId);
609 if (defaultScreen != nullptr)
610 {
611 ScreenId groupDmsId = defaultScreen->groupDmsId_;
612 absController_->dmsScreenGroupMap_[groupDmsId] = nullptr;
613 ASSERT_EQ(false, absController_->MakeExpand(screenIds, startPoints));
614 ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screenIds, ScreenCombination::SCREEN_EXPAND));
615 }
616 }
617
618 /**
619 * @tc.name: RemoveVirtualScreenFromGroup
620 * @tc.desc: RemoveVirtualScreenFromGroup test
621 * @tc.type: FUNC
622 */
623 HWTEST_F(AbstractScreenControllerTest, RemoveVirtualScreenFromGroup01, Function | SmallTest | Level3)
624 {
625 std::vector<ScreenId> screens {0, 1, 2, 3, 4, 5, 6, 7};
626 absController_->abstractScreenCallback_ = nullptr;
627 absController_->RemoveVirtualScreenFromGroup(screens);
628 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
629 }
630
631 /**
632 * @tc.name: OnRemoteDied
633 * @tc.desc: OnRemoteDied test
634 * @tc.type: FUNC
635 */
636 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied01, Function | SmallTest | Level3)
637 {
638 sptr<IRemoteObject> agent = nullptr;
639 ASSERT_EQ(false, absController_->OnRemoteDied(agent));
640 }
641
642 /**
643 * @tc.name: OnRemoteDied
644 * @tc.desc: OnRemoteDied test
645 * @tc.type: FUNC
646 */
647 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied02, Function | SmallTest | Level3)
648 {
649 sptr<IRemoteObject> agent = new IRemoteObjectMocker();
650 ASSERT_EQ(true, absController_->OnRemoteDied(agent));
651 }
652
653 /**
654 * @tc.name: OnRemoteDied
655 * @tc.desc: OnRemoteDied test
656 * @tc.type: FUNC
657 */
658 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied03, Function | SmallTest | Level3)
659 {
660 sptr<IRemoteObject> agent = new IRemoteObjectMocker();
661 std::vector<ScreenId> screens {5};
662 absController_->screenAgentMap_.insert(std::make_pair(agent, screens));
663 ASSERT_EQ(true, absController_->OnRemoteDied(agent));
664 ASSERT_EQ(0, absController_->screenAgentMap_.size());
665 }
666
667 /**
668 * @tc.name: CreateAndGetNewScreenId
669 * @tc.desc: CreateAndGetNewScreenId test
670 * @tc.type: FUNC
671 */
672 HWTEST_F(AbstractScreenControllerTest, CreateAndGetNewScreenId01, Function | SmallTest | Level3)
673 {
674 ScreenId rsScreenId = 1;
675 ScreenId dmsScreenId = absController_->screenIdManager_.dmsScreenCount_;
676 ASSERT_EQ(dmsScreenId, absController_->screenIdManager_.CreateAndGetNewScreenId(rsScreenId));
677 ASSERT_EQ(++dmsScreenId, absController_->screenIdManager_.dmsScreenCount_);
678 }
679
680 /**
681 * @tc.name: ConvertToRsScreenId
682 * @tc.desc: ConvertToRsScreenId test
683 * @tc.type: FUNC
684 */
685 HWTEST_F(AbstractScreenControllerTest, ConvertToRsScreenId01, Function | SmallTest | Level3)
686 {
687 ScreenId rsScreenId;
688 ScreenId dmsScreenId = 8;
689 ASSERT_EQ(false, absController_->screenIdManager_.ConvertToRsScreenId(dmsScreenId, rsScreenId));
690 }
691
692 /**
693 * @tc.name: NotifyScreenConnected
694 * @tc.desc: NotifyScreenConnected test
695 * @tc.type: FUNC
696 */
697 HWTEST_F(AbstractScreenControllerTest, NotifyScreenConnected, Function | SmallTest | Level3)
698 {
699 sptr<ScreenInfo> screenInfo = nullptr;
700 absController_->NotifyScreenConnected(screenInfo);
701 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
702 }
703
704 /**
705 * @tc.name: NotifyScreenConnected
706 * @tc.desc: NotifyScreenConnected test
707 * @tc.type: FUNC
708 */
709 HWTEST_F(AbstractScreenControllerTest, NotifyScreenChanged, Function | SmallTest | Level3)
710 {
711 sptr<ScreenInfo> screenInfo = nullptr;
712 absController_->NotifyScreenChanged(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
713 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
714 }
715
716 /**
717 * @tc.name: NotifyScreenConnected
718 * @tc.desc: NotifyScreenConnected test
719 * @tc.type: FUNC
720 */
721 HWTEST_F(AbstractScreenControllerTest, NotifyScreenGroupChanged, Function | SmallTest | Level3)
722 {
723 sptr<ScreenInfo> screenInfo = nullptr;
724 absController_->NotifyScreenGroupChanged(screenInfo, ScreenGroupChangeEvent::ADD_TO_GROUP);
725 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
726 }
727
728 /**
729 * @tc.name: NotifyScreenConnected
730 * @tc.desc: NotifyScreenConnected test
731 * @tc.type: FUNC
732 */
733 HWTEST_F(AbstractScreenControllerTest, SetScreenPowerForAll, Function | SmallTest | Level3)
734 {
735 for (uint32_t i = 0; i < screenVec.size(); ++i) {
736 if (screenVec[i] != nullptr && screenVec[i]->type_ == ScreenType::REAL) {
737 screenVec[i]->type_ = ScreenType::UNDEFINED;
738 }
739 }
740 ASSERT_EQ(false, absController_->SetScreenPowerForAll(ScreenPowerState::INVALID_STATE,
741 PowerStateChangeReason::POWER_BUTTON));
742 }
743 /**
744 * @tc.name: SetVirtualPixelRatio
745 * @tc.desc: SetVirtualPixelRatio test
746 * @tc.type: FUNC
747 */
748 HWTEST_F(AbstractScreenControllerTest, SetVirtualPixelRatio01, Function | SmallTest | Level3)
749 {
750 auto screen = screenVec[0];
751 ScreenId id = 0;
752 float ratio = 1.0;
753 screen->isScreenGroup_ = true;
754 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, absController_->SetVirtualPixelRatio(id, ratio));
755 }
756 /**
757 * @tc.name: SetVirtualPixelRatio
758 * @tc.desc: SetVirtualPixelRatio test
759 * @tc.type: FUNC
760 */
761 HWTEST_F(AbstractScreenControllerTest, SetVirtualPixelRatio02, Function | SmallTest | Level3)
762 {
763 ScreenId id = 0;
764 float ratio = 1.0;
765 absController_->abstractScreenCallback_ = nullptr;
766 ASSERT_EQ(DMError::DM_OK, absController_->SetVirtualPixelRatio(id, ratio));
767 }
768 }
769 } // namespace Rosen
770 } // namespace OHOS
771