1 /*
2 * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "display_manager.cpp"
19 #include "display_manager.h"
20 #include "display_manager_proxy.h"
21 #include "dm_common.h"
22 #include "mock_display_manager_adapter.h"
23 #include "scene_board_judgement.h"
24 #include "singleton_mocker.h"
25 #include "window_scene.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32 using Mocker = SingletonMocker<DisplayManagerAdapter, MockDisplayManagerAdapter>;
33 using MockerManager = SingletonMocker<DisplayManager, MockDisplayManger>;
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 void SetUp() override;
66 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 static constexpr DisplayId DEFAULT_DISPLAY = 1ULL;
87 static const int32_t EXECUTION_TIMES = 1;
88 static const int32_t PIXELMAP_SIZE = 2;
89 static const int32_t SDR_PIXELMAP = 0;
90 static const int32_t HDR_PIXELMAP = 1;
91
92 /**
93 * @tc.name: Freeze01
94 * @tc.desc: success
95 * @tc.type: FUNC
96 */
97 HWTEST_F(DisplayManagerTest, Freeze01, TestSize.Level1)
98 {
99 std::vector<DisplayId> displayIds;
100 displayIds.push_back(0);
101 bool ret = DisplayManager::GetInstance().Freeze(displayIds);
102 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
103 ASSERT_TRUE(ret);
104 } else {
105 ASSERT_FALSE(ret);
106 }
107 }
108
109 /**
110 * @tc.name: Freeze02
111 * @tc.desc: test Freeze displayIds exceed the maximum
112 * @tc.type: FUNC
113 */
114 HWTEST_F(DisplayManagerTest, Freeze02, TestSize.Level1)
115 {
116 std::vector<DisplayId> displayIds;
117 for (uint32_t i = 0; i < 33; i++) { // MAX_DISPLAY_SIZE + 1
118 displayIds.push_back(i);
119 }
120 bool ret = DisplayManager::GetInstance().Freeze(displayIds);
121 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
122 ASSERT_FALSE(ret);
123 }
124 }
125
126 /**
127 * @tc.name: Freeze03
128 * @tc.desc: test Freeze displayIds empty
129 * @tc.type: FUNC
130 */
131 HWTEST_F(DisplayManagerTest, Freeze03, TestSize.Level1)
132 {
133 std::vector<DisplayId> displayIds;
134 bool ret = DisplayManager::GetInstance().Freeze(displayIds);
135 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
136 ASSERT_FALSE(ret);
137 }
138 }
139
140 /**
141 * @tc.name: Unfreeze01
142 * @tc.desc: success
143 * @tc.type: FUNC
144 */
145 HWTEST_F(DisplayManagerTest, Unfreeze01, TestSize.Level1)
146 {
147 std::vector<DisplayId> displayIds;
148 displayIds.push_back(0);
149 bool ret = DisplayManager::GetInstance().Unfreeze(displayIds);
150 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
151 ASSERT_TRUE(ret);
152 } else {
153 ASSERT_FALSE(ret);
154 }
155 }
156
157 /**
158 * @tc.name: Unfreeze02
159 * @tc.desc: test Freeze displayIds exceed the maximum
160 * @tc.type: FUNC
161 */
162 HWTEST_F(DisplayManagerTest, Unfreeze02, TestSize.Level1)
163 {
164 std::vector<DisplayId> displayIds;
165 for (uint32_t i = 0; i < 33; i++) { // MAX_DISPLAY_SIZE + 1
166 displayIds.push_back(i);
167 }
168
169 bool ret = DisplayManager::GetInstance().Unfreeze(displayIds);
170 ASSERT_FALSE(ret);
171 }
172
173 /**
174 * @tc.name: Unfreeze03
175 * @tc.desc: test Freeze displayIds empty
176 * @tc.type: FUNC
177 */
178 HWTEST_F(DisplayManagerTest, Unfreeze03, TestSize.Level1)
179 {
180 std::vector<DisplayId> displayIds;
181 bool ret = DisplayManager::GetInstance().Unfreeze(displayIds);
182 ASSERT_FALSE(ret);
183 }
184
185 /**
186 * @tc.name: RegisterScreenshotListener01
187 * @tc.desc: test RegisterScreenshotListener with null listener
188 * @tc.type: FUNC
189 */
190 HWTEST_F(DisplayManagerTest, RegisterScreenshotListener01, TestSize.Level1)
191 {
192 DMError ret = DisplayManager::GetInstance().RegisterScreenshotListener(nullptr);
193 ASSERT_FALSE(DMError::DM_OK == ret);
194 }
195
196 /**
197 * @tc.name: RegisterScreenshotListener02
198 * @tc.desc: test RegisterScreenshotListener with null listener
199 * @tc.type: FUNC
200 */
201 HWTEST_F(DisplayManagerTest, RegisterScreenshotListener02, TestSize.Level1)
202 {
203 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
204 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_NULLPTR));
205 sptr<DisplayManager::IScreenshotListener> listener = new DmMockScreenshotListener();
206 DMError ret = DisplayManager::GetInstance().RegisterScreenshotListener(listener);
207 ASSERT_FALSE(DMError::DM_OK == ret);
208 }
209
210 /**
211 * @tc.name: UnregisterScreenshotListener01
212 * @tc.desc: test UnregisterScreenshotListener with null listener
213 * @tc.type: FUNC
214 */
215 HWTEST_F(DisplayManagerTest, UnregisterScreenshotListener01, TestSize.Level1)
216 {
217 DMError ret = DisplayManager::GetInstance().UnregisterScreenshotListener(nullptr);
218 ASSERT_FALSE(DMError::DM_OK == ret);
219 }
220
221 /**
222 * @tc.name: UnregisterScreenshotListener02
223 * @tc.desc: test UnregisterScreenshotListener with null listener
224 * @tc.type: FUNC
225 */
226 HWTEST_F(DisplayManagerTest, UnregisterScreenshotListener02, TestSize.Level1)
227 {
228 sptr<DisplayManager::IScreenshotListener> listener = new DmMockScreenshotListener();
229 DMError ret = DisplayManager::GetInstance().UnregisterScreenshotListener(listener);
230 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
231 }
232
233 /**
234 * @tc.name: OnDisplayCreate01
235 * @tc.desc: OnDisplayCreate
236 * @tc.type: FUNC
237 */
238 HWTEST_F(DisplayManagerTest, OnDisplayCreate01, TestSize.Level1)
239 {
240 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
241 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
242 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
243 DisplayManager::GetInstance().RegisterDisplayListener(listener);
244 auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
245 ASSERT_NE(displayManagerListener, nullptr);
246 displayManagerListener->OnDisplayCreate(nullptr);
247 sptr<DisplayInfo> displayInfo = new DisplayInfo();
248 displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
249 displayManagerListener->OnDisplayCreate(displayInfo);
250 displayInfo->SetDisplayId(0);
251 displayManagerListener->OnDisplayCreate(displayInfo);
252 ASSERT_NE(displayManagerListener->pImpl_, nullptr);
253 displayManagerListener->pImpl_ = nullptr;
254 displayManagerListener->OnDisplayCreate(displayInfo);
255 DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
256 }
257
258 /**
259 * @tc.name: CheckRectValid
260 * @tc.desc: CheckRectValid all
261 * @tc.type: FUNC
262 */
263 HWTEST_F(DisplayManagerTest, CheckRectValid, TestSize.Level1)
264 {
265 int32_t oriHeight = 500;
266 int32_t oriWidth = 500;
267 Media::Rect rect = {.left = 1, .top = 1, .width = 1, .height = 1};
268 bool ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
269 ASSERT_TRUE(ret);
270 rect.left = -1;
271 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
272 ASSERT_FALSE(ret);
273 rect.left = 1;
274 rect.top = -1;
275 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
276 ASSERT_FALSE(ret);
277 rect.top = 1;
278 rect.width = -1;
279 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
280 ASSERT_FALSE(ret);
281 rect.width = 1;
282 rect.height = -1;
283 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
284 ASSERT_FALSE(ret);
285 rect.width = 500;
286 rect.height = 1;
287 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
288 ASSERT_FALSE(ret);
289 rect.width = 1;
290 rect.height = 500;
291 ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
292 ASSERT_FALSE(ret);
293 }
294
295 /**
296 * @tc.name: CheckSizeValid
297 * @tc.desc: CheckSizeValid all
298 * @tc.type: FUNC
299 */
300 HWTEST_F(DisplayManagerTest, CheckSizeValid, TestSize.Level1)
301 {
302 int32_t oriHeight = 500;
303 int32_t oriWidth = 500;
304 Media::Size size = {.width = 1, .height = 1};
305 bool ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
306 ASSERT_TRUE(ret);
307 size.width = -1;
308 ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
309 ASSERT_FALSE(ret);
310 size.width = 1;
311 size.height = -1;
312 ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
313 ASSERT_FALSE(ret);
314 size.width = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT + 1;
315 size.height = 1;
316 ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
317 ASSERT_FALSE(ret);
318 size.width = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT;
319 size.height = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT + 1;
320 ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
321 ASSERT_FALSE(ret);
322 }
323
324 /**
325 * @tc.name: ImplGetDefaultDisplay01
326 * @tc.desc: Impl GetDefaultDisplay nullptr
327 * @tc.type: FUNC
328 */
329 HWTEST_F(DisplayManagerTest, ImplGetDefaultDisplay01, TestSize.Level1)
330 {
331 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
332 EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(1).WillOnce(Return(nullptr));
333 sptr<Display> display = DisplayManager::GetInstance().pImpl_->GetDefaultDisplay();
334 ASSERT_EQ(display, nullptr);
335 }
336
337 /**
338 * @tc.name: GetDisplayByScreen
339 * @tc.desc: for interface coverage & check GetDisplayByScreen
340 * @tc.type: FUNC
341 */
342 HWTEST_F(DisplayManagerTest, GetDisplayByScreen, TestSize.Level1)
343 {
344 auto& displayManager = DisplayManager::GetInstance();
345 sptr<Display> display = displayManager.GetDisplayByScreen(SCREEN_ID_INVALID);
346 ASSERT_EQ(display, nullptr);
347
348 sptr<DisplayInfo> displayInfo = new DisplayInfo();
349 displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
350 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
351 EXPECT_CALL(m->Mock(), GetDisplayInfoByScreenId(_)).Times(1).WillOnce(Return(displayInfo));
352 display = displayManager.GetDisplayByScreen(1);
353 ASSERT_EQ(display, nullptr);
354 }
355
356 /**
357 * @tc.name: ImplGetDefaultDisplaySync
358 * @tc.desc: Impl GetDefaultDisplaySync nullptr
359 * @tc.type: FUNC
360 */
361 HWTEST_F(DisplayManagerTest, ImplGetDefaultDisplaySync, TestSize.Level1)
362 {
363 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
364 EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(6).WillRepeatedly(Return(nullptr));
365 sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplaySync();
366 ASSERT_EQ(display, nullptr);
367 }
368
369 /**
370 * @tc.name: GetScreenBrightness
371 * @tc.desc: GetScreenBrightness fun
372 * @tc.type: FUNC
373 */
374 HWTEST_F(DisplayManagerTest, GetScreenBrightness, TestSize.Level1)
375 {
376 uint64_t screenId = 2;
377 auto ret = DisplayManager::GetInstance().GetScreenBrightness(screenId);
378 ASSERT_FALSE(ret == 1);
379 }
380
381 /**
382 * @tc.name: GetDisplayById
383 * @tc.desc: GetDisplayById fun
384 * @tc.type: FUNC
385 */
386 HWTEST_F(DisplayManagerTest, GetDisplayById, TestSize.Level1)
387 {
388 DisplayId displayId = -1;
389 g_dmIsDestroyed = true;
390 auto ret = DisplayManager::GetInstance().GetDisplayById(displayId);
391 ASSERT_EQ(ret, nullptr);
392 }
393
394 /**
395 * @tc.name: RegisterPrivateWindowListener
396 * @tc.desc: RegisterPrivateWindowListener fun
397 * @tc.type: FUNC
398 */
399 HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListener01, TestSize.Level1)
400 {
401 sptr<DisplayManager::IPrivateWindowListener> listener;
402 auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListener(listener);
403 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
404 }
405
406 /**
407 * @tc.name: RegisterPrivateWindowListener
408 * @tc.desc: RegisterPrivateWindowListener fun
409 * @tc.type: FUNC
410 */
411 HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListener02, TestSize.Level1)
412 {
413 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
414 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
415 sptr<DisplayManager::IPrivateWindowListener> listener = new DmMockPrivateWindowListener();
416 auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListener(listener);
417 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
418 }
419
420 /**
421 * @tc.name: UnregisterPrivateWindowListener
422 * @tc.desc: UnregisterPrivateWindowListener fun
423 * @tc.type: FUNC
424 */
425 HWTEST_F(DisplayManagerTest, UnregisterPrivateWindowListener, TestSize.Level1)
426 {
427 sptr<DisplayManager::IPrivateWindowListener> listener = nullptr;
428 auto ret = DisplayManager::GetInstance().UnregisterPrivateWindowListener(listener);
429 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
430 }
431
432 /**
433 * @tc.name: ImplUnregisterPrivateWindowListener
434 * @tc.desc: ImplUnregisterPrivateWindowListener fun
435 * @tc.type: FUNC
436 */
437 HWTEST_F(DisplayManagerTest, ImplUnregisterPrivateWindowListener, TestSize.Level1)
438 {
439 std::recursive_mutex mutex;
440 DisplayManager::Impl impl(mutex);
441 sptr<DisplayManager::IPrivateWindowListener> listener;
442 auto ret = impl.UnregisterPrivateWindowListener(listener);
443 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
444 }
445
446 /**
447 * @tc.name: RegisterPrivateWindowListChangeListener
448 * @tc.desc: RegisterPrivateWindowListChangeListener fun
449 * @tc.type: FUNC
450 */
451 HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListChangeListener, TestSize.Level1)
452 {
453 sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
454 auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener);
455 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
456 listener = new DisplayManager::IPrivateWindowListChangeListener();
457 ret = DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener);
458 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterPrivateWindowListChangeListener(listener));
459 listener.clear();
460 }
461
462 /**
463 * @tc.name: UnregisterPrivateWindowListChangeListener
464 * @tc.desc: UnregisterPrivateWindowListChangeListener fun
465 * @tc.type: FUNC
466 */
467 HWTEST_F(DisplayManagerTest, UnregisterPrivateWindowListChangeListener, TestSize.Level1)
468 {
469 sptr<DisplayManager::IPrivateWindowListChangeListener> listener = nullptr;
470 auto ret = DisplayManager::GetInstance().UnregisterPrivateWindowListChangeListener(listener);
471 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
472 listener = new DisplayManager::IPrivateWindowListChangeListener();
473 ret = DisplayManager::GetInstance().UnregisterPrivateWindowListChangeListener(listener);
474 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterPrivateWindowListChangeListener(listener));
475 listener.clear();
476 }
477
478 /**
479 * @tc.name: ImplRegisterPrivateWindowListChangeListener
480 * @tc.desc: ImplRegisterPrivateWindowListChangeListener fun
481 * @tc.type: FUNC
482 */
483 HWTEST_F(DisplayManagerTest, ImplRegisterPrivateWindowListChangeListener01, TestSize.Level1)
484 {
485 std::recursive_mutex mutex;
486 sptr<DisplayManager::Impl> impl_;
487 sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
488 DisplayManager::GetInstance().pImpl_->privateWindowListChangeListenerAgent_ = nullptr;
489 sptr<DisplayManager::Impl::DisplayManagerPrivateWindowListAgent> privateWindowListChangeListenerAgent =
490 new DisplayManager::Impl::DisplayManagerPrivateWindowListAgent(impl_);
491 auto ret = DisplayManager::GetInstance().pImpl_->RegisterPrivateWindowListChangeListener(listener);
492 ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
493 privateWindowListChangeListenerAgent,
494 DisplayManagerAgentType::PRIVATE_WINDOW_LIST_LISTENER));
495 listener = nullptr;
496 privateWindowListChangeListenerAgent.clear();
497 }
498
499 /**
500 * @tc.name: ImplRegisterPrivateWindowListChangeListener
501 * @tc.desc: ImplRegisterPrivateWindowListChangeListener fun
502 * @tc.type: FUNC
503 */
504 HWTEST_F(DisplayManagerTest, ImplRegisterPrivateWindowListChangeListener02, TestSize.Level1)
505 {
506 std::recursive_mutex mutex;
507 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
508 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
509 sptr<DisplayManager::Impl> impl_;
510 sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
511 DisplayManager::GetInstance().pImpl_->privateWindowListChangeListenerAgent_ = nullptr;
512 sptr<DisplayManager::Impl::DisplayManagerPrivateWindowListAgent> privateWindowListChangeListenerAgent =
513 new DisplayManager::Impl::DisplayManagerPrivateWindowListAgent(impl_);
514 auto ret = DisplayManager::GetInstance().pImpl_->RegisterPrivateWindowListChangeListener(listener);
515 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
516 listener = nullptr;
517 privateWindowListChangeListenerAgent.clear();
518 }
519
520 /**
521 * @tc.name: ImplUnregisterPrivateWindowListChangeListener
522 * @tc.desc: ImplUnregisterPrivateWindowListChangeListener fun
523 * @tc.type: FUNC
524 */
525 HWTEST_F(DisplayManagerTest, ImplUnregisterPrivateWindowListChangeListener, TestSize.Level1)
526 {
527 std::recursive_mutex mutex;
528 DisplayManager::Impl impl(mutex);
529 sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
530 auto ret = impl.UnregisterPrivateWindowListChangeListener(listener);
531 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
532 }
533
534 /**
535 * @tc.name: ImplUnregisterFoldStatusListener
536 * @tc.desc: ImplUnregisterFoldStatusListener fun
537 * @tc.type: FUNC
538 */
539 HWTEST_F(DisplayManagerTest, ImplUnregisterFoldStatusListener, TestSize.Level1)
540 {
541 sptr<DisplayManager::IFoldStatusListener> listener;
542 auto ret = DisplayManager::GetInstance().pImpl_->UnregisterFoldStatusListener(listener);
543 ASSERT_NE(ret, DMError::DM_OK);
544 listener.clear();
545 }
546
547 /**
548 * @tc.name: RegisterFoldStatusListener
549 * @tc.desc: RegisterFoldStatusListener fun
550 * @tc.type: FUNC
551 */
552 HWTEST_F(DisplayManagerTest, RegisterFoldStatusListener, TestSize.Level1)
553 {
554 sptr<DisplayManager::IFoldStatusListener> listener;
555 auto ret = DisplayManager::GetInstance().RegisterFoldStatusListener(listener);
556 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
557 listener = new DisplayManager::IFoldStatusListener();
558 ret = DisplayManager::GetInstance().RegisterFoldStatusListener(listener);
559 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterFoldStatusListener(listener));
560 listener.clear();
561 }
562
563 /**
564 * @tc.name: ImplRegisterFoldStatusListener
565 * @tc.desc: ImplRegisterFoldStatusListener fun
566 * @tc.type: FUNC
567 */
568 HWTEST_F(DisplayManagerTest, ImplRegisterFoldStatusListener, TestSize.Level1)
569 {
570 sptr<DisplayManager::IFoldStatusListener> listener;
571 sptr<DisplayManager::Impl> impl_;
572 DisplayManager::GetInstance().pImpl_->foldStatusListenerAgent_ = nullptr;
573 sptr<DisplayManager::Impl::DisplayManagerFoldStatusAgent> foldStatusListenerAgent =
574 new DisplayManager::Impl::DisplayManagerFoldStatusAgent(impl_);
575 auto ret = DisplayManager::GetInstance().pImpl_->RegisterFoldStatusListener(listener);
576 ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
577 foldStatusListenerAgent,
578 DisplayManagerAgentType::FOLD_STATUS_CHANGED_LISTENER));
579 listener = nullptr;
580 foldStatusListenerAgent.clear();
581 }
582
583 /**
584 * @tc.name: UnregisterFoldStatusListener
585 * @tc.desc: UnregisterFoldStatusListener fun
586 * @tc.type: FUNC
587 */
588 HWTEST_F(DisplayManagerTest, UnregisterFoldStatusListener, TestSize.Level1)
589 {
590 sptr<DisplayManager::IFoldStatusListener> listener;
591 auto ret = DisplayManager::GetInstance().UnregisterFoldStatusListener(listener);
592 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
593 listener = new DisplayManager::IFoldStatusListener();
594 ret = DisplayManager::GetInstance().UnregisterFoldStatusListener(listener);
595 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterFoldStatusListener(listener));
596 listener.clear();
597 }
598
599 /**
600 * @tc.name: RegisterDisplayModeListener
601 * @tc.desc: RegisterDisplayModeListener fun
602 * @tc.type: FUNC
603 */
604 HWTEST_F(DisplayManagerTest, RegisterDisplayModeListener, TestSize.Level1)
605 {
606 sptr<DisplayManager::IDisplayModeListener> listener;
607 auto ret = DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
608 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
609 listener = new DisplayManager::IDisplayModeListener();
610 ret = DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
611 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterDisplayModeListener(listener));
612 listener.clear();
613 }
614
615 /**
616 * @tc.name: ImplRegisterDisplayModeListener
617 * @tc.desc: ImplRegisterDisplayModeListener fun
618 * @tc.type: FUNC
619 */
620 HWTEST_F(DisplayManagerTest, ImplRegisterDisplayModeListener, TestSize.Level1)
621 {
622 sptr<DisplayManager::IDisplayModeListener> listener;
623 DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ = nullptr;
624 sptr<DisplayManager::Impl> impl_;
625 sptr<DisplayManager::Impl::DisplayManagerDisplayModeAgent> displayModeListenerAgent =
626 new DisplayManager::Impl::DisplayManagerDisplayModeAgent(impl_);
627 auto ret = DisplayManager::GetInstance().pImpl_->RegisterDisplayModeListener(listener);
628 ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
629 displayModeListenerAgent,
630 DisplayManagerAgentType::DISPLAY_MODE_CHANGED_LISTENER));
631 listener.clear();
632 displayModeListenerAgent.clear();
633 }
634
635 /**
636 * @tc.name: UnregisterDisplayModeListener
637 * @tc.desc: UnregisterDisplayModeListener fun
638 * @tc.type: FUNC
639 */
640 HWTEST_F(DisplayManagerTest, UnregisterDisplayModeListener, TestSize.Level1)
641 {
642 sptr<DisplayManager::IDisplayModeListener> listener;
643 auto ret = DisplayManager::GetInstance().UnregisterDisplayModeListener(listener);
644 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
645 listener = new DisplayManager::IDisplayModeListener();
646 ret = DisplayManager::GetInstance().UnregisterDisplayModeListener(listener);
647 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterDisplayModeListener(listener));
648 listener.clear();
649 }
650
651 /**
652 * @tc.name: ImplUnregisterDisplayModeListener
653 * @tc.desc: ImplUnregisterDisplayModeListener fun
654 * @tc.type: FUNC
655 */
656 HWTEST_F(DisplayManagerTest, ImplUnregisterDisplayModeListener, TestSize.Level1)
657 {
658 sptr<DisplayManager::IDisplayModeListener> listener;
659 auto ret = DisplayManager::GetInstance().pImpl_->UnregisterDisplayModeListener(listener);
660 ASSERT_EQ(ret, DMError::DM_OK);
661 listener.clear();
662 }
663
664 /**
665 * @tc.name: OnDisplayCreate02
666 * @tc.desc: OnDisplayCreate
667 * @tc.type: FUNC
668 */
669 HWTEST_F(DisplayManagerTest, OnDisplayCreate02, TestSize.Level1)
670 {
671 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
672 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
673 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
674 DisplayManager::GetInstance().RegisterDisplayListener(listener);
675 auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
676 ASSERT_NE(displayManagerListener, nullptr);
677
678 sptr<DisplayInfo> displayInfo = nullptr;
679 displayManagerListener->OnDisplayCreate(displayInfo);
680 ASSERT_NE(displayManagerListener->pImpl_, nullptr);
681 }
682
683 /**
684 * @tc.name: RegisterDisplayListener
685 * @tc.desc: RegisterDisplayListener fun
686 * @tc.type: FUNC
687 */
688 HWTEST_F(DisplayManagerTest, RegisterDisplayListener, TestSize.Level1)
689 {
690 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
691 bool hasPrivate = true;
692 DisplayManager::GetInstance().pImpl_->NotifyPrivateWindowStateChanged(hasPrivate);
693 auto ret = DisplayManager::GetInstance().RegisterDisplayListener(listener);
694 ASSERT_EQ(ret, DMError::DM_OK);
695 }
696
697 /**
698 * @tc.name: UnregisterDisplayListener
699 * @tc.desc: UnregisterDisplayListener fun
700 * @tc.type: FUNC
701 */
702 HWTEST_F(DisplayManagerTest, UnregisterDisplayListener, TestSize.Level1)
703 {
704 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
705 sptr<DisplayManager::Impl> impl_;
706 auto ret = DisplayManager::GetInstance().UnregisterDisplayListener(listener);
707 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
708 }
709
710 /**
711 * @tc.name: HasPrivateWindow
712 * @tc.desc: HasPrivateWindow fun
713 * @tc.type: FUNC
714 */
715 HWTEST_F(DisplayManagerTest, HasPrivateWindow, TestSize.Level1)
716 {
717 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
718 bool hasPrivateWindow = false;
719 auto ret = DisplayManager::GetInstance().HasPrivateWindow(0, hasPrivateWindow);
720 ASSERT_EQ(ret, DMError::DM_OK);
721 }
722
723 /**
724 * @tc.name: HasPrivateWindow02
725 * @tc.desc: HasPrivateWindow fun
726 * @tc.type: FUNC
727 */
728 HWTEST_F(DisplayManagerTest, HasPrivateWindow02, TestSize.Level1)
729 {
730 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
731 sptr<DisplayManager::Impl> impl_;
732 bool hasPrivateWindow = false;
733 auto ret = DisplayManager::GetInstance().pImpl_->HasPrivateWindow(0, hasPrivateWindow);
734 ASSERT_EQ(ret, DMError::DM_OK);
735 }
736
737 /**
738 * @tc.name: IsFoldable
739 * @tc.desc: IsFoldable all
740 * @tc.type: FUNC
741 */
742 HWTEST_F(DisplayManagerTest, IsFoldable, TestSize.Level1)
743 {
744 bool ret = DisplayManager::GetInstance().IsFoldable();
745 ASSERT_FALSE(ret);
746 }
747
748 /**
749 * @tc.name: IsFoldable
750 * @tc.desc: IsFoldable fun
751 * @tc.type: FUNC
752 */
753 HWTEST_F(DisplayManagerTest, IsFoldable01, TestSize.Level1)
754 {
755 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
756 FoldDisplayMode mode = FoldDisplayMode{0};
757 DisplayManager::GetInstance().SetFoldDisplayMode(mode);
758 DisplayManager::GetInstance().SetFoldStatusLocked(false);
759 sptr<DisplayManager::Impl> impl_;
760 auto ret = DisplayManager::GetInstance().pImpl_->IsFoldable();
761 ASSERT_FALSE(ret);
762 }
763
764 /**
765 * @tc.name: AddSurfaceNodeToDisplay
766 * @tc.desc: AddSurfaceNodeToDisplay fun
767 * @tc.type: FUNC
768 */
769 HWTEST_F(DisplayManagerTest, AddSurfaceNodeToDisplay, TestSize.Level1)
770 {
771 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
772 std::shared_ptr<class RSSurfaceNode> surfaceNode;
773 auto ret = DisplayManager::GetInstance().AddSurfaceNodeToDisplay(0, surfaceNode);
774 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
775 ASSERT_NE(ret, DMError::DM_ERROR_IPC_FAILED);
776 } else {
777 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
778 }
779 }
780
781 /**
782 * @tc.name: RemoveSurfaceNodeFromDisplay
783 * @tc.desc: RemoveSurfaceNodeFromDisplay fun
784 * @tc.type: FUNC
785 */
786 HWTEST_F(DisplayManagerTest, RemoveSurfaceNodeFromDisplay, TestSize.Level1)
787 {
788 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
789 std::shared_ptr<class RSSurfaceNode> surfaceNode;
790 DisplayManager::GetInstance().OnRemoteDied();
791 auto ret = DisplayManager::GetInstance().RemoveSurfaceNodeFromDisplay(0, surfaceNode);
792 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
793 ASSERT_NE(ret, DMError::DM_ERROR_IPC_FAILED);
794 } else {
795 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
796 }
797 }
798
799 /**
800 * @tc.name: RegisterFoldAngleListener01
801 * @tc.desc: RegisterFoldAngleListener01 fun
802 * @tc.type: FUNC
803 */
804 HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener01, TestSize.Level1)
805 {
806 sptr<DisplayManager::IFoldAngleListener> listener = nullptr;
807 auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
808 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
809 listener = new DisplayManager::IFoldAngleListener();
810 ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
811 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterFoldAngleListener(listener));
812 listener.clear();
813 }
814
815 /**
816 * @tc.name: RegisterFoldAngleListener02
817 * @tc.desc: RegisterFoldAngleListener01 fun
818 * @tc.type: FUNC
819 */
820 HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener02, TestSize.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_->foldAngleListenerAgent_ = nullptr;
825 sptr<DisplayManager::IFoldAngleListener> listener = new DmMockFoldAngleListener();
826 auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
827 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
828 listener.clear();
829 }
830
831 /**
832 * @tc.name: UnregisterFoldAngleListener01
833 * @tc.desc: UnregisterFoldAngleListener01 fun
834 * @tc.type: FUNC
835 */
836 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener01, TestSize.Level1)
837 {
838 sptr<DisplayManager::IFoldAngleListener> listener;
839 auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
840 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
841 listener = new DisplayManager::IFoldAngleListener();
842 ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
843 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterFoldAngleListener(listener));
844 listener.clear();
845 }
846
847 /**
848 * @tc.name: UnregisterFoldAngleListener02
849 * @tc.desc: UnregisterFoldAngleListener02 fun
850 * @tc.type: FUNC
851 */
852 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener02, TestSize.Level1)
853 {
854 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
855 sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
856 DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
857 auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
858 ASSERT_EQ(ret, DMError::DM_OK);
859 listener.clear();
860 }
861
862 /**
863 * @tc.name: UnregisterFoldAngleListener03
864 * @tc.desc: UnregisterFoldAngleListener03 fun
865 * @tc.type: FUNC
866 */
867 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener03, TestSize.Level1)
868 {
869 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
870 DisplayManager::GetInstance().pImpl_->foldAngleListeners_.clear();
871 sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
872 DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
873 auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
874 ASSERT_EQ(ret, DMError::DM_OK);
875 listener.clear();
876 }
877
878 /**
879 * @tc.name: RegisterCaptureStatusListener01
880 * @tc.desc: RegisterCaptureStatusListener01 fun
881 * @tc.type: FUNC
882 */
883 HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener01, TestSize.Level1)
884 {
885 sptr<DisplayManager::ICaptureStatusListener> listener = nullptr;
886 auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
887 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
888 listener = new DisplayManager::ICaptureStatusListener();
889 ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
890 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterCaptureStatusListener(listener));
891 listener.clear();
892 }
893
894 /**
895 * @tc.name: RegisterCaptureStatusListener02
896 * @tc.desc: RegisterCaptureStatusListener02 fun
897 * @tc.type: FUNC
898 */
899 HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener02, TestSize.Level1)
900 {
901 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
902 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
903 DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ = nullptr;
904 sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
905 auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
906 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
907 listener.clear();
908 }
909
910 /**
911 * @tc.name: UnregisterCaptureStatusListener01
912 * @tc.desc: UnregisterCaptureStatusListener01 fun
913 * @tc.type: FUNC
914 */
915 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener01, TestSize.Level1)
916 {
917 sptr<DisplayManager::ICaptureStatusListener> listener;
918 auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
919 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
920 listener = new DisplayManager::ICaptureStatusListener();
921 ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
922 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterCaptureStatusListener(listener));
923 listener.clear();
924 }
925
926 /**
927 * @tc.name: UnregisterCaptureStatusListener02
928 * @tc.desc: UnregisterCaptureStatusListener02 fun
929 * @tc.type: FUNC
930 */
931 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener02, TestSize.Level1)
932 {
933 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
934 sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
935 DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
936 auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
937 ASSERT_EQ(ret, DMError::DM_OK);
938 listener.clear();
939 }
940
941 /**
942 * @tc.name: UnregisterCaptureStatusListener03
943 * @tc.desc: UnregisterCaptureStatusListener03 fun
944 * @tc.type: FUNC
945 */
946 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener03, TestSize.Level1)
947 {
948 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
949 DisplayManager::GetInstance().pImpl_->captureStatusListeners_.clear();
950 sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
951 DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
952 auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
953 ASSERT_EQ(ret, DMError::DM_OK);
954 listener.clear();
955 }
956
957 /**
958 * @tc.name: RegisterDisplayUpdateListener01
959 * @tc.desc: RegisterDisplayUpdateListener01 fun
960 * @tc.type: FUNC
961 */
962 HWTEST_F(DisplayManagerTest, RegisterDisplayUpdateListener01, TestSize.Level1)
963 {
964 sptr<DisplayManager::IDisplayUpdateListener> listener = nullptr;
965 auto ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
966 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
967 listener = new DisplayManager::IDisplayUpdateListener();
968 ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
969 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterDisplayUpdateListener(listener));
970 listener.clear();
971 }
972
973 /**
974 * @tc.name: IsCaptured01
975 * @tc.desc: IsCaptured01 fun
976 * @tc.type: FUNC
977 */
978 HWTEST_F(DisplayManagerTest, IsCaptured01, TestSize.Level1)
979 {
980 auto ret = DisplayManager::GetInstance().IsCaptured();
981 ASSERT_FALSE(ret);
982 }
983
984 /**
985 * @tc.name: isinsideof
986 * @tc.desc: isinside0f fun
987 * @tc.type: FUNC
988 */
989 HWTEST_F(DisplayManagerTest, isinsideof, TestSize.Level1)
990 {
991 DMRect rect = {2, 2, 2, 2};
992 DMRect rect1 = {2, 2, 2, 2};
993 ASSERT_EQ(rect.IsInsideOf(rect1), true);
994 }
995
996 /**
997 * @tc.name: GetAllDisplayPhysicalResolution
998 * @tc.desc: GetAllDisplayPhysicalResolution test
999 * @tc.type: FUNC
1000 */
1001 HWTEST_F(DisplayManagerTest, GetAllDisplayPhysicalResolution, TestSize.Level1)
1002 {
1003 std::vector<DisplayPhysicalResolution> allSize = DisplayManager::GetInstance().GetAllDisplayPhysicalResolution();
1004 ASSERT_TRUE(!allSize.empty());
1005 }
1006
1007 /**
1008 * @tc.name: ClearDisplayStateCallback
1009 * @tc.desc: ClearDisplayStateCallback test
1010 * @tc.type: FUNC
1011 */
1012 HWTEST_F(DisplayManagerTest, ClearDisplayStateCallback, TestSize.Level1)
1013 {
1014 DisplayManager::GetInstance().pImpl_->ClearDisplayStateCallback();
1015 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayStateAgent_ == nullptr);
1016 }
1017
1018 /**
1019 * @tc.name: ClearFoldStatusCallback
1020 * @tc.desc: ClearFoldStatusCallback test
1021 * @tc.type: FUNC
1022 */
1023 HWTEST_F(DisplayManagerTest, ClearFoldStatusCallback, TestSize.Level1)
1024 {
1025 DisplayManager::GetInstance().pImpl_->ClearFoldStatusCallback();
1026 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldStatusListenerAgent_ == nullptr);
1027 }
1028
1029 /**
1030 * @tc.name: ClearFoldAngleCallback
1031 * @tc.desc: ClearFoldAngleCallback test
1032 * @tc.type: FUNC
1033 */
1034 HWTEST_F(DisplayManagerTest, ClearFoldAngleCallback, TestSize.Level1)
1035 {
1036 DisplayManager::GetInstance().pImpl_->ClearFoldAngleCallback();
1037 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ == nullptr);
1038 }
1039
1040 /**
1041 * @tc.name: ClearCaptureStatusCallback
1042 * @tc.desc: ClearCaptureStatusCallback test
1043 * @tc.type: FUNC
1044 */
1045 HWTEST_F(DisplayManagerTest, ClearCaptureStatusCallback, TestSize.Level1)
1046 {
1047 DisplayManager::GetInstance().pImpl_->ClearCaptureStatusCallback();
1048 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ == nullptr);
1049 }
1050
1051 /**
1052 * @tc.name: ClearDisplayModeCallback
1053 * @tc.desc: ClearDisplayModeCallback test
1054 * @tc.type: FUNC
1055 */
1056 HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback01, TestSize.Level1)
1057 {
1058 DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
1059 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
1060 }
1061
1062 /**
1063 * @tc.name: ClearDisplayModeCallback
1064 * @tc.desc: ClearDisplayModeCallback test
1065 * @tc.type: FUNC
1066 */
1067 HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback02, TestSize.Level1)
1068 {
1069 sptr<DisplayManager::IDisplayModeListener> listener = new DisplayManager::IDisplayModeListener();
1070 DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
1071 DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
1072 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
1073 }
1074
1075 /**
1076 * @tc.name: GetDisplayByScreenId
1077 * @tc.desc: GetDisplayByScreenId test
1078 * @tc.type: FUNC
1079 */
1080 HWTEST_F(DisplayManagerTest, GetDisplayByScreenId, TestSize.Level1)
1081 {
1082 ScreenId screenId = -1;
1083 auto ret = DisplayManager::GetInstance().pImpl_->GetDisplayByScreenId(screenId);
1084 ASSERT_TRUE(ret == nullptr);
1085 }
1086
1087 /**
1088 * @tc.name: UnregisterDisplayUpdateListener
1089 * @tc.desc: UnregisterDisplayUpdateListener fun
1090 * @tc.type: FUNC
1091 */
1092 HWTEST_F(DisplayManagerTest, UnregisterDisplayUpdateListener, TestSize.Level1)
1093 {
1094 sptr<DisplayManager::IDisplayUpdateListener> listener;
1095 auto ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1096 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1097 listener = new DisplayManager::IDisplayUpdateListener();
1098 ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1099 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterDisplayUpdateListener(listener));
1100 listener.clear();
1101 }
1102
1103 /**
1104 * @tc.name: RegisterAvailableAreaListener
1105 * @tc.desc: RegisterAvailableAreaListener fun
1106 * @tc.type: FUNC
1107 */
1108 HWTEST_F(DisplayManagerTest, RegisterAvailableAreaListener, TestSize.Level1)
1109 {
1110 sptr<DisplayManager::IAvailableAreaListener> listener;
1111 auto ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1112 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1113 listener = new DisplayManager::IAvailableAreaListener();
1114 ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1115 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterAvailableAreaListener(listener));
1116 listener.clear();
1117 }
1118
1119 /**
1120 * @tc.name: UnregisterAvailableAreaListener
1121 * @tc.desc: UnregisterAvailableAreaListener fun
1122 * @tc.type: FUNC
1123 */
1124 HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener, TestSize.Level1)
1125 {
1126 sptr<DisplayManager::IAvailableAreaListener> listener;
1127 auto ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1128 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1129 listener = new DisplayManager::IAvailableAreaListener();
1130 ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1131 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterAvailableAreaListener(listener));
1132 listener.clear();
1133 }
1134
1135 /**
1136 * @tc.name: GetDisplayInfoSrting
1137 * @tc.desc: GetDisplayInfoSrting fun
1138 * @tc.type: FUNC
1139 */
1140 HWTEST_F(DisplayManagerTest, GetDisplayInfoSrting, TestSize.Level1)
1141 {
1142 sptr<DisplayInfo> displayInfo = nullptr;
1143 auto ret =DisplayManager::GetInstance().pImpl_->GetDisplayInfoSrting(displayInfo);
1144 ASSERT_EQ(displayInfo, nullptr);
1145 }
1146
1147 /**
1148 * @tc.name: OnRemoteDied
1149 * @tc.desc: OnRemoteDied fun
1150 * @tc.type: FUNC
1151 */
1152 HWTEST_F(DisplayManagerTest, OnRemoteDied, TestSize.Level1)
1153 {
1154 g_dmIsDestroyed = true;
1155 DisplayManager::GetInstance().OnRemoteDied();
1156 ASSERT_EQ(g_dmIsDestroyed, true);
1157 }
1158
1159 /**
1160 * @tc.name: SetDisplayScale
1161 * @tc.desc: SetDisplayScale test
1162 * @tc.type: FUNC
1163 */
1164 HWTEST_F(DisplayManagerTest, SetDisplayScale, TestSize.Level1)
1165 {
1166 DisplayManager& displayManager = DisplayManager::GetInstance();
1167 ASSERT_NE(displayManager.pImpl_, nullptr);
1168 const float scaleX = 1.0f;
1169 const float scaleY = 1.0f;
1170 const float pivotX = 0.5f;
1171 const float pivotY = 0.5f;
1172 sptr<Display> display = displayManager.GetDefaultDisplay();
1173 ASSERT_NE(display, nullptr);
1174 ScreenId screenId = display->GetScreenId();
1175 displayManager.SetDisplayScale(screenId, scaleX, scaleY, pivotX, pivotY);
1176 }
1177
1178 /**
1179 * @tc.name: Clear
1180 * @tc.desc: Clear test
1181 * @tc.type: FUNC
1182 */
1183 HWTEST_F(DisplayManagerTest, Clear01, TestSize.Level1)
1184 {
1185 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1186 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1187 EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1188 DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
1189 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
1190 DisplayManager::GetInstance().RegisterDisplayListener(listener);
1191 auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
1192 ASSERT_NE(displayManagerListener, nullptr);
1193 DisplayManager::GetInstance().pImpl_->Clear();
1194 ASSERT_EQ(DisplayManager::GetInstance().pImpl_->displayManagerListener_, nullptr);
1195 }
1196
1197 /**
1198 * @tc.name: Clear
1199 * @tc.desc: Clear test
1200 * @tc.type: FUNC
1201 */
1202 HWTEST_F(DisplayManagerTest, Clear02, TestSize.Level1)
1203 {
1204 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1205 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1206 EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1207 DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_ = nullptr;
1208 sptr<IDisplayPowerEventListener> listener = new DmMockDisplayPowerEventListener();
1209 DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener);
1210 auto powerEventListenerAgent = DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_;
1211 ASSERT_NE(powerEventListenerAgent, nullptr);
1212 DisplayManager::GetInstance().pImpl_->Clear();
1213 ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1214 }
1215
1216 /**
1217 * @tc.name: NotifyCaptureStatusChanged
1218 * @tc.desc: NotifyCaptureStatusChanged fun
1219 * @tc.type: FUNC
1220 */
1221 HWTEST_F(DisplayManagerTest, NotifyCaptureStatusChanged, TestSize.Level1)
1222 {
1223 DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ = nullptr;
1224 sptr<DisplayManager::Impl> impl_;
1225 sptr<DisplayManager::Impl::DisplayManagerDisplayModeAgent> displayModeListenerAgent =
1226 new DisplayManager::Impl::DisplayManagerDisplayModeAgent(impl_);
1227 bool isCapture = true;
1228 DisplayManager::GetInstance().pImpl_->NotifyCaptureStatusChanged(isCapture);
1229 ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1230 }
1231
1232 /**
1233 * @tc.name: NotifyCaptureStatusChanged01
1234 * @tc.desc: NotifyCaptureStatusChanged01 fun
1235 * @tc.type: FUNC
1236 */
1237 HWTEST_F(DisplayManagerTest, NotifyCaptureStatusChanged01, TestSize.Level1)
1238 {
1239 DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ = nullptr;
1240 sptr<DisplayManager::Impl> impl_;
1241 sptr<DisplayManager::Impl::DisplayManagerDisplayModeAgent> displayModeListenerAgent =
1242 new DisplayManager::Impl::DisplayManagerDisplayModeAgent(impl_);
1243 bool isCapture = true;
1244 DisplayManager::GetInstance().pImpl_->NotifyCaptureStatusChanged(isCapture);
1245 ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1246 }
1247
1248 /**
1249 * @tc.name: RegisterFoldAngleListener03
1250 * @tc.desc: RegisterFoldAngleListener03 fun
1251 * @tc.type: FUNC
1252 */
1253 HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener03, TestSize.Level1)
1254 {
1255 sptr<DisplayManager::IFoldAngleListener> listener = nullptr;
1256 auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1257 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1258 listener = new DisplayManager::IFoldAngleListener();
1259 ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1260 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterFoldAngleListener(listener));
1261 listener.clear();
1262 }
1263
1264 /**
1265 * @tc.name: RegisterFoldAngleListener04
1266 * @tc.desc: RegisterFoldAngleListener04 fun
1267 * @tc.type: FUNC
1268 */
1269 HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener04, TestSize.Level1)
1270 {
1271 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1272 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
1273 DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ = nullptr;
1274 sptr<DisplayManager::IFoldAngleListener> listener = new DmMockFoldAngleListener();
1275 auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1276 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
1277 listener.clear();
1278 }
1279
1280 /**
1281 * @tc.name: UnregisterFoldAngleListener04
1282 * @tc.desc: UnregisterFoldAngleListener04 fun
1283 * @tc.type: FUNC
1284 */
1285 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener04, TestSize.Level1)
1286 {
1287 sptr<DisplayManager::IFoldAngleListener> listener;
1288 auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
1289 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1290 listener = new DisplayManager::IFoldAngleListener();
1291 ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
1292 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterFoldAngleListener(listener));
1293 listener.clear();
1294 }
1295
1296 /**
1297 * @tc.name: UnregisterFoldAngleListener05
1298 * @tc.desc: UnregisterFoldAngleListener05 fun
1299 * @tc.type: FUNC
1300 */
1301 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener05, TestSize.Level1)
1302 {
1303 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
1304 sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
1305 DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1306 auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
1307 ASSERT_EQ(ret, DMError::DM_OK);
1308 listener.clear();
1309 }
1310
1311 /**
1312 * @tc.name: UnregisterFoldAngleListener06
1313 * @tc.desc: UnregisterFoldAngleListener06 fun
1314 * @tc.type: FUNC
1315 */
1316 HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener06, TestSize.Level1)
1317 {
1318 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
1319 DisplayManager::GetInstance().pImpl_->foldAngleListeners_.clear();
1320 sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
1321 DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1322 auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
1323 ASSERT_EQ(ret, DMError::DM_OK);
1324 listener.clear();
1325 }
1326
1327 /**
1328 * @tc.name: RegisterCaptureStatusListener03
1329 * @tc.desc: RegisterCaptureStatusListener03 fun
1330 * @tc.type: FUNC
1331 */
1332 HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener03, TestSize.Level1)
1333 {
1334 sptr<DisplayManager::ICaptureStatusListener> listener = nullptr;
1335 auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1336 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1337 listener = new DisplayManager::ICaptureStatusListener();
1338 ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1339 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterCaptureStatusListener(listener));
1340 listener.clear();
1341 }
1342
1343 /**
1344 * @tc.name: RegisterCaptureStatusListener04
1345 * @tc.desc: RegisterCaptureStatusListener04 fun
1346 * @tc.type: FUNC
1347 */
1348 HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener04, TestSize.Level1)
1349 {
1350 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1351 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
1352 DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ = nullptr;
1353 sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
1354 auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1355 ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
1356 listener.clear();
1357 }
1358
1359 /**
1360 * @tc.name: UnregisterCaptureStatusListener04
1361 * @tc.desc: UnregisterCaptureStatusListener04 fun
1362 * @tc.type: FUNC
1363 */
1364 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener04, TestSize.Level1)
1365 {
1366 sptr<DisplayManager::ICaptureStatusListener> listener;
1367 auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
1368 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1369 listener = new DisplayManager::ICaptureStatusListener();
1370 ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
1371 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterCaptureStatusListener(listener));
1372 listener.clear();
1373 }
1374
1375 /**
1376 * @tc.name: UnregisterCaptureStatusListener05
1377 * @tc.desc: UnregisterCaptureStatusListener05 fun
1378 * @tc.type: FUNC
1379 */
1380 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener05, TestSize.Level1)
1381 {
1382 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
1383 sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
1384 DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1385 auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
1386 ASSERT_EQ(ret, DMError::DM_OK);
1387 listener.clear();
1388 }
1389
1390 /**
1391 * @tc.name: UnregisterCaptureStatusListener06
1392 * @tc.desc: UnregisterCaptureStatusListener06 fun
1393 * @tc.type: FUNC
1394 */
1395 HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener06, TestSize.Level1)
1396 {
1397 ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
1398 DisplayManager::GetInstance().pImpl_->captureStatusListeners_.clear();
1399 sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
1400 DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1401 auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
1402 ASSERT_EQ(ret, DMError::DM_OK);
1403 listener.clear();
1404 }
1405
1406 /**
1407 * @tc.name: RegisterDisplayUpdateListener02
1408 * @tc.desc: RegisterDisplayUpdateListener02 fun
1409 * @tc.type: FUNC
1410 */
1411 HWTEST_F(DisplayManagerTest, RegisterDisplayUpdateListener02, TestSize.Level1)
1412 {
1413 sptr<DisplayManager::IDisplayUpdateListener> listener = nullptr;
1414 auto ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
1415 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1416 listener = new DisplayManager::IDisplayUpdateListener();
1417 ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
1418 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterDisplayUpdateListener(listener));
1419 listener.clear();
1420 }
1421
1422 /**
1423 * @tc.name: IsCaptured02
1424 * @tc.desc: IsCaptured02 fun
1425 * @tc.type: FUNC
1426 */
1427 HWTEST_F(DisplayManagerTest, IsCaptured02, TestSize.Level1)
1428 {
1429 auto ret = DisplayManager::GetInstance().IsCaptured();
1430 ASSERT_FALSE(ret);
1431 }
1432
1433 /**
1434 * @tc.name: isinsideof01
1435 * @tc.desc: isinsideof01 fun
1436 * @tc.type: FUNC
1437 */
1438 HWTEST_F(DisplayManagerTest, isinsideof01, TestSize.Level1)
1439 {
1440 DMRect rect = {2, 2, 2, 2};
1441 DMRect rect1 = {2, 2, 2, 2};
1442 ASSERT_EQ(rect.IsInsideOf(rect1), true);
1443 }
1444
1445 /**
1446 * @tc.name: GetAllDisplayPhysicalResolution01
1447 * @tc.desc: GetAllDisplayPhysicalResolution01 test
1448 * @tc.type: FUNC
1449 */
1450 HWTEST_F(DisplayManagerTest, GetAllDisplayPhysicalResolution01, TestSize.Level1)
1451 {
1452 std::vector<DisplayPhysicalResolution> allSize = DisplayManager::GetInstance().GetAllDisplayPhysicalResolution();
1453 ASSERT_TRUE(!allSize.empty());
1454 }
1455
1456 /**
1457 * @tc.name: ClearDisplayStateCallback01
1458 * @tc.desc: ClearDisplayStateCallback01 test
1459 * @tc.type: FUNC
1460 */
1461 HWTEST_F(DisplayManagerTest, ClearDisplayStateCallback01, TestSize.Level1)
1462 {
1463 DisplayManager::GetInstance().pImpl_->ClearDisplayStateCallback();
1464 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayStateAgent_ == nullptr);
1465 }
1466
1467 /**
1468 * @tc.name: ClearFoldStatusCallback01
1469 * @tc.desc: ClearFoldStatusCallback01 test
1470 * @tc.type: FUNC
1471 */
1472 HWTEST_F(DisplayManagerTest, ClearFoldStatusCallback01, TestSize.Level1)
1473 {
1474 DisplayManager::GetInstance().pImpl_->ClearFoldStatusCallback();
1475 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldStatusListenerAgent_ == nullptr);
1476 }
1477
1478 /**
1479 * @tc.name: ClearFoldAngleCallback01
1480 * @tc.desc: ClearFoldAngleCallback01 test
1481 * @tc.type: FUNC
1482 */
1483 HWTEST_F(DisplayManagerTest, ClearFoldAngleCallback01, TestSize.Level1)
1484 {
1485 DisplayManager::GetInstance().pImpl_->ClearFoldAngleCallback();
1486 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ == nullptr);
1487 }
1488
1489 /**
1490 * @tc.name: ClearCaptureStatusCallback01
1491 * @tc.desc: ClearCaptureStatusCallback01 test
1492 * @tc.type: FUNC
1493 */
1494 HWTEST_F(DisplayManagerTest, ClearCaptureStatusCallback01, TestSize.Level1)
1495 {
1496 DisplayManager::GetInstance().pImpl_->ClearCaptureStatusCallback();
1497 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ == nullptr);
1498 }
1499
1500 /**
1501 * @tc.name: ClearDisplayModeCallback03
1502 * @tc.desc: ClearDisplayModeCallback03 test
1503 * @tc.type: FUNC
1504 */
1505 HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback03, TestSize.Level1)
1506 {
1507 DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
1508 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
1509 }
1510
1511 /**
1512 * @tc.name: ClearDisplayModeCallback04
1513 * @tc.desc: ClearDisplayModeCallback04 test
1514 * @tc.type: FUNC
1515 */
1516 HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback04, TestSize.Level1)
1517 {
1518 sptr<DisplayManager::IDisplayModeListener> listener = new DisplayManager::IDisplayModeListener();
1519 DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
1520 DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
1521 ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
1522 }
1523
1524 /**
1525 * @tc.name: GetDisplayByScreenId01
1526 * @tc.desc: GetDisplayByScreenId01 test
1527 * @tc.type: FUNC
1528 */
1529 HWTEST_F(DisplayManagerTest, GetDisplayByScreenId01, TestSize.Level1)
1530 {
1531 ScreenId screenId = -1;
1532 auto ret = DisplayManager::GetInstance().pImpl_->GetDisplayByScreenId(screenId);
1533 ASSERT_TRUE(ret == nullptr);
1534 }
1535
1536 /**
1537 * @tc.name: UnregisterDisplayUpdateListener01
1538 * @tc.desc: UnregisterDisplayUpdateListener01 fun
1539 * @tc.type: FUNC
1540 */
1541 HWTEST_F(DisplayManagerTest, UnregisterDisplayUpdateListener01, TestSize.Level1)
1542 {
1543 sptr<DisplayManager::IDisplayUpdateListener> listener;
1544 auto ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1545 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1546 listener = new DisplayManager::IDisplayUpdateListener();
1547 ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1548 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterDisplayUpdateListener(listener));
1549 listener.clear();
1550 }
1551
1552 /**
1553 * @tc.name: RegisterAvailableAreaListener01
1554 * @tc.desc: RegisterAvailableAreaListener01 fun
1555 * @tc.type: FUNC
1556 */
1557 HWTEST_F(DisplayManagerTest, RegisterAvailableAreaListener01, TestSize.Level1)
1558 {
1559 sptr<DisplayManager::IAvailableAreaListener> listener;
1560 auto ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1561 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1562 listener = new DisplayManager::IAvailableAreaListener();
1563 ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1564 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterAvailableAreaListener(listener));
1565 listener.clear();
1566 }
1567
1568 /**
1569 * @tc.name: UnregisterAvailableAreaListener01
1570 * @tc.desc: UnregisterAvailableAreaListener01 fun
1571 * @tc.type: FUNC
1572 */
1573 HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener01, TestSize.Level1)
1574 {
1575 sptr<DisplayManager::IAvailableAreaListener> listener;
1576 auto ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1577 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1578 listener = new DisplayManager::IAvailableAreaListener();
1579 ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1580 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterAvailableAreaListener(listener));
1581 listener.clear();
1582 }
1583
1584 /**
1585 * @tc.name: GetDisplayInfoSrting01
1586 * @tc.desc: GetDisplayInfoSrting01 fun
1587 * @tc.type: FUNC
1588 */
1589 HWTEST_F(DisplayManagerTest, GetDisplayInfoSrting01, TestSize.Level1)
1590 {
1591 sptr<DisplayInfo> displayInfo = nullptr;
1592 auto ret =DisplayManager::GetInstance().pImpl_->GetDisplayInfoSrting(displayInfo);
1593 ASSERT_EQ(displayInfo, nullptr);
1594 }
1595
1596 /**
1597 * @tc.name: OnRemoteDied01
1598 * @tc.desc: OnRemoteDied01 fun
1599 * @tc.type: FUNC
1600 */
1601 HWTEST_F(DisplayManagerTest, OnRemoteDied01, TestSize.Level1)
1602 {
1603 g_dmIsDestroyed = true;
1604 DisplayManager::GetInstance().OnRemoteDied();
1605 ASSERT_EQ(g_dmIsDestroyed, true);
1606 }
1607
1608 /**
1609 * @tc.name: SetDisplayScale01
1610 * @tc.desc: SetDisplayScale01 test
1611 * @tc.type: FUNC
1612 */
1613 HWTEST_F(DisplayManagerTest, SetDisplayScale01, TestSize.Level1)
1614 {
1615 DisplayManager& displayManager = DisplayManager::GetInstance();
1616 ASSERT_NE(displayManager.pImpl_, nullptr);
1617 const float scaleX = 1.0f;
1618 const float scaleY = 1.0f;
1619 const float pivotX = 0.5f;
1620 const float pivotY = 0.5f;
1621 sptr<Display> display = displayManager.GetDefaultDisplay();
1622 ASSERT_NE(display, nullptr);
1623 ScreenId screenId = display->GetScreenId();
1624 displayManager.SetDisplayScale(screenId, scaleX, scaleY, pivotX, pivotY);
1625 }
1626
1627 /**
1628 * @tc.name: Clear03
1629 * @tc.desc: Clear03 test
1630 * @tc.type: FUNC
1631 */
1632 HWTEST_F(DisplayManagerTest, Clear03, TestSize.Level1)
1633 {
1634 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1635 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1636 EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1637 DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
1638 sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
1639 DisplayManager::GetInstance().RegisterDisplayListener(listener);
1640 auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
1641 ASSERT_NE(displayManagerListener, nullptr);
1642 DisplayManager::GetInstance().pImpl_->Clear();
1643 ASSERT_EQ(DisplayManager::GetInstance().pImpl_->displayManagerListener_, nullptr);
1644 }
1645
1646 /**
1647 * @tc.name: Clear04
1648 * @tc.desc: Clear04 test
1649 * @tc.type: FUNC
1650 */
1651 HWTEST_F(DisplayManagerTest, Clear04, TestSize.Level1)
1652 {
1653 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1654 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1655 EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1656 DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_ = nullptr;
1657 sptr<IDisplayPowerEventListener> listener = new DmMockDisplayPowerEventListener();
1658 DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener);
1659 auto powerEventListenerAgent = DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_;
1660 ASSERT_NE(powerEventListenerAgent, nullptr);
1661 DisplayManager::GetInstance().pImpl_->Clear();
1662 ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1663 }
1664
1665 /**
1666 * @tc.name: GetScreenCapture
1667 * @tc.desc: GetScreenCapture test
1668 * @tc.type: FUNC
1669 */
1670 HWTEST_F(DisplayManagerTest, GetScreenCapture, TestSize.Level1)
1671 {
1672 CaptureOption captureOption;
1673 sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplay();
1674 ASSERT_NE(display, nullptr);
1675 captureOption.displayId_ = display->GetId();
1676 DmErrorCode errCode;
1677 std::shared_ptr<Media::PixelMap> pixelMap = DisplayManager::GetInstance().GetScreenCapture(captureOption,
1678 &errCode);
1679 }
1680
1681 /**
1682 * @tc.name: GetPrimaryDisplaySync
1683 * @tc.desc: GetPrimaryDisplaySync test
1684 * @tc.type: FUNC
1685 */
1686 HWTEST_F(DisplayManagerTest, GetPrimaryDisplaySync, TestSize.Level1)
1687 {
1688 sptr<Display> display = DisplayManager::GetInstance().GetPrimaryDisplaySync();
1689 ASSERT_NE(display, nullptr);
1690 }
1691
1692 /**
1693 * @tc.name: RegisterScreenMagneticStateListener
1694 * @tc.desc: RegisterScreenMagneticStateListener fun
1695 * @tc.type: FUNC
1696 */
1697 HWTEST_F(DisplayManagerTest, RegisterScreenMagneticStateListener, TestSize.Level1)
1698 {
1699 sptr<DisplayManager::IScreenMagneticStateListener> listener;
1700 auto ret = DisplayManager::GetInstance().RegisterScreenMagneticStateListener(listener);
1701 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1702 listener = new DisplayManager::IScreenMagneticStateListener();
1703 ret = DisplayManager::GetInstance().RegisterScreenMagneticStateListener(listener);
1704 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterScreenMagneticStateListener(listener));
1705 listener.clear();
1706 }
1707
1708 /**
1709 * @tc.name: ImplRegisterScreenMagneticStateListener
1710 * @tc.desc: ImplRegisterScreenMagneticStateListener fun
1711 * @tc.type: FUNC
1712 */
1713 HWTEST_F(DisplayManagerTest, ImplRegisterScreenMagneticStateListener, TestSize.Level1)
1714 {
1715 sptr<DisplayManager::IScreenMagneticStateListener> listener;
1716 DisplayManager::GetInstance().pImpl_->screenMagneticStateListenerAgent_ = nullptr;
1717 sptr<DisplayManager::Impl> impl_;
1718 sptr<DisplayManager::Impl::DisplayManagerScreenMagneticStateAgent> screenMagneticStateListenerAgent =
1719 new DisplayManager::Impl::DisplayManagerScreenMagneticStateAgent(impl_);
1720 auto ret = DisplayManager::GetInstance().pImpl_->RegisterScreenMagneticStateListener(listener);
1721 ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
1722 screenMagneticStateListenerAgent,
1723 DisplayManagerAgentType::SCREEN_MAGNETIC_STATE_CHANGED_LISTENER));
1724 listener.clear();
1725 screenMagneticStateListenerAgent.clear();
1726 }
1727
1728 /**
1729 * @tc.name: UnregisterScreenMagneticStateListener
1730 * @tc.desc: UnregisterScreenMagneticStateListener fun
1731 * @tc.type: FUNC
1732 */
1733 HWTEST_F(DisplayManagerTest, UnregisterScreenMagneticStateListener, TestSize.Level1)
1734 {
1735 sptr<DisplayManager::IScreenMagneticStateListener> listener;
1736 auto ret = DisplayManager::GetInstance().UnregisterScreenMagneticStateListener(listener);
1737 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1738 listener = new DisplayManager::IScreenMagneticStateListener();
1739 ret = DisplayManager::GetInstance().UnregisterScreenMagneticStateListener(listener);
1740 ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterScreenMagneticStateListener(listener));
1741 listener.clear();
1742 }
1743
1744 /**
1745 * @tc.name: ImplUnregisterScreenMagneticStateListener
1746 * @tc.desc: ImplUnregisterScreenMagneticStateListener fun
1747 * @tc.type: FUNC
1748 */
1749 HWTEST_F(DisplayManagerTest, ImplUnregisterScreenMagneticStateListener, TestSize.Level1)
1750 {
1751 sptr<DisplayManager::IScreenMagneticStateListener> listener;
1752 auto ret = DisplayManager::GetInstance().pImpl_->UnregisterScreenMagneticStateListener(listener);
1753 ASSERT_EQ(ret, DMError::DM_OK);
1754 listener.clear();
1755 }
1756
1757 /**
1758 * @tc.name: GetCutoutInfoWithRotation
1759 * @tc.desc: GetCutoutInfoWithRotation with right rotation
1760 * @tc.type: FUNC
1761 */
1762 HWTEST_F(DisplayManagerTest, GetCutoutInfoWithRotation, Function | SmallTest | Level2)
1763 {
1764 Rotation rotation = Rotation::ROTATION_0;
1765 sptr<CutoutInfo> info = DisplayManager::GetInstance().GetCutoutInfoWithRotation(rotation);
1766 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1767 ASSERT_NE(nullptr, info);
1768 }
1769 }
1770
1771 /**
1772 * @tc.name: GetVisibleAreaDisplayInfoById_ShouldReturnNull_WhenDisplayInfoIsNull
1773 * @tc.desc: Test GetVisibleAreaDisplayInfoById function when the returned DisplayInfo is
1774 * @tc.type: FUNC
1775 */
1776 HWTEST_F(DisplayManagerTest, GetVisibleAreaDisplayInfoById_ShouldReturnNull_WhenDisplayInfoIsNull, TestSize.Level1)
1777 {
1778 DisplayId displayId = 123;
1779 g_dmIsDestroyed = true;
1780
1781 auto result = DisplayManagerAdapter::GetInstance().GetVisibleAreaDisplayInfoById(displayId);
1782
1783 EXPECT_EQ(result, nullptr);
1784 }
1785
1786 /**
1787 * @tc.name: GetSnapshotByPicker_LockFailed_Test
1788 * @tc.desc: Test GetSnapshotByPicker when try_lock fails
1789 * @tc.type: FUNC
1790 */
1791 HWTEST_F(DisplayManagerTest, GetSnapshotByPicker_LockFailed_Test, TestSize.Level1)
1792 {
1793 DisplayManager displayManager;
1794 Media::Rect rect;
1795 DmErrorCode errorCode;
1796
1797 std::unique_lock<std::mutex> lock(snapBypickerMutex, std::defer_lock);
1798
1799 auto result = displayManager.GetSnapshotByPicker(rect, &errorCode);
1800 EXPECT_EQ(result, nullptr);
1801 }
1802
1803 /**
1804 * @tc.name: GetSnapshotByPicker_GetSnapshotFailed_Test
1805 * @tc.desc: Test GetSnapshotByPicker when GetSnapshotByPicker returns nullptr
1806 * @tc.type: FUNC
1807 */
1808 HWTEST_F(DisplayManagerTest, GetSnapshotByPicker_GetSnapshotFailed_Test, TestSize.Level1)
1809 {
1810 DisplayManager displayManager;
1811 Media::Rect rect;
1812 DmErrorCode errorCode;
1813
1814 std::shared_ptr<Media::PixelMap> screenShot =
1815 SingletonContainer::Get<DisplayManagerAdapter>().GetSnapshotByPicker(rect, &errorCode);
1816
1817 auto result = displayManager.GetSnapshotByPicker(rect, &errorCode);
1818 EXPECT_EQ(result, nullptr);
1819 }
1820
1821 /**
1822 * @tc.name: GetSnapshotByPicker_InvalidSize_Test
1823 * @tc.desc: Test GetSnapshotByPicker when rect has invalid size
1824 * @tc.type: FUNC
1825 */
1826 HWTEST_F(DisplayManagerTest, GetSnapshotByPicker_InvalidSize_Test, TestSize.Level1)
1827 {
1828 DisplayManager displayManager;
1829 Media::Rect rect;
1830 rect.width = 0;
1831 rect.height = 0;
1832 DmErrorCode errorCode;
1833
1834 auto result = displayManager.GetSnapshotByPicker(rect, &errorCode);
1835 EXPECT_EQ(result, nullptr);
1836 }
1837
1838 /**
1839 * @tc.name: GetSnapshotByPicker_CreatePixelMapFailed_Test
1840 * @tc.desc: Test GetSnapshotByPicker when Media::PixelMap::Create returns nullptr
1841 * @tc.type: FUNC
1842 */
1843 HWTEST_F(DisplayManagerTest, GetSnapshotByPicker_CreatePixelMapFailed_Test, TestSize.Level1)
1844 {
1845 DisplayManager displayManager;
1846 Media::Rect rect;
1847 DmErrorCode errorCode;
1848 auto pixelMap = nullptr;
1849
1850 auto result = displayManager.GetSnapshotByPicker(rect, &errorCode);
1851 EXPECT_EQ(result, pixelMap);
1852 }
1853
1854 /**
1855 * @tc.name: GetScreenshotreturnsnullptr
1856 * @tc.desc: GetScreenshot returns nullptr fun
1857 * @tc.type: FUNC
1858 */
1859 HWTEST_F(DisplayManagerTest, GetScreenshotreturnsnullptr, TestSize.Level1)
1860 {
1861 DisplayManager displayManager;
1862 SnapShotConfig config;
1863 DmErrorCode errorCode;
1864 bool isUseDma = false;
1865
1866 auto result = displayManager.GetScreenshotwithConfig(config, &errorCode, isUseDma);
1867 EXPECT_EQ(result, nullptr);
1868 }
1869
1870 /**
1871 * @tc.name: GetScreenHdrshot_ShouldReturnNullptrVector_WhenSnapshotFails
1872 * @tc.desc: Test that GetScreenHDRshot returns a vector with two nullptrs when the snapshot fails.
1873 * @tc.type: FUNC
1874 */
1875 HWTEST_F(DisplayManagerTest, GetScreenHdrshot_ShouldReturnNullptrVector_WhenSnapshotFails, TestSize.Level1)
1876 {
1877 DisplayManager displayManager;
1878 DisplayId validDisplayId = DEFAULT_DISPLAY;
1879 DmErrorCode errorCode;
1880 bool isUseDma = false;
1881 bool isCaptureFullOfScreen = false;
1882
1883 // Mock the behavior of DisplayManagerAdapter to return a vector with size != PIXMAP_VECTOR_SIZE
1884 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1885 EXPECT_CALL(m->Mock(), GetDisplayHDRSnapshot(_, _, _, _)).Times(EXECUTION_TIMES).WillOnce(
1886 Return(std::vector<std::shared_ptr<Media::PixelMap>> { nullptr }));
1887
1888 std::vector<std::shared_ptr<Media::PixelMap>> result = displayManager.GetScreenHDRshot(
1889 validDisplayId, errorCode, isUseDma, isCaptureFullOfScreen);
1890
1891 EXPECT_EQ(result.size(), PIXELMAP_SIZE);
1892 EXPECT_EQ(result[SDR_PIXELMAP], nullptr);
1893 EXPECT_EQ(result[HDR_PIXELMAP], nullptr);
1894 }
1895
1896 /**
1897 * @tc.name: GetScreenHdrshot_ShouldReturnSnapshotVector_WhenSnapshotSizeIsTwo
1898 * @tc.desc: Test that GetScreenHDRshot returns a vector with two nullptrs when snapshotSize is two.
1899 * @tc.type: FUNC
1900 */
1901 HWTEST_F(DisplayManagerTest, GetScreenHdrshot_ShouldReturnSnapshotVector_WhenSnapshotSizeIsTwo, TestSize.Level1)
1902 {
1903 DisplayManager displayManager;
1904 DisplayManagerAdapter displayManagerAdapter;
1905 DisplayId validDisplayId = DEFAULT_DISPLAY;
1906 DmErrorCode errorCode;
1907 bool isUseDma = false;
1908 bool isCaptureFullOfScreen = false;
1909
1910 // Mock the GetDisplayHDRSnapshot function to return a vector with size equal to 2
1911 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1912 EXPECT_CALL(m->Mock(), GetDisplayHDRSnapshot(_, _, _, _)).Times(EXECUTION_TIMES).WillOnce(
1913 Return(std::vector<std::shared_ptr<Media::PixelMap>> { nullptr, nullptr }));
1914
1915 std::vector<std::shared_ptr<Media::PixelMap>> result =
1916 displayManager.GetScreenHDRshot(validDisplayId, errorCode, isUseDma, isCaptureFullOfScreen);
1917
1918 EXPECT_EQ(result.size(), PIXELMAP_SIZE);
1919 EXPECT_EQ(result[SDR_PIXELMAP], nullptr);
1920 EXPECT_EQ(result[HDR_PIXELMAP], nullptr);
1921 }
1922
1923 /**
1924 * @tc.name: GetScreenHdrshot_GetDisplayHDRSnapshot
1925 * @tc.desc: Test that GetScreenHDRshot returns a vector when snapshotSize is two.
1926 * @tc.type: FUNC
1927 */
1928 HWTEST_F(DisplayManagerTest, GetScreenHdrshot_GetDisplayHDRSnapshot, TestSize.Level1)
1929 {
1930 DisplayManager displayManager;
1931 DisplayManagerAdapter displayManagerAdapter;
1932 DisplayId validDisplayId = DEFAULT_DISPLAY;
1933 DmErrorCode errorCode;
1934 bool isUseDma = false;
1935 bool isCaptureFullOfScreen = false;
1936
1937 std::vector<std::shared_ptr<Media::PixelMap>> result =
1938 displayManager.GetScreenHDRshot(validDisplayId, errorCode, isUseDma, isCaptureFullOfScreen);
1939
1940 EXPECT_EQ(result.size(), PIXELMAP_SIZE);
1941 EXPECT_EQ(result[SDR_PIXELMAP], nullptr);
1942 EXPECT_EQ(result[HDR_PIXELMAP], nullptr);
1943 }
1944
1945 /**
1946 * @tc.name: GetScreenHdrshot_GetDisplayHDRSnapshot001
1947 * @tc.desc: Test that GetScreenHDRshot returns a vector when snapshotSize is two.
1948 * @tc.type: FUNC
1949 */
1950 HWTEST_F(DisplayManagerTest, GetScreenHdrshot_GetDisplayHDRSnapshot001, TestSize.Level1)
1951 {
1952 DisplayManager displayManager;
1953 DisplayManagerAdapter displayManagerAdapter;
1954 DisplayId validDisplayId = DEFAULT_DISPLAY;
1955 DmErrorCode errorCode;
1956 bool isUseDma = false;
1957 bool isCaptureFullOfScreen = false;
1958
1959 std::vector<std::shared_ptr<Media::PixelMap>> result =
1960 displayManager.GetScreenHDRshot(validDisplayId, errorCode, isUseDma, isCaptureFullOfScreen);
1961
1962 EXPECT_EQ(result.size(), PIXELMAP_SIZE);
1963 EXPECT_EQ(result[SDR_PIXELMAP], nullptr);
1964 EXPECT_EQ(result[HDR_PIXELMAP], nullptr);
1965 }
1966
1967 /**
1968 * @tc.name: GetScreenHdrshot_GetDisplayHDRSnapshot002
1969 * @tc.desc: Test that GetScreenHDRshot returns a vector when snapshotSize is two.
1970 * @tc.type: FUNC
1971 */
1972 HWTEST_F(DisplayManagerTest, GetScreenHdrshot_GetDisplayHDRSnapshot002, TestSize.Level1)
1973 {
1974 DisplayManager displayManager;
1975 DisplayManagerAdapter displayManagerAdapter;
1976 DisplayId validDisplayId = DEFAULT_DISPLAY;
1977 DmErrorCode errorCode;
1978 bool isUseDma = false;
1979 bool isCaptureFullOfScreen = false;
1980
1981 sptr<IScreenSessionManager> screenSessionManagerServiceProxyTmp =
1982 SingletonContainer::Get<DisplayManagerAdapter>().screenSessionManagerServiceProxy_;
1983 SingletonContainer::Get<DisplayManagerAdapter>().screenSessionManagerServiceProxy_ = nullptr;
1984 std::vector<std::shared_ptr<Media::PixelMap>> result =
1985 displayManager.GetScreenHDRshot(validDisplayId, errorCode, isUseDma, isCaptureFullOfScreen);
1986 SingletonContainer::Get<DisplayManagerAdapter>().screenSessionManagerServiceProxy_ =
1987 screenSessionManagerServiceProxyTmp;
1988 EXPECT_EQ(result.size(), PIXELMAP_SIZE);
1989 EXPECT_EQ(result[SDR_PIXELMAP], nullptr);
1990 EXPECT_EQ(result[HDR_PIXELMAP], nullptr);
1991 }
1992
1993 /**
1994 * @tc.name: InvalidimageRect
1995 * @tc.desc: Invalid imageRect fun
1996 * @tc.type: FUNC
1997 */
1998 HWTEST_F(DisplayManagerTest, InvalidimageRect, TestSize.Level1)
1999 {
2000 DisplayManager displayManager;
2001 SnapShotConfig config;
2002 config.imageRect_.left = -1;
2003 DmErrorCode errorCode;
2004 bool isUseDma = false;
2005
2006 auto result = displayManager.GetScreenshotwithConfig(config, &errorCode, isUseDma);
2007 EXPECT_EQ(result, nullptr);
2008 }
2009
2010 /**
2011 * @tc.name: InvalidimageSize
2012 * @tc.desc: Invalid imageSize fun
2013 * @tc.type: FUNC
2014 */
2015 HWTEST_F(DisplayManagerTest, InvalidimageSize, TestSize.Level1)
2016 {
2017 DisplayManager displayManager;
2018 SnapShotConfig config;
2019 config.imageSize_.width = 0;
2020 DmErrorCode errorCode;
2021 bool isUseDma = false;
2022
2023 auto result = displayManager.GetScreenshotwithConfig(config, &errorCode, isUseDma);
2024 EXPECT_EQ(result, nullptr);
2025 }
2026
2027 /**
2028 * @tc.name: Media::PixelMap::Create returns nullptr
2029 * @tc.desc: Media::PixelMap::Create returns nullptr fun
2030 * @tc.type: FUNC
2031 */
2032 HWTEST_F(DisplayManagerTest, PixelMapCreateReturnsNullptr, TestSize.Level1)
2033 {
2034 DisplayManager displayManager;
2035 SnapShotConfig config;
2036 DmErrorCode errorCode;
2037 bool isUseDma = false;
2038
2039 auto result = displayManager.GetScreenshotwithConfig(config, &errorCode, isUseDma);
2040 EXPECT_EQ(result, nullptr);
2041 }
2042
2043 /**
2044 * @tc.name: GetCallingAbilityDisplayId_shouldReturnInvalid_WhenListIsEmpty
2045 * @tc.desc: GetCallingAbilityDisplayId function when displayIdList_ is empty.
2046 * @tc.type: FUNC
2047 */
2048 HWTEST_F(DisplayManagerTest, GetCallingAbilityDisplayId_shouldReturnInvalid_WhenListIsEmpty, TestSize.Level1)
2049 {
2050 DisplayManager displayManager;
2051 displayManager.displayIdList_.clear();
2052 EXPECT_EQ(displayManager.GetCallingAbilityDisplayId(), DISPLAY_ID_INVALID);
2053 }
2054
2055 /**
2056 * @tc.name: GetCallingAbilityDisplayId_shouldReturnInvalid_WhenListContainsOneId
2057 * @tc.desc: Test GetCallingAbilityDisplayId function when displayIdList_ contains one id.
2058 * @tc.type: FUNC
2059 */
2060 HWTEST_F(DisplayManagerTest, GetCallingAbilityDisplayId_shouldReturnInvalid_WhenListContainsOneId, TestSize.Level1)
2061 {
2062 DisplayManager displayManager;
2063 displayManager.displayIdList_.clear();
2064 ASSERT_TRUE(SingletonContainer::Get<DisplayManagerAdapter>().InitDMSProxy());
2065 sptr<IRemoteObject> obj;
2066 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
2067 ASSERT_NE(SingletonContainer::Get<DisplayManagerAdapter>().screenSessionManagerServiceProxy_, nullptr);
2068 obj = SingletonContainer::Get<DisplayManagerAdapter>().screenSessionManagerServiceProxy_->AsObject();
2069 } else {
2070 ASSERT_NE(SingletonContainer::Get<DisplayManagerAdapter>().displayManagerServiceProxy_, nullptr);
2071 obj = SingletonContainer::Get<DisplayManagerAdapter>().displayManagerServiceProxy_->AsObject();
2072 }
2073 sptr<IRemoteObject> weakPtr = obj;
2074 DisplayId displayId = DISPLAY_ID_INVALID;
2075 displayManager.displayIdList_.emplace_back(weakPtr, displayId);
2076 EXPECT_EQ(displayManager.GetCallingAbilityDisplayId(), DISPLAY_ID_INVALID);
2077 }
2078
2079 /**
2080 * @tc.name: GetCallingAbilityDisplayId_shouldReturnInvalid_WhenListContainsMultipleDifferentIds
2081 * @tc.desc: Test GetCallingAbilityDisplayId function when displayIdList_ multiple different ids.
2082 * @tc.type: FUNC
2083 */
2084 HWTEST_F(DisplayManagerTest, GetCallingAbilityDisplayId_shouldReturnInvalid_WhenListContainsMultipleDifferentIds,
2085 TestSize.Level1)
2086 {
2087 DisplayManager displayManager;
2088 displayManager.displayIdList_.clear();
2089
2090 ASSERT_TRUE(SingletonContainer::Get<DisplayManagerAdapter>().InitDMSProxy());
2091 sptr<IRemoteObject> obj;
2092 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
2093 ASSERT_NE(SingletonContainer::Get<DisplayManagerAdapter>().screenSessionManagerServiceProxy_, nullptr);
2094 obj = SingletonContainer::Get<DisplayManagerAdapter>().screenSessionManagerServiceProxy_->AsObject();
2095 } else {
2096 ASSERT_NE(SingletonContainer::Get<DisplayManagerAdapter>().displayManagerServiceProxy_, nullptr);
2097 obj = SingletonContainer::Get<DisplayManagerAdapter>().displayManagerServiceProxy_->AsObject();
2098 }
2099 sptr<IRemoteObject> weakPtr = obj;
2100 DisplayId displayId = DISPLAY_ID_INVALID;
2101 displayManager.displayIdList_.emplace_back(weakPtr, displayId);
2102
2103 ASSERT_TRUE(SingletonContainer::Get<DisplayManagerAdapter>().InitDMSProxy());
2104 sptr<IRemoteObject> obj_01;
2105 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
2106 ASSERT_NE(SingletonContainer::Get<DisplayManagerAdapter>().screenSessionManagerServiceProxy_, nullptr);
2107 obj_01 = SingletonContainer::Get<DisplayManagerAdapter>().screenSessionManagerServiceProxy_->AsObject();
2108 } else {
2109 ASSERT_NE(SingletonContainer::Get<DisplayManagerAdapter>().displayManagerServiceProxy_, nullptr);
2110 obj_01 = SingletonContainer::Get<DisplayManagerAdapter>().displayManagerServiceProxy_->AsObject();
2111 }
2112 sptr<IRemoteObject> weakPtr_01 = obj_01;
2113 DisplayId displayId_01 = 2;
2114 displayManager.displayIdList_.emplace_back(weakPtr_01, displayId_01);
2115
2116 EXPECT_EQ(displayManager.GetCallingAbilityDisplayId(), DISPLAY_ID_INVALID);
2117 }
2118
2119 /**
2120 * @tc.name: ShouldReturnUNKNOWN
2121 * @tc.desc: GetFoldDisplayMode returns UNKNOWN
2122 * @tc.type: FUNC
2123 */
2124 HWTEST_F(DisplayManagerTest, ShouldNotReturnGLOBAL_FULL, TestSize.Level1)
2125 {
2126 DisplayManager displayManager;
2127 DisplayManagerAdapter displayManagerAdapter;
2128 SingletonContainer::Get<DisplayManagerAdapter>().InitDMSProxy();
2129 displayManagerAdapter.SetFoldDisplayMode(FoldDisplayMode::GLOBAL_FULL);
2130
2131 auto result = displayManager.GetFoldDisplayModeForExternal();
2132
2133 EXPECT_NE(result, OHOS::Rosen::FoldDisplayMode::GLOBAL_FULL);
2134 }
2135
2136 /**
2137 * @tc.name: RegisterAvailableAreaListener001
2138 * @tc.desc: RegisterAvailableAreaListener001 with nullptr listener
2139 * @tc.type: FUNC
2140 */
2141 HWTEST_F(DisplayManagerTest, RegisterAvailableAreaListener001, TestSize.Level1)
2142 {
2143 DisplayManager dm;
2144 auto result = dm.RegisterAvailableAreaListener(nullptr, 1);
2145 EXPECT_EQ(result, DMError::DM_ERROR_NULLPTR);
2146 }
2147
2148 /**
2149 * @tc.name: RegisterAvailableAreaListener002
2150 * @tc.desc: RegisterAvailableAreaListener002 with non-null listener
2151 * @tc.type: FUNC
2152 */
2153 HWTEST_F(DisplayManagerTest, RegisterAvailableAreaListener002, TestSize.Level1)
2154 {
2155 DisplayManager dm;
2156 sptr<DisplayManager::IAvailableAreaListener> listener;
2157 listener = new DisplayManager::IAvailableAreaListener();
2158 auto result = dm.RegisterAvailableAreaListener(listener, 1);
2159 EXPECT_EQ(result, DMError::DM_OK);
2160 }
2161
2162 /**
2163 * @tc.name: ShouldRegisterListenerWhenAgentIsNull
2164 * @tc.desc: ShouldRegisterListenerWhenAgentIsNull
2165 * @tc.type: FUNC
2166 */
2167 HWTEST_F(DisplayManagerTest, ShouldRegisterListenerWhenAgentIsNull, TestSize.Level1)
2168 {
2169 DisplayManager dm;
2170 sptr<DisplayManager::IAvailableAreaListener> listener;
2171 listener = new DisplayManager::IAvailableAreaListener();
2172 DisplayId displayId = 1;
2173
2174 DMError result = dm.RegisterAvailableAreaListener(listener, displayId);
2175
2176 EXPECT_EQ(result, DMError::DM_OK);
2177 }
2178
2179 /**
2180 * @tc.name: UnregisterAvailableAreaListener001
2181 * @tc.desc: UnregisterAvailableAreaListener001
2182 * @tc.type: FUNC
2183 */
2184 HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener001, TestSize.Level1)
2185 {
2186 DisplayManager dm;
2187 auto result = dm.UnregisterAvailableAreaListener(nullptr, 1);
2188 EXPECT_EQ(result, DMError::DM_ERROR_NULLPTR);
2189 }
2190
2191 /**
2192 * @tc.name: UnregisterAvailableAreaListener002
2193 * @tc.desc: UnregisterAvailableAreaListener002
2194 * @tc.type: FUNC
2195 */
2196 HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener002, TestSize.Level1)
2197 {
2198 DisplayManager dm;
2199 sptr<DisplayManager::IAvailableAreaListener> listener;
2200 listener = new DisplayManager::IAvailableAreaListener();
2201 DisplayId displayId = 1;
2202
2203 EXPECT_EQ(dm.UnregisterAvailableAreaListener(listener, displayId), DMError::DM_ERROR_NULLPTR);
2204 }
2205
2206 /**
2207 * @tc.name: UnregisterAvailableAreaListener003
2208 * @tc.desc: UnregisterAvailableAreaListener003
2209 * @tc.type: FUNC
2210 */
2211 HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener003, TestSize.Level1)
2212 {
2213 DisplayManager dm;
2214 sptr<DisplayManager::IAvailableAreaListener> listener;
2215 listener = new DisplayManager::IAvailableAreaListener();
2216 auto result = dm.UnregisterAvailableAreaListener(nullptr, 1);
2217 EXPECT_EQ(result, DMError::DM_ERROR_NULLPTR);
2218 }
2219
2220 /**
2221 * @tc.name: UnregisterAvailableAreaListener004
2222 * @tc.desc: UnregisterAvailableAreaListener004
2223 * @tc.type: FUNC
2224 */
2225 HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener004, TestSize.Level1)
2226 {
2227 DisplayManager displayManager;
2228 sptr<DisplayManager::IAvailableAreaListener> listener;
2229 listener = new DisplayManager::IAvailableAreaListener();
2230 DisplayId displayId = 100;
2231
2232 DMError result = displayManager.UnregisterAvailableAreaListener(listener, displayId);
2233
2234 EXPECT_EQ(result, DMError::DM_ERROR_NULLPTR);
2235 }
2236
2237 /**
2238 * @tc.name: UnregisterAvailableAreaListener005
2239 * @tc.desc: UnregisterAvailableAreaListener005
2240 * @tc.type: FUNC
2241 */
2242 HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener005, TestSize.Level1)
2243 {
2244 DisplayManager displayManager;
2245 sptr<DisplayManager::IAvailableAreaListener> listener;
2246 listener = new DisplayManager::IAvailableAreaListener();
2247 DisplayId displayId = 1;
2248
2249 std::set<sptr<DisplayManager::IAvailableAreaListener>> mySet;
2250 mySet.insert(listener);
2251 displayManager.pImpl_->availableAreaListenersMap_.insert({displayId, mySet});
2252 DMError result = displayManager.UnregisterAvailableAreaListener(listener, displayId);
2253
2254 EXPECT_EQ(result, DMError::DM_OK);
2255 }
2256
2257 /**
2258 * @tc.name: UnregisterAvailableAreaListener006
2259 * @tc.desc: UnregisterAvailableAreaListener006
2260 * @tc.type: FUNC
2261 */
2262 HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener006, TestSize.Level1)
2263 {
2264 DisplayManager displayManager;
2265 sptr<DisplayManager::IAvailableAreaListener> listener;
2266 listener = new DisplayManager::IAvailableAreaListener();
2267 DisplayId displayId = 1;
2268
2269 std::set<sptr<DisplayManager::IAvailableAreaListener>> mySet;
2270 displayManager.pImpl_->availableAreaListenersMap_.insert({displayId, mySet});
2271 DMError result = displayManager.UnregisterAvailableAreaListener(listener, displayId);
2272
2273 EXPECT_EQ(result, DMError::DM_ERROR_NULLPTR);
2274 }
2275
2276 /**
2277 * @tc.name: GetScreenshotWithOption_ShouldReturnNull_WhenDisplayIdInvalid
2278 * @tc.desc: Test GetScreenshotWithOption function when display is idInvalid
2279 * @tc.type: FUNC
2280 */
2281 HWTEST_F(DisplayManagerTest, GetScreenshotWithOption_ShouldReturnNull_WhenDisplayIdInvalid, TestSize.Level1)
2282 {
2283 CaptureOption captureOption;
2284 captureOption.displayId_ = DISPLAY_ID_INVALID;
2285 DmErrorCode errorCode;
2286
2287 std::shared_ptr<Media::PixelMap> result =
2288 DisplayManager::GetInstance().GetScreenshotWithOption(captureOption, &errorCode);
2289 EXPECT_EQ(result, nullptr);
2290 }
2291
2292 /**
2293 * @tc.name: GetScreenshotWithOption_ShouldReturnNull_WhenGetSnapshotFailed
2294 * @tc.desc: Test GetScreenshotWithOption function when GetDisplaySnapshotWithOption returns nullptr.
2295 * @tc.type: FUNC
2296 */
2297 HWTEST_F(DisplayManagerTest, GetScreenshotWithOption_ShouldReturnNull_WhenGetSnapshotFailed, TestSize.Level1)
2298 {
2299 CaptureOption captureOption;
2300 captureOption.displayId_ = 1;
2301 DmErrorCode errorCode;
2302
2303 std::shared_ptr<Media::PixelMap> result =
2304 DisplayManager::GetInstance().GetScreenshotWithOption(captureOption, &errorCode);
2305 EXPECT_EQ(result, nullptr);
2306 }
2307
2308 /**
2309 * @tc.name: ShouldReturnNullptrWhenScreenshotCaptureFailes
2310 * @tc.desc: Test screenshot capture failure
2311 * @tc.type: FUNC
2312 */
2313 HWTEST_F(DisplayManagerTest, ShouldReturnNullptrWhenScreenshotCaptureFailes, TestSize.Level1)
2314 {
2315 CaptureOption captureOption;
2316 Media::Rect rect;
2317 Media::Size size;
2318 int rotation = 0;
2319 DmErrorCode errorCode;
2320
2321 auto result =
2322 DisplayManager::GetInstance().GetScreenshotWithOption(captureOption, rect, size, rotation, &errorCode);
2323 EXPECT_EQ(result, nullptr);
2324 }
2325
2326 /**
2327 * @tc.name: GetScreenHDRshotWithOption_ShouldReturnNull_WhenDisplayIdInvalid
2328 * @tc.desc: Test GetScreenHDRshotWithOption function when display is idInvalid
2329 * @tc.type: FUNC
2330 */
2331 HWTEST_F(DisplayManagerTest, GetScreenHDRshotWithOption_ShouldReturnNull_WhenDisplayIdInvalid, TestSize.Level1)
2332 {
2333 CaptureOption captureOption;
2334 captureOption.displayId_ = DISPLAY_ID_INVALID;
2335 DmErrorCode errorCode;
2336
2337 std::vector<std::shared_ptr<Media::PixelMap>> pixRVec= { nullptr, nullptr };
2338 std::vector<std::shared_ptr<Media::PixelMap>> result =
2339 DisplayManager::GetInstance().GetScreenHDRshotWithOption(captureOption, errorCode);
2340 EXPECT_EQ(result, pixRVec);
2341 }
2342
2343 /**
2344 * @tc.name: GetScreenHDRshotWithOption_ShouldReturnNull_WhenGetSnapshotFailed
2345 * @tc.desc: Test GetScreenHDRshotWithOption function when GetDisplaySnapshotWithOption returns { nullptr, nullptr }.
2346 * @tc.type: FUNC
2347 */
2348 HWTEST_F(DisplayManagerTest, GetScreenHDRshotWithOption_ShouldReturnNull_WhenGetSnapshotFailed, TestSize.Level1)
2349 {
2350 CaptureOption captureOption;
2351 captureOption.displayId_ = DEFAULT_DISPLAY;
2352 DmErrorCode errorCode;
2353
2354 std::vector<std::shared_ptr<Media::PixelMap>> pixRVec= { nullptr, nullptr };
2355 std::vector<std::shared_ptr<Media::PixelMap>> result =
2356 DisplayManager::GetInstance().GetScreenHDRshotWithOption(captureOption, errorCode);
2357 EXPECT_EQ(result, pixRVec);
2358 }
2359
2360 /**
2361 * @tc.name: GetScreenHDRshotWithOption_WhenDisplayIdIsValidButSnapshotFails
2362 * @tc.desc: Test that the function returns a vector with two nullptrs when displayId is valid but snapshot fails.
2363 * @tc.type: FUNC
2364 */
2365 HWTEST_F(DisplayManagerTest, GetScreenHDRshotWithOption_WhenDisplayIdIsValidButSnapshotFails, TestSize.Level1)
2366 {
2367 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
2368 return;
2369 }
2370 CaptureOption captureOption;
2371 captureOption.displayId_ = DEFAULT_DISPLAY;
2372 DmErrorCode errorCode;
2373
2374 std::unique_ptr<MockerManager> m = std::make_unique<MockerManager>();
2375
2376 EXPECT_CALL(m->Mock(), GetDisplayHDRSnapshotWithOption(_, _)).Times(1).WillOnce(
2377 Return(std::vector<std::shared_ptr<Media::PixelMap>> { nullptr, nullptr }));
2378
2379 std::vector<std::shared_ptr<Media::PixelMap>> result =
2380 DisplayManager::GetInstance().GetScreenHDRshotWithOption(captureOption, errorCode);
2381
2382 EXPECT_EQ(result.size(), PIXELMAP_SIZE);
2383 EXPECT_EQ(result[SDR_PIXELMAP], nullptr);
2384 EXPECT_EQ(result[HDR_PIXELMAP], nullptr);
2385 }
2386
2387 /**
2388 * @tc.name: GetPrimaryDisplaySystemDpi
2389 * @tc.desc: Test GetPrimaryDisplaySystemDpi
2390 * @tc.type: FUNC
2391 */
2392 HWTEST_F(DisplayManagerTest, GetPrimaryDisplaySystemDpi, TestSize.Level1)
2393 {
2394 sptr<DisplayInfo> displayInfo = new DisplayInfo();
2395 float dpi = DisplayManager::GetInstance().GetPrimaryDisplaySystemDpi();
2396 EXPECT_EQ(dpi, displayInfo->GetDensityInCurResolution());
2397 }
2398
2399 /**
2400 * @tc.name: ConvertRelativeCoordinateToGlobalNullDisplay
2401 * @tc.desc: Test convert relative coordinate to global coordinate failed
2402 * @tc.type: FUNC
2403 */
2404 HWTEST_F(DisplayManagerTest, ConvertRelativeCoordinateToGlobalNullDisplay, TestSize.Level1)
2405 {
2406 RelativePosition relativePosition = {100, {1, 2}};
2407 Position globalPosition;
2408 DMError errorCode = DisplayManager::GetInstance().ConvertRelativeCoordinateToGlobal(relativePosition,
2409 globalPosition);
2410 EXPECT_EQ(errorCode, DMError::DM_ERROR_ILLEGAL_PARAM);
2411 }
2412
2413 /**
2414 * @tc.name: ConvertRelativeCoordinateToGlobalSuccess
2415 * @tc.desc: Test convert relative coordinate to global coordinate success
2416 * @tc.type: FUNC
2417 */
2418 HWTEST_F(DisplayManagerTest, ConvertRelativeCoordinateToGlobalSuccess, TestSize.Level1)
2419 {
2420 RelativePosition relativePosition = {0, {10, 20}};
2421 Position globalPosition;
2422 DMError errorCode = DisplayManager::GetInstance().ConvertRelativeCoordinateToGlobal(relativePosition,
2423 globalPosition);
2424 EXPECT_EQ(errorCode, DMError::DM_OK);
2425 EXPECT_EQ(globalPosition.x, 10);
2426 EXPECT_EQ(globalPosition.y, 20);
2427 }
2428
2429 /**
2430 * @tc.name: ConvertGlobalCoordinateToRelativeOutDisplay
2431 * @tc.desc: Test convert relative coordinate to global coordinate failed
2432 * @tc.type: FUNC
2433 */
2434 HWTEST_F(DisplayManagerTest, ConvertGlobalCoordinateToRelativeOutDisplay, TestSize.Level1)
2435 {
2436 RelativePosition relativePosition;
2437 Position globalPosition = {10000, 20000};
2438 DMError errorCode = DisplayManager::GetInstance().ConvertGlobalCoordinateToRelative(globalPosition,
2439 relativePosition);
2440 EXPECT_EQ(errorCode, DMError::DM_OK);
2441 EXPECT_EQ(relativePosition.displayId, 0);
2442 EXPECT_EQ(relativePosition.position.x, 10000);
2443 EXPECT_EQ(relativePosition.position.y, 20000);
2444 }
2445
2446 /**
2447 * @tc.name: ConvertGlobalCoordinateToRelativeIndisplay
2448 * @tc.desc: Test convert relative coordinate to global coordinate success
2449 * @tc.type: FUNC
2450 */
2451 HWTEST_F(DisplayManagerTest, ConvertGlobalCoordinateToRelativeIndisplay, TestSize.Level1)
2452 {
2453 RelativePosition relativePosition;
2454 Position globalPosition = {10, 20};
2455 DMError errorCode = DisplayManager::GetInstance().ConvertGlobalCoordinateToRelative(globalPosition,
2456 relativePosition);
2457 EXPECT_EQ(errorCode, DMError::DM_OK);
2458 EXPECT_EQ(relativePosition.displayId, 0);
2459 EXPECT_EQ(relativePosition.position.x, 10);
2460 EXPECT_EQ(relativePosition.position.y, 20);
2461 }
2462
2463 /**
2464 * @tc.name: ConvertGlobalCoordinateToRelativeNullDisplay
2465 * @tc.desc: Test convert relative coordinate to global coordinate while display is null.
2466 * @tc.type: FUNC
2467 */
2468 HWTEST_F(DisplayManagerTest, ConvertGlobalCoordinateToRelativeNullDisplay, TestSize.Level1)
2469 {
2470 RelativePosition relativePosition;
2471 Position globalPosition = {10000, 20000};
2472 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
2473 EXPECT_CALL(m->Mock(), GetAllDisplayIds()).Times(1).WillOnce(Return(std::vector<DisplayId>{-1}));
2474 DMError errorCode = DisplayManager::GetInstance().ConvertGlobalCoordinateToRelative(globalPosition,
2475 relativePosition);
2476 EXPECT_EQ(errorCode, DMError::DM_OK);
2477 EXPECT_EQ(relativePosition.displayId, 0);
2478 EXPECT_EQ(relativePosition.position.x, 10000);
2479 EXPECT_EQ(relativePosition.position.y, 20000);
2480 }
2481
2482 /**
2483 * @tc.name: ConvertGlobalCoordinateToRelativeWithDisplayIdInvalidDisplay
2484 * @tc.desc: Test convert relative coordinate to global coordinate failed
2485 * @tc.type: FUNC
2486 */
2487 HWTEST_F(DisplayManagerTest, ConvertGlobalCoordinateToRelativeWithDisplayIdInvalidDisplay, TestSize.Level1)
2488 {
2489 RelativePosition relativePosition;
2490 Position globalPosition = {10, 20};
2491 DisplayId displayId = 100;
2492 DMError errorCode = DisplayManager::GetInstance().ConvertGlobalCoordinateToRelativeWithDisplayId(globalPosition,
2493 displayId, relativePosition);
2494 EXPECT_EQ(errorCode, DMError::DM_OK);
2495 EXPECT_EQ(relativePosition.displayId, 0);
2496 EXPECT_EQ(relativePosition.position.x, 10);
2497 EXPECT_EQ(relativePosition.position.y, 20);
2498 }
2499
2500 /**
2501 * @tc.name: ConvertGlobalCoordinateToRelativeWithDisplayIdOutRange
2502 * @tc.desc: Test convert relative coordinate to global coordinate failed
2503 * @tc.type: FUNC
2504 */
2505 HWTEST_F(DisplayManagerTest, ConvertGlobalCoordinateToRelativeWithDisplayIdOutRange, TestSize.Level1)
2506 {
2507 RelativePosition relativePosition;
2508 Position globalPosition = {-10000, -20000};
2509 DisplayId displayId = 0;
2510 DMError errorCode = DisplayManager::GetInstance().ConvertGlobalCoordinateToRelativeWithDisplayId(globalPosition,
2511 displayId, relativePosition);
2512 EXPECT_EQ(errorCode, DMError::DM_OK);
2513 EXPECT_EQ(relativePosition.displayId, 0);
2514 EXPECT_EQ(relativePosition.position.x, -10000);
2515 EXPECT_EQ(relativePosition.position.y, -20000);
2516 }
2517
2518 /**
2519 * @tc.name: ConvertGlobalCoordinateToRelativeWithDisplayIdInRange
2520 * @tc.desc: Test convert relative coordinate to global coordinate success
2521 * @tc.type: FUNC
2522 */
2523 HWTEST_F(DisplayManagerTest, ConvertGlobalCoordinateToRelativeWithDisplayIdInRange, TestSize.Level1)
2524 {
2525 RelativePosition relativePosition;
2526 Position globalPosition = {10, 20};
2527 DisplayId displayId = 0;
2528 DMError errorCode = DisplayManager::GetInstance().ConvertGlobalCoordinateToRelativeWithDisplayId(globalPosition,
2529 displayId, relativePosition);
2530 EXPECT_EQ(errorCode, DMError::DM_OK);
2531 EXPECT_EQ(relativePosition.displayId, 0);
2532 EXPECT_EQ(relativePosition.position.x, 10);
2533 EXPECT_EQ(relativePosition.position.y, 20);
2534 }
2535
2536 /**
2537 * @tc.name: SetVirtualScreenAsDefault
2538 * @tc.desc: Test SetVirtualScreenAsDefault
2539 * @tc.type: FUNC
2540 */
2541 HWTEST_F(DisplayManagerTest, SetVirtualScreenAsDefault, TestSize.Level1)
2542 {
2543 #define SCREENLESS_ENABLE
2544 uint64_t screenId = 0;
2545 bool res = SingletonContainer::Get<DisplayManager>().SetVirtualScreenAsDefault(screenId);
2546 EXPECT_FALSE(res);
2547 #undef SCREENLESS_ENABLE
2548 }
2549 }
2550 } // namespace Rosen
2551 } // namespace OHOS
2552