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