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 #include "dm_common.h"
21 
22 #include "mock_display_manager_adapter.h"
23 #include "singleton_mocker.h"
24 #include "display_manager.cpp"
25 #include "window_scene.h"
26 #include "scene_board_judgement.h"
27 
28 using namespace testing;
29 using namespace testing::ext;
30 
31 namespace OHOS {
32 namespace Rosen {
33 using Mocker = SingletonMocker<DisplayManagerAdapter, MockDisplayManagerAdapter>;
34 class DmMockScreenshotListener : public DisplayManager::IScreenshotListener {
35 public:
OnScreenshot(const ScreenshotInfo info)36     void OnScreenshot(const ScreenshotInfo info) override {}
37 };
38 class DmMockPrivateWindowListener : public DisplayManager::IPrivateWindowListener {
39 public:
40     void OnPrivateWindow([[maybe_unused]]bool) override {}
41 };
42 class DmMockFoldAngleListener : public DisplayManager::IFoldAngleListener {
43 public:
44     void OnFoldAngleChanged([[maybe_unused]]std::vector<float>) override {}
45 };
46 class DmMockCaptureStatusListener : public DisplayManager::ICaptureStatusListener {
47 public:
48     void  OnCaptureStatusChanged([[maybe_unused]]bool) override {}
49 };
50 class DmMockDisplayListener : public DisplayManager::IDisplayListener {
51 public:
OnCreate(DisplayId)52     void OnCreate(DisplayId) override {}
OnDestroy(DisplayId)53     void OnDestroy(DisplayId) override {}
OnChange(DisplayId)54     void OnChange(DisplayId) override {}
55 };
56 class DmMockDisplayPowerEventListener : public IDisplayPowerEventListener {
57 public:
OnDisplayPowerEvent(DisplayPowerEvent,EventStatus)58     void OnDisplayPowerEvent(DisplayPowerEvent, EventStatus) override {}
59 };
60 
61 class DisplayManagerTest : public testing::Test {
62 public:
63     static void SetUpTestCase();
64     static void TearDownTestCase();
65     virtual void SetUp() override;
66     virtual void TearDown() override;
67 };
68 
SetUpTestCase()69 void DisplayManagerTest::SetUpTestCase()
70 {
71 }
72 
TearDownTestCase()73 void DisplayManagerTest::TearDownTestCase()
74 {
75 }
76 
SetUp()77 void DisplayManagerTest::SetUp()
78 {
79 }
80 
TearDown()81 void DisplayManagerTest::TearDown()
82 {
83 }
84 
85 namespace {
86 /**
87  * @tc.name: Freeze01
88  * @tc.desc: success
89  * @tc.type: FUNC
90  */
91 HWTEST_F(DisplayManagerTest, Freeze01, Function | SmallTest | Level1)
92 {
93     std::vector<DisplayId> displayIds;
94     displayIds.push_back(0);
95     bool ret = DisplayManager::GetInstance().Freeze(displayIds);
96     if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
97         ASSERT_TRUE(ret);
98     } else {
99         ASSERT_FALSE(ret);
100     }
101 }
102 
103 /**
104  * @tc.name: Freeze02
105  * @tc.desc: test Freeze displayIds exceed the maximum
106  * @tc.type: FUNC
107  */
108 HWTEST_F(DisplayManagerTest, Freeze02, Function | SmallTest | Level1)
109 {
110     std::vector<DisplayId> displayIds;
111     for (uint32_t i = 0; i < 33; i++) { // MAX_DISPLAY_SIZE + 1
112         displayIds.push_back(i);
113     }
114     bool ret = DisplayManager::GetInstance().Freeze(displayIds);
115     if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
116         ASSERT_FALSE(ret);
117     }
118 }
119 
120 /**
121  * @tc.name: Freeze03
122  * @tc.desc: test Freeze displayIds empty
123  * @tc.type: FUNC
124  */
125 HWTEST_F(DisplayManagerTest, Freeze03, Function | SmallTest | Level1)
126 {
127     std::vector<DisplayId> displayIds;
128     bool ret = DisplayManager::GetInstance().Freeze(displayIds);
129     if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
130         ASSERT_FALSE(ret);
131     }
132 }
133 
134 /**
135  * @tc.name: Unfreeze01
136  * @tc.desc: success
137  * @tc.type: FUNC
138  */
139 HWTEST_F(DisplayManagerTest, Unfreeze01, Function | SmallTest | Level1)
140 {
141     std::vector<DisplayId> displayIds;
142     displayIds.push_back(0);
143     bool ret = DisplayManager::GetInstance().Unfreeze(displayIds);
144     if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
145         ASSERT_TRUE(ret);
146     } else {
147         ASSERT_FALSE(ret);
148     }
149 }
150 
151 /**
152  * @tc.name: Unfreeze02
153  * @tc.desc: test Freeze displayIds exceed the maximum
154  * @tc.type: FUNC
155  */
156 HWTEST_F(DisplayManagerTest, Unfreeze02, Function | SmallTest | Level1)
157 {
158     std::vector<DisplayId> displayIds;
159     for (uint32_t i = 0; i < 33; i++) { // MAX_DISPLAY_SIZE + 1
160         displayIds.push_back(i);
161     }
162 
163     bool ret = DisplayManager::GetInstance().Unfreeze(displayIds);
164     ASSERT_FALSE(ret);
165 }
166 
167 /**
168  * @tc.name: Unfreeze03
169  * @tc.desc: test Freeze displayIds empty
170  * @tc.type: FUNC
171  */
172 HWTEST_F(DisplayManagerTest, Unfreeze03, Function | SmallTest | Level1)
173 {
174     std::vector<DisplayId> displayIds;
175     bool ret = DisplayManager::GetInstance().Unfreeze(displayIds);
176     ASSERT_FALSE(ret);
177 }
178 
179 /**
180  * @tc.name: RegisterScreenshotListener01
181  * @tc.desc: test RegisterScreenshotListener with null listener
182  * @tc.type: FUNC
183  */
184 HWTEST_F(DisplayManagerTest, RegisterScreenshotListener01, Function | SmallTest | Level1)
185 {
186     DMError ret = DisplayManager::GetInstance().RegisterScreenshotListener(nullptr);
187     ASSERT_FALSE(DMError::DM_OK == ret);
188 }
189 
190 /**
191  * @tc.name: RegisterScreenshotListener02
192  * @tc.desc: test RegisterScreenshotListener with null listener
193  * @tc.type: FUNC
194  */
195 HWTEST_F(DisplayManagerTest, RegisterScreenshotListener02, Function | SmallTest | Level1)
196 {
197     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
198     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_NULLPTR));
199     sptr<DisplayManager::IScreenshotListener> listener = new DmMockScreenshotListener();
200     DMError ret = DisplayManager::GetInstance().RegisterScreenshotListener(listener);
201     ASSERT_FALSE(DMError::DM_OK == ret);
202 }
203 
204 /**
205  * @tc.name: UnregisterScreenshotListener01
206  * @tc.desc: test UnregisterScreenshotListener with null listener
207  * @tc.type: FUNC
208  */
209 HWTEST_F(DisplayManagerTest, UnregisterScreenshotListener01, Function | SmallTest | Level1)
210 {
211     DMError ret = DisplayManager::GetInstance().UnregisterScreenshotListener(nullptr);
212     ASSERT_FALSE(DMError::DM_OK == ret);
213 }
214 
215 /**
216  * @tc.name: UnregisterScreenshotListener02
217  * @tc.desc: test UnregisterScreenshotListener with null listener
218  * @tc.type: FUNC
219  */
220 HWTEST_F(DisplayManagerTest, UnregisterScreenshotListener02, Function | SmallTest | Level1)
221 {
222     sptr<DisplayManager::IScreenshotListener> listener = new DmMockScreenshotListener();
223     DMError ret = DisplayManager::GetInstance().UnregisterScreenshotListener(listener);
224     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
225 }
226 
227 /**
228  * @tc.name: OnDisplayCreate01
229  * @tc.desc: OnDisplayCreate
230  * @tc.type: FUNC
231  */
232 HWTEST_F(DisplayManagerTest, OnDisplayCreate01, Function | SmallTest | Level1)
233 {
234     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
235     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
236     sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
237     DisplayManager::GetInstance().RegisterDisplayListener(listener);
238     auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
239     ASSERT_NE(displayManagerListener, nullptr);
240     displayManagerListener->OnDisplayCreate(nullptr);
241     sptr<DisplayInfo> displayInfo = new DisplayInfo();
242     displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
243     displayManagerListener->OnDisplayCreate(displayInfo);
244     displayInfo->SetDisplayId(0);
245     displayManagerListener->OnDisplayCreate(displayInfo);
246     ASSERT_NE(displayManagerListener->pImpl_, nullptr);
247     displayManagerListener->pImpl_ = nullptr;
248     displayManagerListener->OnDisplayCreate(displayInfo);
249     DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
250 }
251 
252 /**
253  * @tc.name: OnDisplayDestroy
254  * @tc.desc: OnDisplayDestroy
255  * @tc.type: FUNC
256  */
257 HWTEST_F(DisplayManagerTest, OnDisplayDestroy, Function | SmallTest | Level1)
258 {
259     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
260     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
261     sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
262     DisplayManager::GetInstance().RegisterDisplayListener(listener);
263     auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
264     ASSERT_NE(displayManagerListener, nullptr);
265     displayManagerListener->OnDisplayDestroy(DISPLAY_ID_INVALID);
266     displayManagerListener->OnDisplayDestroy(0);
267     displayManagerListener->pImpl_ = nullptr;
268     displayManagerListener->OnDisplayDestroy(1);
269     DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
270 }
271 
272 /**
273  * @tc.name: OnDisplayChange
274  * @tc.desc: OnDisplayChange
275  * @tc.type: FUNC
276  */
277 HWTEST_F(DisplayManagerTest, OnDisplayChange, Function | SmallTest | Level1)
278 {
279     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
280     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
281     sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
282     DisplayManager::GetInstance().RegisterDisplayListener(listener);
283     auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
284     ASSERT_NE(displayManagerListener, nullptr);
285     DisplayChangeEvent event = DisplayChangeEvent::DISPLAY_SIZE_CHANGED;
286     displayManagerListener->OnDisplayChange(nullptr, event);
287     sptr<DisplayInfo> displayInfo = new DisplayInfo();
288     displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
289     displayManagerListener->OnDisplayChange(displayInfo, event);
290     displayInfo->SetDisplayId(0);
291     displayManagerListener->OnDisplayChange(displayInfo, event);
292     ASSERT_NE(displayManagerListener->pImpl_, nullptr);
293     displayManagerListener->pImpl_ = nullptr;
294     displayManagerListener->OnDisplayChange(displayInfo, event);
295     DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
296 }
297 
298 /**
299  * @tc.name: CheckRectValid
300  * @tc.desc: CheckRectValid all
301  * @tc.type: FUNC
302  */
303 HWTEST_F(DisplayManagerTest, CheckRectValid, Function | SmallTest | Level1)
304 {
305     int32_t oriHeight = 500;
306     int32_t oriWidth = 500;
307     Media::Rect rect = {.left = 1, .top = 1, .width = 1, .height = 1};
308     bool ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
309     ASSERT_TRUE(ret);
310     rect.left = -1;
311     ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
312     ASSERT_FALSE(ret);
313     rect.left = 1;
314     rect.top = -1;
315     ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
316     ASSERT_FALSE(ret);
317     rect.top = 1;
318     rect.width = -1;
319     ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
320     ASSERT_FALSE(ret);
321     rect.width = 1;
322     rect.height = -1;
323     ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
324     ASSERT_FALSE(ret);
325     rect.width = 500;
326     rect.height = 1;
327     ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
328     ASSERT_FALSE(ret);
329     rect.width = 1;
330     rect.height = 500;
331     ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
332     ASSERT_FALSE(ret);
333 }
334 
335 /**
336  * @tc.name: CheckSizeValid
337  * @tc.desc: CheckSizeValid all
338  * @tc.type: FUNC
339  */
340 HWTEST_F(DisplayManagerTest, CheckSizeValid, Function | SmallTest | Level1)
341 {
342     int32_t oriHeight = 500;
343     int32_t oriWidth = 500;
344     Media::Size size = {.width = 1, .height = 1};
345     bool ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
346     ASSERT_TRUE(ret);
347     size.width = -1;
348     ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
349     ASSERT_FALSE(ret);
350     size.width = 1;
351     size.height = -1;
352     ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
353     ASSERT_FALSE(ret);
354     size.width = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT + 1;
355     size.height = 1;
356     ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
357     ASSERT_FALSE(ret);
358     size.width = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT;
359     size.height = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT + 1;
360     ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
361     ASSERT_FALSE(ret);
362 }
363 
364 /**
365  * @tc.name: ImplGetDefaultDisplay01
366  * @tc.desc: Impl GetDefaultDisplay nullptr
367  * @tc.type: FUNC
368  */
369 HWTEST_F(DisplayManagerTest, ImplGetDefaultDisplay01, Function | SmallTest | Level1)
370 {
371     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
372     EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(1).WillOnce(Return(nullptr));
373     sptr<Display> display = DisplayManager::GetInstance().pImpl_->GetDefaultDisplay();
374     ASSERT_EQ(display, nullptr);
375 }
376 
377 /**
378  * @tc.name: GetDisplayByScreen
379  * @tc.desc: for interface coverage & check GetDisplayByScreen
380  * @tc.type: FUNC
381  */
382 HWTEST_F(DisplayManagerTest, GetDisplayByScreen, Function | SmallTest | Level1)
383 {
384     auto& displayManager = DisplayManager::GetInstance();
385     sptr<Display> display = displayManager.GetDisplayByScreen(SCREEN_ID_INVALID);
386     ASSERT_EQ(display, nullptr);
387 
388     sptr<DisplayInfo> displayInfo = new DisplayInfo();
389     displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
390     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
391     EXPECT_CALL(m->Mock(), GetDisplayInfoByScreenId(_)).Times(1).WillOnce(Return(displayInfo));
392     display = displayManager.GetDisplayByScreen(1);
393     ASSERT_EQ(display, nullptr);
394 }
395 
396 /**
397  * @tc.name: ImplGetDefaultDisplaySync
398  * @tc.desc: Impl GetDefaultDisplaySync nullptr
399  * @tc.type: FUNC
400  */
401 HWTEST_F(DisplayManagerTest, ImplGetDefaultDisplaySync, Function | SmallTest | Level1)
402 {
403     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
404     EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(6).WillRepeatedly(Return(nullptr));
405     sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplaySync();
406     ASSERT_EQ(display, nullptr);
407 }
408 
409 /**
410  * @tc.name: GetScreenBrightness
411  * @tc.desc: GetScreenBrightness fun
412  * @tc.type: FUNC
413  */
414 HWTEST_F(DisplayManagerTest, GetScreenBrightness, Function | SmallTest | Level1)
415 {
416     uint64_t screenId = 2;
417     auto ret = DisplayManager::GetInstance().GetScreenBrightness(screenId);
418     ASSERT_FALSE(ret == 1);
419 }
420 
421 /**
422  * @tc.name: GetDisplayById
423  * @tc.desc: GetDisplayById fun
424  * @tc.type: FUNC
425  */
426 HWTEST_F(DisplayManagerTest, GetDisplayById, Function | SmallTest | Level1)
427 {
428     DisplayId displayId = -1;
429     g_dmIsDestroyed = true;
430     auto ret = DisplayManager::GetInstance().GetDisplayById(displayId);
431     ASSERT_EQ(ret, nullptr);
432 }
433 
434 /**
435  * @tc.name: RegisterPrivateWindowListener
436  * @tc.desc: RegisterPrivateWindowListener fun
437  * @tc.type: FUNC
438  */
439 HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListener01, Function | SmallTest | Level1)
440 {
441     sptr<DisplayManager::IPrivateWindowListener> listener;
442     auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListener(listener);
443     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
444 }
445 
446 /**
447  * @tc.name: RegisterPrivateWindowListener
448  * @tc.desc: RegisterPrivateWindowListener fun
449  * @tc.type: FUNC
450  */
451 HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListener02, Function | SmallTest | Level1)
452 {
453     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
454     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
455     sptr<DisplayManager::IPrivateWindowListener> listener = new DmMockPrivateWindowListener();
456     auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListener(listener);
457     ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
458 }
459 
460 /**
461  * @tc.name: UnregisterPrivateWindowListener
462  * @tc.desc: UnregisterPrivateWindowListener fun
463  * @tc.type: FUNC
464  */
465 HWTEST_F(DisplayManagerTest, UnregisterPrivateWindowListener, Function | SmallTest | Level1)
466 {
467     sptr<DisplayManager::IPrivateWindowListener> listener = nullptr;
468     sptr<DisplayManager::Impl> impl_;
469     auto ret = DisplayManager::GetInstance().UnregisterPrivateWindowListener(listener);
470     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
471 }
472 
473 /**
474  * @tc.name: ImplUnregisterPrivateWindowListener
475  * @tc.desc: ImplUnregisterPrivateWindowListener fun
476  * @tc.type: FUNC
477  */
478 HWTEST_F(DisplayManagerTest, ImplUnregisterPrivateWindowListener, Function | SmallTest | Level1)
479 {
480     std::recursive_mutex mutex;
481     DisplayManager::Impl impl(mutex);
482     sptr<DisplayManager::IPrivateWindowListener> listener;
483     auto ret = impl.UnregisterPrivateWindowListener(listener);
484     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
485 }
486 
487 /**
488  * @tc.name: RegisterPrivateWindowListChangeListener
489  * @tc.desc: RegisterPrivateWindowListChangeListener fun
490  * @tc.type: FUNC
491  */
492 HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListChangeListener, Function | SmallTest | Level1)
493 {
494     sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
495     auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener);
496     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
497     listener = new DisplayManager::IPrivateWindowListChangeListener();
498     ret = DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener);
499     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterPrivateWindowListChangeListener(listener));
500     listener.clear();
501 }
502 
503 /**
504  * @tc.name: UnregisterPrivateWindowListChangeListener
505  * @tc.desc: UnregisterPrivateWindowListChangeListener fun
506  * @tc.type: FUNC
507  */
508 HWTEST_F(DisplayManagerTest, UnregisterPrivateWindowListChangeListener, Function | SmallTest | Level1)
509 {
510     sptr<DisplayManager::IPrivateWindowListChangeListener> listener = nullptr;
511     auto ret = DisplayManager::GetInstance().UnregisterPrivateWindowListChangeListener(listener);
512     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
513     listener = new DisplayManager::IPrivateWindowListChangeListener();
514     ret = DisplayManager::GetInstance().UnregisterPrivateWindowListChangeListener(listener);
515     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterPrivateWindowListChangeListener(listener));
516     listener.clear();
517 }
518 
519 /**
520  * @tc.name: ImplRegisterPrivateWindowListChangeListener
521  * @tc.desc: ImplRegisterPrivateWindowListChangeListener fun
522  * @tc.type: FUNC
523  */
524 HWTEST_F(DisplayManagerTest, ImplRegisterPrivateWindowListChangeListener01, Function | SmallTest | Level1)
525 {
526     std::recursive_mutex mutex;
527     sptr<DisplayManager::Impl> impl_;
528     sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
529     DisplayManager::GetInstance().pImpl_->privateWindowListChangeListenerAgent_ = nullptr;
530     sptr<DisplayManager::Impl::DisplayManagerPrivateWindowListAgent> privateWindowListChangeListenerAgent =
531         new DisplayManager::Impl::DisplayManagerPrivateWindowListAgent(impl_);
532     auto ret = DisplayManager::GetInstance().pImpl_->RegisterPrivateWindowListChangeListener(listener);
533     ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
534             privateWindowListChangeListenerAgent,
535             DisplayManagerAgentType::PRIVATE_WINDOW_LIST_LISTENER));
536     listener = nullptr;
537     privateWindowListChangeListenerAgent.clear();
538 }
539 
540 /**
541  * @tc.name: ImplRegisterPrivateWindowListChangeListener
542  * @tc.desc: ImplRegisterPrivateWindowListChangeListener fun
543  * @tc.type: FUNC
544  */
545 HWTEST_F(DisplayManagerTest, ImplRegisterPrivateWindowListChangeListener02, Function | SmallTest | Level1)
546 {
547     std::recursive_mutex mutex;
548     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
549     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
550     sptr<DisplayManager::Impl> impl_;
551     sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
552     DisplayManager::GetInstance().pImpl_->privateWindowListChangeListenerAgent_ = nullptr;
553     sptr<DisplayManager::Impl::DisplayManagerPrivateWindowListAgent> privateWindowListChangeListenerAgent =
554         new DisplayManager::Impl::DisplayManagerPrivateWindowListAgent(impl_);
555     auto ret = DisplayManager::GetInstance().pImpl_->RegisterPrivateWindowListChangeListener(listener);
556     ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
557     listener = nullptr;
558     privateWindowListChangeListenerAgent.clear();
559 }
560 
561 /**
562  * @tc.name: ImplUnregisterPrivateWindowListChangeListener
563  * @tc.desc: ImplUnregisterPrivateWindowListChangeListener fun
564  * @tc.type: FUNC
565  */
566 HWTEST_F(DisplayManagerTest, ImplUnregisterPrivateWindowListChangeListener, Function | SmallTest | Level1)
567 {
568     std::recursive_mutex mutex;
569     DisplayManager::Impl impl(mutex);
570     sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
571     auto ret = impl.UnregisterPrivateWindowListChangeListener(listener);
572     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
573 }
574 
575 /**
576  * @tc.name: ImplUnregisterFoldStatusListener
577  * @tc.desc: ImplUnregisterFoldStatusListener fun
578  * @tc.type: FUNC
579  */
580 HWTEST_F(DisplayManagerTest, ImplUnregisterFoldStatusListener, Function | SmallTest | Level1)
581 {
582     sptr<DisplayManager::IFoldStatusListener> listener;
583     auto ret = DisplayManager::GetInstance().pImpl_->UnregisterFoldStatusListener(listener);
584     ASSERT_NE(ret, DMError::DM_OK);
585     listener.clear();
586 }
587 
588 /**
589  * @tc.name: RegisterFoldStatusListener
590  * @tc.desc: RegisterFoldStatusListener fun
591  * @tc.type: FUNC
592  */
593 HWTEST_F(DisplayManagerTest, RegisterFoldStatusListener, Function | SmallTest | Level1)
594 {
595     sptr<DisplayManager::IFoldStatusListener> listener;
596     auto ret = DisplayManager::GetInstance().RegisterFoldStatusListener(listener);
597     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
598     listener = new DisplayManager::IFoldStatusListener();
599     ret = DisplayManager::GetInstance().RegisterFoldStatusListener(listener);
600     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterFoldStatusListener(listener));
601     listener.clear();
602 }
603 
604 /**
605  * @tc.name: ImplRegisterFoldStatusListener
606  * @tc.desc: ImplRegisterFoldStatusListener fun
607  * @tc.type: FUNC
608  */
609 HWTEST_F(DisplayManagerTest, ImplRegisterFoldStatusListener, Function | SmallTest | Level1)
610 {
611     sptr<DisplayManager::IFoldStatusListener> listener;
612     sptr<DisplayManager::Impl> impl_;
613     DisplayManager::GetInstance().pImpl_->foldStatusListenerAgent_ = nullptr;
614     sptr<DisplayManager::Impl::DisplayManagerFoldStatusAgent> foldStatusListenerAgent =
615         new DisplayManager::Impl::DisplayManagerFoldStatusAgent(impl_);
616     auto ret = DisplayManager::GetInstance().pImpl_->RegisterFoldStatusListener(listener);
617     ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
618             foldStatusListenerAgent,
619             DisplayManagerAgentType::FOLD_STATUS_CHANGED_LISTENER));
620     listener = nullptr;
621     foldStatusListenerAgent.clear();
622 }
623 
624 /**
625  * @tc.name: UnregisterFoldStatusListener
626  * @tc.desc: UnregisterFoldStatusListener fun
627  * @tc.type: FUNC
628  */
629 HWTEST_F(DisplayManagerTest, UnregisterFoldStatusListener, Function | SmallTest | Level1)
630 {
631     sptr<DisplayManager::IFoldStatusListener> listener;
632     auto ret = DisplayManager::GetInstance().UnregisterFoldStatusListener(listener);
633     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
634     listener = new DisplayManager::IFoldStatusListener();
635     ret = DisplayManager::GetInstance().UnregisterFoldStatusListener(listener);
636     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterFoldStatusListener(listener));
637     listener.clear();
638 }
639 
640 /**
641  * @tc.name: RegisterDisplayModeListener
642  * @tc.desc: RegisterDisplayModeListener fun
643  * @tc.type: FUNC
644  */
645 HWTEST_F(DisplayManagerTest, RegisterDisplayModeListener, Function | SmallTest | Level1)
646 {
647     sptr<DisplayManager::IDisplayModeListener> listener;
648     auto ret = DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
649     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
650     listener = new DisplayManager::IDisplayModeListener();
651     ret = DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
652     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterDisplayModeListener(listener));
653     listener.clear();
654 }
655 
656 /**
657  * @tc.name: ImplRegisterDisplayModeListener
658  * @tc.desc: ImplRegisterDisplayModeListener fun
659  * @tc.type: FUNC
660  */
661 HWTEST_F(DisplayManagerTest, ImplRegisterDisplayModeListener, Function | SmallTest | Level1)
662 {
663     sptr<DisplayManager::IDisplayModeListener> listener;
664     DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ = nullptr;
665     sptr<DisplayManager::Impl> impl_;
666     sptr<DisplayManager::Impl::DisplayManagerDisplayModeAgent> displayModeListenerAgent =
667         new DisplayManager::Impl::DisplayManagerDisplayModeAgent(impl_);
668     auto ret = DisplayManager::GetInstance().pImpl_->RegisterDisplayModeListener(listener);
669     ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
670             displayModeListenerAgent,
671             DisplayManagerAgentType::DISPLAY_MODE_CHANGED_LISTENER));
672     listener.clear();
673     displayModeListenerAgent.clear();
674 }
675 
676 /**
677  * @tc.name: UnregisterDisplayModeListener
678  * @tc.desc: UnregisterDisplayModeListener fun
679  * @tc.type: FUNC
680  */
681 HWTEST_F(DisplayManagerTest, UnregisterDisplayModeListener, Function | SmallTest | Level1)
682 {
683     sptr<DisplayManager::IDisplayModeListener> listener;
684     auto ret = DisplayManager::GetInstance().UnregisterDisplayModeListener(listener);
685     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
686     listener = new DisplayManager::IDisplayModeListener();
687     ret = DisplayManager::GetInstance().UnregisterDisplayModeListener(listener);
688     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterDisplayModeListener(listener));
689     listener.clear();
690 }
691 
692 /**
693  * @tc.name: ImplUnregisterDisplayModeListener
694  * @tc.desc: ImplUnregisterDisplayModeListener fun
695  * @tc.type: FUNC
696  */
697 HWTEST_F(DisplayManagerTest, ImplUnregisterDisplayModeListener, Function | SmallTest | Level1)
698 {
699     sptr<DisplayManager::IDisplayModeListener> listener;
700     auto ret = DisplayManager::GetInstance().pImpl_->UnregisterDisplayModeListener(listener);
701     ASSERT_EQ(ret, DMError::DM_OK);
702     listener.clear();
703 }
704 
705 /**
706  * @tc.name: ImplUpdateDisplayInfoLocked
707  * @tc.desc: ImplUpdateDisplayInfoLocked fun
708  * @tc.type: FUNC
709  */
710 HWTEST_F(DisplayManagerTest, ImplUpdateDisplayInfoLocked, Function | SmallTest | Level1)
711 {
712     sptr<DisplayInfo> displayInfo = new DisplayInfo();
713     displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
714     auto ret = DisplayManager::GetInstance().pImpl_->UpdateDisplayInfoLocked(displayInfo);
715     ASSERT_EQ(ret, false);
716     displayInfo.clear();
717 }
718 
719 
720 /**
721  * @tc.name: RegisterFoldAngleListener01
722  * @tc.desc: RegisterFoldAngleListener01 fun
723  * @tc.type: FUNC
724  */
725 HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener01, Function | SmallTest | Level1)
726 {
727     sptr<DisplayManager::IFoldAngleListener> listener = nullptr;
728     auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
729     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
730     listener = new DisplayManager::IFoldAngleListener();
731     ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
732     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterFoldAngleListener(listener));
733     listener.clear();
734 }
735 
736 /**
737  * @tc.name: RegisterFoldAngleListener02
738  * @tc.desc: RegisterFoldAngleListener01 fun
739  * @tc.type: FUNC
740  */
741 HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener02, Function | SmallTest | Level1)
742 {
743     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
744     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
745     DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ = nullptr;
746     sptr<DisplayManager::IFoldAngleListener> listener = new DmMockFoldAngleListener();
747     auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
748     ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
749     listener.clear();
750 }
751 
752 /**
753  * @tc.name: UnregisterFoldAngleListener01
754  * @tc.desc: UnregisterFoldAngleListener01 fun
755  * @tc.type: FUNC
756  */
757 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener01, Function | SmallTest | Level1)
758 {
759     sptr<DisplayManager::IFoldAngleListener> listener;
760     auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
761     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
762     listener = new DisplayManager::IFoldAngleListener();
763     ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
764     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterFoldAngleListener(listener));
765     listener.clear();
766 }
767 
768 /**
769  * @tc.name: UnregisterFoldAngleListener02
770  * @tc.desc: UnregisterFoldAngleListener02 fun
771  * @tc.type: FUNC
772  */
773 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener02, Function | SmallTest | Level1)
774 {
775     ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
776     sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
777     DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
778     auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
779     ASSERT_EQ(ret, DMError::DM_OK);
780     listener.clear();
781 }
782 
783 /**
784  * @tc.name: UnregisterFoldAngleListener03
785  * @tc.desc: UnregisterFoldAngleListener03 fun
786  * @tc.type: FUNC
787  */
788 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener03, Function | SmallTest | Level1)
789 {
790     ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
791     DisplayManager::GetInstance().pImpl_->foldAngleListeners_.clear();
792     sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
793     DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
794     auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
795     ASSERT_EQ(ret, DMError::DM_OK);
796     listener.clear();
797 }
798 
799 /**
800  * @tc.name: RegisterCaptureStatusListener01
801  * @tc.desc: RegisterCaptureStatusListener01 fun
802  * @tc.type: FUNC
803  */
804 HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener01, Function | SmallTest | Level1)
805 {
806     sptr<DisplayManager::ICaptureStatusListener> listener = nullptr;
807     auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
808     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
809     listener = new DisplayManager::ICaptureStatusListener();
810     ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
811     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterCaptureStatusListener(listener));
812     listener.clear();
813 }
814 
815 /**
816  * @tc.name: RegisterCaptureStatusListener02
817  * @tc.desc: RegisterCaptureStatusListener02 fun
818  * @tc.type: FUNC
819  */
820 HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener02, Function | SmallTest | Level1)
821 {
822     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
823     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
824     DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ = nullptr;
825     sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
826     auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
827     ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
828     listener.clear();
829 }
830 
831 /**
832  * @tc.name: UnregisterCaptureStatusListener01
833  * @tc.desc: UnregisterCaptureStatusListener01 fun
834  * @tc.type: FUNC
835  */
836 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener01, Function | SmallTest | Level1)
837 {
838     sptr<DisplayManager::ICaptureStatusListener> listener;
839     auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
840     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
841     listener = new DisplayManager::ICaptureStatusListener();
842     ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
843     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterCaptureStatusListener(listener));
844     listener.clear();
845 }
846 
847 /**
848  * @tc.name: UnregisterCaptureStatusListener02
849  * @tc.desc: UnregisterCaptureStatusListener02 fun
850  * @tc.type: FUNC
851  */
852 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener02, Function | SmallTest | Level1)
853 {
854     ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
855     sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
856     DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
857     auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
858     ASSERT_EQ(ret, DMError::DM_OK);
859     listener.clear();
860 }
861 
862 /**
863  * @tc.name: UnregisterCaptureStatusListener03
864  * @tc.desc: UnregisterCaptureStatusListener03 fun
865  * @tc.type: FUNC
866  */
867 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener03, Function | SmallTest | Level1)
868 {
869     ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
870     DisplayManager::GetInstance().pImpl_->captureStatusListeners_.clear();
871     sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
872     DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
873     auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
874     ASSERT_EQ(ret, DMError::DM_OK);
875     listener.clear();
876 }
877 
878 
879 /**
880  * @tc.name: RegisterDisplayUpdateListener01
881  * @tc.desc: RegisterDisplayUpdateListener01 fun
882  * @tc.type: FUNC
883  */
884 HWTEST_F(DisplayManagerTest, RegisterDisplayUpdateListener01, Function | SmallTest | Level1)
885 {
886     sptr<DisplayManager::IDisplayUpdateListener> listener = nullptr;
887     auto ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
888     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
889     listener = new DisplayManager::IDisplayUpdateListener();
890     ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
891     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterDisplayUpdateListener(listener));
892     listener.clear();
893 }
894 
895 /**
896  * @tc.name: IsCaptured01
897  * @tc.desc: IsCaptured01 fun
898  * @tc.type: FUNC
899  */
900 HWTEST_F(DisplayManagerTest, IsCaptured01, Function | SmallTest | Level1)
901 {
902     auto ret = DisplayManager::GetInstance().IsCaptured();
903     ASSERT_FALSE(ret);
904 }
905 
906 /**
907  * @tc.name: isinsideof
908  * @tc.desc: isinside0f fun
909  * @tc.type: FUNC
910  */
911 HWTEST_F(DisplayManagerTest, isinsideof, Function | SmallTest | Level1)
912 {
913     DMRect rect = {2, 2, 2, 2};
914     DMRect rect1 = {2, 2, 2, 2};
915     ASSERT_EQ(rect.IsInsideOf(rect1), true);
916 }
917 
918 /**
919  * @tc.name: GetAllDisplayPhysicalResolution
920  * @tc.desc: GetAllDisplayPhysicalResolution test
921  * @tc.type: FUNC
922  */
923 HWTEST_F(DisplayManagerTest, GetAllDisplayPhysicalResolution, Function | SmallTest | Level1)
924 {
925     std::vector<DisplayPhysicalResolution> allSize = DisplayManager::GetInstance().GetAllDisplayPhysicalResolution();
926     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
927         ASSERT_TRUE(!allSize.empty());
928     } else {
929         ASSERT_TRUE(!allSize.empty());
930     }
931 }
932 
933 /**
934  * @tc.name: ClearDisplayStateCallback
935  * @tc.desc: ClearDisplayStateCallback test
936  * @tc.type: FUNC
937  */
938 HWTEST_F(DisplayManagerTest, ClearDisplayStateCallback, Function | SmallTest | Level1)
939 {
940     DisplayManager::GetInstance().pImpl_->ClearDisplayStateCallback();
941     ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayStateAgent_ == nullptr);
942 }
943 
944 /**
945  * @tc.name: ClearFoldStatusCallback
946  * @tc.desc: ClearFoldStatusCallback test
947  * @tc.type: FUNC
948  */
949 HWTEST_F(DisplayManagerTest, ClearFoldStatusCallback, Function | SmallTest | Level1)
950 {
951     DisplayManager::GetInstance().pImpl_->ClearFoldStatusCallback();
952     ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldStatusListenerAgent_ == nullptr);
953 }
954 
955 /**
956  * @tc.name: ClearFoldAngleCallback
957  * @tc.desc: ClearFoldAngleCallback test
958  * @tc.type: FUNC
959  */
960 HWTEST_F(DisplayManagerTest, ClearFoldAngleCallback, Function | SmallTest | Level1)
961 {
962     DisplayManager::GetInstance().pImpl_->ClearFoldAngleCallback();
963     ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ == nullptr);
964 }
965 
966 /**
967  * @tc.name: ClearCaptureStatusCallback
968  * @tc.desc: ClearCaptureStatusCallback test
969  * @tc.type: FUNC
970  */
971 HWTEST_F(DisplayManagerTest, ClearCaptureStatusCallback, Function | SmallTest | Level1)
972 {
973     DisplayManager::GetInstance().pImpl_->ClearCaptureStatusCallback();
974     ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ == nullptr);
975 }
976 
977 /**
978  * @tc.name: ClearDisplayModeCallback
979  * @tc.desc: ClearDisplayModeCallback test
980  * @tc.type: FUNC
981  */
982 HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback01, Function | SmallTest | Level1)
983 {
984     DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
985     ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
986 }
987 
988 /**
989  * @tc.name: ClearDisplayModeCallback
990  * @tc.desc: ClearDisplayModeCallback test
991  * @tc.type: FUNC
992  */
993 HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback02, Function | SmallTest | Level1)
994 {
995     sptr<DisplayManager::IDisplayModeListener> listener = new DisplayManager::IDisplayModeListener();
996     DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
997     DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
998     ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
999 }
1000 
1001 /**
1002  * @tc.name: GetDisplayByScreenId
1003  * @tc.desc: GetDisplayByScreenId test
1004  * @tc.type: FUNC
1005  */
1006 HWTEST_F(DisplayManagerTest, GetDisplayByScreenId, Function | SmallTest | Level1)
1007 {
1008     ScreenId screenId = -1;
1009     auto ret = DisplayManager::GetInstance().pImpl_->GetDisplayByScreenId(screenId);
1010     ASSERT_TRUE(ret == nullptr);
1011 }
1012 
1013 /**
1014  * @tc.name: UnregisterDisplayUpdateListener
1015  * @tc.desc: UnregisterDisplayUpdateListener fun
1016  * @tc.type: FUNC
1017  */
1018 HWTEST_F(DisplayManagerTest, UnregisterDisplayUpdateListener, Function | SmallTest | Level1)
1019 {
1020     sptr<DisplayManager::IDisplayUpdateListener> listener;
1021     auto ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1022     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1023     listener = new DisplayManager::IDisplayUpdateListener();
1024     ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1025     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterDisplayUpdateListener(listener));
1026     listener.clear();
1027 }
1028 
1029 /**
1030  * @tc.name: RegisterAvailableAreaListener
1031  * @tc.desc: RegisterAvailableAreaListener fun
1032  * @tc.type: FUNC
1033  */
1034 HWTEST_F(DisplayManagerTest, RegisterAvailableAreaListener, Function | SmallTest | Level1)
1035 {
1036     sptr<DisplayManager::IAvailableAreaListener> listener;
1037     auto ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1038     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1039     listener = new DisplayManager::IAvailableAreaListener();
1040     ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1041     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterAvailableAreaListener(listener));
1042     listener.clear();
1043 }
1044 
1045 /**
1046  * @tc.name: UnregisterAvailableAreaListener
1047  * @tc.desc: UnregisterAvailableAreaListener fun
1048  * @tc.type: FUNC
1049  */
1050 HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener, Function | SmallTest | Level1)
1051 {
1052     sptr<DisplayManager::IAvailableAreaListener> listener;
1053     auto ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1054     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1055     listener = new DisplayManager::IAvailableAreaListener();
1056     ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1057     ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterAvailableAreaListener(listener));
1058     listener.clear();
1059 }
1060 
1061 /**
1062  * @tc.name: GetDisplayInfoSrting
1063  * @tc.desc: GetDisplayInfoSrting fun
1064  * @tc.type: FUNC
1065  */
1066 HWTEST_F(DisplayManagerTest, GetDisplayInfoSrting, Function | SmallTest | Level1)
1067 {
1068     sptr<DisplayInfo> displayInfo = nullptr;
1069     auto ret =DisplayManager::GetInstance().pImpl_->GetDisplayInfoSrting(displayInfo);
1070     ASSERT_EQ(displayInfo, nullptr);
1071 }
1072 
1073 /**
1074  * @tc.name: OnRemoteDied
1075  * @tc.desc: OnRemoteDied fun
1076  * @tc.type: FUNC
1077  */
1078 HWTEST_F(DisplayManagerTest, OnRemoteDied, Function | SmallTest | Level1)
1079 {
1080     g_dmIsDestroyed = true;
1081     DisplayManager::GetInstance().OnRemoteDied();
1082     ASSERT_EQ(g_dmIsDestroyed, true);
1083 }
1084 
1085 /**
1086  * @tc.name: Clear
1087  * @tc.desc: Clear test
1088  * @tc.type: FUNC
1089  */
1090 HWTEST_F(DisplayManagerTest, Clear01, Function | SmallTest | Level1)
1091 {
1092     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1093     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1094     EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1095     DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
1096     sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
1097     DisplayManager::GetInstance().RegisterDisplayListener(listener);
1098     auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
1099     ASSERT_NE(displayManagerListener, nullptr);
1100     DisplayManager::GetInstance().pImpl_->Clear();
1101     ASSERT_EQ(DisplayManager::GetInstance().pImpl_->displayManagerListener_, nullptr);
1102 }
1103 
1104 /**
1105  * @tc.name: Clear
1106  * @tc.desc: Clear test
1107  * @tc.type: FUNC
1108  */
1109 HWTEST_F(DisplayManagerTest, Clear02, Function | SmallTest | Level1)
1110 {
1111     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1112     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1113     EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1114     DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_ = nullptr;
1115     sptr<IDisplayPowerEventListener> listener = new DmMockDisplayPowerEventListener();
1116     DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener);
1117     auto powerEventListenerAgent = DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_;
1118     ASSERT_NE(powerEventListenerAgent, nullptr);
1119     DisplayManager::GetInstance().pImpl_->Clear();
1120     ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1121 }
1122 
1123 /**
1124  * @tc.name: NotifyCaptureStatusChanged
1125  * @tc.desc: NotifyCaptureStatusChanged fun
1126  * @tc.type: FUNC
1127  */
1128 HWTEST_F(DisplayManagerTest, NotifyCaptureStatusChanged, Function | SmallTest | Level1)
1129 {
1130     DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ = nullptr;
1131     sptr<DisplayManager::Impl> impl_;
1132     sptr<DisplayManager::Impl::DisplayManagerDisplayModeAgent> displayModeListenerAgent =
1133         new DisplayManager::Impl::DisplayManagerDisplayModeAgent(impl_);
1134     bool isCapture = true;
1135     DisplayManager::GetInstance().pImpl_->NotifyCaptureStatusChanged(isCapture);
1136     ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1137 }
1138 
1139 /**
1140  * @tc.name: SetDisplayScale
1141  * @tc.desc: SetDisplayScale test
1142  * @tc.type: FUNC
1143  */
1144 HWTEST_F(DisplayManagerTest, SetDisplayScale, Function | SmallTest | Level1)
1145 {
1146     DisplayManager& displayManager = DisplayManager::GetInstance();
1147     ASSERT_NE(displayManager.pImpl_, nullptr);
1148     const float scaleX = 1.0f;
1149     const float scaleY = 1.0f;
1150     const float pivotX = 0.5f;
1151     const float pivotY = 0.5f;
1152     sptr<Display> display = displayManager.GetDefaultDisplay();
1153     ASSERT_NE(display, nullptr);
1154     ScreenId screenId = display->GetScreenId();
1155     displayManager.SetDisplayScale(screenId, scaleX, scaleY, pivotX, pivotY);
1156 }
1157 
1158 /**
1159  * @tc.name: GetScreenCapture
1160  * @tc.desc: GetScreenCapture test
1161  * @tc.type: FUNC
1162  */
1163 HWTEST_F(DisplayManagerTest, GetScreenCapture, Function | SmallTest | Level1)
1164 {
1165     CaptureOption captureOption;
1166     sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplay();
1167     ASSERT_NE(display, nullptr);
1168     captureOption.displayId_ = display->GetId();
1169     DmErrorCode errCode;
1170     std::shared_ptr<Media::PixelMap> pixelMap = DisplayManager::GetInstance().GetScreenCapture(captureOption,
1171         &errCode);
1172     ASSERT_EQ(pixelMap, nullptr);
1173 }
1174 
1175 /**
1176  * @tc.name: GetPrimaryDisplaySync
1177  * @tc.desc: GetPrimaryDisplaySync test
1178  * @tc.type: FUNC
1179  */
1180 HWTEST_F(DisplayManagerTest, GetPrimaryDisplaySync, Function | SmallTest | Level1)
1181 {
1182     sptr<Display> display = DisplayManager::GetInstance().GetPrimaryDisplaySync();
1183     ASSERT_NE(display, nullptr);
1184 }
1185 }
1186 } // namespace Rosen
1187 } // namespace OHOS