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 }
78
TearDown()79 void AbstractDisplayControllerTest::TearDown()
80 {
81 absScreenController_->ProcessScreenDisconnected(defaultScreenId_);
82 absScreenController_ = nullptr;
83 absDisplayController_ = nullptr;
84 displayCutoutController_ = nullptr;
85 }
86
InitScreen()87 void AbstractDisplayControllerTest::InitScreen()
88 {
89 modesInfo_ = new SupportedScreenModes();
90 modesInfo_->width_ = 200; // 200 is test width
91 modesInfo_->height_ = 200; // 200 is test height
92 modesInfo_->refreshRate_ = 60; // 60 is test data
93 absScreen_->modes_[0] = modesInfo_;
94 }
95
96 namespace {
97 /**
98 * @tc.name: OnAbstractScreenConnectAndDisConnect01
99 * @tc.desc: OnAbstractScreenConnectAndDisConnect with nullptr
100 * @tc.type: FUNC
101 */
102 HWTEST_F(AbstractDisplayControllerTest, OnAbstractScreenConnectAndDisConnect01, Function | SmallTest | Level3)
103 {
104 sptr<AbstractScreen> absScreen = nullptr;
105 absDisplayController_->OnAbstractScreenConnect(absScreen);
106 absDisplayController_->OnAbstractScreenDisconnect(absScreen);
107 absScreen_->groupDmsId_ = SCREEN_ID_INVALID;
108 EXPECT_EQ(nullptr, absScreen_->GetGroup());
109 absDisplayController_->OnAbstractScreenConnect(absScreen_);
110 absDisplayController_->OnAbstractScreenDisconnect(absScreen_);
111 }
112
113 /**
114 * @tc.name: OnAbstractScreenConnectAndDisConnect02
115 * @tc.desc: OnAbstractScreenConnectAndDisConnect02 with different ScreenCombination
116 * @tc.type: FUNC
117 */
118 HWTEST_F(AbstractDisplayControllerTest, OnAbstractScreenConnectAndDisConnect02, Function | SmallTest | Level3)
119 {
120 auto group = absScreen_->GetGroup();
121 EXPECT_NE(nullptr, group);
122 group->abstractScreenMap_.insert(std::make_pair(100, std::make_pair(absScreen_, Point(0, 0)))); // 100 is test data
123 group->combination_ = ScreenCombination::SCREEN_MIRROR;
124 absDisplayController_->OnAbstractScreenConnect(absScreen_);
125 absDisplayController_->OnAbstractScreenDisconnect(absScreen_);
126 }
127
128 /**
129 * @tc.name: OnAbstractScreenConnectAndDisConnect03
130 * @tc.desc: OnAbstractScreenConnectAndDisConnect03 with different ScreenCombination
131 * @tc.type: FUNC
132 */
133 HWTEST_F(AbstractDisplayControllerTest, OnAbstractScreenConnectAndDisConnect03, Function | SmallTest | Level3)
134 {
135 auto group = absScreen_->GetGroup();
136 EXPECT_NE(nullptr, group);
137 group->abstractScreenMap_.insert(std::make_pair(100, std::make_pair(absScreen_, Point(0, 0)))); // 100 is test data
138 group->combination_ = ScreenCombination::SCREEN_EXPAND;
139 absDisplayController_->OnAbstractScreenConnect(absScreen_);
140 absDisplayController_->OnAbstractScreenDisconnect(absScreen_);
141
142 group->combination_ = static_cast<ScreenCombination>(100); // 100 is test data
143 absDisplayController_->OnAbstractScreenConnect(absScreen_);
144 absDisplayController_->OnAbstractScreenDisconnect(absScreen_);
145 }
146
147 /**
148 * @tc.name: ProcessNormalScreenDisconnected01
149 * @tc.desc: ProcessNormalScreenDisconnected01 failed
150 * @tc.type: FUNC
151 */
152 HWTEST_F(AbstractDisplayControllerTest, ProcessNormalScreenDisconnected01, Function | SmallTest | Level3)
153 {
154 sptr<AbstractScreen> absScreen = nullptr;
155 sptr<AbstractScreenGroup> screenGroup = nullptr;
156 auto displayId = absDisplayController_->ProcessNormalScreenDisconnected(absScreen, absScreen_->GetGroup(),
157 absDisplay_);
158 EXPECT_EQ(DISPLAY_ID_INVALID, displayId);
159
160 displayId = absDisplayController_->ProcessNormalScreenDisconnected(absScreen_, screenGroup, absDisplay_);
161 EXPECT_EQ(DISPLAY_ID_INVALID, displayId);
162
163 absDisplayController_->abstractDisplayMap_.clear();
164 displayId = absDisplayController_->ProcessNormalScreenDisconnected(absScreen_, screenGroup, absDisplay_);
165 EXPECT_EQ(DISPLAY_ID_INVALID, displayId);
166 }
167
168 /**
169 * @tc.name: ProcessExpandScreenDisconnected01
170 * @tc.desc: ProcessExpandScreenDisconnected01 failed
171 * @tc.type: FUNC
172 */
173 HWTEST_F(AbstractDisplayControllerTest, ProcessExpandScreenDisconnected01, Function | SmallTest | Level3)
174 {
175 sptr<AbstractScreen> absScreen = nullptr;
176 sptr<AbstractScreenGroup> screenGroup = nullptr;
177 auto displayId = absDisplayController_->ProcessExpandScreenDisconnected(absScreen, absScreen_->GetGroup(),
178 absDisplay_);
179 EXPECT_EQ(DISPLAY_ID_INVALID, displayId);
180
181 displayId = absDisplayController_->ProcessExpandScreenDisconnected(absScreen_, screenGroup, absDisplay_);
182 EXPECT_EQ(DISPLAY_ID_INVALID, displayId);
183
184 absDisplayController_->abstractDisplayMap_.clear();
185 displayId = absDisplayController_->ProcessExpandScreenDisconnected(absScreen_, screenGroup, absDisplay_);
186 EXPECT_EQ(DISPLAY_ID_INVALID, displayId);
187 }
188
189 /**
190 * @tc.name: OnAbstractScreenChange01
191 * @tc.desc: OnAbstractScreenChange01
192 * @tc.type: FUNC
193 */
194 HWTEST_F(AbstractDisplayControllerTest, OnAbstractScreenChange01, Function | SmallTest | Level3)
195 {
196 sptr<AbstractScreen> absScreen = nullptr;
197 absDisplayController_->OnAbstractScreenChange(absScreen, DisplayChangeEvent::UNKNOWN);
198 EXPECT_NE(nullptr, absScreen_);
199 absDisplayController_->OnAbstractScreenChange(absScreen_, DisplayChangeEvent::UNKNOWN);
200 absDisplayController_->OnAbstractScreenChange(absScreen_, DisplayChangeEvent::DISPLAY_SIZE_CHANGED);
201 }
202
203 /**
204 * @tc.name: ProcessDisplayRotationChange01
205 * @tc.desc: ProcessDisplayRotationChange01
206 * @tc.type: FUNC
207 */
208 HWTEST_F(AbstractDisplayControllerTest, ProcessDisplayRotationChange01, Function | SmallTest | Level3)
209 {
210 sptr<AbstractScreen> absScreen = new AbstractScreen(absScreenController_, name_, 1, 1);
211 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen));
212 absDisplayController_->ProcessDisplayRotationChange(absScreen);
213
214 auto display = absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_);
215 EXPECT_NE(nullptr, display);
216 display->rotation_ = absScreen_->rotation_;
217 EXPECT_EQ(false, display->RequestRotation(absScreen->rotation_));
218 absDisplayController_->ProcessDisplayRotationChange(absScreen_);
219 }
220
221 /**
222 * @tc.name: ProcessDisplayCompression01
223 * @tc.desc: ProcessDisplayCompression01
224 * @tc.type: FUNC
225 */
226 HWTEST_F(AbstractDisplayControllerTest, ProcessDisplayCompression01, Function | SmallTest | Level3)
227 {
228 bool isWaterfallDisplayOrigin = DisplayCutoutController::IsWaterfallDisplay();
229 bool isCompressionEnableOrigin =
230 DisplayCutoutController::IsWaterfallAreaCompressionEnableWhenHorizontal();
231 uint32_t testSizeOrigin = DisplayCutoutController::GetWaterfallAreaCompressionSizeWhenHorizontal();
232 DisplayCutoutController::SetIsWaterfallDisplay(true);
233 DisplayCutoutController::SetWaterfallAreaCompressionEnableWhenHorzontal(true);
234 EXPECT_EQ(true, DisplayCutoutController::IsWaterfallAreaCompressionEnableWhenHorizontal());
235 DisplayCutoutController::SetWaterfallAreaCompressionSizeWhenHorizontal(20); // 20 is test size
236 uint32_t sizeInVp = DisplayCutoutController::GetWaterfallAreaCompressionSizeWhenHorizontal();
237 EXPECT_NE(0, sizeInVp);
238 auto mode = absScreen_->GetActiveScreenMode();
239 EXPECT_NE(nullptr, mode);
240 mode->height_ = 60; // 60 is test data
241 absDisplayController_->ProcessDisplayCompression(absScreen_);
242
243 mode->width_ = 60; // 60 is test data
244 absDisplayController_->ProcessDisplayCompression(absScreen_);
245
246 mode->height_ = 100; // 100 is test data
247 absDisplayController_->ProcessDisplayCompression(absScreen_);
248
249 auto oriIdx = absScreen_->activeIdx_;
250 absScreen_->activeIdx_ = -1;
251 absDisplayController_->ProcessDisplayCompression(absScreen_);
252 absScreen_->activeIdx_ = oriIdx;
253
254 DisplayCutoutController::SetIsWaterfallDisplay(isWaterfallDisplayOrigin);
255 DisplayCutoutController::SetWaterfallAreaCompressionEnableWhenHorzontal(isCompressionEnableOrigin);
256 DisplayCutoutController::SetWaterfallAreaCompressionSizeWhenHorizontal(testSizeOrigin);
257 }
258
259 /**
260 * @tc.name: GetAbstractDisplayByAbsScreen01
261 * @tc.desc: GetAbstractDisplayByAbsScreen01
262 * @tc.type: FUNC
263 */
264 HWTEST_F(AbstractDisplayControllerTest, GetAbstractDisplayByAbsScreen01, Function | SmallTest | Level3)
265 {
266 EXPECT_NE(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_));
267
268 auto oriId = absScreen_->groupDmsId_;
269 absScreen_->groupDmsId_ = SCREEN_ID_INVALID;
270 sptr<AbstractScreenGroup> group = absScreen_->GetGroup();
271 EXPECT_EQ(nullptr, group);
272 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_));
273 absScreen_->groupDmsId_ = oriId;
274
275 group = absScreen_->GetGroup();
276 EXPECT_NE(nullptr, group);
277 absDisplayController_->abstractDisplayMap_.clear();
278 group->combination_ = ScreenCombination::SCREEN_ALONE;
279 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_));
280
281 group->combination_ = ScreenCombination::SCREEN_EXPAND;
282 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_));
283
284 group->combination_ = ScreenCombination::SCREEN_MIRROR;
285 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_));
286
287 group->combination_ = static_cast<ScreenCombination>(100); // 100 is test data
288 EXPECT_EQ(nullptr, absDisplayController_->GetAbstractDisplayByAbsScreen(absScreen_));
289 }
290
291 /**
292 * @tc.name: ProcessDisplayUpdateOrientation01
293 * @tc.desc: ProcessDisplayUpdateOrientation01
294 * @tc.type: FUNC
295 */
296 HWTEST_F(AbstractDisplayControllerTest, ProcessDisplayUpdateOrientation01, Function | SmallTest | Level3)
297 {
298 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen_);
299
300 auto oriId = absScreen_->groupDmsId_;
301 absScreen_->groupDmsId_ = SCREEN_ID_INVALID;
302 sptr<AbstractScreenGroup> group = absScreen_->GetGroup();
303 EXPECT_EQ(nullptr, group);
304 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen_);
305 absScreen_->groupDmsId_ = oriId;
306
307 group = absScreen_->GetGroup();
308 EXPECT_NE(nullptr, group);
309 absDisplayController_->abstractDisplayMap_.clear();
310 group->combination_ = ScreenCombination::SCREEN_ALONE;
311 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen_);
312
313 group->combination_ = ScreenCombination::SCREEN_EXPAND;
314 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen_);
315
316 group->combination_ = ScreenCombination::SCREEN_MIRROR;
317 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen_);
318
319 group->combination_ = static_cast<ScreenCombination>(100); // 100 is test data
320 absDisplayController_->ProcessDisplayUpdateOrientation(absScreen_);
321 }
322
323 /**
324 * @tc.name: ProcessDisplaySizeChange01
325 * @tc.desc: ProcessDisplaySizeChange01
326 * @tc.type: FUNC
327 */
328 HWTEST_F(AbstractDisplayControllerTest, ProcessDisplaySizeChange01, Function | SmallTest | Level3)
329 {
330 absDisplayController_->ProcessDisplaySizeChange(absScreen_);
331 auto display = absDisplayController_->abstractDisplayMap_.at(defaultDisplayId_);
332 EXPECT_NE(nullptr, display);
333 display->screenId_ = SCREEN_ID_INVALID;
334 absDisplayController_->ProcessDisplaySizeChange(absScreen_);
335
336 absDisplayController_->abstractDisplayMap_[defaultDisplayId_] = nullptr;
337 absDisplayController_->ProcessDisplaySizeChange(absScreen_);
338
339 absDisplayController_->abstractDisplayMap_.clear();
340 absDisplayController_->ProcessDisplaySizeChange(absScreen_);
341
342 auto oriIdx = absScreen_->activeIdx_;
343 absScreen_->activeIdx_ = -1;
344 auto mode = absScreen_->GetActiveScreenMode();
345 EXPECT_EQ(nullptr, mode);
346 absDisplayController_->ProcessDisplaySizeChange(absScreen_);
347 absScreen_->activeIdx_ = oriIdx;
348 }
349
350 /**
351 * @tc.name: UpdateDisplaySize01
352 * @tc.desc: UpdateDisplaySize01
353 * @tc.type: FUNC
354 */
355 HWTEST_F(AbstractDisplayControllerTest, UpdateDisplaySize01, Function | SmallTest | Level3)
356 {
357 EXPECT_EQ(false, absDisplayController_->UpdateDisplaySize(nullptr, modesInfo_));
358
359 EXPECT_EQ(false, absDisplayController_->UpdateDisplaySize(absDisplay_, nullptr));
360
361 EXPECT_EQ(false, absDisplayController_->UpdateDisplaySize(nullptr, nullptr));
362
363 sptr<SupportedScreenModes> info = new SupportedScreenModes();
364
365 info->height_ = absDisplay_->GetHeight();
366 info->width_ = absDisplay_->GetWidth();
367 EXPECT_EQ(false, absDisplayController_->UpdateDisplaySize(absDisplay_, info));
368
369 info->width_ = absDisplay_->GetWidth();
370 info->height_ = 200; // 200 is test height
371 EXPECT_EQ(true, absDisplayController_->UpdateDisplaySize(absDisplay_, info));
372
373 info->width_ = 200; // 200 is test height
374 info->height_ = absDisplay_->GetHeight();
375 EXPECT_EQ(true, absDisplayController_->UpdateDisplaySize(absDisplay_, info));
376
377 info->width_ = 100; // 100 is test width
378 info->height_ = 100; // 100 is test height
379 EXPECT_EQ(true, absDisplayController_->UpdateDisplaySize(absDisplay_, info));
380 }
381
382 /**
383 * @tc.name: ProcessVirtualPixelRatioChange01
384 * @tc.desc: ProcessVirtualPixelRatioChange01
385 * @tc.type: FUNC
386 */
387 HWTEST_F(AbstractDisplayControllerTest, ProcessVirtualPixelRatioChange01, Function | SmallTest | Level3)
388 {
389 auto display = absDisplayController_->abstractDisplayMap_.at(defaultDisplayId_);
390 EXPECT_NE(nullptr, display);
391 display->screenId_ = SCREEN_ID_INVALID;
392 absDisplayController_->ProcessVirtualPixelRatioChange(absScreen_);
393
394 absDisplayController_->abstractDisplayMap_.clear();
395 absDisplayController_->ProcessVirtualPixelRatioChange(absScreen_);
396 }
397
398 /**
399 * @tc.name: BindAloneScreenLocked01
400 * @tc.desc: BindAloneScreenLocked01
401 * @tc.type: FUNC
402 */
403 HWTEST_F(AbstractDisplayControllerTest, BindAloneScreenLocked01, Function | SmallTest | Level3)
404 {
405 absDisplayController_->BindAloneScreenLocked(nullptr);
406
407 sptr<AbstractScreen> absScreen = new AbstractScreen(absScreenController_, name_, 1, 1);
408 EXPECT_NE(nullptr, absScreen);
409 absDisplayController_->BindAloneScreenLocked(absScreen);
410
411 absDisplayController_->dummyDisplay_ = absDisplay_;
412 sptr<SupportedScreenModes> info = absScreen_->GetActiveScreenMode();
413 info->height_ = absDisplay_->GetHeight();
414 info->width_ = absDisplay_->GetWidth();
415 bool updateFlag = static_cast<uint32_t>(absDisplayController_->dummyDisplay_->GetHeight()) == info->height_
416 && static_cast<uint32_t>(absDisplayController_->dummyDisplay_->GetWidth()) == info->width_;
417 EXPECT_NE(nullptr, info);
418 EXPECT_EQ(true, updateFlag);
419 absDisplayController_->BindAloneScreenLocked(absScreen_);
420
421 absDisplay_->SetWidth(100); // 100 is test size
422 absDisplay_->SetHeight(100); // 100 is test size
423 absDisplayController_->dummyDisplay_ = absDisplay_;
424 EXPECT_NE(nullptr, info);
425 updateFlag = static_cast<uint32_t>(absDisplayController_->dummyDisplay_->GetHeight()) == info->height_
426 && static_cast<uint32_t>(absDisplayController_->dummyDisplay_->GetWidth()) == info->width_;
427 EXPECT_EQ(false, updateFlag);
428 absDisplayController_->BindAloneScreenLocked(absScreen_);
429
430 auto oriIdx = absScreen_->activeIdx_;
431 absScreen_->activeIdx_ = -1;
432 info = absScreen_->GetActiveScreenMode();
433 EXPECT_EQ(nullptr, info);
434 absDisplayController_->BindAloneScreenLocked(absScreen_);
435 absScreen_->activeIdx_ = oriIdx;
436 }
437
438 /**
439 * @tc.name: AddScreenToExpandLocked01
440 * @tc.desc: AddScreenToExpandLocked01
441 * @tc.type: FUNC
442 */
443 HWTEST_F(AbstractDisplayControllerTest, AddScreenToExpandLocked01, Function | SmallTest | Level3)
444 {
445 absDisplayController_->AddScreenToExpandLocked(nullptr);
446
447 sptr<AbstractScreen> absScreen = new AbstractScreen(absScreenController_, name_, 1, 1);
448 EXPECT_NE(nullptr, absScreen);
449 absDisplayController_->AddScreenToExpandLocked(absScreen);
450
451 absDisplayController_->AddScreenToExpandLocked(absScreen_);
452
453 absDisplayController_->abstractDisplayMap_.clear();
454 absDisplayController_->AddScreenToExpandLocked(absScreen_);
455
456 absDisplayController_->abstractDisplayMap_.clear();
457 absScreen_->type_ = ScreenType::VIRTUAL;
458 absDisplayController_->AddScreenToExpandLocked(absScreen_);
459 }
460
461 /**
462 * @tc.name: SetFreeze01
463 * @tc.desc: SetFreeze01
464 * @tc.type: FUNC
465 */
466 HWTEST_F(AbstractDisplayControllerTest, SetFreeze01, Function | SmallTest | Level3)
467 {
468 absDisplayController_->abstractDisplayMap_.clear();
469 std::vector<DisplayId> displayIds(1, 0);
470 auto iter = absDisplayController_->abstractDisplayMap_.find(0);
471 EXPECT_EQ(true, iter == absDisplayController_->abstractDisplayMap_.end());
472 absDisplayController_->SetFreeze(displayIds, false);
473 }
474
475 /**
476 * @tc.name: GetAllDisplayInfoOfGroup01
477 * @tc.desc: GetAllDisplayInfoOfGroup01
478 * @tc.type: FUNC
479 */
480 HWTEST_F(AbstractDisplayControllerTest, GetAllDisplayInfoOfGroup01, Function | SmallTest | Level3)
481 {
482 sptr<DisplayInfo> displayInfo = new DisplayInfo();
483 EXPECT_NE(nullptr, displayInfo);
484 displayInfo->SetScreenGroupId(100); // 100 is test size
485 auto displayInfoMap = absDisplayController_->GetAllDisplayInfoOfGroup(displayInfo);
486 EXPECT_EQ(0, displayInfoMap.size());
487 }
488
489 /**
490 * @tc.name: GetDefaultDisplayId01
491 * @tc.desc: GetDefaultDisplayId01
492 * @tc.type: FUNC
493 */
494 HWTEST_F(AbstractDisplayControllerTest, GetDefaultDisplayId01, Function | SmallTest | Level3)
495 {
496 auto absDisplayController = new AbstractDisplayController(mutex_, [](DisplayId, sptr<DisplayInfo>,
__anonb964bc490302(DisplayId, sptr<DisplayInfo>, const std::map<DisplayId, sptr<DisplayInfo>>&, DisplayStateChangeType) 497 const std::map<DisplayId, sptr<DisplayInfo>>&, DisplayStateChangeType) {});
498 EXPECT_NE(nullptr, absDisplayController);
499 absDisplayController->abstractScreenController_ = new AbstractScreenController(mutex_);
500 EXPECT_NE(nullptr, absDisplayController->abstractScreenController_);
501 ScreenId defaultScreenId = absDisplayController->abstractScreenController_->GetDefaultAbstractScreenId();
502 sptr<AbstractDisplay> defaultDisplay = absDisplayController->GetAbstractDisplayByScreen(defaultScreenId);
503 EXPECT_EQ(nullptr, defaultDisplay);
504 EXPECT_EQ(DISPLAY_ID_INVALID, absDisplayController->GetDefaultDisplayId());
505 }
506 }
507 } // namespace Rosen
508 } // namespace OHOS
509