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:
OnPrivateWindow(bool)40 void OnPrivateWindow([[maybe_unused]]bool) override {}
41 };
42 class DmMockFoldAngleListener : public DisplayManager::IFoldAngleListener {
43 public:
OnFoldAngleChanged(std::vector<float>)44 void OnFoldAngleChanged([[maybe_unused]]std::vector<float>) override {}
45 };
46 class DmMockCaptureStatusListener : public DisplayManager::ICaptureStatusListener {
47 public:
OnCaptureStatusChanged(bool)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: CheckRectValid
254 * @tc.desc: CheckRectValid all
255 * @tc.type: FUNC
256 */
257 HWTEST_F(DisplayManagerTest, CheckRectValid, Function | SmallTest | Level1)
258 {
259 int32_t oriHeight = 500;
260 int32_t oriWidth = 500;
261 Media::Rect rect = {.left = 1, .top = 1, .width = 1, .height = 1};
262 bool ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
263 ASSERT_TRUE(ret);
264 rect.left = -1;
265 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
266 ASSERT_FALSE(ret);
267 rect.left = 1;
268 rect.top = -1;
269 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
270 ASSERT_FALSE(ret);
271 rect.top = 1;
272 rect.width = -1;
273 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
274 ASSERT_FALSE(ret);
275 rect.width = 1;
276 rect.height = -1;
277 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
278 ASSERT_FALSE(ret);
279 rect.width = 500;
280 rect.height = 1;
281 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
282 ASSERT_FALSE(ret);
283 rect.width = 1;
284 rect.height = 500;
285 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
286 ASSERT_FALSE(ret);
287 }
288
289 /**
290 * @tc.name: CheckSizeValid
291 * @tc.desc: CheckSizeValid all
292 * @tc.type: FUNC
293 */
294 HWTEST_F(DisplayManagerTest, CheckSizeValid, Function | SmallTest | Level1)
295 {
296 int32_t oriHeight = 500;
297 int32_t oriWidth = 500;
298 Media::Size size = {.width = 1, .height = 1};
299 bool ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
300 ASSERT_TRUE(ret);
301 size.width = -1;
302 ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
303 ASSERT_FALSE(ret);
304 size.width = 1;
305 size.height = -1;
306 ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
307 ASSERT_FALSE(ret);
308 size.width = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT + 1;
309 size.height = 1;
310 ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
311 ASSERT_FALSE(ret);
312 size.width = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT;
313 size.height = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT + 1;
314 ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
315 ASSERT_FALSE(ret);
316 }
317
318 /**
319 * @tc.name: ImplGetDefaultDisplay01
320 * @tc.desc: Impl GetDefaultDisplay nullptr
321 * @tc.type: FUNC
322 */
323 HWTEST_F(DisplayManagerTest, ImplGetDefaultDisplay01, Function | SmallTest | Level1)
324 {
325 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
326 EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(1).WillOnce(Return(nullptr));
327 sptr<Display> display = DisplayManager::GetInstance().pImpl_->GetDefaultDisplay();
328 ASSERT_EQ(display, nullptr);
329 }
330
331 /**
332 * @tc.name: GetDisplayByScreen
333 * @tc.desc: for interface coverage & check GetDisplayByScreen
334 * @tc.type: FUNC
335 */
336 HWTEST_F(DisplayManagerTest, GetDisplayByScreen, Function | SmallTest | Level1)
337 {
338 auto& displayManager = DisplayManager::GetInstance();
339 sptr<Display> display = displayManager.GetDisplayByScreen(SCREEN_ID_INVALID);
340 ASSERT_EQ(display, nullptr);
341
342 sptr<DisplayInfo> displayInfo = new DisplayInfo();
343 displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
344 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
345 EXPECT_CALL(m->Mock(), GetDisplayInfoByScreenId(_)).Times(1).WillOnce(Return(displayInfo));
346 display = displayManager.GetDisplayByScreen(1);
347 ASSERT_EQ(display, nullptr);
348 }
349
350 /**
351 * @tc.name: ImplGetDefaultDisplaySync
352 * @tc.desc: Impl GetDefaultDisplaySync nullptr
353 * @tc.type: FUNC
354 */
355 HWTEST_F(DisplayManagerTest, ImplGetDefaultDisplaySync, Function | SmallTest | Level1)
356 {
357 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
358 EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(6).WillRepeatedly(Return(nullptr));
359 sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplaySync();
360 ASSERT_EQ(display, nullptr);
361 }
362
363 /**
364 * @tc.name: GetScreenBrightness
365 * @tc.desc: GetScreenBrightness fun
366 * @tc.type: FUNC
367 */
368 HWTEST_F(DisplayManagerTest, GetScreenBrightness, Function | SmallTest | Level1)
369 {
370 uint64_t screenId = 2;
371 auto ret = DisplayManager::GetInstance().GetScreenBrightness(screenId);
372 ASSERT_FALSE(ret == 1);
373 }
374
375 /**
376 * @tc.name: GetDisplayById
377 * @tc.desc: GetDisplayById fun
378 * @tc.type: FUNC
379 */
380 HWTEST_F(DisplayManagerTest, GetDisplayById, Function | SmallTest | Level1)
381 {
382 DisplayId displayId = -1;
383 g_dmIsDestroyed = true;
384 auto ret = DisplayManager::GetInstance().GetDisplayById(displayId);
385 ASSERT_EQ(ret, nullptr);
386 }
387
388 /**
389 * @tc.name: RegisterPrivateWindowListener
390 * @tc.desc: RegisterPrivateWindowListener fun
391 * @tc.type: FUNC
392 */
393 HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListener01, Function | SmallTest | Level1)
394 {
395 sptr<DisplayManager::IPrivateWindowListener> listener;
396 auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListener(listener);
397 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
398 }
399
400 /**
401 * @tc.name: RegisterPrivateWindowListener
402 * @tc.desc: RegisterPrivateWindowListener fun
403 * @tc.type: FUNC
404 */
405 HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListener02, Function | SmallTest | Level1)
406 {
407 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
408 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
409 sptr<DisplayManager::IPrivateWindowListener> listener = new DmMockPrivateWindowListener();
410 auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListener(listener);
411 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
412 }
413
414 /**
415 * @tc.name: UnregisterPrivateWindowListener
416 * @tc.desc: UnregisterPrivateWindowListener fun
417 * @tc.type: FUNC
418 */
419 HWTEST_F(DisplayManagerTest, UnregisterPrivateWindowListener, Function | SmallTest | Level1)
420 {
421 sptr<DisplayManager::IPrivateWindowListener> listener = nullptr;
422 sptr<DisplayManager::Impl> impl_;
423 auto ret = DisplayManager::GetInstance().UnregisterPrivateWindowListener(listener);
424 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
425 }
426
427 /**
428 * @tc.name: ImplUnregisterPrivateWindowListener
429 * @tc.desc: ImplUnregisterPrivateWindowListener fun
430 * @tc.type: FUNC
431 */
432 HWTEST_F(DisplayManagerTest, ImplUnregisterPrivateWindowListener, Function | SmallTest | Level1)
433 {
434 std::recursive_mutex mutex;
435 DisplayManager::Impl impl(mutex);
436 sptr<DisplayManager::IPrivateWindowListener> listener;
437 auto ret = impl.UnregisterPrivateWindowListener(listener);
438 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
439 }
440
441 /**
442 * @tc.name: RegisterPrivateWindowListChangeListener
443 * @tc.desc: RegisterPrivateWindowListChangeListener fun
444 * @tc.type: FUNC
445 */
446 HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListChangeListener, Function | SmallTest | Level1)
447 {
448 sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
449 auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener);
450 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
451 listener = new DisplayManager::IPrivateWindowListChangeListener();
452 ret = DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener);
453 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterPrivateWindowListChangeListener(listener));
454 listener.clear();
455 }
456
457 /**
458 * @tc.name: UnregisterPrivateWindowListChangeListener
459 * @tc.desc: UnregisterPrivateWindowListChangeListener fun
460 * @tc.type: FUNC
461 */
462 HWTEST_F(DisplayManagerTest, UnregisterPrivateWindowListChangeListener, Function | SmallTest | Level1)
463 {
464 sptr<DisplayManager::IPrivateWindowListChangeListener> listener = nullptr;
465 auto ret = DisplayManager::GetInstance().UnregisterPrivateWindowListChangeListener(listener);
466 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
467 listener = new DisplayManager::IPrivateWindowListChangeListener();
468 ret = DisplayManager::GetInstance().UnregisterPrivateWindowListChangeListener(listener);
469 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterPrivateWindowListChangeListener(listener));
470 listener.clear();
471 }
472
473 /**
474 * @tc.name: ImplRegisterPrivateWindowListChangeListener
475 * @tc.desc: ImplRegisterPrivateWindowListChangeListener fun
476 * @tc.type: FUNC
477 */
478 HWTEST_F(DisplayManagerTest, ImplRegisterPrivateWindowListChangeListener01, Function | SmallTest | Level1)
479 {
480 std::recursive_mutex mutex;
481 sptr<DisplayManager::Impl> impl_;
482 sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
483 DisplayManager::GetInstance().pImpl_->privateWindowListChangeListenerAgent_ = nullptr;
484 sptr<DisplayManager::Impl::DisplayManagerPrivateWindowListAgent> privateWindowListChangeListenerAgent =
485 new DisplayManager::Impl::DisplayManagerPrivateWindowListAgent(impl_);
486 auto ret = DisplayManager::GetInstance().pImpl_->RegisterPrivateWindowListChangeListener(listener);
487 ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
488 privateWindowListChangeListenerAgent,
489 DisplayManagerAgentType::PRIVATE_WINDOW_LIST_LISTENER));
490 listener = nullptr;
491 privateWindowListChangeListenerAgent.clear();
492 }
493
494 /**
495 * @tc.name: ImplRegisterPrivateWindowListChangeListener
496 * @tc.desc: ImplRegisterPrivateWindowListChangeListener fun
497 * @tc.type: FUNC
498 */
499 HWTEST_F(DisplayManagerTest, ImplRegisterPrivateWindowListChangeListener02, Function | SmallTest | Level1)
500 {
501 std::recursive_mutex mutex;
502 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
503 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
504 sptr<DisplayManager::Impl> impl_;
505 sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
506 DisplayManager::GetInstance().pImpl_->privateWindowListChangeListenerAgent_ = nullptr;
507 sptr<DisplayManager::Impl::DisplayManagerPrivateWindowListAgent> privateWindowListChangeListenerAgent =
508 new DisplayManager::Impl::DisplayManagerPrivateWindowListAgent(impl_);
509 auto ret = DisplayManager::GetInstance().pImpl_->RegisterPrivateWindowListChangeListener(listener);
510 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
511 listener = nullptr;
512 privateWindowListChangeListenerAgent.clear();
513 }
514
515 /**
516 * @tc.name: ImplUnregisterPrivateWindowListChangeListener
517 * @tc.desc: ImplUnregisterPrivateWindowListChangeListener fun
518 * @tc.type: FUNC
519 */
520 HWTEST_F(DisplayManagerTest, ImplUnregisterPrivateWindowListChangeListener, Function | SmallTest | Level1)
521 {
522 std::recursive_mutex mutex;
523 DisplayManager::Impl impl(mutex);
524 sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
525 auto ret = impl.UnregisterPrivateWindowListChangeListener(listener);
526 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
527 }
528
529 /**
530 * @tc.name: ImplUnregisterFoldStatusListener
531 * @tc.desc: ImplUnregisterFoldStatusListener fun
532 * @tc.type: FUNC
533 */
534 HWTEST_F(DisplayManagerTest, ImplUnregisterFoldStatusListener, Function | SmallTest | Level1)
535 {
536 sptr<DisplayManager::IFoldStatusListener> listener;
537 auto ret = DisplayManager::GetInstance().pImpl_->UnregisterFoldStatusListener(listener);
538 ASSERT_NE(ret, DMError::DM_OK);
539 listener.clear();
540 }
541
542 /**
543 * @tc.name: RegisterFoldStatusListener
544 * @tc.desc: RegisterFoldStatusListener fun
545 * @tc.type: FUNC
546 */
547 HWTEST_F(DisplayManagerTest, RegisterFoldStatusListener, Function | SmallTest | Level1)
548 {
549 sptr<DisplayManager::IFoldStatusListener> listener;
550 auto ret = DisplayManager::GetInstance().RegisterFoldStatusListener(listener);
551 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
552 listener = new DisplayManager::IFoldStatusListener();
553 ret = DisplayManager::GetInstance().RegisterFoldStatusListener(listener);
554 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterFoldStatusListener(listener));
555 listener.clear();
556 }
557
558 /**
559 * @tc.name: ImplRegisterFoldStatusListener
560 * @tc.desc: ImplRegisterFoldStatusListener fun
561 * @tc.type: FUNC
562 */
563 HWTEST_F(DisplayManagerTest, ImplRegisterFoldStatusListener, Function | SmallTest | Level1)
564 {
565 sptr<DisplayManager::IFoldStatusListener> listener;
566 sptr<DisplayManager::Impl> impl_;
567 DisplayManager::GetInstance().pImpl_->foldStatusListenerAgent_ = nullptr;
568 sptr<DisplayManager::Impl::DisplayManagerFoldStatusAgent> foldStatusListenerAgent =
569 new DisplayManager::Impl::DisplayManagerFoldStatusAgent(impl_);
570 auto ret = DisplayManager::GetInstance().pImpl_->RegisterFoldStatusListener(listener);
571 ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
572 foldStatusListenerAgent,
573 DisplayManagerAgentType::FOLD_STATUS_CHANGED_LISTENER));
574 listener = nullptr;
575 foldStatusListenerAgent.clear();
576 }
577
578 /**
579 * @tc.name: UnregisterFoldStatusListener
580 * @tc.desc: UnregisterFoldStatusListener fun
581 * @tc.type: FUNC
582 */
583 HWTEST_F(DisplayManagerTest, UnregisterFoldStatusListener, Function | SmallTest | Level1)
584 {
585 sptr<DisplayManager::IFoldStatusListener> listener;
586 auto ret = DisplayManager::GetInstance().UnregisterFoldStatusListener(listener);
587 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
588 listener = new DisplayManager::IFoldStatusListener();
589 ret = DisplayManager::GetInstance().UnregisterFoldStatusListener(listener);
590 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterFoldStatusListener(listener));
591 listener.clear();
592 }
593
594 /**
595 * @tc.name: RegisterDisplayModeListener
596 * @tc.desc: RegisterDisplayModeListener fun
597 * @tc.type: FUNC
598 */
599 HWTEST_F(DisplayManagerTest, RegisterDisplayModeListener, Function | SmallTest | Level1)
600 {
601 sptr<DisplayManager::IDisplayModeListener> listener;
602 auto ret = DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
603 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
604 listener = new DisplayManager::IDisplayModeListener();
605 ret = DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
606 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterDisplayModeListener(listener));
607 listener.clear();
608 }
609
610 /**
611 * @tc.name: ImplRegisterDisplayModeListener
612 * @tc.desc: ImplRegisterDisplayModeListener fun
613 * @tc.type: FUNC
614 */
615 HWTEST_F(DisplayManagerTest, ImplRegisterDisplayModeListener, Function | SmallTest | Level1)
616 {
617 sptr<DisplayManager::IDisplayModeListener> listener;
618 DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ = nullptr;
619 sptr<DisplayManager::Impl> impl_;
620 sptr<DisplayManager::Impl::DisplayManagerDisplayModeAgent> displayModeListenerAgent =
621 new DisplayManager::Impl::DisplayManagerDisplayModeAgent(impl_);
622 auto ret = DisplayManager::GetInstance().pImpl_->RegisterDisplayModeListener(listener);
623 ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
624 displayModeListenerAgent,
625 DisplayManagerAgentType::DISPLAY_MODE_CHANGED_LISTENER));
626 listener.clear();
627 displayModeListenerAgent.clear();
628 }
629
630 /**
631 * @tc.name: UnregisterDisplayModeListener
632 * @tc.desc: UnregisterDisplayModeListener fun
633 * @tc.type: FUNC
634 */
635 HWTEST_F(DisplayManagerTest, UnregisterDisplayModeListener, Function | SmallTest | Level1)
636 {
637 sptr<DisplayManager::IDisplayModeListener> listener;
638 auto ret = DisplayManager::GetInstance().UnregisterDisplayModeListener(listener);
639 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
640 listener = new DisplayManager::IDisplayModeListener();
641 ret = DisplayManager::GetInstance().UnregisterDisplayModeListener(listener);
642 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterDisplayModeListener(listener));
643 listener.clear();
644 }
645
646 /**
647 * @tc.name: ImplUnregisterDisplayModeListener
648 * @tc.desc: ImplUnregisterDisplayModeListener fun
649 * @tc.type: FUNC
650 */
651 HWTEST_F(DisplayManagerTest, ImplUnregisterDisplayModeListener, Function | SmallTest | Level1)
652 {
653 sptr<DisplayManager::IDisplayModeListener> listener;
654 auto ret = DisplayManager::GetInstance().pImpl_->UnregisterDisplayModeListener(listener);
655 ASSERT_EQ(ret, DMError::DM_OK);
656 listener.clear();
657 }
658
659 /**
660 * @tc.name: OnDisplayCreate02
661 * @tc.desc: OnDisplayCreate
662 * @tc.type: FUNC
663 */
664 HWTEST_F(DisplayManagerTest, OnDisplayCreate02, Function | SmallTest | Level1)
665 {
666 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
667 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
668 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
669 DisplayManager::GetInstance().RegisterDisplayListener(listener);
670 auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
671 ASSERT_NE(displayManagerListener, nullptr);
672
673 sptr<DisplayInfo> displayInfo = nullptr;
674 displayManagerListener->OnDisplayCreate(displayInfo);
675 ASSERT_NE(displayManagerListener->pImpl_, nullptr);
676 }
677
678 /**
679 * @tc.name: RegisterDisplayListener
680 * @tc.desc: RegisterDisplayListener fun
681 * @tc.type: FUNC
682 */
683 HWTEST_F(DisplayManagerTest, RegisterDisplayListener, Function | SmallTest | Level1)
684 {
685 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
686 bool hasPrivate = true;
687 DisplayManager::GetInstance().pImpl_->NotifyPrivateWindowStateChanged(hasPrivate);
688 auto ret = DisplayManager::GetInstance().RegisterDisplayListener(listener);
689 ASSERT_EQ(ret, DMError::DM_OK);
690 }
691
692 /**
693 * @tc.name: UnregisterDisplayListener
694 * @tc.desc: UnregisterDisplayListener fun
695 * @tc.type: FUNC
696 */
697 HWTEST_F(DisplayManagerTest, UnregisterDisplayListener, Function | SmallTest | Level1)
698 {
699 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
700 sptr<DisplayManager::Impl> impl_;
701 auto ret = DisplayManager::GetInstance().UnregisterDisplayListener(listener);
702 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
703 }
704
705 /**
706 * @tc.name: HasPrivateWindow
707 * @tc.desc: HasPrivateWindow fun
708 * @tc.type: FUNC
709 */
710 HWTEST_F(DisplayManagerTest, HasPrivateWindow, Function | SmallTest | Level1)
711 {
712 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
713 bool hasPrivateWindow = false;
714 auto ret = DisplayManager::GetInstance().HasPrivateWindow(0, hasPrivateWindow);
715 ASSERT_EQ(ret, DMError::DM_OK);
716 }
717
718 /**
719 * @tc.name: HasPrivateWindow02
720 * @tc.desc: HasPrivateWindow fun
721 * @tc.type: FUNC
722 */
723 HWTEST_F(DisplayManagerTest, HasPrivateWindow02, Function | SmallTest | Level1)
724 {
725 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
726 sptr<DisplayManager::Impl> impl_;
727 bool hasPrivateWindow = false;
728 auto ret = DisplayManager::GetInstance().pImpl_->HasPrivateWindow(0, hasPrivateWindow);
729 ASSERT_EQ(ret, DMError::DM_OK);
730 }
731
732 /**
733 * @tc.name: IsFoldable
734 * @tc.desc: IsFoldable all
735 * @tc.type: FUNC
736 */
737 HWTEST_F(DisplayManagerTest, IsFoldable, Function | SmallTest | Level1)
738 {
739 bool ret = DisplayManager::GetInstance().IsFoldable();
740 ASSERT_FALSE(ret);
741 }
742
743 /**
744 * @tc.name: IsFoldable
745 * @tc.desc: IsFoldable fun
746 * @tc.type: FUNC
747 */
748 HWTEST_F(DisplayManagerTest, IsFoldable01, Function | SmallTest | Level1)
749 {
750 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
751 FoldDisplayMode mode = FoldDisplayMode{0};
752 DisplayManager::GetInstance().SetFoldDisplayMode(mode);
753 DisplayManager::GetInstance().SetFoldStatusLocked(false);
754 sptr<DisplayManager::Impl> impl_;
755 auto ret = DisplayManager::GetInstance().pImpl_->IsFoldable();
756 ASSERT_FALSE(ret);
757 }
758
759 /**
760 * @tc.name: AddSurfaceNodeToDisplay
761 * @tc.desc: AddSurfaceNodeToDisplay fun
762 * @tc.type: FUNC
763 */
764 HWTEST_F(DisplayManagerTest, AddSurfaceNodeToDisplay, Function | SmallTest | Level1)
765 {
766 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
767 std::shared_ptr<class RSSurfaceNode> surfaceNode;
768 auto ret = DisplayManager::GetInstance().AddSurfaceNodeToDisplay(0, surfaceNode);
769 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
770 ASSERT_NE(ret, DMError::DM_ERROR_IPC_FAILED);
771 } else {
772 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
773 }
774 }
775
776 /**
777 * @tc.name: RemoveSurfaceNodeFromDisplay
778 * @tc.desc: RemoveSurfaceNodeFromDisplay fun
779 * @tc.type: FUNC
780 */
781 HWTEST_F(DisplayManagerTest, RemoveSurfaceNodeFromDisplay, Function | SmallTest | Level1)
782 {
783 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
784 std::shared_ptr<class RSSurfaceNode> surfaceNode;
785 DisplayManager::GetInstance().OnRemoteDied();
786 auto ret = DisplayManager::GetInstance().RemoveSurfaceNodeFromDisplay(0, surfaceNode);
787 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
788 ASSERT_NE(ret, DMError::DM_ERROR_IPC_FAILED);
789 } else {
790 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
791 }
792 }
793
794 /**
795 * @tc.name: RegisterFoldAngleListener01
796 * @tc.desc: RegisterFoldAngleListener01 fun
797 * @tc.type: FUNC
798 */
799 HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener01, Function | SmallTest | Level1)
800 {
801 sptr<DisplayManager::IFoldAngleListener> listener = nullptr;
802 auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
803 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
804 listener = new DisplayManager::IFoldAngleListener();
805 ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
806 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterFoldAngleListener(listener));
807 listener.clear();
808 }
809
810 /**
811 * @tc.name: RegisterFoldAngleListener02
812 * @tc.desc: RegisterFoldAngleListener01 fun
813 * @tc.type: FUNC
814 */
815 HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener02, Function | SmallTest | Level1)
816 {
817 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
818 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
819 DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ = nullptr;
820 sptr<DisplayManager::IFoldAngleListener> listener = new DmMockFoldAngleListener();
821 auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
822 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
823 listener.clear();
824 }
825
826 /**
827 * @tc.name: UnregisterFoldAngleListener01
828 * @tc.desc: UnregisterFoldAngleListener01 fun
829 * @tc.type: FUNC
830 */
831 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener01, Function | SmallTest | Level1)
832 {
833 sptr<DisplayManager::IFoldAngleListener> listener;
834 auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
835 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
836 listener = new DisplayManager::IFoldAngleListener();
837 ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
838 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterFoldAngleListener(listener));
839 listener.clear();
840 }
841
842 /**
843 * @tc.name: UnregisterFoldAngleListener02
844 * @tc.desc: UnregisterFoldAngleListener02 fun
845 * @tc.type: FUNC
846 */
847 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener02, Function | SmallTest | Level1)
848 {
849 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
850 sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
851 DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
852 auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
853 ASSERT_EQ(ret, DMError::DM_OK);
854 listener.clear();
855 }
856
857 /**
858 * @tc.name: UnregisterFoldAngleListener03
859 * @tc.desc: UnregisterFoldAngleListener03 fun
860 * @tc.type: FUNC
861 */
862 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener03, Function | SmallTest | Level1)
863 {
864 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
865 DisplayManager::GetInstance().pImpl_->foldAngleListeners_.clear();
866 sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
867 DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
868 auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
869 ASSERT_EQ(ret, DMError::DM_OK);
870 listener.clear();
871 }
872
873 /**
874 * @tc.name: RegisterCaptureStatusListener01
875 * @tc.desc: RegisterCaptureStatusListener01 fun
876 * @tc.type: FUNC
877 */
878 HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener01, Function | SmallTest | Level1)
879 {
880 sptr<DisplayManager::ICaptureStatusListener> listener = nullptr;
881 auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
882 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
883 listener = new DisplayManager::ICaptureStatusListener();
884 ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
885 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterCaptureStatusListener(listener));
886 listener.clear();
887 }
888
889 /**
890 * @tc.name: RegisterCaptureStatusListener02
891 * @tc.desc: RegisterCaptureStatusListener02 fun
892 * @tc.type: FUNC
893 */
894 HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener02, Function | SmallTest | Level1)
895 {
896 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
897 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
898 DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ = nullptr;
899 sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
900 auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
901 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
902 listener.clear();
903 }
904
905 /**
906 * @tc.name: UnregisterCaptureStatusListener01
907 * @tc.desc: UnregisterCaptureStatusListener01 fun
908 * @tc.type: FUNC
909 */
910 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener01, Function | SmallTest | Level1)
911 {
912 sptr<DisplayManager::ICaptureStatusListener> listener;
913 auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
914 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
915 listener = new DisplayManager::ICaptureStatusListener();
916 ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
917 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterCaptureStatusListener(listener));
918 listener.clear();
919 }
920
921 /**
922 * @tc.name: UnregisterCaptureStatusListener02
923 * @tc.desc: UnregisterCaptureStatusListener02 fun
924 * @tc.type: FUNC
925 */
926 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener02, Function | SmallTest | Level1)
927 {
928 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
929 sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
930 DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
931 auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
932 ASSERT_EQ(ret, DMError::DM_OK);
933 listener.clear();
934 }
935
936 /**
937 * @tc.name: UnregisterCaptureStatusListener03
938 * @tc.desc: UnregisterCaptureStatusListener03 fun
939 * @tc.type: FUNC
940 */
941 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener03, Function | SmallTest | Level1)
942 {
943 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
944 DisplayManager::GetInstance().pImpl_->captureStatusListeners_.clear();
945 sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
946 DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
947 auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
948 ASSERT_EQ(ret, DMError::DM_OK);
949 listener.clear();
950 }
951
952 /**
953 * @tc.name: RegisterDisplayUpdateListener01
954 * @tc.desc: RegisterDisplayUpdateListener01 fun
955 * @tc.type: FUNC
956 */
957 HWTEST_F(DisplayManagerTest, RegisterDisplayUpdateListener01, Function | SmallTest | Level1)
958 {
959 sptr<DisplayManager::IDisplayUpdateListener> listener = nullptr;
960 auto ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
961 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
962 listener = new DisplayManager::IDisplayUpdateListener();
963 ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
964 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterDisplayUpdateListener(listener));
965 listener.clear();
966 }
967
968 /**
969 * @tc.name: IsCaptured01
970 * @tc.desc: IsCaptured01 fun
971 * @tc.type: FUNC
972 */
973 HWTEST_F(DisplayManagerTest, IsCaptured01, Function | SmallTest | Level1)
974 {
975 auto ret = DisplayManager::GetInstance().IsCaptured();
976 ASSERT_FALSE(ret);
977 }
978
979 /**
980 * @tc.name: isinsideof
981 * @tc.desc: isinside0f fun
982 * @tc.type: FUNC
983 */
984 HWTEST_F(DisplayManagerTest, isinsideof, Function | SmallTest | Level1)
985 {
986 DMRect rect = {2, 2, 2, 2};
987 DMRect rect1 = {2, 2, 2, 2};
988 ASSERT_EQ(rect.IsInsideOf(rect1), true);
989 }
990
991 /**
992 * @tc.name: GetAllDisplayPhysicalResolution
993 * @tc.desc: GetAllDisplayPhysicalResolution test
994 * @tc.type: FUNC
995 */
996 HWTEST_F(DisplayManagerTest, GetAllDisplayPhysicalResolution, Function | SmallTest | Level1)
997 {
998 std::vector<DisplayPhysicalResolution> allSize = DisplayManager::GetInstance().GetAllDisplayPhysicalResolution();
999 ASSERT_TRUE(!allSize.empty());
1000 }
1001
1002 /**
1003 * @tc.name: ClearDisplayStateCallback
1004 * @tc.desc: ClearDisplayStateCallback test
1005 * @tc.type: FUNC
1006 */
1007 HWTEST_F(DisplayManagerTest, ClearDisplayStateCallback, Function | SmallTest | Level1)
1008 {
1009 DisplayManager::GetInstance().pImpl_->ClearDisplayStateCallback();
1010 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayStateAgent_ == nullptr);
1011 }
1012
1013 /**
1014 * @tc.name: ClearFoldStatusCallback
1015 * @tc.desc: ClearFoldStatusCallback test
1016 * @tc.type: FUNC
1017 */
1018 HWTEST_F(DisplayManagerTest, ClearFoldStatusCallback, Function | SmallTest | Level1)
1019 {
1020 DisplayManager::GetInstance().pImpl_->ClearFoldStatusCallback();
1021 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldStatusListenerAgent_ == nullptr);
1022 }
1023
1024 /**
1025 * @tc.name: ClearFoldAngleCallback
1026 * @tc.desc: ClearFoldAngleCallback test
1027 * @tc.type: FUNC
1028 */
1029 HWTEST_F(DisplayManagerTest, ClearFoldAngleCallback, Function | SmallTest | Level1)
1030 {
1031 DisplayManager::GetInstance().pImpl_->ClearFoldAngleCallback();
1032 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ == nullptr);
1033 }
1034
1035 /**
1036 * @tc.name: ClearCaptureStatusCallback
1037 * @tc.desc: ClearCaptureStatusCallback test
1038 * @tc.type: FUNC
1039 */
1040 HWTEST_F(DisplayManagerTest, ClearCaptureStatusCallback, Function | SmallTest | Level1)
1041 {
1042 DisplayManager::GetInstance().pImpl_->ClearCaptureStatusCallback();
1043 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ == nullptr);
1044 }
1045
1046 /**
1047 * @tc.name: ClearDisplayModeCallback
1048 * @tc.desc: ClearDisplayModeCallback test
1049 * @tc.type: FUNC
1050 */
1051 HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback01, Function | SmallTest | Level1)
1052 {
1053 DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
1054 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
1055 }
1056
1057 /**
1058 * @tc.name: ClearDisplayModeCallback
1059 * @tc.desc: ClearDisplayModeCallback test
1060 * @tc.type: FUNC
1061 */
1062 HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback02, Function | SmallTest | Level1)
1063 {
1064 sptr<DisplayManager::IDisplayModeListener> listener = new DisplayManager::IDisplayModeListener();
1065 DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
1066 DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
1067 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
1068 }
1069
1070 /**
1071 * @tc.name: GetDisplayByScreenId
1072 * @tc.desc: GetDisplayByScreenId test
1073 * @tc.type: FUNC
1074 */
1075 HWTEST_F(DisplayManagerTest, GetDisplayByScreenId, Function | SmallTest | Level1)
1076 {
1077 ScreenId screenId = -1;
1078 auto ret = DisplayManager::GetInstance().pImpl_->GetDisplayByScreenId(screenId);
1079 ASSERT_TRUE(ret == nullptr);
1080 }
1081
1082 /**
1083 * @tc.name: UnregisterDisplayUpdateListener
1084 * @tc.desc: UnregisterDisplayUpdateListener fun
1085 * @tc.type: FUNC
1086 */
1087 HWTEST_F(DisplayManagerTest, UnregisterDisplayUpdateListener, Function | SmallTest | Level1)
1088 {
1089 sptr<DisplayManager::IDisplayUpdateListener> listener;
1090 auto ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1091 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1092 listener = new DisplayManager::IDisplayUpdateListener();
1093 ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1094 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterDisplayUpdateListener(listener));
1095 listener.clear();
1096 }
1097
1098 /**
1099 * @tc.name: RegisterAvailableAreaListener
1100 * @tc.desc: RegisterAvailableAreaListener fun
1101 * @tc.type: FUNC
1102 */
1103 HWTEST_F(DisplayManagerTest, RegisterAvailableAreaListener, Function | SmallTest | Level1)
1104 {
1105 sptr<DisplayManager::IAvailableAreaListener> listener;
1106 auto ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1107 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1108 listener = new DisplayManager::IAvailableAreaListener();
1109 ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1110 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterAvailableAreaListener(listener));
1111 listener.clear();
1112 }
1113
1114 /**
1115 * @tc.name: UnregisterAvailableAreaListener
1116 * @tc.desc: UnregisterAvailableAreaListener fun
1117 * @tc.type: FUNC
1118 */
1119 HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener, Function | SmallTest | Level1)
1120 {
1121 sptr<DisplayManager::IAvailableAreaListener> listener;
1122 auto ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1123 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1124 listener = new DisplayManager::IAvailableAreaListener();
1125 ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1126 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterAvailableAreaListener(listener));
1127 listener.clear();
1128 }
1129
1130 /**
1131 * @tc.name: GetDisplayInfoSrting
1132 * @tc.desc: GetDisplayInfoSrting fun
1133 * @tc.type: FUNC
1134 */
1135 HWTEST_F(DisplayManagerTest, GetDisplayInfoSrting, Function | SmallTest | Level1)
1136 {
1137 sptr<DisplayInfo> displayInfo = nullptr;
1138 auto ret =DisplayManager::GetInstance().pImpl_->GetDisplayInfoSrting(displayInfo);
1139 ASSERT_EQ(displayInfo, nullptr);
1140 }
1141
1142 /**
1143 * @tc.name: OnRemoteDied
1144 * @tc.desc: OnRemoteDied fun
1145 * @tc.type: FUNC
1146 */
1147 HWTEST_F(DisplayManagerTest, OnRemoteDied, Function | SmallTest | Level1)
1148 {
1149 g_dmIsDestroyed = true;
1150 DisplayManager::GetInstance().OnRemoteDied();
1151 ASSERT_EQ(g_dmIsDestroyed, true);
1152 }
1153
1154 /**
1155 * @tc.name: SetDisplayScale
1156 * @tc.desc: SetDisplayScale test
1157 * @tc.type: FUNC
1158 */
1159 HWTEST_F(DisplayManagerTest, SetDisplayScale, Function | SmallTest | Level1)
1160 {
1161 DisplayManager& displayManager = DisplayManager::GetInstance();
1162 ASSERT_NE(displayManager.pImpl_, nullptr);
1163 const float scaleX = 1.0f;
1164 const float scaleY = 1.0f;
1165 const float pivotX = 0.5f;
1166 const float pivotY = 0.5f;
1167 sptr<Display> display = displayManager.GetDefaultDisplay();
1168 ASSERT_NE(display, nullptr);
1169 ScreenId screenId = display->GetScreenId();
1170 displayManager.SetDisplayScale(screenId, scaleX, scaleY, pivotX, pivotY);
1171 }
1172
1173 /**
1174 * @tc.name: Clear
1175 * @tc.desc: Clear test
1176 * @tc.type: FUNC
1177 */
1178 HWTEST_F(DisplayManagerTest, Clear01, Function | SmallTest | Level1)
1179 {
1180 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1181 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1182 EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1183 DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
1184 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
1185 DisplayManager::GetInstance().RegisterDisplayListener(listener);
1186 auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
1187 ASSERT_NE(displayManagerListener, nullptr);
1188 DisplayManager::GetInstance().pImpl_->Clear();
1189 ASSERT_EQ(DisplayManager::GetInstance().pImpl_->displayManagerListener_, nullptr);
1190 }
1191
1192 /**
1193 * @tc.name: Clear
1194 * @tc.desc: Clear test
1195 * @tc.type: FUNC
1196 */
1197 HWTEST_F(DisplayManagerTest, Clear02, Function | SmallTest | Level1)
1198 {
1199 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1200 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1201 EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1202 DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_ = nullptr;
1203 sptr<IDisplayPowerEventListener> listener = new DmMockDisplayPowerEventListener();
1204 DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener);
1205 auto powerEventListenerAgent = DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_;
1206 ASSERT_NE(powerEventListenerAgent, nullptr);
1207 DisplayManager::GetInstance().pImpl_->Clear();
1208 ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1209 }
1210
1211 /**
1212 * @tc.name: NotifyCaptureStatusChanged
1213 * @tc.desc: NotifyCaptureStatusChanged fun
1214 * @tc.type: FUNC
1215 */
1216 HWTEST_F(DisplayManagerTest, NotifyCaptureStatusChanged, Function | SmallTest | Level1)
1217 {
1218 DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ = nullptr;
1219 sptr<DisplayManager::Impl> impl_;
1220 sptr<DisplayManager::Impl::DisplayManagerDisplayModeAgent> displayModeListenerAgent =
1221 new DisplayManager::Impl::DisplayManagerDisplayModeAgent(impl_);
1222 bool isCapture = true;
1223 DisplayManager::GetInstance().pImpl_->NotifyCaptureStatusChanged(isCapture);
1224 ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1225 }
1226
1227 /**
1228 * @tc.name: NotifyCaptureStatusChanged01
1229 * @tc.desc: NotifyCaptureStatusChanged01 fun
1230 * @tc.type: FUNC
1231 */
1232 HWTEST_F(DisplayManagerTest, NotifyCaptureStatusChanged01, Function | SmallTest | Level1)
1233 {
1234 DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ = nullptr;
1235 sptr<DisplayManager::Impl> impl_;
1236 sptr<DisplayManager::Impl::DisplayManagerDisplayModeAgent> displayModeListenerAgent =
1237 new DisplayManager::Impl::DisplayManagerDisplayModeAgent(impl_);
1238 bool isCapture = true;
1239 DisplayManager::GetInstance().pImpl_->NotifyCaptureStatusChanged(isCapture);
1240 ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1241 }
1242
1243 /**
1244 * @tc.name: RegisterFoldAngleListener03
1245 * @tc.desc: RegisterFoldAngleListener03 fun
1246 * @tc.type: FUNC
1247 */
1248 HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener03, Function | SmallTest | Level1)
1249 {
1250 sptr<DisplayManager::IFoldAngleListener> listener = nullptr;
1251 auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1252 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1253 listener = new DisplayManager::IFoldAngleListener();
1254 ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1255 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterFoldAngleListener(listener));
1256 listener.clear();
1257 }
1258
1259 /**
1260 * @tc.name: RegisterFoldAngleListener04
1261 * @tc.desc: RegisterFoldAngleListener04 fun
1262 * @tc.type: FUNC
1263 */
1264 HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener04, Function | SmallTest | Level1)
1265 {
1266 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1267 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
1268 DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ = nullptr;
1269 sptr<DisplayManager::IFoldAngleListener> listener = new DmMockFoldAngleListener();
1270 auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1271 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
1272 listener.clear();
1273 }
1274
1275 /**
1276 * @tc.name: UnregisterFoldAngleListener04
1277 * @tc.desc: UnregisterFoldAngleListener04 fun
1278 * @tc.type: FUNC
1279 */
1280 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener04, Function | SmallTest | Level1)
1281 {
1282 sptr<DisplayManager::IFoldAngleListener> listener;
1283 auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
1284 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1285 listener = new DisplayManager::IFoldAngleListener();
1286 ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
1287 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterFoldAngleListener(listener));
1288 listener.clear();
1289 }
1290
1291 /**
1292 * @tc.name: UnregisterFoldAngleListener05
1293 * @tc.desc: UnregisterFoldAngleListener05 fun
1294 * @tc.type: FUNC
1295 */
1296 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener05, Function | SmallTest | Level1)
1297 {
1298 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
1299 sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
1300 DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1301 auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
1302 ASSERT_EQ(ret, DMError::DM_OK);
1303 listener.clear();
1304 }
1305
1306 /**
1307 * @tc.name: UnregisterFoldAngleListener06
1308 * @tc.desc: UnregisterFoldAngleListener06 fun
1309 * @tc.type: FUNC
1310 */
1311 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener06, Function | SmallTest | Level1)
1312 {
1313 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
1314 DisplayManager::GetInstance().pImpl_->foldAngleListeners_.clear();
1315 sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
1316 DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1317 auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
1318 ASSERT_EQ(ret, DMError::DM_OK);
1319 listener.clear();
1320 }
1321
1322 /**
1323 * @tc.name: RegisterCaptureStatusListener03
1324 * @tc.desc: RegisterCaptureStatusListener03 fun
1325 * @tc.type: FUNC
1326 */
1327 HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener03, Function | SmallTest | Level1)
1328 {
1329 sptr<DisplayManager::ICaptureStatusListener> listener = nullptr;
1330 auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1331 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1332 listener = new DisplayManager::ICaptureStatusListener();
1333 ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1334 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterCaptureStatusListener(listener));
1335 listener.clear();
1336 }
1337
1338 /**
1339 * @tc.name: RegisterCaptureStatusListener04
1340 * @tc.desc: RegisterCaptureStatusListener04 fun
1341 * @tc.type: FUNC
1342 */
1343 HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener04, Function | SmallTest | Level1)
1344 {
1345 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1346 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
1347 DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ = nullptr;
1348 sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
1349 auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1350 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
1351 listener.clear();
1352 }
1353
1354 /**
1355 * @tc.name: UnregisterCaptureStatusListener04
1356 * @tc.desc: UnregisterCaptureStatusListener04 fun
1357 * @tc.type: FUNC
1358 */
1359 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener04, Function | SmallTest | Level1)
1360 {
1361 sptr<DisplayManager::ICaptureStatusListener> listener;
1362 auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
1363 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1364 listener = new DisplayManager::ICaptureStatusListener();
1365 ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
1366 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterCaptureStatusListener(listener));
1367 listener.clear();
1368 }
1369
1370 /**
1371 * @tc.name: UnregisterCaptureStatusListener05
1372 * @tc.desc: UnregisterCaptureStatusListener05 fun
1373 * @tc.type: FUNC
1374 */
1375 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener05, Function | SmallTest | Level1)
1376 {
1377 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
1378 sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
1379 DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1380 auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
1381 ASSERT_EQ(ret, DMError::DM_OK);
1382 listener.clear();
1383 }
1384
1385 /**
1386 * @tc.name: UnregisterCaptureStatusListener06
1387 * @tc.desc: UnregisterCaptureStatusListener06 fun
1388 * @tc.type: FUNC
1389 */
1390 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener06, Function | SmallTest | Level1)
1391 {
1392 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
1393 DisplayManager::GetInstance().pImpl_->captureStatusListeners_.clear();
1394 sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
1395 DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1396 auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
1397 ASSERT_EQ(ret, DMError::DM_OK);
1398 listener.clear();
1399 }
1400
1401 /**
1402 * @tc.name: RegisterDisplayUpdateListener02
1403 * @tc.desc: RegisterDisplayUpdateListener02 fun
1404 * @tc.type: FUNC
1405 */
1406 HWTEST_F(DisplayManagerTest, RegisterDisplayUpdateListener02, Function | SmallTest | Level1)
1407 {
1408 sptr<DisplayManager::IDisplayUpdateListener> listener = nullptr;
1409 auto ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
1410 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1411 listener = new DisplayManager::IDisplayUpdateListener();
1412 ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
1413 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterDisplayUpdateListener(listener));
1414 listener.clear();
1415 }
1416
1417 /**
1418 * @tc.name: IsCaptured02
1419 * @tc.desc: IsCaptured02 fun
1420 * @tc.type: FUNC
1421 */
1422 HWTEST_F(DisplayManagerTest, IsCaptured02, Function | SmallTest | Level1)
1423 {
1424 auto ret = DisplayManager::GetInstance().IsCaptured();
1425 ASSERT_FALSE(ret);
1426 }
1427
1428 /**
1429 * @tc.name: isinsideof01
1430 * @tc.desc: isinsideof01 fun
1431 * @tc.type: FUNC
1432 */
1433 HWTEST_F(DisplayManagerTest, isinsideof01, Function | SmallTest | Level1)
1434 {
1435 DMRect rect = {2, 2, 2, 2};
1436 DMRect rect1 = {2, 2, 2, 2};
1437 ASSERT_EQ(rect.IsInsideOf(rect1), true);
1438 }
1439
1440 /**
1441 * @tc.name: GetAllDisplayPhysicalResolution01
1442 * @tc.desc: GetAllDisplayPhysicalResolution01 test
1443 * @tc.type: FUNC
1444 */
1445 HWTEST_F(DisplayManagerTest, GetAllDisplayPhysicalResolution01, Function | SmallTest | Level1)
1446 {
1447 std::vector<DisplayPhysicalResolution> allSize = DisplayManager::GetInstance().GetAllDisplayPhysicalResolution();
1448 ASSERT_TRUE(!allSize.empty());
1449 }
1450
1451 /**
1452 * @tc.name: ClearDisplayStateCallback01
1453 * @tc.desc: ClearDisplayStateCallback01 test
1454 * @tc.type: FUNC
1455 */
1456 HWTEST_F(DisplayManagerTest, ClearDisplayStateCallback01, Function | SmallTest | Level1)
1457 {
1458 DisplayManager::GetInstance().pImpl_->ClearDisplayStateCallback();
1459 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayStateAgent_ == nullptr);
1460 }
1461
1462 /**
1463 * @tc.name: ClearFoldStatusCallback01
1464 * @tc.desc: ClearFoldStatusCallback01 test
1465 * @tc.type: FUNC
1466 */
1467 HWTEST_F(DisplayManagerTest, ClearFoldStatusCallback01, Function | SmallTest | Level1)
1468 {
1469 DisplayManager::GetInstance().pImpl_->ClearFoldStatusCallback();
1470 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldStatusListenerAgent_ == nullptr);
1471 }
1472
1473 /**
1474 * @tc.name: ClearFoldAngleCallback01
1475 * @tc.desc: ClearFoldAngleCallback01 test
1476 * @tc.type: FUNC
1477 */
1478 HWTEST_F(DisplayManagerTest, ClearFoldAngleCallback01, Function | SmallTest | Level1)
1479 {
1480 DisplayManager::GetInstance().pImpl_->ClearFoldAngleCallback();
1481 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ == nullptr);
1482 }
1483
1484 /**
1485 * @tc.name: ClearCaptureStatusCallback01
1486 * @tc.desc: ClearCaptureStatusCallback01 test
1487 * @tc.type: FUNC
1488 */
1489 HWTEST_F(DisplayManagerTest, ClearCaptureStatusCallback01, Function | SmallTest | Level1)
1490 {
1491 DisplayManager::GetInstance().pImpl_->ClearCaptureStatusCallback();
1492 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ == nullptr);
1493 }
1494
1495 /**
1496 * @tc.name: ClearDisplayModeCallback03
1497 * @tc.desc: ClearDisplayModeCallback03 test
1498 * @tc.type: FUNC
1499 */
1500 HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback03, Function | SmallTest | Level1)
1501 {
1502 DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
1503 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
1504 }
1505
1506 /**
1507 * @tc.name: ClearDisplayModeCallback04
1508 * @tc.desc: ClearDisplayModeCallback04 test
1509 * @tc.type: FUNC
1510 */
1511 HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback04, Function | SmallTest | Level1)
1512 {
1513 sptr<DisplayManager::IDisplayModeListener> listener = new DisplayManager::IDisplayModeListener();
1514 DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
1515 DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
1516 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
1517 }
1518
1519 /**
1520 * @tc.name: GetDisplayByScreenId01
1521 * @tc.desc: GetDisplayByScreenId01 test
1522 * @tc.type: FUNC
1523 */
1524 HWTEST_F(DisplayManagerTest, GetDisplayByScreenId01, Function | SmallTest | Level1)
1525 {
1526 ScreenId screenId = -1;
1527 auto ret = DisplayManager::GetInstance().pImpl_->GetDisplayByScreenId(screenId);
1528 ASSERT_TRUE(ret == nullptr);
1529 }
1530
1531 /**
1532 * @tc.name: UnregisterDisplayUpdateListener01
1533 * @tc.desc: UnregisterDisplayUpdateListener01 fun
1534 * @tc.type: FUNC
1535 */
1536 HWTEST_F(DisplayManagerTest, UnregisterDisplayUpdateListener01, Function | SmallTest | Level1)
1537 {
1538 sptr<DisplayManager::IDisplayUpdateListener> listener;
1539 auto ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1540 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1541 listener = new DisplayManager::IDisplayUpdateListener();
1542 ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1543 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterDisplayUpdateListener(listener));
1544 listener.clear();
1545 }
1546
1547 /**
1548 * @tc.name: RegisterAvailableAreaListener01
1549 * @tc.desc: RegisterAvailableAreaListener01 fun
1550 * @tc.type: FUNC
1551 */
1552 HWTEST_F(DisplayManagerTest, RegisterAvailableAreaListener01, Function | SmallTest | Level1)
1553 {
1554 sptr<DisplayManager::IAvailableAreaListener> listener;
1555 auto ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1556 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1557 listener = new DisplayManager::IAvailableAreaListener();
1558 ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1559 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterAvailableAreaListener(listener));
1560 listener.clear();
1561 }
1562
1563 /**
1564 * @tc.name: UnregisterAvailableAreaListener01
1565 * @tc.desc: UnregisterAvailableAreaListener01 fun
1566 * @tc.type: FUNC
1567 */
1568 HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener01, Function | SmallTest | Level1)
1569 {
1570 sptr<DisplayManager::IAvailableAreaListener> listener;
1571 auto ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1572 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1573 listener = new DisplayManager::IAvailableAreaListener();
1574 ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1575 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterAvailableAreaListener(listener));
1576 listener.clear();
1577 }
1578
1579 /**
1580 * @tc.name: GetDisplayInfoSrting01
1581 * @tc.desc: GetDisplayInfoSrting01 fun
1582 * @tc.type: FUNC
1583 */
1584 HWTEST_F(DisplayManagerTest, GetDisplayInfoSrting01, Function | SmallTest | Level1)
1585 {
1586 sptr<DisplayInfo> displayInfo = nullptr;
1587 auto ret =DisplayManager::GetInstance().pImpl_->GetDisplayInfoSrting(displayInfo);
1588 ASSERT_EQ(displayInfo, nullptr);
1589 }
1590
1591 /**
1592 * @tc.name: OnRemoteDied01
1593 * @tc.desc: OnRemoteDied01 fun
1594 * @tc.type: FUNC
1595 */
1596 HWTEST_F(DisplayManagerTest, OnRemoteDied01, Function | SmallTest | Level1)
1597 {
1598 g_dmIsDestroyed = true;
1599 DisplayManager::GetInstance().OnRemoteDied();
1600 ASSERT_EQ(g_dmIsDestroyed, true);
1601 }
1602
1603 /**
1604 * @tc.name: SetDisplayScale01
1605 * @tc.desc: SetDisplayScale01 test
1606 * @tc.type: FUNC
1607 */
1608 HWTEST_F(DisplayManagerTest, SetDisplayScale01, Function | SmallTest | Level1)
1609 {
1610 DisplayManager& displayManager = DisplayManager::GetInstance();
1611 ASSERT_NE(displayManager.pImpl_, nullptr);
1612 const float scaleX = 1.0f;
1613 const float scaleY = 1.0f;
1614 const float pivotX = 0.5f;
1615 const float pivotY = 0.5f;
1616 sptr<Display> display = displayManager.GetDefaultDisplay();
1617 ASSERT_NE(display, nullptr);
1618 ScreenId screenId = display->GetScreenId();
1619 displayManager.SetDisplayScale(screenId, scaleX, scaleY, pivotX, pivotY);
1620 }
1621
1622 /**
1623 * @tc.name: Clear03
1624 * @tc.desc: Clear03 test
1625 * @tc.type: FUNC
1626 */
1627 HWTEST_F(DisplayManagerTest, Clear03, Function | SmallTest | Level1)
1628 {
1629 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1630 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1631 EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1632 DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
1633 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
1634 DisplayManager::GetInstance().RegisterDisplayListener(listener);
1635 auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
1636 ASSERT_NE(displayManagerListener, nullptr);
1637 DisplayManager::GetInstance().pImpl_->Clear();
1638 ASSERT_EQ(DisplayManager::GetInstance().pImpl_->displayManagerListener_, nullptr);
1639 }
1640
1641 /**
1642 * @tc.name: Clear04
1643 * @tc.desc: Clear04 test
1644 * @tc.type: FUNC
1645 */
1646 HWTEST_F(DisplayManagerTest, Clear04, Function | SmallTest | Level1)
1647 {
1648 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1649 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1650 EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1651 DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_ = nullptr;
1652 sptr<IDisplayPowerEventListener> listener = new DmMockDisplayPowerEventListener();
1653 DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener);
1654 auto powerEventListenerAgent = DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_;
1655 ASSERT_NE(powerEventListenerAgent, nullptr);
1656 DisplayManager::GetInstance().pImpl_->Clear();
1657 ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1658 }
1659
1660 /**
1661 * @tc.name: GetScreenCapture
1662 * @tc.desc: GetScreenCapture test
1663 * @tc.type: FUNC
1664 */
1665 HWTEST_F(DisplayManagerTest, GetScreenCapture, Function | SmallTest | Level1)
1666 {
1667 CaptureOption captureOption;
1668 sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplay();
1669 ASSERT_NE(display, nullptr);
1670 captureOption.displayId_ = display->GetId();
1671 DmErrorCode errCode;
1672 std::shared_ptr<Media::PixelMap> pixelMap = DisplayManager::GetInstance().GetScreenCapture(captureOption,
1673 &errCode);
1674 }
1675
1676 /**
1677 * @tc.name: GetPrimaryDisplaySync
1678 * @tc.desc: GetPrimaryDisplaySync test
1679 * @tc.type: FUNC
1680 */
1681 HWTEST_F(DisplayManagerTest, GetPrimaryDisplaySync, Function | SmallTest | Level1)
1682 {
1683 sptr<Display> display = DisplayManager::GetInstance().GetPrimaryDisplaySync();
1684 ASSERT_NE(display, nullptr);
1685 }
1686
1687 /**
1688 * @tc.name: RegisterScreenMagneticStateListener
1689 * @tc.desc: RegisterScreenMagneticStateListener fun
1690 * @tc.type: FUNC
1691 */
1692 HWTEST_F(DisplayManagerTest, RegisterScreenMagneticStateListener, Function | SmallTest | Level1)
1693 {
1694 sptr<DisplayManager::IScreenMagneticStateListener> listener;
1695 auto ret = DisplayManager::GetInstance().RegisterScreenMagneticStateListener(listener);
1696 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1697 listener = new DisplayManager::IScreenMagneticStateListener();
1698 ret = DisplayManager::GetInstance().RegisterScreenMagneticStateListener(listener);
1699 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterScreenMagneticStateListener(listener));
1700 listener.clear();
1701 }
1702
1703 /**
1704 * @tc.name: ImplRegisterScreenMagneticStateListener
1705 * @tc.desc: ImplRegisterScreenMagneticStateListener fun
1706 * @tc.type: FUNC
1707 */
1708 HWTEST_F(DisplayManagerTest, ImplRegisterScreenMagneticStateListener, Function | SmallTest | Level1)
1709 {
1710 sptr<DisplayManager::IScreenMagneticStateListener> listener;
1711 DisplayManager::GetInstance().pImpl_->screenMagneticStateListenerAgent_ = nullptr;
1712 sptr<DisplayManager::Impl> impl_;
1713 sptr<DisplayManager::Impl::DisplayManagerScreenMagneticStateAgent> screenMagneticStateListenerAgent =
1714 new DisplayManager::Impl::DisplayManagerScreenMagneticStateAgent(impl_);
1715 auto ret = DisplayManager::GetInstance().pImpl_->RegisterScreenMagneticStateListener(listener);
1716 ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
1717 screenMagneticStateListenerAgent,
1718 DisplayManagerAgentType::SCREEN_MAGNETIC_STATE_CHANGED_LISTENER));
1719 listener.clear();
1720 screenMagneticStateListenerAgent.clear();
1721 }
1722
1723 /**
1724 * @tc.name: UnregisterScreenMagneticStateListener
1725 * @tc.desc: UnregisterScreenMagneticStateListener fun
1726 * @tc.type: FUNC
1727 */
1728 HWTEST_F(DisplayManagerTest, UnregisterScreenMagneticStateListener, Function | SmallTest | Level1)
1729 {
1730 sptr<DisplayManager::IScreenMagneticStateListener> listener;
1731 auto ret = DisplayManager::GetInstance().UnregisterScreenMagneticStateListener(listener);
1732 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1733 listener = new DisplayManager::IScreenMagneticStateListener();
1734 ret = DisplayManager::GetInstance().UnregisterScreenMagneticStateListener(listener);
1735 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterScreenMagneticStateListener(listener));
1736 listener.clear();
1737 }
1738
1739 /**
1740 * @tc.name: ImplUnregisterScreenMagneticStateListener
1741 * @tc.desc: ImplUnregisterScreenMagneticStateListener fun
1742 * @tc.type: FUNC
1743 */
1744 HWTEST_F(DisplayManagerTest, ImplUnregisterScreenMagneticStateListener, Function | SmallTest | Level1)
1745 {
1746 sptr<DisplayManager::IScreenMagneticStateListener> listener;
1747 auto ret = DisplayManager::GetInstance().pImpl_->UnregisterScreenMagneticStateListener(listener);
1748 ASSERT_EQ(ret, DMError::DM_OK);
1749 listener.clear();
1750 }
1751 }
1752 } // namespace Rosen
1753 } // namespace OHOS