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