1 /*
2 * Copyright (c) 2022-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 #include "display_manager.h"
18 #include "display_manager_proxy.h"
19 #include "window.h"
20
21 #include "mock_display_manager_adapter.h"
22 #include "singleton_mocker.h"
23 #include "display_manager.cpp"
24 #include "window_scene.h"
25 #include "scene_board_judgement.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32 using Mocker = SingletonMocker<DisplayManagerAdapter, MockDisplayManagerAdapter>;
33 class DmMockScreenshotListener : public DisplayManager::IScreenshotListener {
34 public:
OnScreenshot(const ScreenshotInfo info)35 void OnScreenshot(const ScreenshotInfo info) override {}
36 };
37 class DmMockDisplayListener : public DisplayManager::IDisplayListener {
38 public:
OnCreate(DisplayId)39 void OnCreate(DisplayId) override {}
OnDestroy(DisplayId)40 void OnDestroy(DisplayId) override {}
OnChange(DisplayId)41 void OnChange(DisplayId) override {}
42 };
43 class DisplayManagerTest : public testing::Test {
44 public:
45 static void SetUpTestCase();
46 static void TearDownTestCase();
47 virtual void SetUp() override;
48 virtual void TearDown() override;
49 };
50
SetUpTestCase()51 void DisplayManagerTest::SetUpTestCase()
52 {
53 }
54
TearDownTestCase()55 void DisplayManagerTest::TearDownTestCase()
56 {
57 }
58
SetUp()59 void DisplayManagerTest::SetUp()
60 {
61 }
62
TearDown()63 void DisplayManagerTest::TearDown()
64 {
65 }
66
67 namespace {
68 /**
69 * @tc.name: Freeze01
70 * @tc.desc: success
71 * @tc.type: FUNC
72 */
73 HWTEST_F(DisplayManagerTest, Freeze01, Function | SmallTest | Level1)
74 {
75 std::vector<DisplayId> displayIds;
76 displayIds.push_back(0);
77 bool ret = DisplayManager::GetInstance().Freeze(displayIds);
78 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
79 ASSERT_TRUE(ret);
80 } else {
81 ASSERT_FALSE(ret);
82 }
83 }
84
85 /**
86 * @tc.name: Freeze02
87 * @tc.desc: test Freeze displayIds exceed the maximum
88 * @tc.type: FUNC
89 */
90 HWTEST_F(DisplayManagerTest, Freeze02, Function | SmallTest | Level1)
91 {
92 std::vector<DisplayId> displayIds;
93 for (uint32_t i = 0; i < 33; i++) { // MAX_DISPLAY_SIZE + 1
94 displayIds.push_back(i);
95 }
96 bool ret = DisplayManager::GetInstance().Freeze(displayIds);
97 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
98 ASSERT_FALSE(ret);
99 }
100 }
101
102 /**
103 * @tc.name: Freeze03
104 * @tc.desc: test Freeze displayIds empty
105 * @tc.type: FUNC
106 */
107 HWTEST_F(DisplayManagerTest, Freeze03, Function | SmallTest | Level1)
108 {
109 std::vector<DisplayId> displayIds;
110 bool ret = DisplayManager::GetInstance().Freeze(displayIds);
111 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
112 ASSERT_FALSE(ret);
113 }
114 }
115
116 /**
117 * @tc.name: Unfreeze01
118 * @tc.desc: success
119 * @tc.type: FUNC
120 */
121 HWTEST_F(DisplayManagerTest, Unfreeze01, Function | SmallTest | Level1)
122 {
123 std::vector<DisplayId> displayIds;
124 displayIds.push_back(0);
125 bool ret = DisplayManager::GetInstance().Unfreeze(displayIds);
126 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
127 ASSERT_TRUE(ret);
128 } else {
129 ASSERT_FALSE(ret);
130 }
131 }
132
133 /**
134 * @tc.name: Unfreeze02
135 * @tc.desc: test Freeze displayIds exceed the maximum
136 * @tc.type: FUNC
137 */
138 HWTEST_F(DisplayManagerTest, Unfreeze02, Function | SmallTest | Level1)
139 {
140 std::vector<DisplayId> displayIds;
141 for (uint32_t i = 0; i < 33; i++) { // MAX_DISPLAY_SIZE + 1
142 displayIds.push_back(i);
143 }
144
145 bool ret = DisplayManager::GetInstance().Unfreeze(displayIds);
146 ASSERT_FALSE(ret);
147 }
148
149 /**
150 * @tc.name: Unfreeze03
151 * @tc.desc: test Freeze displayIds empty
152 * @tc.type: FUNC
153 */
154 HWTEST_F(DisplayManagerTest, Unfreeze03, Function | SmallTest | Level1)
155 {
156 std::vector<DisplayId> displayIds;
157 bool ret = DisplayManager::GetInstance().Unfreeze(displayIds);
158 ASSERT_FALSE(ret);
159 }
160
161 /**
162 * @tc.name: RegisterScreenshotListener01
163 * @tc.desc: test RegisterScreenshotListener with null listener
164 * @tc.type: FUNC
165 */
166 HWTEST_F(DisplayManagerTest, RegisterScreenshotListener01, Function | SmallTest | Level1)
167 {
168 DMError ret = DisplayManager::GetInstance().RegisterScreenshotListener(nullptr);
169 ASSERT_FALSE(DMError::DM_OK == ret);
170 }
171
172 /**
173 * @tc.name: RegisterScreenshotListener02
174 * @tc.desc: test RegisterScreenshotListener with null listener
175 * @tc.type: FUNC
176 */
177 HWTEST_F(DisplayManagerTest, RegisterScreenshotListener02, Function | SmallTest | Level1)
178 {
179 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
180 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_NULLPTR));
181 sptr<DisplayManager::IScreenshotListener> listener = new DmMockScreenshotListener();
182 DMError ret = DisplayManager::GetInstance().RegisterScreenshotListener(listener);
183 ASSERT_FALSE(DMError::DM_OK == ret);
184 }
185
186 /**
187 * @tc.name: UnregisterScreenshotListener01
188 * @tc.desc: test UnregisterScreenshotListener with null listener
189 * @tc.type: FUNC
190 */
191 HWTEST_F(DisplayManagerTest, UnregisterScreenshotListener01, Function | SmallTest | Level1)
192 {
193 DMError ret = DisplayManager::GetInstance().UnregisterScreenshotListener(nullptr);
194 ASSERT_FALSE(DMError::DM_OK == ret);
195 }
196
197 /**
198 * @tc.name: OnDisplayCreate01
199 * @tc.desc: OnDisplayCreate
200 * @tc.type: FUNC
201 */
202 HWTEST_F(DisplayManagerTest, OnDisplayCreate01, Function | SmallTest | Level1)
203 {
204 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
205 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
206 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
207 DisplayManager::GetInstance().RegisterDisplayListener(listener);
208 auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
209 ASSERT_NE(displayManagerListener, nullptr);
210 displayManagerListener->OnDisplayCreate(nullptr);
211 sptr<DisplayInfo> displayInfo = new DisplayInfo();
212 displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
213 displayManagerListener->OnDisplayCreate(displayInfo);
214 displayInfo->SetDisplayId(0);
215 displayManagerListener->OnDisplayCreate(displayInfo);
216 ASSERT_NE(displayManagerListener->pImpl_, nullptr);
217 displayManagerListener->pImpl_ = nullptr;
218 displayManagerListener->OnDisplayCreate(displayInfo);
219 DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
220 }
221
222 /**
223 * @tc.name: CheckRectValid
224 * @tc.desc: CheckRectValid all
225 * @tc.type: FUNC
226 */
227 HWTEST_F(DisplayManagerTest, CheckRectValid, Function | SmallTest | Level1)
228 {
229 int32_t oriHeight = 500;
230 int32_t oriWidth = 500;
231 Media::Rect rect = {.left = 1, .top = 1, .width = 1, .height = 1};
232 bool ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
233 ASSERT_TRUE(ret);
234 rect.left = -1;
235 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
236 ASSERT_FALSE(ret);
237 rect.left = 1;
238 rect.top = -1;
239 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
240 ASSERT_FALSE(ret);
241 rect.top = 1;
242 rect.width = -1;
243 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
244 ASSERT_FALSE(ret);
245 rect.width = 1;
246 rect.height = -1;
247 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
248 ASSERT_FALSE(ret);
249 rect.width = 500;
250 rect.height = 1;
251 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
252 ASSERT_FALSE(ret);
253 rect.width = 1;
254 rect.height = 500;
255 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
256 ASSERT_FALSE(ret);
257 }
258
259 /**
260 * @tc.name: CheckSizeValid
261 * @tc.desc: CheckSizeValid all
262 * @tc.type: FUNC
263 */
264 HWTEST_F(DisplayManagerTest, CheckSizeValid, Function | SmallTest | Level1)
265 {
266 int32_t oriHeight = 500;
267 int32_t oriWidth = 500;
268 Media::Size size = {.width = 1, .height = 1};
269 bool ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
270 ASSERT_TRUE(ret);
271 size.width = -1;
272 ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
273 ASSERT_FALSE(ret);
274 size.width = 1;
275 size.height = -1;
276 ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
277 ASSERT_FALSE(ret);
278 size.width = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT + 1;
279 size.height = 1;
280 ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
281 ASSERT_FALSE(ret);
282 size.width = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT;
283 size.height = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT + 1;
284 ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
285 ASSERT_FALSE(ret);
286 }
287
288 /**
289 * @tc.name: ImplGetDefaultDisplay01
290 * @tc.desc: Impl GetDefaultDisplay nullptr
291 * @tc.type: FUNC
292 */
293 HWTEST_F(DisplayManagerTest, ImplGetDefaultDisplay01, Function | SmallTest | Level1)
294 {
295 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
296 EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(1).WillOnce(Return(nullptr));
297 sptr<Display> display = DisplayManager::GetInstance().pImpl_->GetDefaultDisplay();
298 ASSERT_EQ(display, nullptr);
299 }
300
301 /**
302 * @tc.name: GetDisplayByScreen
303 * @tc.desc: for interface coverage & check GetDisplayByScreen
304 * @tc.type: FUNC
305 */
306 HWTEST_F(DisplayManagerTest, GetDisplayByScreen, Function | SmallTest | Level1)
307 {
308 auto& displayManager = DisplayManager::GetInstance();
309 sptr<Display> display = displayManager.GetDisplayByScreen(SCREEN_ID_INVALID);
310 ASSERT_EQ(display, nullptr);
311
312 sptr<DisplayInfo> displayInfo = new DisplayInfo();
313 displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
314 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
315 EXPECT_CALL(m->Mock(), GetDisplayInfoByScreenId(_)).Times(1).WillOnce(Return(displayInfo));
316 display = displayManager.GetDisplayByScreen(1);
317 ASSERT_EQ(display, nullptr);
318 }
319
320 /**
321 * @tc.name: ImplGetDefaultDisplaySync
322 * @tc.desc: Impl GetDefaultDisplaySync nullptr
323 * @tc.type: FUNC
324 */
325 HWTEST_F(DisplayManagerTest, ImplGetDefaultDisplaySync, Function | SmallTest | Level1)
326 {
327 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
328 EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(6).WillRepeatedly(Return(nullptr));
329 sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplaySync();
330 ASSERT_EQ(display, nullptr);
331 }
332
333 /**
334 * @tc.name: GetScreenBrightness
335 * @tc.desc: GetScreenBrightness fun
336 * @tc.type: FUNC
337 */
338 HWTEST_F(DisplayManagerTest, GetScreenBrightness, Function | SmallTest | Level1)
339 {
340 uint64_t screenId = 2;
341 auto ret = DisplayManager::GetInstance().GetScreenBrightness(screenId);
342 ASSERT_FALSE(ret == 1);
343 }
344
345 /**
346 * @tc.name: GetDisplayById
347 * @tc.desc: GetDisplayById fun
348 * @tc.type: FUNC
349 */
350 HWTEST_F(DisplayManagerTest, GetDisplayById, Function | SmallTest | Level1)
351 {
352 DisplayId displayId = 0;
353 DisplayManager::GetInstance().destroyed_ = true;
354 auto ret = DisplayManager::GetInstance().GetDisplayById(displayId);
355 ASSERT_EQ(ret, nullptr);
356 }
357
358 /**
359 * @tc.name: RegisterPrivateWindowListener
360 * @tc.desc: RegisterPrivateWindowListener fun
361 * @tc.type: FUNC
362 */
363 HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListener, Function | SmallTest | Level1)
364 {
365 sptr<DisplayManager::IPrivateWindowListener> listener;
366 auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListener(listener);
367 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
368 }
369
370 /**
371 * @tc.name: UnregisterPrivateWindowListener
372 * @tc.desc: UnregisterPrivateWindowListener fun
373 * @tc.type: FUNC
374 */
375 HWTEST_F(DisplayManagerTest, UnregisterPrivateWindowListener, Function | SmallTest | Level1)
376 {
377 sptr<DisplayManager::IPrivateWindowListener> listener = nullptr;
378 sptr<DisplayManager::Impl> impl_;
379 auto ret = DisplayManager::GetInstance().UnregisterPrivateWindowListener(listener);
380 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
381 }
382
383 /**
384 * @tc.name: ImplUnregisterPrivateWindowListener
385 * @tc.desc: ImplUnregisterPrivateWindowListener fun
386 * @tc.type: FUNC
387 */
388 HWTEST_F(DisplayManagerTest, ImplUnregisterPrivateWindowListener, Function | SmallTest | Level1)
389 {
390 std::recursive_mutex mutex;
391 DisplayManager::Impl impl(mutex);
392 sptr<DisplayManager::IPrivateWindowListener> listener;
393 auto ret = impl.UnregisterPrivateWindowListener(listener);
394 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
395 }
396
397 /**
398 * @tc.name: ImplUnregisterFoldStatusListener
399 * @tc.desc: ImplUnregisterFoldStatusListener fun
400 * @tc.type: FUNC
401 */
402 HWTEST_F(DisplayManagerTest, ImplUnregisterFoldStatusListener, Function | SmallTest | Level1)
403 {
404 sptr<DisplayManager::IFoldStatusListener> listener;
405 auto ret = DisplayManager::GetInstance().pImpl_->UnregisterFoldStatusListener(listener);
406 ASSERT_NE(ret, DMError::DM_OK);
407 listener.clear();
408 }
409
410 /**
411 * @tc.name: RegisterFoldStatusListener
412 * @tc.desc: RegisterFoldStatusListener fun
413 * @tc.type: FUNC
414 */
415 HWTEST_F(DisplayManagerTest, RegisterFoldStatusListener, Function | SmallTest | Level1)
416 {
417 sptr<DisplayManager::IFoldStatusListener> listener;
418 auto ret = DisplayManager::GetInstance().RegisterFoldStatusListener(listener);
419 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
420 listener = new DisplayManager::IFoldStatusListener();
421 ret = DisplayManager::GetInstance().RegisterFoldStatusListener(listener);
422 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterFoldStatusListener(listener));
423 listener.clear();
424 }
425
426 /**
427 * @tc.name: ImplRegisterFoldStatusListener
428 * @tc.desc: ImplRegisterFoldStatusListener fun
429 * @tc.type: FUNC
430 */
431 HWTEST_F(DisplayManagerTest, ImplRegisterFoldStatusListener, Function | SmallTest | Level1)
432 {
433 sptr<DisplayManager::IFoldStatusListener> listener;
434 sptr<DisplayManager::Impl> impl_;
435 DisplayManager::GetInstance().pImpl_->foldStatusListenerAgent_ = nullptr;
436 sptr<DisplayManager::Impl::DisplayManagerFoldStatusAgent> foldStatusListenerAgent =
437 new DisplayManager::Impl::DisplayManagerFoldStatusAgent(impl_);
438 auto ret = DisplayManager::GetInstance().pImpl_->RegisterFoldStatusListener(listener);
439 ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
440 foldStatusListenerAgent,
441 DisplayManagerAgentType::FOLD_STATUS_CHANGED_LISTENER));
442 listener = nullptr;
443 foldStatusListenerAgent.clear();
444 }
445
446 /**
447 * @tc.name: UnregisterFoldStatusListener
448 * @tc.desc: UnregisterFoldStatusListener fun
449 * @tc.type: FUNC
450 */
451 HWTEST_F(DisplayManagerTest, UnregisterFoldStatusListener, Function | SmallTest | Level1)
452 {
453 sptr<DisplayManager::IFoldStatusListener> listener;
454 auto ret = DisplayManager::GetInstance().UnregisterFoldStatusListener(listener);
455 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
456 listener = new DisplayManager::IFoldStatusListener();
457 ret = DisplayManager::GetInstance().UnregisterFoldStatusListener(listener);
458 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterFoldStatusListener(listener));
459 listener.clear();
460 }
461
462 /**
463 * @tc.name: RegisterDisplayModeListener
464 * @tc.desc: RegisterDisplayModeListener fun
465 * @tc.type: FUNC
466 */
467 HWTEST_F(DisplayManagerTest, RegisterDisplayModeListener, Function | SmallTest | Level1)
468 {
469 sptr<DisplayManager::IDisplayModeListener> listener;
470 auto ret = DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
471 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
472 listener = new DisplayManager::IDisplayModeListener();
473 ret = DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
474 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterDisplayModeListener(listener));
475 listener.clear();
476 }
477
478 /**
479 * @tc.name: ImplRegisterDisplayModeListener
480 * @tc.desc: ImplRegisterDisplayModeListener fun
481 * @tc.type: FUNC
482 */
483 HWTEST_F(DisplayManagerTest, ImplRegisterDisplayModeListener, Function | SmallTest | Level1)
484 {
485 sptr<DisplayManager::IDisplayModeListener> listener;
486 DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ = nullptr;
487 sptr<DisplayManager::Impl> impl_;
488 sptr<DisplayManager::Impl::DisplayManagerDisplayModeAgent> displayModeListenerAgent =
489 new DisplayManager::Impl::DisplayManagerDisplayModeAgent(impl_);
490 auto ret = DisplayManager::GetInstance().pImpl_->RegisterDisplayModeListener(listener);
491 ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
492 displayModeListenerAgent,
493 DisplayManagerAgentType::DISPLAY_MODE_CHANGED_LISTENER));
494 listener.clear();
495 displayModeListenerAgent.clear();
496 }
497
498 /**
499 * @tc.name: UnregisterDisplayModeListener
500 * @tc.desc: UnregisterDisplayModeListener fun
501 * @tc.type: FUNC
502 */
503 HWTEST_F(DisplayManagerTest, UnregisterDisplayModeListener, Function | SmallTest | Level1)
504 {
505 sptr<DisplayManager::IDisplayModeListener> listener;
506 auto ret = DisplayManager::GetInstance().UnregisterDisplayModeListener(listener);
507 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
508 listener = new DisplayManager::IDisplayModeListener();
509 ret = DisplayManager::GetInstance().UnregisterDisplayModeListener(listener);
510 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterDisplayModeListener(listener));
511 listener.clear();
512 }
513
514 /**
515 * @tc.name: ImplUnregisterDisplayModeListener
516 * @tc.desc: ImplUnregisterDisplayModeListener fun
517 * @tc.type: FUNC
518 */
519 HWTEST_F(DisplayManagerTest, ImplUnregisterDisplayModeListener, Function | SmallTest | Level1)
520 {
521 sptr<DisplayManager::IDisplayModeListener> listener;
522 auto ret = DisplayManager::GetInstance().pImpl_->UnregisterDisplayModeListener(listener);
523 ASSERT_EQ(ret, DMError::DM_OK);
524 listener.clear();
525 }
526
527 /**
528 * @tc.name: OnDisplayCreate02
529 * @tc.desc: OnDisplayCreate
530 * @tc.type: FUNC
531 */
532 HWTEST_F(DisplayManagerTest, OnDisplayCreate02, Function | SmallTest | Level1)
533 {
534 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
535 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
536 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
537 DisplayManager::GetInstance().RegisterDisplayListener(listener);
538 auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
539 ASSERT_NE(displayManagerListener, nullptr);
540
541 sptr<DisplayInfo> displayInfo = nullptr;
542 displayManagerListener->OnDisplayCreate(displayInfo);
543 ASSERT_NE(displayManagerListener->pImpl_, nullptr);
544 }
545
546 /**
547 * @tc.name: RegisterDisplayListener
548 * @tc.desc: RegisterDisplayListener fun
549 * @tc.type: FUNC
550 */
551 HWTEST_F(DisplayManagerTest, RegisterDisplayListener, Function | SmallTest | Level1)
552 {
553 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
554 bool hasPrivate = true;
555 DisplayManager::GetInstance().pImpl_->NotifyPrivateWindowStateChanged(hasPrivate);
556 auto ret = DisplayManager::GetInstance().RegisterDisplayListener(listener);
557 ASSERT_EQ(ret, DMError::DM_OK);
558 }
559
560 /**
561 * @tc.name: UnregisterDisplayListener
562 * @tc.desc: UnregisterDisplayListener fun
563 * @tc.type: FUNC
564 */
565 HWTEST_F(DisplayManagerTest, UnregisterDisplayListener, Function | SmallTest | Level1)
566 {
567 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
568 sptr<DisplayManager::Impl> impl_;
569 auto ret = DisplayManager::GetInstance().UnregisterDisplayListener(listener);
570 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
571 }
572
573 /**
574 * @tc.name: HasPrivateWindow
575 * @tc.desc: HasPrivateWindow fun
576 * @tc.type: FUNC
577 */
578 HWTEST_F(DisplayManagerTest, HasPrivateWindow, Function | SmallTest | Level1)
579 {
580 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
581 bool hasPrivateWindow = false;
582 auto ret = DisplayManager::GetInstance().HasPrivateWindow(0, hasPrivateWindow);
583 ASSERT_EQ(ret, DMError::DM_OK);
584 }
585
586 /**
587 * @tc.name: HasPrivateWindow02
588 * @tc.desc: HasPrivateWindow fun
589 * @tc.type: FUNC
590 */
591 HWTEST_F(DisplayManagerTest, HasPrivateWindow02, Function | SmallTest | Level1)
592 {
593 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
594 sptr<DisplayManager::Impl> impl_;
595 bool hasPrivateWindow = false;
596 auto ret = DisplayManager::GetInstance().pImpl_->HasPrivateWindow(0, hasPrivateWindow);
597 ASSERT_EQ(ret, DMError::DM_OK);
598 }
599
600 /**
601 * @tc.name: IsFoldable
602 * @tc.desc: IsFoldable all
603 * @tc.type: FUNC
604 */
605 HWTEST_F(DisplayManagerTest, IsFoldable, Function | SmallTest | Level1)
606 {
607 bool ret = DisplayManager::GetInstance().IsFoldable();
608 ASSERT_FALSE(ret);
609 }
610
611 /**
612 * @tc.name: IsFoldable
613 * @tc.desc: IsFoldable fun
614 * @tc.type: FUNC
615 */
616 HWTEST_F(DisplayManagerTest, IsFoldable01, Function | SmallTest | Level1)
617 {
618 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
619 FoldDisplayMode mode = FoldDisplayMode{0};
620 DisplayManager::GetInstance().SetFoldDisplayMode(mode);
621 DisplayManager::GetInstance().SetFoldStatusLocked(false);
622 sptr<DisplayManager::Impl> impl_;
623 auto ret = DisplayManager::GetInstance().pImpl_->IsFoldable();
624 ASSERT_FALSE(ret);
625 }
626
627 /**
628 * @tc.name: AddSurfaceNodeToDisplay
629 * @tc.desc: AddSurfaceNodeToDisplay fun
630 * @tc.type: FUNC
631 */
632 HWTEST_F(DisplayManagerTest, AddSurfaceNodeToDisplay, Function | SmallTest | Level1)
633 {
634 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
635 std::shared_ptr<class RSSurfaceNode> surfaceNode;
636 auto ret = DisplayManager::GetInstance().AddSurfaceNodeToDisplay(0, surfaceNode);
637 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
638 }
639
640 /**
641 * @tc.name: RemoveSurfaceNodeFromDisplay
642 * @tc.desc: RemoveSurfaceNodeFromDisplay fun
643 * @tc.type: FUNC
644 */
645 HWTEST_F(DisplayManagerTest, RemoveSurfaceNodeFromDisplay, Function | SmallTest | Level1)
646 {
647 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
648 std::shared_ptr<class RSSurfaceNode> surfaceNode;
649 DisplayManager::GetInstance().OnRemoteDied();
650 auto ret = DisplayManager::GetInstance().RemoveSurfaceNodeFromDisplay(0, surfaceNode);
651 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
652 }
653 }
654 } // namespace Rosen
655 } // namespace OHOS