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: GetAllValidScreenIds
82 * @tc.desc: GetAllValidScreenIds test
83 * @tc.type: FUNC
84 */
85 HWTEST_F(AbstractScreenControllerTest, GetAllValidScreenIds, Function | SmallTest | Level3)
86 {
87 std::vector<ScreenId> screenIds {0, 1, 1, 2, 2, 3, 4};
88 std::vector<ScreenId> valid {0, 1, 2, 3};
89 ASSERT_EQ(valid, absController_->GetAllValidScreenIds(screenIds));
90 }
91 /**
92 * @tc.name: GetRSDisplayNodeByScreenId
93 * @tc.desc: GetRSDisplayNodeByScreenId test
94 * @tc.type: FUNC
95 */
96 HWTEST_F(AbstractScreenControllerTest, GetRSDisplayNodeByScreenId, Function | SmallTest | Level3)
97 {
98 ScreenId id = 6;
99 std::shared_ptr<RSDisplayNode> node = nullptr;
100 ASSERT_EQ(node, absController_->GetRSDisplayNodeByScreenId(id));
101 }
102 /**
103 * @tc.name: UpdateRSTree
104 * @tc.desc: UpdateRSTree test
105 * @tc.type: FUNC
106 */
107 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree01, Function | SmallTest | Level3)
108 {
109 ScreenId id = 8;
110 std::shared_ptr<RSSurfaceNode> node = nullptr;
111 absController_->UpdateRSTree(id, id, node, true, true);
112 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(id));
113 }
114 /**
115 * @tc.name: UpdateRSTree
116 * @tc.desc: UpdateRSTree test
117 * @tc.type: FUNC
118 */
119 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree02, Function | SmallTest | Level3)
120 {
121 ScreenId id = 1;
122 ScreenId parentId = 8;
123 std::shared_ptr<RSSurfaceNode> node = nullptr;
124 absController_->UpdateRSTree(id, parentId, node, true, true);
125 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
126 ASSERT_EQ(nullptr, absController_->GetAbstractScreen(parentId));
127 }
128 /**
129 * @tc.name: UpdateRSTree
130 * @tc.desc: UpdateRSTree test
131 * @tc.type: FUNC
132 */
133 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree03, Function | SmallTest | Level3)
134 {
135 ScreenId id = 1;
136 ScreenId parentId = 2;
137 std::shared_ptr<RSSurfaceNode> node = nullptr;
138 ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
139 sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
140 ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
141 parentScreen->rsDisplayNode_ = nullptr;
142 absController_->UpdateRSTree(id, parentId, node, true, true);
143 }
144 /**
145 * @tc.name: RegisterAbstractScreenCallback
146 * @tc.desc: RegisterAbstractScreenCallback test
147 * @tc.type: FUNC
148 */
149 HWTEST_F(AbstractScreenControllerTest, RegisterAbstractScreenCallback, Function | SmallTest | Level3)
150 {
151 sptr<AbstractScreenController::AbstractScreenCallback> cb = nullptr;
152 absController_->RegisterAbstractScreenCallback(cb);
153 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
154 }
155 /**
156 * @tc.name: AddToGroupLocked
157 * @tc.desc: AddToGroupLocked test
158 * @tc.type: FUNC
159 */
160 HWTEST_F(AbstractScreenControllerTest, AddToGroupLocked, Function | SmallTest | Level3)
161 {
162 ASSERT_EQ(false, absController_->dmsScreenGroupMap_.empty());
163 ASSERT_EQ(nullptr, absController_->AddToGroupLocked(screenVec[0]));
164 }
165 /**
166 * @tc.name: RemoveFromGroupLocked
167 * @tc.desc: RemoveFromGroupLocked test
168 * @tc.type: FUNC
169 */
170 HWTEST_F(AbstractScreenControllerTest, RemoveFromGroupLocked01, Function | SmallTest | Level3)
171 {
172 sptr<AbstractScreen> screen = screenVec[0];
173 screen->groupDmsId_ = 0;
174 ASSERT_EQ(nullptr, absController_->RemoveFromGroupLocked(screen));
175 }
176 /**
177 * @tc.name: RemoveChildFromGroup
178 * @tc.desc: RemoveChildFromGroup test
179 * @tc.type: FUNC
180 */
181 HWTEST_F(AbstractScreenControllerTest, RemoveChildFromGroup01, Function | SmallTest | Level3)
182 {
183 sptr<AbstractScreen> screen = screenVec[0];
184 ScreenId dmsId = screen->dmsId_;
185 Point point;
186 auto p = std::make_pair(screen, point);
187 sptr<AbstractScreenGroup> screenGroup = absController_->dmsScreenGroupMap_[0];
188 screenGroup->abstractScreenMap_.insert(std::make_pair(dmsId, p));
189 ASSERT_EQ(true, absController_->RemoveChildFromGroup(screen, screenGroup));
190 }
191 /**
192 * @tc.name: AddAsSuccedentScreenLocked
193 * @tc.desc: AddAsSuccedentScreenLocked test
194 * @tc.type: FUNC
195 */
196 HWTEST_F(AbstractScreenControllerTest, AddAsSuccedentScreenLocked01, Function | SmallTest | Level3)
197 {
198 sptr<AbstractScreen> screen = screenVec[0];
199 absController_->dmsScreenMap_.erase(absController_->GetDefaultAbstractScreenId());
200 ASSERT_EQ(nullptr, absController_->AddAsSuccedentScreenLocked(screen));
201 }
202 /**
203 * @tc.name: AddAsSuccedentScreenLocked
204 * @tc.desc: AddAsSuccedentScreenLocked test
205 * @tc.type: FUNC
206 */
207 HWTEST_F(AbstractScreenControllerTest, AddAsSuccedentScreenLocked02, Function | SmallTest | Level3)
208 {
209 sptr<AbstractScreen> screen = screenVec[0];
210 ASSERT_EQ(nullptr, absController_->AddAsSuccedentScreenLocked(screen));
211 }
212 /**
213 * @tc.name: CreateVirtualScreen
214 * @tc.desc: CreateVirtualScreen test
215 * @tc.type: FUNC
216 */
217 HWTEST_F(AbstractScreenControllerTest, CreateVirtualScreen01, Function | SmallTest | Level3)
218 {
219 VirtualScreenOption option;
220 sptr<IRemoteObject> displayManagerAgent = new IRemoteObjectMocker();
221 ASSERT_EQ(0, absController_->CreateVirtualScreen(option, displayManagerAgent));
222 }
223 /**
224 * @tc.name: InitVirtualScreen
225 * @tc.desc: InitVirtualScreen test
226 * @tc.type: FUNC
227 */
228 HWTEST_F(AbstractScreenControllerTest, InitVirtualScreen01, Function | SmallTest | Level3)
229 {
230 VirtualScreenOption option;
231 absController_->dmsScreenMap_.erase(absController_->GetDefaultAbstractScreenId());
232 sptr<AbstractScreen> screen = absController_->InitVirtualScreen(0, 0, option);
233 ASSERT_EQ(0, screen->activeIdx_);
234 }
235 /**
236 * @tc.name: InitVirtualScreen
237 * @tc.desc: InitVirtualScreen test
238 * @tc.type: FUNC
239 */
240 HWTEST_F(AbstractScreenControllerTest, InitVirtualScreen02, Function | SmallTest | Level3)
241 {
242 VirtualScreenOption option;
243 sptr<AbstractScreen> defaultScreen = absController_->dmsScreenMap_[absController_->GetDefaultAbstractScreenId()];
244 sptr<SupportedScreenModes> modes;
245 defaultScreen->modes_.emplace_back(modes);
246 defaultScreen->activeIdx_ = 0;
247 ASSERT_EQ(nullptr, defaultScreen->GetActiveScreenMode());
248 sptr<AbstractScreen> screen = absController_->InitVirtualScreen(0, 0, option);
249 ASSERT_EQ(ScreenType::VIRTUAL, screen->type_);
250 }
251 /**
252 * @tc.name: DestroyVirtualScreen
253 * @tc.desc: DestroyVirtualScreen test
254 * @tc.type: FUNC
255 */
256 HWTEST_F(AbstractScreenControllerTest, DestroyVirtualScreen01, Function | SmallTest | Level3)
257 {
258 ScreenId id = 5;
259 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, absController_->DestroyVirtualScreen(id));
260 }
261 /**
262 * @tc.name: DestroyVirtualScreen
263 * @tc.desc: DestroyVirtualScreen test
264 * @tc.type: FUNC
265 */
266 HWTEST_F(AbstractScreenControllerTest, DestroyVirtualScreen02, Function | SmallTest | Level3)
267 {
268 ScreenId id = 1;
269 ASSERT_EQ(DMError::DM_OK, absController_->DestroyVirtualScreen(id));
270 }
271 /**
272 * @tc.name: SetVirtualScreenSurface
273 * @tc.desc: SetVirtualScreenSurface test
274 * @tc.type: FUNC
275 */
276 HWTEST_F(AbstractScreenControllerTest, SetVirtualScreenSurface01, Function | SmallTest | Level3)
277 {
278 ScreenId id = 6;
279 sptr<Surface> surface = nullptr;
280 ASSERT_EQ(DMError::DM_ERROR_RENDER_SERVICE_FAILED, absController_->SetVirtualScreenSurface(id, surface));
281 }
282 /**
283 * @tc.name: SetBuildInDefaultOrientation
284 * @tc.desc: SetBuildInDefaultOrientation test
285 * @tc.type: FUNC
286 */
287 HWTEST_F(AbstractScreenControllerTest, SetBuildInDefaultOrientation, Function | SmallTest | Level3)
288 {
289 Orientation orientation = Orientation::BEGIN;
290 absController_->SetBuildInDefaultOrientation(orientation);
291 ASSERT_EQ(orientation, absController_->buildInDefaultOrientation_);
292 }
293 /**
294 * @tc.name: SetOrientation
295 * @tc.desc: SetOrientation test
296 * @tc.type: FUNC
297 */
298 HWTEST_F(AbstractScreenControllerTest, SetOrientation01, Function | SmallTest | Level3)
299 {
300 absController_->dmsScreenMap_[1]->isScreenGroup_ = true;
301 Orientation orientation = Orientation::BEGIN;
302 ASSERT_EQ(false, absController_->SetOrientation(1, orientation, true));
303 }
304 /**
305 * @tc.name: SetRotation
306 * @tc.desc: SetRotation test
307 * @tc.type: FUNC
308 */
309 HWTEST_F(AbstractScreenControllerTest, SetRotation01, Function | SmallTest | Level3)
310 {
311 absController_->dmsScreenMap_[1]->rotation_ = Rotation::ROTATION_180;
312 absController_->screenIdManager_.dms2RsScreenIdMap_.erase(1);
313 ASSERT_EQ(false, absController_->SetRotation(1, Rotation::ROTATION_0, true));
314 }
315 /**
316 * @tc.name: SetScreenActiveMode
317 * @tc.desc: SetScreenActiveMode test
318 * @tc.type: FUNC
319 */
320 HWTEST_F(AbstractScreenControllerTest, SetScreenActiveMode01, Function | SmallTest | Level3)
321 {
322 ASSERT_EQ(false, absController_->SetScreenActiveMode(5, 0));
323 }
324 /**
325 * @tc.name: SetScreenActiveMode
326 * @tc.desc: SetScreenActiveMode test
327 * @tc.type: FUNC
328 */
329 HWTEST_F(AbstractScreenControllerTest, SetScreenActiveMode02, Function | SmallTest | Level3)
330 {
331 absController_->screenIdManager_.dms2RsScreenIdMap_.erase(1);
332 ASSERT_EQ(false, absController_->SetScreenActiveMode(1, 0));
333 }
334 /**
335 * @tc.name: ProcessScreenModeChanged
336 * @tc.desc: ProcessScreenModeChanged test
337 * @tc.type: FUNC
338 */
339 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged01, Function | SmallTest | Level3)
340 {
341 absController_->ProcessScreenModeChanged(7);
342 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
343 }
344 /**
345 * @tc.name: ProcessScreenModeChanged
346 * @tc.desc: ProcessScreenModeChanged test
347 * @tc.type: FUNC
348 */
349 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged02, Function | SmallTest | Level3)
350 {
351 absController_->ProcessScreenModeChanged(5);
352 ASSERT_EQ(nullptr, absController_->dmsScreenMap_[5]);
353 }
354 /**
355 * @tc.name: ProcessScreenModeChanged
356 * @tc.desc: ProcessScreenModeChanged test
357 * @tc.type: FUNC
358 */
359 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged03, Function | SmallTest | Level3)
360 {
361 absController_->ProcessScreenModeChanged(2);
362 ASSERT_NE(nullptr, absController_->dmsScreenMap_[2]);
363 }
364 /**
365 * @tc.name: ChangeScreenGroup
366 * @tc.desc: ChangeScreenGroup test
367 * @tc.type: FUNC
368 */
369 HWTEST_F(AbstractScreenControllerTest, ChangeScreenGroup01, Function | SmallTest | Level3)
370 {
371 sptr<AbstractScreenGroup> group = screenGroupVec[0];
372 Point point;
373 auto abs2pointPair = std::make_pair(screenVec[0], point);
374 group->abstractScreenMap_.insert(std::make_pair(0, abs2pointPair));
375 group->abstractScreenMap_.insert(std::make_pair(1, abs2pointPair));
376 std::vector<Point> startPoints;
377 std::vector<ScreenId> screens;
378 for (ScreenId i = 0; i < 7; ++i) {
379 screens.emplace_back(i);
380 startPoints.emplace_back(point);
381 if (i < absController_->dmsScreenMap_.size() && absController_->dmsScreenMap_[i] != nullptr) {
382 absController_->dmsScreenMap_[i]->groupDmsId_ = 1;
383 }
384 }
385 absController_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_ALONE);
386 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
387 }
388 /**
389 * @tc.name: ChangeScreenGroup
390 * @tc.desc: ChangeScreenGroup test
391 * @tc.type: FUNC
392 */
393 HWTEST_F(AbstractScreenControllerTest, ChangeScreenGroup02, Function | SmallTest | Level3)
394 {
395 sptr<AbstractScreenGroup> group = screenGroupVec[0];
396 Point point;
397 auto abs2pointPair = std::make_pair(screenVec[0], point);
398 group->abstractScreenMap_.insert(std::make_pair(0, abs2pointPair));
399 group->abstractScreenMap_.insert(std::make_pair(1, abs2pointPair));
400 std::vector<Point> startPoints;
401 std::vector<ScreenId> screens;
402 for(ScreenId i = 0; i < 7; ++i) {
403 screens.emplace_back(i);
404 startPoints.emplace_back(point);
405 if (i < absController_->dmsScreenMap_.size() && absController_->dmsScreenMap_[i] != nullptr) {
406 absController_->dmsScreenMap_[i]->groupDmsId_ = 1;
407 }
408 }
409 absController_->abstractScreenCallback_ = nullptr;
410 absController_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_ALONE);
411 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
412 }
413 /**
414 * @tc.name: ChangeScreenGroup
415 * @tc.desc: ChangeScreenGroup test
416 * @tc.type: FUNC
417 */
418 HWTEST_F(AbstractScreenControllerTest, AddScreenToGroup01, Function | SmallTest | Level3)
419 {
420 sptr<AbstractScreenGroup> group = screenGroupVec[0];
421 std::vector<ScreenId> addScreens {0, 1, 2, 3, 4, 5};
422 Point point;
423 std::vector<Point> addChildPos(10, point);
424 std::map<ScreenId, bool> removeChildResMap;
425 absController_->AddScreenToGroup(group, addScreens, addChildPos, removeChildResMap);
426 absController_->abstractScreenCallback_ = nullptr;
427 absController_->rSScreenChangeListener_ = nullptr;
428 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
429 }
430 /**
431 * @tc.name: MakeExpand
432 * @tc.desc: MakeExpand test
433 * @tc.type: FUNC
434 */
435 HWTEST_F(AbstractScreenControllerTest, MakeExpand01, Function | SmallTest | Level3)
436 {
437 std::vector<ScreenId> screenIds;
438 std::vector<Point> startPoints;
439 ScreenId defaultId = absController_->GetDefaultAbstractScreenId();
440 absController_->dmsScreenMap_[defaultId] = nullptr;
441 ASSERT_EQ(false, absController_->MakeExpand(screenIds, startPoints));
442 }
443 /**
444 * @tc.name: MakeExpand
445 * @tc.desc: MakeExpand test
446 * @tc.type: FUNC
447 */
448 HWTEST_F(AbstractScreenControllerTest, MakeExpand02, Function | SmallTest | Level3)
449 {
450 std::vector<ScreenId> screenIds;
451 std::vector<Point> startPoints;
452 ScreenId defaultId = absController_->GetDefaultAbstractScreenId();
453 auto defaultScreen = absController_->GetAbstractScreen(defaultId);
454 ScreenId groupDmsId = defaultScreen->groupDmsId_;
455 absController_->dmsScreenGroupMap_[groupDmsId] = nullptr;
456 ASSERT_EQ(false, absController_->MakeExpand(screenIds, startPoints));
457 }
458 /**
459 * @tc.name: RemoveVirtualScreenFromGroup
460 * @tc.desc: RemoveVirtualScreenFromGroup test
461 * @tc.type: FUNC
462 */
463 HWTEST_F(AbstractScreenControllerTest, RemoveVirtualScreenFromGroup01, Function | SmallTest | Level3)
464 {
465 std::vector<ScreenId> screens {0, 1, 2, 3, 4, 5, 6, 7};
466 absController_->abstractScreenCallback_ = nullptr;
467 absController_->RemoveVirtualScreenFromGroup(screens);
468 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
469 }
470 /**
471 * @tc.name: OnRemoteDied
472 * @tc.desc: OnRemoteDied test
473 * @tc.type: FUNC
474 */
475 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied01, Function | SmallTest | Level3)
476 {
477 sptr<IRemoteObject> agent = nullptr;
478 ASSERT_EQ(false, absController_->OnRemoteDied(agent));
479 }
480 /**
481 * @tc.name: OnRemoteDied
482 * @tc.desc: OnRemoteDied test
483 * @tc.type: FUNC
484 */
485 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied02, Function | SmallTest | Level3)
486 {
487 sptr<IRemoteObject> agent = new IRemoteObjectMocker();
488 ASSERT_EQ(true, absController_->OnRemoteDied(agent));
489 }
490 /**
491 * @tc.name: OnRemoteDied
492 * @tc.desc: OnRemoteDied test
493 * @tc.type: FUNC
494 */
495 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied03, Function | SmallTest | Level3)
496 {
497 sptr<IRemoteObject> agent = new IRemoteObjectMocker();
498 std::vector<ScreenId> screens {5};
499 absController_->screenAgentMap_.insert(std::make_pair(agent, screens));
500 ASSERT_EQ(true, absController_->OnRemoteDied(agent));
501 ASSERT_EQ(0, absController_->screenAgentMap_.size());
502 }
503 /**
504 * @tc.name: CreateAndGetNewScreenId
505 * @tc.desc: CreateAndGetNewScreenId test
506 * @tc.type: FUNC
507 */
508 HWTEST_F(AbstractScreenControllerTest, CreateAndGetNewScreenId01, Function | SmallTest | Level3)
509 {
510 ScreenId rsScreenId = 1;
511 ScreenId dmsScreenId = absController_->screenIdManager_.dmsScreenCount_;
512 ASSERT_EQ(dmsScreenId, absController_->screenIdManager_.CreateAndGetNewScreenId(rsScreenId));
513 ASSERT_EQ(++dmsScreenId, absController_->screenIdManager_.dmsScreenCount_);
514 }
515 /**
516 * @tc.name: ConvertToRsScreenId
517 * @tc.desc: ConvertToRsScreenId test
518 * @tc.type: FUNC
519 */
520 HWTEST_F(AbstractScreenControllerTest, ConvertToRsScreenId01, Function | SmallTest | Level3)
521 {
522 ScreenId rsScreenId;
523 ScreenId dmsScreenId = 8;
524 ASSERT_EQ(false, absController_->screenIdManager_.ConvertToRsScreenId(dmsScreenId, rsScreenId));
525 }
526 /**
527 * @tc.name: NotifyScreenConnected
528 * @tc.desc: NotifyScreenConnected test
529 * @tc.type: FUNC
530 */
531 HWTEST_F(AbstractScreenControllerTest, NotifyScreenConnected, Function | SmallTest | Level3)
532 {
533 sptr<ScreenInfo> screenInfo = nullptr;
534 absController_->NotifyScreenConnected(screenInfo);
535 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
536 }
537 /**
538 * @tc.name: NotifyScreenConnected
539 * @tc.desc: NotifyScreenConnected test
540 * @tc.type: FUNC
541 */
542 HWTEST_F(AbstractScreenControllerTest, NotifyScreenChanged, Function | SmallTest | Level3)
543 {
544 sptr<ScreenInfo> screenInfo = nullptr;
545 absController_->NotifyScreenChanged(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
546 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
547 }
548 /**
549 * @tc.name: NotifyScreenConnected
550 * @tc.desc: NotifyScreenConnected test
551 * @tc.type: FUNC
552 */
553 HWTEST_F(AbstractScreenControllerTest, NotifyScreenGroupChanged, Function | SmallTest | Level3)
554 {
555 sptr<ScreenInfo> screenInfo = nullptr;
556 absController_->NotifyScreenGroupChanged(screenInfo, ScreenGroupChangeEvent::ADD_TO_GROUP);
557 ASSERT_EQ(6, absController_->dmsScreenMap_.size());
558 }
559 /**
560 * @tc.name: NotifyScreenConnected
561 * @tc.desc: NotifyScreenConnected test
562 * @tc.type: FUNC
563 */
564 HWTEST_F(AbstractScreenControllerTest, SetScreenPowerForAll, Function | SmallTest | Level3)
565 {
566 for (uint32_t i = 0; i < screenVec.size(); ++i) {
567 if (screenVec[i] != nullptr && screenVec[i]->type_ == ScreenType::REAL) {
568 screenVec[i]->type_ = ScreenType::UNDEFINED;
569 }
570 }
571 ASSERT_EQ(false, absController_->SetScreenPowerForAll(ScreenPowerState::INVALID_STATE,
572 PowerStateChangeReason::POWER_BUTTON));
573 }
574 /**
575 * @tc.name: SetVirtualPixelRatio
576 * @tc.desc: SetVirtualPixelRatio test
577 * @tc.type: FUNC
578 */
579 HWTEST_F(AbstractScreenControllerTest, SetVirtualPixelRatio01, Function | SmallTest | Level3)
580 {
581 auto screen = screenVec[0];
582 ScreenId id = 0;
583 float ratio = 1.0;
584 screen->isScreenGroup_ = true;
585 ASSERT_EQ(false, absController_->SetVirtualPixelRatio(id, ratio));
586 }
587 /**
588 * @tc.name: SetVirtualPixelRatio
589 * @tc.desc: SetVirtualPixelRatio test
590 * @tc.type: FUNC
591 */
592 HWTEST_F(AbstractScreenControllerTest, SetVirtualPixelRatio02, Function | SmallTest | Level3)
593 {
594 ScreenId id = 0;
595 float ratio = 1.0;
596 absController_->abstractScreenCallback_ = nullptr;
597 ASSERT_EQ(true, absController_->SetVirtualPixelRatio(id, ratio));
598 }
599 }
600 } // namespace Rosen
601 } // namespace OHOS
602