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_display.h"
19 #include "abstract_display_controller.h"
20 #include "display_cutout_controller.h"
21 #include "modifier_render_thread/rs_modifiers_draw_thread.h"
22 #include "screen.h"
23 #include "scene_board_judgement.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Rosen {
30 class AbstractDisplayControllerTest : public testing::Test {
31 public:
32 static void SetUpTestCase();
33 static void TearDownTestCase();
34 void SetUp() override;
35 void TearDown() override;
36
37 private:
38 void InitScreen();
39 std::string name_ = "abstract_display_controller_test";
40 sptr<SupportedScreenModes> modesInfo_;
41 std::recursive_mutex mutex_;
42 sptr<AbstractScreenController> absScreenController_ = nullptr;
43 sptr<AbstractDisplayController> absDisplayController_ = nullptr;
44 sptr<AbstractScreen> absScreen_ = nullptr;
45 ScreenId defaultScreenId_ = 0;
46 DisplayId defaultDisplayId_ = 0;
47 sptr<AbstractDisplay> absDisplay_ = nullptr;
48 sptr<DisplayCutoutController> displayCutoutController_ = nullptr;
49 };
50
SetUpTestCase()51 void AbstractDisplayControllerTest::SetUpTestCase()
52 {
53 }
54
TearDownTestCase()55 void AbstractDisplayControllerTest::TearDownTestCase()
56 {
57 #ifdef RS_ENABLE_VK
58 RSModifiersDrawThread::Destroy();
59 #endif
60 }
61
SetUp()62 void AbstractDisplayControllerTest::SetUp()
63 {
64 absDisplayController_ = new AbstractDisplayController(mutex_, [](DisplayId, sptr<DisplayInfo>,
65 const std::map<DisplayId, sptr<DisplayInfo>>&, DisplayStateChangeType) {});
66 ASSERT_NE(nullptr, absDisplayController_);
67 absScreenController_ = new AbstractScreenController(mutex_);
68 ASSERT_NE(nullptr, absScreenController_);
69 absDisplayController_->Init(absScreenController_);
70
71 ScreenId id = absScreenController_->GetDefaultAbstractScreenId();
72 defaultScreenId_ = id;
73
74 absScreen_ = absScreenController_->GetAbstractScreen(defaultScreenId_);
75 ASSERT_NE(nullptr, absScreen_);
76
77 InitScreen();
78 absDisplay_ = absDisplayController_->GetAbstractDisplayByScreen(defaultScreenId_);
79 ASSERT_NE(nullptr, absDisplay_);
80 defaultDisplayId_ = absDisplay_->GetId();
81 displayCutoutController_ = new DisplayCutoutController();
82 DisplayId displayid = 1;
83 absDisplayController_->abstractDisplayMap_.insert(std::make_pair(displayid, absDisplay_));
84 }
85
TearDown()86 void AbstractDisplayControllerTest::TearDown()
87 {
88 absScreenController_->ProcessScreenDisconnected(defaultScreenId_);
89 absScreenController_ = nullptr;
90 absDisplayController_ = nullptr;
91 displayCutoutController_ = nullptr;
92 }
93
InitScreen()94 void AbstractDisplayControllerTest::InitScreen()
95 {
96 modesInfo_ = new SupportedScreenModes();
97 modesInfo_->width_ = 200; // 200 is test width
98 modesInfo_->height_ = 200; // 200 is test height
99 modesInfo_->refreshRate_ = 60; // 60 is test data
100 absScreen_->modes_[0] = modesInfo_;
101 }
102
103 namespace {
104 /**
105 * @tc.name: OnAbstractScreenConnectAndDisConnect01
106 * @tc.desc: OnAbstractScreenConnectAndDisConnect with nullptr
107 * @tc.type: FUNC
108 */
109 HWTEST_F(AbstractDisplayControllerTest, OnAbstractScreenConnectAndDisConnect01, TestSize.Level1)
110 {
111 sptr<AbstractScreen> absScreen = nullptr;
112 absDisplayController_->OnAbstractScreenConnect(absScreen);
113 absDisplayController_->OnAbstractScreenDisconnect(absScreen);
114 absScreen_->groupDmsId_ = SCREEN_ID_INVALID;
115 EXPECT_EQ(nullptr, absScreen_->GetGroup());
116 absDisplayController_->OnAbstractScreenConnect(absScreen_);
117 absDisplayController_->OnAbstractScreenDisconnect(absScreen_);
118 }
119
120 /**
121 * @tc.name: OnAbstractScreenConnectAndDisConnect02
122 * @tc.desc: OnAbstractScreenConnectAndDisConnect02 with different ScreenCombination
123 * @tc.type: FUNC
124 */
125 HWTEST_F(AbstractDisplayControllerTest, OnAbstractScreenConnectAndDisConnect02, TestSize.Level1)
126 {
127 auto group = absScreen_->GetGroup();
128 EXPECT_NE(nullptr, group);
129 group->screenMap_.insert(std::make_pair(100, absScreen_)); // 100 is test data
130 group->combination_ = ScreenCombination::SCREEN_MIRROR;
131 absDisplayController_->OnAbstractScreenConnect(absScreen_);
132 absDisplayController_->OnAbstractScreenDisconnect(absScreen_);
133 }
134
135 /**
136 * @tc.name: OnAbstractScreenConnectAndDisConnect03
137 * @tc.desc: OnAbstractScreenConnectAndDisConnect03 with different ScreenCombination
138 * @tc.type: FUNC
139 */
140 HWTEST_F(AbstractDisplayControllerTest, OnAbstractScreenConnectAndDisConnect03, TestSize.Level1)
141 {
142 auto group = absScreen_->GetGroup();
143 EXPECT_NE(nullptr, group);
144 group->screenMap_.insert(std::make_pair(100, absScreen_)); // 100 is test data
145 group->combination_ = ScreenCombination::SCREEN_EXPAND;
146 absDisplayController_->OnAbstractScreenConnect(absScreen_);
147 absDisplayController_->OnAbstractScreenDisconnect(absScreen_);
148
149 group->combination_ = static_cast<ScreenCombination>(100); // 100 is test data
150 absDisplayController_->OnAbstractScreenConnect(absScreen_);
151 absDisplayController_->OnAbstractScreenDisconnect(absScreen_);
152 }
153
154 /**
155 * @tc.name: ProcessNormalScreenDisconnected01
156 * @tc.desc: ProcessNormalScreenDisconnected01 failed
157 * @tc.type: FUNC
158 */
159 HWTEST_F(AbstractDisplayControllerTest, ProcessNormalScreenDisconnected01, TestSize.Level1)
160 {
161 sptr<AbstractScreen> absScreen = nullptr;
162 sptr<AbstractScreenGroup> screenGroup = nullptr;
163 auto displayId = absDisplayController_->ProcessNormalScreenDisconnected(absScreen, absScreen_->GetGroup(),
164 absDisplay_);
165 EXPECT_EQ(DISPLAY_ID_INVALID, displayId);
166
167 displayId = absDisplayController_->ProcessNormalScreenDisconnected(absScreen_, screenGroup, absDisplay_);
168 EXPECT_EQ(DISPLAY_ID_INVALID, displayId);
169
170 absDisplayController_->abstractDisplayMap_.clear();
171 displayId = absDisplayController_->ProcessNormalScreenDisconnected(absScreen_, screenGroup, absDisplay_);
172 EXPECT_EQ(DISPLAY_ID_INVALID, displayId);
173 }
174
175 /**
176 * @tc.name: ProcessExpandScreenDisconnected01
177 * @tc.desc: ProcessExpandScreenDisconnected01 failed
178 * @tc.type: FUNC
179 */
180 HWTEST_F(AbstractDisplayControllerTest, ProcessExpandScreenDisconnected01, TestSize.Level1)
181 {
182 sptr<AbstractScreen> absScreen = nullptr;
183 sptr<AbstractScreenGroup> screenGroup = nullptr;
184 auto displayId = absDisplayController_->ProcessExpandScreenDisconnected(absScreen, absScreen_->GetGroup(),
185 absDisplay_);
186 EXPECT_EQ(DISPLAY_ID_INVALID, displayId);
187
188 displayId = absDisplayController_->ProcessExpandScreenDisconnected(absScreen_, screenGroup, absDisplay_);
189 EXPECT_EQ(DISPLAY_ID_INVALID, displayId);
190
191 absDisplayController_->abstractDisplayMap_.clear();
192 displayId = absDisplayController_->ProcessExpandScreenDisconnected(absScreen_, screenGroup, absDisplay_);
193 EXPECT_EQ(DISPLAY_ID_INVALID, displayId);
194 }
195
196 /**
197 * @tc.name: OnAbstractScreenChange01
198 * @tc.desc: OnAbstractScreenChange01
199 * @tc.type: FUNC
200 */
201 HWTEST_F(AbstractDisplayControllerTest, OnAbstractScreenChange01, TestSize.Level1)
202 {
203 sptr<AbstractScreen> absScreen = nullptr;
204 absDisplayController_->OnAbstractScreenChange(absScreen, DisplayChangeEvent::UNKNOWN);
205 EXPECT_NE(nullptr, absScreen_);
206 absDisplayController_->OnAbstractScreenChange(absScreen_, DisplayChangeEvent::UNKNOWN);
207 absDisplayController_->OnAbstractScreenChange(absScreen_, DisplayChangeEvent::DISPLAY_SIZE_CHANGED);
208 absDisplayController_->OnAbstractScreenChange(absScreen_, DisplayChangeEvent::UPDATE_ORIENTATION);
209 absDisplayController_->OnAbstractScreenChange(absScreen_, DisplayChangeEvent::UPDATE_ORIENTATION_FROM_WINDOW);
210 absDisplayController_->OnAbstractScreenChange(absScreen_, DisplayChangeEvent::DISPLAY_VIRTUAL_PIXEL_RATIO_CHANGED);
211 absDisplayController_->OnAbstractScreenChange(absScreen_, DisplayChangeEvent::UPDATE_ROTATION);
212 absDisplayController_->OnAbstractScreenChange(absScreen_, DisplayChangeEvent::UPDATE_ROTATION_FROM_WINDOW);
213 }
214
215 /**
216 * @tc.name: ProcessDisplayRotationChange01
217 * @tc.desc: ProcessDisplayRotationChange01
218 * @tc.type: FUNC
219 */
220 HWTEST_F(AbstractDisplayControllerTest, ProcessDisplayRotationChange01, TestSize.Level1)
221 {
222 sptr<AbstractScreen> absScreen = new AbstractScreen(absScreenController_, name_, 1, 1);
223 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen));
224 absDisplayController_->ProcessDisplayRotationChange(absScreen, DisplayStateChangeType::UPDATE_ROTATION);
225
226 auto display = absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_);
227 EXPECT_NE(nullptr, display);
228 display->rotation_ = absScreen_->rotation_;
229 EXPECT_EQ(false, display->RequestRotation(absScreen->rotation_));
230 absDisplayController_->ProcessDisplayRotationChange(absScreen_, DisplayStateChangeType::UPDATE_ROTATION);
231 display->rotation_ = Rotation::ROTATION_270;
232 EXPECT_EQ(true, display->RequestRotation(absScreen_->rotation_));
233 absDisplayController_->ProcessDisplayRotationChange(absScreen_, DisplayStateChangeType::UPDATE_ROTATION);
234 }
235
236 /**
237 * @tc.name: ProcessDisplayCompression01
238 * @tc.desc: ProcessDisplayCompression01
239 * @tc.type: FUNC
240 */
241 HWTEST_F(AbstractDisplayControllerTest, ProcessDisplayCompression01, TestSize.Level1)
242 {
243 bool isWaterfallDisplayOrigin = DisplayCutoutController::IsWaterfallDisplay();
244 bool isCompressionEnableOrigin =
245 DisplayCutoutController::IsWaterfallAreaCompressionEnableWhenHorizontal();
246 uint32_t testSizeOrigin = DisplayCutoutController::GetWaterfallAreaCompressionSizeWhenHorizontal();
247 DisplayCutoutController::SetIsWaterfallDisplay(true);
248 DisplayCutoutController::SetWaterfallAreaCompressionEnableWhenHorzontal(true);
249 EXPECT_EQ(true, DisplayCutoutController::IsWaterfallAreaCompressionEnableWhenHorizontal());
250 DisplayCutoutController::SetWaterfallAreaCompressionSizeWhenHorizontal(20); // 20 is test size
251 uint32_t sizeInVp = DisplayCutoutController::GetWaterfallAreaCompressionSizeWhenHorizontal();
252 EXPECT_EQ(20, sizeInVp);
253 auto mode = absScreen_->GetActiveScreenMode();
254 EXPECT_NE(nullptr, mode);
255 mode->height_ = 60; // 60 is test data
256 absDisplayController_->ProcessDisplayCompression(absScreen_);
257
258 mode->width_ = 60; // 60 is test data
259 absDisplayController_->ProcessDisplayCompression(absScreen_);
260
261 mode->height_ = 100; // 100 is test data
262 absDisplayController_->ProcessDisplayCompression(absScreen_);
263
264 mode->width_ = 100; // 100 is test data
265 absDisplayController_->ProcessDisplayCompression(absScreen_);
266
267 sptr<DisplayInfo> displayInfo = new(std::nothrow) DisplayInfo();
268 displayInfo->rotation_ = static_cast<Rotation>(Rotation::ROTATION_90);
269
270 auto oriIdx = absScreen_->activeIdx_;
271 absScreen_->activeIdx_ = -1;
272 absDisplayController_->ProcessDisplayCompression(absScreen_);
273 absScreen_->activeIdx_ = oriIdx;
274
275 DisplayCutoutController::SetIsWaterfallDisplay(isWaterfallDisplayOrigin);
276 DisplayCutoutController::SetWaterfallAreaCompressionEnableWhenHorzontal(isCompressionEnableOrigin);
277 DisplayCutoutController::SetWaterfallAreaCompressionSizeWhenHorizontal(testSizeOrigin);
278 }
279
280 /**
281 * @tc.name: GetAbstractDisplayByAbsScreen01
282 * @tc.desc: GetAbstractDisplayByAbsScreen01
283 * @tc.type: FUNC
284 */
285 HWTEST_F(AbstractDisplayControllerTest, GetAbstractDisplayByAbsScreen01, TestSize.Level1)
286 {
287 auto ret = absDisplayController_->GetAbstractDisplayByAbsScreen(nullptr);
288 EXPECT_EQ(nullptr, ret);
289
290 EXPECT_NE(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_));
291
292 auto oriId = absScreen_->groupDmsId_;
293 absScreen_->groupDmsId_ = SCREEN_ID_INVALID;
294 sptr<AbstractScreenGroup> group = absScreen_->GetGroup();
295 EXPECT_EQ(nullptr, group);
296 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_));
297 absScreen_->groupDmsId_ = oriId;
298
299 group = absScreen_->GetGroup();
300 EXPECT_NE(nullptr, group);
301 absDisplayController_->abstractDisplayMap_.clear();
302 group->combination_ = ScreenCombination::SCREEN_ALONE;
303 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_));
304
305 group->combination_ = ScreenCombination::SCREEN_EXPAND;
306 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_));
307
308 group->combination_ = ScreenCombination::SCREEN_MIRROR;
309 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_));
310
311 group->combination_ = static_cast<ScreenCombination>(100); // 100 is test data
312 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_));
313 }
314
315 /**
316 * @tc.name: ProcessDisplayUpdateOrientation01
317 * @tc.desc: ProcessDisplayUpdateOrientation01
318 * @tc.type: FUNC
319 */
320 HWTEST_F(AbstractDisplayControllerTest, ProcessDisplayUpdateOrientation01, TestSize.Level1)
321 {
322 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen_, DisplayStateChangeType::UPDATE_ROTATION);
323
324 auto oriId = absScreen_->groupDmsId_;
325 absScreen_->groupDmsId_ = SCREEN_ID_INVALID;
326 sptr<AbstractScreenGroup> group = absScreen_->GetGroup();
327 EXPECT_EQ(nullptr, group);
328 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen_, DisplayStateChangeType::UPDATE_ROTATION);
329 absScreen_->groupDmsId_ = oriId;
330
331 group = absScreen_->GetGroup();
332 EXPECT_NE(nullptr, group);
333 absDisplayController_->abstractDisplayMap_.clear();
334 group->combination_ = ScreenCombination::SCREEN_ALONE;
335 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen_, DisplayStateChangeType::UPDATE_ROTATION);
336
337 group->combination_ = ScreenCombination::SCREEN_EXPAND;
338 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen_, DisplayStateChangeType::UPDATE_ROTATION);
339
340 group->combination_ = ScreenCombination::SCREEN_MIRROR;
341 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen_, DisplayStateChangeType::UPDATE_ROTATION);
342
343 group->combination_ = static_cast<ScreenCombination>(100); // 100 is test data
344 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen_, DisplayStateChangeType::UPDATE_ROTATION);
345
346 sptr<AbstractScreen> absScreen = new AbstractScreen(absScreenController_, name_, 1, 1);
347 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen));
348 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen, DisplayStateChangeType::UPDATE_ROTATION);
349 }
350
351 /**
352 * @tc.name: ProcessDisplaySizeChange01
353 * @tc.desc: ProcessDisplaySizeChange01
354 * @tc.type: FUNC
355 */
356 HWTEST_F(AbstractDisplayControllerTest, ProcessDisplaySizeChange01, TestSize.Level1)
357 {
358 absDisplayController_->ProcessDisplaySizeChange(absScreen_);
359 auto display = absDisplayController_->abstractDisplayMap_.at(defaultDisplayId_);
360 EXPECT_NE(nullptr, display);
361 display->screenId_ = SCREEN_ID_INVALID;
362 absDisplayController_->ProcessDisplaySizeChange(absScreen_);
363
364 absDisplayController_->abstractDisplayMap_[defaultDisplayId_] = nullptr;
365 absDisplayController_->ProcessDisplaySizeChange(absScreen_);
366
367 absDisplayController_->abstractDisplayMap_.clear();
368 absDisplayController_->ProcessDisplaySizeChange(absScreen_);
369
370 SetUp();
371 sptr<AbstractScreen> absScreen = new AbstractScreen(absScreenController_, name_, 1, 1);
372 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen));
373 absDisplayController_->ProcessDisplaySizeChange(absScreen);
374
375 auto oriIdx = absScreen_->activeIdx_;
376 absScreen_->activeIdx_ = -1;
377 auto mode = absScreen_->GetActiveScreenMode();
378 EXPECT_EQ(nullptr, mode);
379 absDisplayController_->ProcessDisplaySizeChange(absScreen_);
380 absScreen_->activeIdx_ = oriIdx;
381 }
382
383 /**
384 * @tc.name: UpdateDisplaySize01
385 * @tc.desc: UpdateDisplaySize01
386 * @tc.type: FUNC
387 */
388 HWTEST_F(AbstractDisplayControllerTest, UpdateDisplaySize01, TestSize.Level1)
389 {
390 EXPECT_EQ(false, absDisplayController_->UpdateDisplaySize(nullptr, modesInfo_));
391
392 EXPECT_EQ(false, absDisplayController_->UpdateDisplaySize(absDisplay_, nullptr));
393
394 EXPECT_EQ(false, absDisplayController_->UpdateDisplaySize(nullptr, nullptr));
395
396 sptr<SupportedScreenModes> info = new SupportedScreenModes();
397
398 info->height_ = absDisplay_->GetHeight();
399 info->width_ = absDisplay_->GetWidth();
400 EXPECT_EQ(false, absDisplayController_->UpdateDisplaySize(absDisplay_, info));
401
402 info->width_ = absDisplay_->GetWidth();
403 info->height_ = 200; // 200 is test height
404 EXPECT_EQ(true, absDisplayController_->UpdateDisplaySize(absDisplay_, info));
405
406 info->width_ = 200; // 200 is test height
407 info->height_ = absDisplay_->GetHeight();
408 EXPECT_EQ(true, absDisplayController_->UpdateDisplaySize(absDisplay_, info));
409
410 info->width_ = 100; // 100 is test width
411 info->height_ = 100; // 100 is test height
412 EXPECT_EQ(true, absDisplayController_->UpdateDisplaySize(absDisplay_, info));
413 }
414
415 /**
416 * @tc.name: ProcessVirtualPixelRatioChange01
417 * @tc.desc: ProcessVirtualPixelRatioChange01
418 * @tc.type: FUNC
419 */
420 HWTEST_F(AbstractDisplayControllerTest, ProcessVirtualPixelRatioChange01, TestSize.Level1)
421 {
422 auto display = absDisplayController_->abstractDisplayMap_.at(defaultDisplayId_);
423 EXPECT_NE(nullptr, display);
424 display->screenId_ = SCREEN_ID_INVALID;
425 absDisplayController_->ProcessVirtualPixelRatioChange(absScreen_);
426
427 absDisplayController_->abstractDisplayMap_.clear();
428 absDisplayController_->ProcessVirtualPixelRatioChange(absScreen_);
429 }
430
431 /**
432 * @tc.name: BindAloneScreenLocked01
433 * @tc.desc: BindAloneScreenLocked01
434 * @tc.type: FUNC
435 */
436 HWTEST_F(AbstractDisplayControllerTest, BindAloneScreenLocked01, TestSize.Level1)
437 {
438 absDisplayController_->BindAloneScreenLocked(nullptr);
439
440 sptr<AbstractScreen> absScreen = new AbstractScreen(absScreenController_, name_, 1, 1);
441 EXPECT_NE(nullptr, absScreen);
442 absDisplayController_->BindAloneScreenLocked(absScreen);
443
444 absDisplayController_->dummyDisplay_ = absDisplay_;
445 sptr<SupportedScreenModes> info = absScreen_->GetActiveScreenMode();
446 info->height_ = absDisplay_->GetHeight();
447 info->width_ = absDisplay_->GetWidth();
448 bool updateFlag = static_cast<uint32_t>(absDisplayController_->dummyDisplay_->GetHeight()) == info->height_
449 && static_cast<uint32_t>(absDisplayController_->dummyDisplay_->GetWidth()) == info->width_;
450 EXPECT_NE(nullptr, info);
451 EXPECT_EQ(true, updateFlag);
452 absDisplayController_->BindAloneScreenLocked(absScreen_);
453
454 absDisplay_->SetWidth(100); // 100 is test size
455 absDisplay_->SetHeight(100); // 100 is test size
456 absDisplayController_->dummyDisplay_ = absDisplay_;
457 EXPECT_NE(nullptr, info);
458 updateFlag = static_cast<uint32_t>(absDisplayController_->dummyDisplay_->GetHeight()) == info->height_
459 && static_cast<uint32_t>(absDisplayController_->dummyDisplay_->GetWidth()) == info->width_;
460 EXPECT_EQ(false, updateFlag);
461 absDisplayController_->BindAloneScreenLocked(absScreen_);
462
463 auto oriIdx = absScreen_->activeIdx_;
464 absScreen_->activeIdx_ = -1;
465 info = absScreen_->GetActiveScreenMode();
466 EXPECT_EQ(nullptr, info);
467 absDisplayController_->BindAloneScreenLocked(absScreen_);
468 absScreen_->activeIdx_ = oriIdx;
469 }
470
471 /**
472 * @tc.name: AddScreenToExpandLocked01
473 * @tc.desc: AddScreenToExpandLocked01
474 * @tc.type: FUNC
475 */
476 HWTEST_F(AbstractDisplayControllerTest, AddScreenToExpandLocked01, TestSize.Level1)
477 {
478 absDisplayController_->AddScreenToExpandLocked(nullptr);
479
480 sptr<AbstractScreen> absScreen = new AbstractScreen(absScreenController_, name_, 1, 1);
481 EXPECT_NE(nullptr, absScreen);
482 absDisplayController_->AddScreenToExpandLocked(absScreen);
483
484 absDisplayController_->AddScreenToExpandLocked(absScreen_);
485
486 absDisplayController_->abstractDisplayMap_.clear();
487 absDisplayController_->AddScreenToExpandLocked(absScreen_);
488
489 absDisplayController_->abstractDisplayMap_.clear();
490 absScreen_->type_ = ScreenType::VIRTUAL;
491 absDisplayController_->AddScreenToExpandLocked(absScreen_);
492 }
493
494 /**
495 * @tc.name: SetFreeze01
496 * @tc.desc: SetFreeze01
497 * @tc.type: FUNC
498 */
499 HWTEST_F(AbstractDisplayControllerTest, SetFreeze01, TestSize.Level1)
500 {
501 absDisplayController_->abstractDisplayMap_.clear();
502 std::vector<DisplayId> displayIds(1, 0);
503 auto iter = absDisplayController_->abstractDisplayMap_.find(0);
504 EXPECT_EQ(true, iter == absDisplayController_->abstractDisplayMap_.end());
505 absDisplayController_->SetFreeze(displayIds, false);
506 }
507
508 /**
509 * @tc.name: GetAllDisplayInfoOfGroup01
510 * @tc.desc: GetAllDisplayInfoOfGroup01
511 * @tc.type: FUNC
512 */
513 HWTEST_F(AbstractDisplayControllerTest, GetAllDisplayInfoOfGroup01, TestSize.Level1)
514 {
515 sptr<DisplayInfo> displayInfo = new DisplayInfo();
516 EXPECT_NE(nullptr, displayInfo);
517 displayInfo->SetScreenGroupId(100); // 100 is test size
518 auto displayInfoMap = absDisplayController_->GetAllDisplayInfoOfGroup(displayInfo);
519 EXPECT_EQ(0, displayInfoMap.size());
520 }
521
522 /**
523 * @tc.name: GetDefaultDisplayId01
524 * @tc.desc: GetDefaultDisplayId01
525 * @tc.type: FUNC
526 */
527 HWTEST_F(AbstractDisplayControllerTest, GetDefaultDisplayId01, TestSize.Level1)
528 {
529 auto absDisplayController = new AbstractDisplayController(mutex_, [](DisplayId, sptr<DisplayInfo>,
__anon646fb5aa0302(DisplayId, sptr<DisplayInfo>, const std::map<DisplayId, sptr<DisplayInfo>>&, DisplayStateChangeType) 530 const std::map<DisplayId, sptr<DisplayInfo>>&, DisplayStateChangeType) {});
531 EXPECT_NE(nullptr, absDisplayController);
532 absDisplayController->abstractScreenController_ = new AbstractScreenController(mutex_);
533 EXPECT_NE(nullptr, absDisplayController->abstractScreenController_);
534 ScreenId defaultScreenId = absDisplayController->abstractScreenController_->GetDefaultAbstractScreenId();
535 sptr<AbstractDisplay> defaultDisplay = absDisplayController->GetAbstractDisplayByScreen(defaultScreenId);
536 EXPECT_EQ(nullptr, defaultDisplay);
537 EXPECT_EQ(DISPLAY_ID_INVALID, absDisplayController->GetDefaultDisplayId());
538 }
539
540 /**
541 * @tc.name: GetAbstractDisplayByScreen
542 * @tc.desc: GetAbstractDisplayByScreen
543 * @tc.type: FUNC
544 */
545 HWTEST_F(AbstractDisplayControllerTest, GetAbstractDisplayByScreen, TestSize.Level1)
546 {
547 ScreenId screenId = SCREEN_ID_INVALID;
548 auto ret = absDisplayController_->GetAbstractDisplayByScreen(screenId);
549 EXPECT_EQ(nullptr, ret);
550 }
551
552 /**
553 * @tc.name: GetScreenSnapshot
554 * @tc.desc: GetScreenSnapshot
555 * @tc.type: FUNC
556 */
557 HWTEST_F(AbstractDisplayControllerTest, GetScreenSnapshot01, TestSize.Level1)
558 {
559 ScreenId screenId = SCREEN_ID_INVALID;
560 auto ret = absDisplayController_->GetScreenSnapshot(screenId);
561 EXPECT_EQ(nullptr, ret);
562 }
563
564 /**
565 * @tc.name: GetScreenSnapshot
566 * @tc.desc: GetScreenSnapshot
567 * @tc.type: FUNC
568 */
569 HWTEST_F(AbstractDisplayControllerTest, GetScreenSnapshot02, TestSize.Level1)
570 {
571 ScreenId screenId = 2;
572 auto ret = absDisplayController_->GetScreenSnapshot(screenId);
573 EXPECT_EQ(nullptr, ret);
574 }
575
576 /**
577 * @tc.name: GetScreenSnapshot
578 * @tc.desc: GetScreenSnapshot
579 * @tc.type: FUNC
580 */
581 HWTEST_F(AbstractDisplayControllerTest, GetScreenSnapshot03, TestSize.Level1)
582 {
583 ScreenId screenId = 1;
584 auto ret = absDisplayController_->GetScreenSnapshot(screenId);
585 ASSERT_EQ(nullptr, ret);
586 }
587
588 /**
589 * @tc.name: FeatureTest
590 * @tc.desc: SetScreenOffsetInner
591 * @tc.type: FUNC
592 */
593 HWTEST_F(AbstractDisplayControllerTest, FeatureTest, TestSize.Level1)
594 {
595 ScreenId screenId = 0;
596 auto ret = absDisplayController_->SetScreenOffsetInner(screenId);
597 EXPECT_TRUE(ret);
598 screenId = 6;
599 ret = absDisplayController_->SetScreenOffsetInner(screenId);
600 EXPECT_FALSE(ret);
601 }
602 }
603 } // namespace Rosen
604 } // namespace OHOS
605