1/*
2 * Copyright (c) 2022-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include <gtest/gtest.h>
17#include "display_manager.h"
18#include "display_manager_proxy.h"
19#include "window.h"
20#include "dm_common.h"
21
22#include "mock_display_manager_adapter.h"
23#include "singleton_mocker.h"
24#include "display_manager.cpp"
25#include "window_scene.h"
26#include "scene_board_judgement.h"
27
28using namespace testing;
29using namespace testing::ext;
30
31namespace OHOS {
32namespace Rosen {
33using Mocker = SingletonMocker<DisplayManagerAdapter, MockDisplayManagerAdapter>;
34class DmMockScreenshotListener : public DisplayManager::IScreenshotListener {
35public:
36    void OnScreenshot(const ScreenshotInfo info) override {}
37};
38class DmMockPrivateWindowListener : public DisplayManager::IPrivateWindowListener {
39public:
40    void OnPrivateWindow([[maybe_unused]]bool) override {}
41};
42class DmMockFoldAngleListener : public DisplayManager::IFoldAngleListener {
43public:
44    void OnFoldAngleChanged([[maybe_unused]]std::vector<float>) override {}
45};
46class DmMockCaptureStatusListener : public DisplayManager::ICaptureStatusListener {
47public:
48    void  OnCaptureStatusChanged([[maybe_unused]]bool) override {}
49};
50class DmMockDisplayListener : public DisplayManager::IDisplayListener {
51public:
52    void OnCreate(DisplayId) override {}
53    void OnDestroy(DisplayId) override {}
54    void OnChange(DisplayId) override {}
55};
56class DmMockDisplayPowerEventListener : public IDisplayPowerEventListener {
57public:
58    void OnDisplayPowerEvent(DisplayPowerEvent, EventStatus) override {}
59};
60
61class DisplayManagerTest : public testing::Test {
62public:
63    static void SetUpTestCase();
64    static void TearDownTestCase();
65    virtual void SetUp() override;
66    virtual void TearDown() override;
67};
68
69void DisplayManagerTest::SetUpTestCase()
70{
71}
72
73void DisplayManagerTest::TearDownTestCase()
74{
75}
76
77void DisplayManagerTest::SetUp()
78{
79}
80
81void DisplayManagerTest::TearDown()
82{
83}
84
85namespace {
86/**
87 * @tc.name: Freeze01
88 * @tc.desc: success
89 * @tc.type: FUNC
90 */
91HWTEST_F(DisplayManagerTest, Freeze01, Function | SmallTest | Level1)
92{
93    std::vector<DisplayId> displayIds;
94    displayIds.push_back(0);
95    bool ret = DisplayManager::GetInstance().Freeze(displayIds);
96    if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
97        ASSERT_TRUE(ret);
98    } else {
99        ASSERT_FALSE(ret);
100    }
101}
102
103/**
104 * @tc.name: Freeze02
105 * @tc.desc: test Freeze displayIds exceed the maximum
106 * @tc.type: FUNC
107 */
108HWTEST_F(DisplayManagerTest, Freeze02, Function | SmallTest | Level1)
109{
110    std::vector<DisplayId> displayIds;
111    for (uint32_t i = 0; i < 33; i++) { // MAX_DISPLAY_SIZE + 1
112        displayIds.push_back(i);
113    }
114    bool ret = DisplayManager::GetInstance().Freeze(displayIds);
115    if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
116        ASSERT_FALSE(ret);
117    }
118}
119
120/**
121 * @tc.name: Freeze03
122 * @tc.desc: test Freeze displayIds empty
123 * @tc.type: FUNC
124 */
125HWTEST_F(DisplayManagerTest, Freeze03, Function | SmallTest | Level1)
126{
127    std::vector<DisplayId> displayIds;
128    bool ret = DisplayManager::GetInstance().Freeze(displayIds);
129    if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
130        ASSERT_FALSE(ret);
131    }
132}
133
134/**
135 * @tc.name: Unfreeze01
136 * @tc.desc: success
137 * @tc.type: FUNC
138 */
139HWTEST_F(DisplayManagerTest, Unfreeze01, Function | SmallTest | Level1)
140{
141    std::vector<DisplayId> displayIds;
142    displayIds.push_back(0);
143    bool ret = DisplayManager::GetInstance().Unfreeze(displayIds);
144    if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
145        ASSERT_TRUE(ret);
146    } else {
147        ASSERT_FALSE(ret);
148    }
149}
150
151/**
152 * @tc.name: Unfreeze02
153 * @tc.desc: test Freeze displayIds exceed the maximum
154 * @tc.type: FUNC
155 */
156HWTEST_F(DisplayManagerTest, Unfreeze02, Function | SmallTest | Level1)
157{
158    std::vector<DisplayId> displayIds;
159    for (uint32_t i = 0; i < 33; i++) { // MAX_DISPLAY_SIZE + 1
160        displayIds.push_back(i);
161    }
162
163    bool ret = DisplayManager::GetInstance().Unfreeze(displayIds);
164    ASSERT_FALSE(ret);
165}
166
167/**
168 * @tc.name: Unfreeze03
169 * @tc.desc: test Freeze displayIds empty
170 * @tc.type: FUNC
171 */
172HWTEST_F(DisplayManagerTest, Unfreeze03, Function | SmallTest | Level1)
173{
174    std::vector<DisplayId> displayIds;
175    bool ret = DisplayManager::GetInstance().Unfreeze(displayIds);
176    ASSERT_FALSE(ret);
177}
178
179/**
180 * @tc.name: RegisterScreenshotListener01
181 * @tc.desc: test RegisterScreenshotListener with null listener
182 * @tc.type: FUNC
183 */
184HWTEST_F(DisplayManagerTest, RegisterScreenshotListener01, Function | SmallTest | Level1)
185{
186    DMError ret = DisplayManager::GetInstance().RegisterScreenshotListener(nullptr);
187    ASSERT_FALSE(DMError::DM_OK == ret);
188}
189
190/**
191 * @tc.name: RegisterScreenshotListener02
192 * @tc.desc: test RegisterScreenshotListener with null listener
193 * @tc.type: FUNC
194 */
195HWTEST_F(DisplayManagerTest, RegisterScreenshotListener02, Function | SmallTest | Level1)
196{
197    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
198    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_NULLPTR));
199    sptr<DisplayManager::IScreenshotListener> listener = new DmMockScreenshotListener();
200    DMError ret = DisplayManager::GetInstance().RegisterScreenshotListener(listener);
201    ASSERT_FALSE(DMError::DM_OK == ret);
202}
203
204/**
205 * @tc.name: UnregisterScreenshotListener01
206 * @tc.desc: test UnregisterScreenshotListener with null listener
207 * @tc.type: FUNC
208 */
209HWTEST_F(DisplayManagerTest, UnregisterScreenshotListener01, Function | SmallTest | Level1)
210{
211    DMError ret = DisplayManager::GetInstance().UnregisterScreenshotListener(nullptr);
212    ASSERT_FALSE(DMError::DM_OK == ret);
213}
214
215/**
216 * @tc.name: UnregisterScreenshotListener02
217 * @tc.desc: test UnregisterScreenshotListener with null listener
218 * @tc.type: FUNC
219 */
220HWTEST_F(DisplayManagerTest, UnregisterScreenshotListener02, Function | SmallTest | Level1)
221{
222    sptr<DisplayManager::IScreenshotListener> listener = new DmMockScreenshotListener();
223    DMError ret = DisplayManager::GetInstance().UnregisterScreenshotListener(listener);
224    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
225}
226
227/**
228 * @tc.name: OnDisplayCreate01
229 * @tc.desc: OnDisplayCreate
230 * @tc.type: FUNC
231 */
232HWTEST_F(DisplayManagerTest, OnDisplayCreate01, Function | SmallTest | Level1)
233{
234    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
235    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
236    sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
237    DisplayManager::GetInstance().RegisterDisplayListener(listener);
238    auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
239    ASSERT_NE(displayManagerListener, nullptr);
240    displayManagerListener->OnDisplayCreate(nullptr);
241    sptr<DisplayInfo> displayInfo = new DisplayInfo();
242    displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
243    displayManagerListener->OnDisplayCreate(displayInfo);
244    displayInfo->SetDisplayId(0);
245    displayManagerListener->OnDisplayCreate(displayInfo);
246    ASSERT_NE(displayManagerListener->pImpl_, nullptr);
247    displayManagerListener->pImpl_ = nullptr;
248    displayManagerListener->OnDisplayCreate(displayInfo);
249    DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
250}
251
252/**
253 * @tc.name: CheckRectValid
254 * @tc.desc: CheckRectValid all
255 * @tc.type: FUNC
256 */
257HWTEST_F(DisplayManagerTest, CheckRectValid, Function | SmallTest | Level1)
258{
259    int32_t oriHeight = 500;
260    int32_t oriWidth = 500;
261    Media::Rect rect = {.left = 1, .top = 1, .width = 1, .height = 1};
262    bool ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
263    ASSERT_TRUE(ret);
264    rect.left = -1;
265    ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
266    ASSERT_FALSE(ret);
267    rect.left = 1;
268    rect.top = -1;
269    ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
270    ASSERT_FALSE(ret);
271    rect.top = 1;
272    rect.width = -1;
273    ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
274    ASSERT_FALSE(ret);
275    rect.width = 1;
276    rect.height = -1;
277    ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
278    ASSERT_FALSE(ret);
279    rect.width = 500;
280    rect.height = 1;
281    ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
282    ASSERT_FALSE(ret);
283    rect.width = 1;
284    rect.height = 500;
285    ret = DisplayManager::GetInstance().pImpl_->CheckRectValid(rect, oriHeight, oriWidth);
286    ASSERT_FALSE(ret);
287}
288
289/**
290 * @tc.name: CheckSizeValid
291 * @tc.desc: CheckSizeValid all
292 * @tc.type: FUNC
293 */
294HWTEST_F(DisplayManagerTest, CheckSizeValid, Function | SmallTest | Level1)
295{
296    int32_t oriHeight = 500;
297    int32_t oriWidth = 500;
298    Media::Size size = {.width = 1, .height = 1};
299    bool ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
300    ASSERT_TRUE(ret);
301    size.width = -1;
302    ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
303    ASSERT_FALSE(ret);
304    size.width = 1;
305    size.height = -1;
306    ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
307    ASSERT_FALSE(ret);
308    size.width = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT + 1;
309    size.height = 1;
310    ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
311    ASSERT_FALSE(ret);
312    size.width = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT;
313    size.height = DisplayManager::MAX_RESOLUTION_SIZE_SCREENSHOT + 1;
314    ret = DisplayManager::GetInstance().pImpl_->CheckSizeValid(size, oriHeight, oriWidth);
315    ASSERT_FALSE(ret);
316}
317
318/**
319 * @tc.name: ImplGetDefaultDisplay01
320 * @tc.desc: Impl GetDefaultDisplay nullptr
321 * @tc.type: FUNC
322 */
323HWTEST_F(DisplayManagerTest, ImplGetDefaultDisplay01, Function | SmallTest | Level1)
324{
325    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
326    EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(1).WillOnce(Return(nullptr));
327    sptr<Display> display = DisplayManager::GetInstance().pImpl_->GetDefaultDisplay();
328    ASSERT_EQ(display, nullptr);
329}
330
331/**
332 * @tc.name: GetDisplayByScreen
333 * @tc.desc: for interface coverage & check GetDisplayByScreen
334 * @tc.type: FUNC
335 */
336HWTEST_F(DisplayManagerTest, GetDisplayByScreen, Function | SmallTest | Level1)
337{
338    auto& displayManager = DisplayManager::GetInstance();
339    sptr<Display> display = displayManager.GetDisplayByScreen(SCREEN_ID_INVALID);
340    ASSERT_EQ(display, nullptr);
341
342    sptr<DisplayInfo> displayInfo = new DisplayInfo();
343    displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
344    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
345    EXPECT_CALL(m->Mock(), GetDisplayInfoByScreenId(_)).Times(1).WillOnce(Return(displayInfo));
346    display = displayManager.GetDisplayByScreen(1);
347    ASSERT_EQ(display, nullptr);
348}
349
350/**
351 * @tc.name: ImplGetDefaultDisplaySync
352 * @tc.desc: Impl GetDefaultDisplaySync nullptr
353 * @tc.type: FUNC
354 */
355HWTEST_F(DisplayManagerTest, ImplGetDefaultDisplaySync, Function | SmallTest | Level1)
356{
357    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
358    EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(6).WillRepeatedly(Return(nullptr));
359    sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplaySync();
360    ASSERT_EQ(display, nullptr);
361}
362
363/**
364 * @tc.name: GetScreenBrightness
365 * @tc.desc: GetScreenBrightness fun
366 * @tc.type: FUNC
367 */
368HWTEST_F(DisplayManagerTest, GetScreenBrightness, Function | SmallTest | Level1)
369{
370    uint64_t screenId = 2;
371    auto ret = DisplayManager::GetInstance().GetScreenBrightness(screenId);
372    ASSERT_FALSE(ret == 1);
373}
374
375/**
376 * @tc.name: GetDisplayById
377 * @tc.desc: GetDisplayById fun
378 * @tc.type: FUNC
379 */
380HWTEST_F(DisplayManagerTest, GetDisplayById, Function | SmallTest | Level1)
381{
382    DisplayId displayId = -1;
383    g_dmIsDestroyed = true;
384    auto ret = DisplayManager::GetInstance().GetDisplayById(displayId);
385    ASSERT_EQ(ret, nullptr);
386}
387
388/**
389 * @tc.name: RegisterPrivateWindowListener
390 * @tc.desc: RegisterPrivateWindowListener fun
391 * @tc.type: FUNC
392 */
393HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListener01, Function | SmallTest | Level1)
394{
395    sptr<DisplayManager::IPrivateWindowListener> listener;
396    auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListener(listener);
397    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
398}
399
400/**
401 * @tc.name: RegisterPrivateWindowListener
402 * @tc.desc: RegisterPrivateWindowListener fun
403 * @tc.type: FUNC
404 */
405HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListener02, Function | SmallTest | Level1)
406{
407    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
408    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
409    sptr<DisplayManager::IPrivateWindowListener> listener = new DmMockPrivateWindowListener();
410    auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListener(listener);
411    ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
412}
413
414/**
415 * @tc.name: UnregisterPrivateWindowListener
416 * @tc.desc: UnregisterPrivateWindowListener fun
417 * @tc.type: FUNC
418 */
419HWTEST_F(DisplayManagerTest, UnregisterPrivateWindowListener, Function | SmallTest | Level1)
420{
421    sptr<DisplayManager::IPrivateWindowListener> listener = nullptr;
422    sptr<DisplayManager::Impl> impl_;
423    auto ret = DisplayManager::GetInstance().UnregisterPrivateWindowListener(listener);
424    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
425}
426
427/**
428 * @tc.name: ImplUnregisterPrivateWindowListener
429 * @tc.desc: ImplUnregisterPrivateWindowListener fun
430 * @tc.type: FUNC
431 */
432HWTEST_F(DisplayManagerTest, ImplUnregisterPrivateWindowListener, Function | SmallTest | Level1)
433{
434    std::recursive_mutex mutex;
435    DisplayManager::Impl impl(mutex);
436    sptr<DisplayManager::IPrivateWindowListener> listener;
437    auto ret = impl.UnregisterPrivateWindowListener(listener);
438    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
439}
440
441/**
442 * @tc.name: RegisterPrivateWindowListChangeListener
443 * @tc.desc: RegisterPrivateWindowListChangeListener fun
444 * @tc.type: FUNC
445 */
446HWTEST_F(DisplayManagerTest, RegisterPrivateWindowListChangeListener, Function | SmallTest | Level1)
447{
448    sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
449    auto ret = DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener);
450    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
451    listener = new DisplayManager::IPrivateWindowListChangeListener();
452    ret = DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener);
453    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterPrivateWindowListChangeListener(listener));
454    listener.clear();
455}
456
457/**
458 * @tc.name: UnregisterPrivateWindowListChangeListener
459 * @tc.desc: UnregisterPrivateWindowListChangeListener fun
460 * @tc.type: FUNC
461 */
462HWTEST_F(DisplayManagerTest, UnregisterPrivateWindowListChangeListener, Function | SmallTest | Level1)
463{
464    sptr<DisplayManager::IPrivateWindowListChangeListener> listener = nullptr;
465    auto ret = DisplayManager::GetInstance().UnregisterPrivateWindowListChangeListener(listener);
466    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
467    listener = new DisplayManager::IPrivateWindowListChangeListener();
468    ret = DisplayManager::GetInstance().UnregisterPrivateWindowListChangeListener(listener);
469    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterPrivateWindowListChangeListener(listener));
470    listener.clear();
471}
472
473/**
474 * @tc.name: ImplRegisterPrivateWindowListChangeListener
475 * @tc.desc: ImplRegisterPrivateWindowListChangeListener fun
476 * @tc.type: FUNC
477 */
478HWTEST_F(DisplayManagerTest, ImplRegisterPrivateWindowListChangeListener01, Function | SmallTest | Level1)
479{
480    std::recursive_mutex mutex;
481    sptr<DisplayManager::Impl> impl_;
482    sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
483    DisplayManager::GetInstance().pImpl_->privateWindowListChangeListenerAgent_ = nullptr;
484    sptr<DisplayManager::Impl::DisplayManagerPrivateWindowListAgent> privateWindowListChangeListenerAgent =
485        new DisplayManager::Impl::DisplayManagerPrivateWindowListAgent(impl_);
486    auto ret = DisplayManager::GetInstance().pImpl_->RegisterPrivateWindowListChangeListener(listener);
487    ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
488            privateWindowListChangeListenerAgent,
489            DisplayManagerAgentType::PRIVATE_WINDOW_LIST_LISTENER));
490    listener = nullptr;
491    privateWindowListChangeListenerAgent.clear();
492}
493
494/**
495 * @tc.name: ImplRegisterPrivateWindowListChangeListener
496 * @tc.desc: ImplRegisterPrivateWindowListChangeListener fun
497 * @tc.type: FUNC
498 */
499HWTEST_F(DisplayManagerTest, ImplRegisterPrivateWindowListChangeListener02, Function | SmallTest | Level1)
500{
501    std::recursive_mutex mutex;
502    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
503    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
504    sptr<DisplayManager::Impl> impl_;
505    sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
506    DisplayManager::GetInstance().pImpl_->privateWindowListChangeListenerAgent_ = nullptr;
507    sptr<DisplayManager::Impl::DisplayManagerPrivateWindowListAgent> privateWindowListChangeListenerAgent =
508        new DisplayManager::Impl::DisplayManagerPrivateWindowListAgent(impl_);
509    auto ret = DisplayManager::GetInstance().pImpl_->RegisterPrivateWindowListChangeListener(listener);
510    ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
511    listener = nullptr;
512    privateWindowListChangeListenerAgent.clear();
513}
514
515/**
516 * @tc.name: ImplUnregisterPrivateWindowListChangeListener
517 * @tc.desc: ImplUnregisterPrivateWindowListChangeListener fun
518 * @tc.type: FUNC
519 */
520HWTEST_F(DisplayManagerTest, ImplUnregisterPrivateWindowListChangeListener, Function | SmallTest | Level1)
521{
522    std::recursive_mutex mutex;
523    DisplayManager::Impl impl(mutex);
524    sptr<DisplayManager::IPrivateWindowListChangeListener> listener;
525    auto ret = impl.UnregisterPrivateWindowListChangeListener(listener);
526    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
527}
528
529/**
530 * @tc.name: ImplUnregisterFoldStatusListener
531 * @tc.desc: ImplUnregisterFoldStatusListener fun
532 * @tc.type: FUNC
533 */
534HWTEST_F(DisplayManagerTest, ImplUnregisterFoldStatusListener, Function | SmallTest | Level1)
535{
536    sptr<DisplayManager::IFoldStatusListener> listener;
537    auto ret = DisplayManager::GetInstance().pImpl_->UnregisterFoldStatusListener(listener);
538    ASSERT_NE(ret, DMError::DM_OK);
539    listener.clear();
540}
541
542/**
543 * @tc.name: RegisterFoldStatusListener
544 * @tc.desc: RegisterFoldStatusListener fun
545 * @tc.type: FUNC
546 */
547HWTEST_F(DisplayManagerTest, RegisterFoldStatusListener, Function | SmallTest | Level1)
548{
549    sptr<DisplayManager::IFoldStatusListener> listener;
550    auto ret = DisplayManager::GetInstance().RegisterFoldStatusListener(listener);
551    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
552    listener = new DisplayManager::IFoldStatusListener();
553    ret = DisplayManager::GetInstance().RegisterFoldStatusListener(listener);
554    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterFoldStatusListener(listener));
555    listener.clear();
556}
557
558/**
559 * @tc.name: ImplRegisterFoldStatusListener
560 * @tc.desc: ImplRegisterFoldStatusListener fun
561 * @tc.type: FUNC
562 */
563HWTEST_F(DisplayManagerTest, ImplRegisterFoldStatusListener, Function | SmallTest | Level1)
564{
565    sptr<DisplayManager::IFoldStatusListener> listener;
566    sptr<DisplayManager::Impl> impl_;
567    DisplayManager::GetInstance().pImpl_->foldStatusListenerAgent_ = nullptr;
568    sptr<DisplayManager::Impl::DisplayManagerFoldStatusAgent> foldStatusListenerAgent =
569        new DisplayManager::Impl::DisplayManagerFoldStatusAgent(impl_);
570    auto ret = DisplayManager::GetInstance().pImpl_->RegisterFoldStatusListener(listener);
571    ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
572            foldStatusListenerAgent,
573            DisplayManagerAgentType::FOLD_STATUS_CHANGED_LISTENER));
574    listener = nullptr;
575    foldStatusListenerAgent.clear();
576}
577
578/**
579 * @tc.name: UnregisterFoldStatusListener
580 * @tc.desc: UnregisterFoldStatusListener fun
581 * @tc.type: FUNC
582 */
583HWTEST_F(DisplayManagerTest, UnregisterFoldStatusListener, Function | SmallTest | Level1)
584{
585    sptr<DisplayManager::IFoldStatusListener> listener;
586    auto ret = DisplayManager::GetInstance().UnregisterFoldStatusListener(listener);
587    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
588    listener = new DisplayManager::IFoldStatusListener();
589    ret = DisplayManager::GetInstance().UnregisterFoldStatusListener(listener);
590    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterFoldStatusListener(listener));
591    listener.clear();
592}
593
594/**
595 * @tc.name: RegisterDisplayModeListener
596 * @tc.desc: RegisterDisplayModeListener fun
597 * @tc.type: FUNC
598 */
599HWTEST_F(DisplayManagerTest, RegisterDisplayModeListener, Function | SmallTest | Level1)
600{
601    sptr<DisplayManager::IDisplayModeListener> listener;
602    auto ret = DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
603    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
604    listener = new DisplayManager::IDisplayModeListener();
605    ret = DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
606    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterDisplayModeListener(listener));
607    listener.clear();
608}
609
610/**
611 * @tc.name: ImplRegisterDisplayModeListener
612 * @tc.desc: ImplRegisterDisplayModeListener fun
613 * @tc.type: FUNC
614 */
615HWTEST_F(DisplayManagerTest, ImplRegisterDisplayModeListener, Function | SmallTest | Level1)
616{
617    sptr<DisplayManager::IDisplayModeListener> listener;
618    DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ = nullptr;
619    sptr<DisplayManager::Impl> impl_;
620    sptr<DisplayManager::Impl::DisplayManagerDisplayModeAgent> displayModeListenerAgent =
621        new DisplayManager::Impl::DisplayManagerDisplayModeAgent(impl_);
622    auto ret = DisplayManager::GetInstance().pImpl_->RegisterDisplayModeListener(listener);
623    ASSERT_EQ(ret, SingletonContainer::Get<DisplayManagerAdapter>().RegisterDisplayManagerAgent(
624            displayModeListenerAgent,
625            DisplayManagerAgentType::DISPLAY_MODE_CHANGED_LISTENER));
626    listener.clear();
627    displayModeListenerAgent.clear();
628}
629
630/**
631 * @tc.name: UnregisterDisplayModeListener
632 * @tc.desc: UnregisterDisplayModeListener fun
633 * @tc.type: FUNC
634 */
635HWTEST_F(DisplayManagerTest, UnregisterDisplayModeListener, Function | SmallTest | Level1)
636{
637    sptr<DisplayManager::IDisplayModeListener> listener;
638    auto ret = DisplayManager::GetInstance().UnregisterDisplayModeListener(listener);
639    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
640    listener = new DisplayManager::IDisplayModeListener();
641    ret = DisplayManager::GetInstance().UnregisterDisplayModeListener(listener);
642    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterDisplayModeListener(listener));
643    listener.clear();
644}
645
646/**
647 * @tc.name: ImplUnregisterDisplayModeListener
648 * @tc.desc: ImplUnregisterDisplayModeListener fun
649 * @tc.type: FUNC
650 */
651HWTEST_F(DisplayManagerTest, ImplUnregisterDisplayModeListener, Function | SmallTest | Level1)
652{
653    sptr<DisplayManager::IDisplayModeListener> listener;
654    auto ret = DisplayManager::GetInstance().pImpl_->UnregisterDisplayModeListener(listener);
655    ASSERT_EQ(ret, DMError::DM_OK);
656    listener.clear();
657}
658
659/**
660 * @tc.name: OnDisplayCreate02
661 * @tc.desc: OnDisplayCreate
662 * @tc.type: FUNC
663 */
664HWTEST_F(DisplayManagerTest, OnDisplayCreate02, Function | SmallTest | Level1)
665{
666    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
667    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
668    sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
669    DisplayManager::GetInstance().RegisterDisplayListener(listener);
670    auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
671    ASSERT_NE(displayManagerListener, nullptr);
672
673    sptr<DisplayInfo> displayInfo = nullptr;
674    displayManagerListener->OnDisplayCreate(displayInfo);
675    ASSERT_NE(displayManagerListener->pImpl_, nullptr);
676}
677
678/**
679 * @tc.name: RegisterDisplayListener
680 * @tc.desc: RegisterDisplayListener fun
681 * @tc.type: FUNC
682 */
683HWTEST_F(DisplayManagerTest, RegisterDisplayListener, Function | SmallTest | Level1)
684{
685    sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
686    bool hasPrivate = true;
687    DisplayManager::GetInstance().pImpl_->NotifyPrivateWindowStateChanged(hasPrivate);
688    auto ret = DisplayManager::GetInstance().RegisterDisplayListener(listener);
689    ASSERT_EQ(ret, DMError::DM_OK);
690}
691
692/**
693 * @tc.name: UnregisterDisplayListener
694 * @tc.desc: UnregisterDisplayListener fun
695 * @tc.type: FUNC
696 */
697HWTEST_F(DisplayManagerTest, UnregisterDisplayListener, Function | SmallTest | Level1)
698{
699    sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
700    sptr<DisplayManager::Impl> impl_;
701    auto ret = DisplayManager::GetInstance().UnregisterDisplayListener(listener);
702    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
703}
704
705/**
706 * @tc.name: HasPrivateWindow
707 * @tc.desc: HasPrivateWindow fun
708 * @tc.type: FUNC
709 */
710HWTEST_F(DisplayManagerTest, HasPrivateWindow, Function | SmallTest | Level1)
711{
712    sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
713    bool hasPrivateWindow = false;
714    auto ret = DisplayManager::GetInstance().HasPrivateWindow(0, hasPrivateWindow);
715    ASSERT_EQ(ret, DMError::DM_OK);
716}
717
718/**
719 * @tc.name: HasPrivateWindow02
720 * @tc.desc: HasPrivateWindow fun
721 * @tc.type: FUNC
722 */
723HWTEST_F(DisplayManagerTest, HasPrivateWindow02, Function | SmallTest | Level1)
724{
725    sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
726    sptr<DisplayManager::Impl> impl_;
727    bool hasPrivateWindow = false;
728    auto ret = DisplayManager::GetInstance().pImpl_->HasPrivateWindow(0, hasPrivateWindow);
729    ASSERT_EQ(ret, DMError::DM_OK);
730}
731
732/**
733 * @tc.name: IsFoldable
734 * @tc.desc: IsFoldable all
735 * @tc.type: FUNC
736 */
737HWTEST_F(DisplayManagerTest, IsFoldable, Function | SmallTest | Level1)
738{
739    bool ret = DisplayManager::GetInstance().IsFoldable();
740    ASSERT_FALSE(ret);
741}
742
743/**
744 * @tc.name: IsFoldable
745 * @tc.desc: IsFoldable fun
746 * @tc.type: FUNC
747 */
748HWTEST_F(DisplayManagerTest, IsFoldable01, Function | SmallTest | Level1)
749{
750    sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
751    FoldDisplayMode mode = FoldDisplayMode{0};
752    DisplayManager::GetInstance().SetFoldDisplayMode(mode);
753    DisplayManager::GetInstance().SetFoldStatusLocked(false);
754    sptr<DisplayManager::Impl> impl_;
755    auto ret = DisplayManager::GetInstance().pImpl_->IsFoldable();
756    ASSERT_FALSE(ret);
757}
758
759/**
760 * @tc.name: AddSurfaceNodeToDisplay
761 * @tc.desc: AddSurfaceNodeToDisplay fun
762 * @tc.type: FUNC
763 */
764HWTEST_F(DisplayManagerTest, AddSurfaceNodeToDisplay, Function | SmallTest | Level1)
765{
766    sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
767    std::shared_ptr<class RSSurfaceNode> surfaceNode;
768    auto ret = DisplayManager::GetInstance().AddSurfaceNodeToDisplay(0, surfaceNode);
769    if (SceneBoardJudgement::IsSceneBoardEnabled()) {
770        ASSERT_NE(ret, DMError::DM_ERROR_IPC_FAILED);
771    } else {
772        ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
773    }
774}
775
776/**
777 * @tc.name: RemoveSurfaceNodeFromDisplay
778 * @tc.desc: RemoveSurfaceNodeFromDisplay fun
779 * @tc.type: FUNC
780 */
781HWTEST_F(DisplayManagerTest, RemoveSurfaceNodeFromDisplay, Function | SmallTest | Level1)
782{
783    sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
784    std::shared_ptr<class RSSurfaceNode> surfaceNode;
785    DisplayManager::GetInstance().OnRemoteDied();
786    auto ret = DisplayManager::GetInstance().RemoveSurfaceNodeFromDisplay(0, surfaceNode);
787    if (SceneBoardJudgement::IsSceneBoardEnabled()) {
788        ASSERT_NE(ret, DMError::DM_ERROR_IPC_FAILED);
789    } else {
790        ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
791    }
792}
793
794/**
795 * @tc.name: RegisterFoldAngleListener01
796 * @tc.desc: RegisterFoldAngleListener01 fun
797 * @tc.type: FUNC
798 */
799HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener01, Function | SmallTest | Level1)
800{
801    sptr<DisplayManager::IFoldAngleListener> listener = nullptr;
802    auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
803    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
804    listener = new DisplayManager::IFoldAngleListener();
805    ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
806    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterFoldAngleListener(listener));
807    listener.clear();
808}
809
810/**
811 * @tc.name: RegisterFoldAngleListener02
812 * @tc.desc: RegisterFoldAngleListener01 fun
813 * @tc.type: FUNC
814 */
815HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener02, Function | SmallTest | Level1)
816{
817    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
818    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
819    DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ = nullptr;
820    sptr<DisplayManager::IFoldAngleListener> listener = new DmMockFoldAngleListener();
821    auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
822    ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
823    listener.clear();
824}
825
826/**
827 * @tc.name: UnregisterFoldAngleListener01
828 * @tc.desc: UnregisterFoldAngleListener01 fun
829 * @tc.type: FUNC
830 */
831HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener01, Function | SmallTest | Level1)
832{
833    sptr<DisplayManager::IFoldAngleListener> listener;
834    auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
835    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
836    listener = new DisplayManager::IFoldAngleListener();
837    ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
838    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterFoldAngleListener(listener));
839    listener.clear();
840}
841
842/**
843 * @tc.name: UnregisterFoldAngleListener02
844 * @tc.desc: UnregisterFoldAngleListener02 fun
845 * @tc.type: FUNC
846 */
847HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener02, Function | SmallTest | Level1)
848{
849    ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
850    sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
851    DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
852    auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
853    ASSERT_EQ(ret, DMError::DM_OK);
854    listener.clear();
855}
856
857/**
858 * @tc.name: UnregisterFoldAngleListener03
859 * @tc.desc: UnregisterFoldAngleListener03 fun
860 * @tc.type: FUNC
861 */
862HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener03, Function | SmallTest | Level1)
863{
864    ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
865    DisplayManager::GetInstance().pImpl_->foldAngleListeners_.clear();
866    sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
867    DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
868    auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
869    ASSERT_EQ(ret, DMError::DM_OK);
870    listener.clear();
871}
872
873/**
874 * @tc.name: RegisterCaptureStatusListener01
875 * @tc.desc: RegisterCaptureStatusListener01 fun
876 * @tc.type: FUNC
877 */
878HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener01, Function | SmallTest | Level1)
879{
880    sptr<DisplayManager::ICaptureStatusListener> listener = nullptr;
881    auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
882    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
883    listener = new DisplayManager::ICaptureStatusListener();
884    ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
885    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterCaptureStatusListener(listener));
886    listener.clear();
887}
888
889/**
890 * @tc.name: RegisterCaptureStatusListener02
891 * @tc.desc: RegisterCaptureStatusListener02 fun
892 * @tc.type: FUNC
893 */
894HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener02, Function | SmallTest | Level1)
895{
896    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
897    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
898    DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ = nullptr;
899    sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
900    auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
901    ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
902    listener.clear();
903}
904
905/**
906 * @tc.name: UnregisterCaptureStatusListener01
907 * @tc.desc: UnregisterCaptureStatusListener01 fun
908 * @tc.type: FUNC
909 */
910HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener01, Function | SmallTest | Level1)
911{
912    sptr<DisplayManager::ICaptureStatusListener> listener;
913    auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
914    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
915    listener = new DisplayManager::ICaptureStatusListener();
916    ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
917    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterCaptureStatusListener(listener));
918    listener.clear();
919}
920
921/**
922 * @tc.name: UnregisterCaptureStatusListener02
923 * @tc.desc: UnregisterCaptureStatusListener02 fun
924 * @tc.type: FUNC
925 */
926HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener02, Function | SmallTest | Level1)
927{
928    ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
929    sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
930    DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
931    auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
932    ASSERT_EQ(ret, DMError::DM_OK);
933    listener.clear();
934}
935
936/**
937 * @tc.name: UnregisterCaptureStatusListener03
938 * @tc.desc: UnregisterCaptureStatusListener03 fun
939 * @tc.type: FUNC
940 */
941HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener03, Function | SmallTest | Level1)
942{
943    ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
944    DisplayManager::GetInstance().pImpl_->captureStatusListeners_.clear();
945    sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
946    DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
947    auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
948    ASSERT_EQ(ret, DMError::DM_OK);
949    listener.clear();
950}
951
952
953/**
954 * @tc.name: RegisterDisplayUpdateListener01
955 * @tc.desc: RegisterDisplayUpdateListener01 fun
956 * @tc.type: FUNC
957 */
958HWTEST_F(DisplayManagerTest, RegisterDisplayUpdateListener01, Function | SmallTest | Level1)
959{
960    sptr<DisplayManager::IDisplayUpdateListener> listener = nullptr;
961    auto ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
962    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
963    listener = new DisplayManager::IDisplayUpdateListener();
964    ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
965    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterDisplayUpdateListener(listener));
966    listener.clear();
967}
968
969/**
970 * @tc.name: IsCaptured01
971 * @tc.desc: IsCaptured01 fun
972 * @tc.type: FUNC
973 */
974HWTEST_F(DisplayManagerTest, IsCaptured01, Function | SmallTest | Level1)
975{
976    auto ret = DisplayManager::GetInstance().IsCaptured();
977    ASSERT_FALSE(ret);
978}
979
980/**
981 * @tc.name: isinsideof
982 * @tc.desc: isinside0f fun
983 * @tc.type: FUNC
984 */
985HWTEST_F(DisplayManagerTest, isinsideof, Function | SmallTest | Level1)
986{
987    DMRect rect = {2, 2, 2, 2};
988    DMRect rect1 = {2, 2, 2, 2};
989    ASSERT_EQ(rect.IsInsideOf(rect1), true);
990}
991
992/**
993 * @tc.name: GetAllDisplayPhysicalResolution
994 * @tc.desc: GetAllDisplayPhysicalResolution test
995 * @tc.type: FUNC
996 */
997HWTEST_F(DisplayManagerTest, GetAllDisplayPhysicalResolution, Function | SmallTest | Level1)
998{
999    std::vector<DisplayPhysicalResolution> allSize = DisplayManager::GetInstance().GetAllDisplayPhysicalResolution();
1000    ASSERT_TRUE(!allSize.empty());
1001}
1002
1003/**
1004 * @tc.name: ClearDisplayStateCallback
1005 * @tc.desc: ClearDisplayStateCallback test
1006 * @tc.type: FUNC
1007 */
1008HWTEST_F(DisplayManagerTest, ClearDisplayStateCallback, Function | SmallTest | Level1)
1009{
1010    DisplayManager::GetInstance().pImpl_->ClearDisplayStateCallback();
1011    ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayStateAgent_ == nullptr);
1012}
1013
1014/**
1015 * @tc.name: ClearFoldStatusCallback
1016 * @tc.desc: ClearFoldStatusCallback test
1017 * @tc.type: FUNC
1018 */
1019HWTEST_F(DisplayManagerTest, ClearFoldStatusCallback, Function | SmallTest | Level1)
1020{
1021    DisplayManager::GetInstance().pImpl_->ClearFoldStatusCallback();
1022    ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldStatusListenerAgent_ == nullptr);
1023}
1024
1025/**
1026 * @tc.name: ClearFoldAngleCallback
1027 * @tc.desc: ClearFoldAngleCallback test
1028 * @tc.type: FUNC
1029 */
1030HWTEST_F(DisplayManagerTest, ClearFoldAngleCallback, Function | SmallTest | Level1)
1031{
1032    DisplayManager::GetInstance().pImpl_->ClearFoldAngleCallback();
1033    ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ == nullptr);
1034}
1035
1036/**
1037 * @tc.name: ClearCaptureStatusCallback
1038 * @tc.desc: ClearCaptureStatusCallback test
1039 * @tc.type: FUNC
1040 */
1041HWTEST_F(DisplayManagerTest, ClearCaptureStatusCallback, Function | SmallTest | Level1)
1042{
1043    DisplayManager::GetInstance().pImpl_->ClearCaptureStatusCallback();
1044    ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ == nullptr);
1045}
1046
1047/**
1048 * @tc.name: ClearDisplayModeCallback
1049 * @tc.desc: ClearDisplayModeCallback test
1050 * @tc.type: FUNC
1051 */
1052HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback01, Function | SmallTest | Level1)
1053{
1054    DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
1055    ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
1056}
1057
1058/**
1059 * @tc.name: ClearDisplayModeCallback
1060 * @tc.desc: ClearDisplayModeCallback test
1061 * @tc.type: FUNC
1062 */
1063HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback02, Function | SmallTest | Level1)
1064{
1065    sptr<DisplayManager::IDisplayModeListener> listener = new DisplayManager::IDisplayModeListener();
1066    DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
1067    DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
1068    ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
1069}
1070
1071/**
1072 * @tc.name: GetDisplayByScreenId
1073 * @tc.desc: GetDisplayByScreenId test
1074 * @tc.type: FUNC
1075 */
1076HWTEST_F(DisplayManagerTest, GetDisplayByScreenId, Function | SmallTest | Level1)
1077{
1078    ScreenId screenId = -1;
1079    auto ret = DisplayManager::GetInstance().pImpl_->GetDisplayByScreenId(screenId);
1080    ASSERT_TRUE(ret == nullptr);
1081}
1082
1083/**
1084 * @tc.name: UnregisterDisplayUpdateListener
1085 * @tc.desc: UnregisterDisplayUpdateListener fun
1086 * @tc.type: FUNC
1087 */
1088HWTEST_F(DisplayManagerTest, UnregisterDisplayUpdateListener, Function | SmallTest | Level1)
1089{
1090    sptr<DisplayManager::IDisplayUpdateListener> listener;
1091    auto ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1092    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1093    listener = new DisplayManager::IDisplayUpdateListener();
1094    ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1095    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterDisplayUpdateListener(listener));
1096    listener.clear();
1097}
1098
1099/**
1100 * @tc.name: RegisterAvailableAreaListener
1101 * @tc.desc: RegisterAvailableAreaListener fun
1102 * @tc.type: FUNC
1103 */
1104HWTEST_F(DisplayManagerTest, RegisterAvailableAreaListener, Function | SmallTest | Level1)
1105{
1106    sptr<DisplayManager::IAvailableAreaListener> listener;
1107    auto ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1108    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1109    listener = new DisplayManager::IAvailableAreaListener();
1110    ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1111    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterAvailableAreaListener(listener));
1112    listener.clear();
1113}
1114
1115/**
1116 * @tc.name: UnregisterAvailableAreaListener
1117 * @tc.desc: UnregisterAvailableAreaListener fun
1118 * @tc.type: FUNC
1119 */
1120HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener, Function | SmallTest | Level1)
1121{
1122    sptr<DisplayManager::IAvailableAreaListener> listener;
1123    auto ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1124    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1125    listener = new DisplayManager::IAvailableAreaListener();
1126    ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1127    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterAvailableAreaListener(listener));
1128    listener.clear();
1129}
1130
1131/**
1132 * @tc.name: GetDisplayInfoSrting
1133 * @tc.desc: GetDisplayInfoSrting fun
1134 * @tc.type: FUNC
1135 */
1136HWTEST_F(DisplayManagerTest, GetDisplayInfoSrting, Function | SmallTest | Level1)
1137{
1138    sptr<DisplayInfo> displayInfo = nullptr;
1139    auto ret =DisplayManager::GetInstance().pImpl_->GetDisplayInfoSrting(displayInfo);
1140    ASSERT_EQ(displayInfo, nullptr);
1141}
1142
1143/**
1144 * @tc.name: OnRemoteDied
1145 * @tc.desc: OnRemoteDied fun
1146 * @tc.type: FUNC
1147 */
1148HWTEST_F(DisplayManagerTest, OnRemoteDied, Function | SmallTest | Level1)
1149{
1150    g_dmIsDestroyed = true;
1151    DisplayManager::GetInstance().OnRemoteDied();
1152    ASSERT_EQ(g_dmIsDestroyed, true);
1153}
1154
1155/**
1156 * @tc.name: SetDisplayScale
1157 * @tc.desc: SetDisplayScale test
1158 * @tc.type: FUNC
1159 */
1160HWTEST_F(DisplayManagerTest, SetDisplayScale, Function | SmallTest | Level1)
1161{
1162    DisplayManager& displayManager = DisplayManager::GetInstance();
1163    ASSERT_NE(displayManager.pImpl_, nullptr);
1164    const float scaleX = 1.0f;
1165    const float scaleY = 1.0f;
1166    const float pivotX = 0.5f;
1167    const float pivotY = 0.5f;
1168    sptr<Display> display = displayManager.GetDefaultDisplay();
1169    ASSERT_NE(display, nullptr);
1170    ScreenId screenId = display->GetScreenId();
1171    displayManager.SetDisplayScale(screenId, scaleX, scaleY, pivotX, pivotY);
1172}
1173
1174/**
1175 * @tc.name: Clear
1176 * @tc.desc: Clear test
1177 * @tc.type: FUNC
1178 */
1179HWTEST_F(DisplayManagerTest, Clear01, Function | SmallTest | Level1)
1180{
1181    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1182    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1183    EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1184    DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
1185    sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
1186    DisplayManager::GetInstance().RegisterDisplayListener(listener);
1187    auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
1188    ASSERT_NE(displayManagerListener, nullptr);
1189    DisplayManager::GetInstance().pImpl_->Clear();
1190    ASSERT_EQ(DisplayManager::GetInstance().pImpl_->displayManagerListener_, nullptr);
1191}
1192
1193/**
1194 * @tc.name: Clear
1195 * @tc.desc: Clear test
1196 * @tc.type: FUNC
1197 */
1198HWTEST_F(DisplayManagerTest, Clear02, Function | SmallTest | Level1)
1199{
1200    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1201    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1202    EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1203    DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_ = nullptr;
1204    sptr<IDisplayPowerEventListener> listener = new DmMockDisplayPowerEventListener();
1205    DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener);
1206    auto powerEventListenerAgent = DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_;
1207    ASSERT_NE(powerEventListenerAgent, nullptr);
1208    DisplayManager::GetInstance().pImpl_->Clear();
1209    ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1210}
1211
1212/**
1213 * @tc.name: NotifyCaptureStatusChanged
1214 * @tc.desc: NotifyCaptureStatusChanged fun
1215 * @tc.type: FUNC
1216 */
1217HWTEST_F(DisplayManagerTest, NotifyCaptureStatusChanged, Function | SmallTest | Level1)
1218{
1219    DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ = nullptr;
1220    sptr<DisplayManager::Impl> impl_;
1221    sptr<DisplayManager::Impl::DisplayManagerDisplayModeAgent> displayModeListenerAgent =
1222        new DisplayManager::Impl::DisplayManagerDisplayModeAgent(impl_);
1223    bool isCapture = true;
1224    DisplayManager::GetInstance().pImpl_->NotifyCaptureStatusChanged(isCapture);
1225    ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1226}
1227
1228/**
1229 * @tc.name: NotifyCaptureStatusChanged01
1230 * @tc.desc: NotifyCaptureStatusChanged01 fun
1231 * @tc.type: FUNC
1232 */
1233HWTEST_F(DisplayManagerTest, NotifyCaptureStatusChanged01, Function | SmallTest | Level1)
1234{
1235    DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ = nullptr;
1236    sptr<DisplayManager::Impl> impl_;
1237    sptr<DisplayManager::Impl::DisplayManagerDisplayModeAgent> displayModeListenerAgent =
1238        new DisplayManager::Impl::DisplayManagerDisplayModeAgent(impl_);
1239    bool isCapture = true;
1240    DisplayManager::GetInstance().pImpl_->NotifyCaptureStatusChanged(isCapture);
1241    ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1242}
1243/**
1244 * @tc.name: RegisterFoldAngleListener03
1245 * @tc.desc: RegisterFoldAngleListener03 fun
1246 * @tc.type: FUNC
1247 */
1248HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener03, Function | SmallTest | Level1)
1249{
1250    sptr<DisplayManager::IFoldAngleListener> listener = nullptr;
1251    auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1252    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1253    listener = new DisplayManager::IFoldAngleListener();
1254    ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1255    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterFoldAngleListener(listener));
1256    listener.clear();
1257}
1258
1259/**
1260 * @tc.name: RegisterFoldAngleListener04
1261 * @tc.desc: RegisterFoldAngleListener04 fun
1262 * @tc.type: FUNC
1263 */
1264HWTEST_F(DisplayManagerTest, RegisterFoldAngleListener04, Function | SmallTest | Level1)
1265{
1266    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1267    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
1268    DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ = nullptr;
1269    sptr<DisplayManager::IFoldAngleListener> listener = new DmMockFoldAngleListener();
1270    auto ret = DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1271    ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
1272    listener.clear();
1273}
1274
1275/**
1276 * @tc.name: UnregisterFoldAngleListener04
1277 * @tc.desc: UnregisterFoldAngleListener04 fun
1278 * @tc.type: FUNC
1279 */
1280HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener04, Function | SmallTest | Level1)
1281{
1282    sptr<DisplayManager::IFoldAngleListener> listener;
1283    auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
1284    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1285    listener = new DisplayManager::IFoldAngleListener();
1286    ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
1287    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterFoldAngleListener(listener));
1288    listener.clear();
1289}
1290
1291/**
1292 * @tc.name: UnregisterFoldAngleListener05
1293 * @tc.desc: UnregisterFoldAngleListener05 fun
1294 * @tc.type: FUNC
1295 */
1296HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener05, Function | SmallTest | Level1)
1297{
1298    ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
1299    sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
1300    DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1301    auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
1302    ASSERT_EQ(ret, DMError::DM_OK);
1303    listener.clear();
1304}
1305
1306/**
1307 * @tc.name: UnregisterFoldAngleListener06
1308 * @tc.desc: UnregisterFoldAngleListener06 fun
1309 * @tc.type: FUNC
1310 */
1311HWTEST_F(DisplayManagerTest, UnregisterFoldAngleListener06, Function | SmallTest | Level1)
1312{
1313    ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->foldAngleListeners_.empty());
1314    DisplayManager::GetInstance().pImpl_->foldAngleListeners_.clear();
1315    sptr<DisplayManager::IFoldAngleListener> listener = new DisplayManager::IFoldAngleListener();
1316    DisplayManager::GetInstance().RegisterFoldAngleListener(listener);
1317    auto ret = DisplayManager::GetInstance().UnregisterFoldAngleListener(listener);
1318    ASSERT_EQ(ret, DMError::DM_OK);
1319    listener.clear();
1320}
1321
1322/**
1323 * @tc.name: RegisterCaptureStatusListener03
1324 * @tc.desc: RegisterCaptureStatusListener03 fun
1325 * @tc.type: FUNC
1326 */
1327HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener03, Function | SmallTest | Level1)
1328{
1329    sptr<DisplayManager::ICaptureStatusListener> listener = nullptr;
1330    auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1331    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1332    listener = new DisplayManager::ICaptureStatusListener();
1333    ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1334    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterCaptureStatusListener(listener));
1335    listener.clear();
1336}
1337
1338/**
1339 * @tc.name: RegisterCaptureStatusListener04
1340 * @tc.desc: RegisterCaptureStatusListener04 fun
1341 * @tc.type: FUNC
1342 */
1343HWTEST_F(DisplayManagerTest, RegisterCaptureStatusListener04, Function | SmallTest | Level1)
1344{
1345    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1346    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
1347    DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ = nullptr;
1348    sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
1349    auto ret = DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1350    ASSERT_EQ(ret, DMError::DM_ERROR_IPC_FAILED);
1351    listener.clear();
1352}
1353
1354/**
1355 * @tc.name: UnregisterCaptureStatusListener04
1356 * @tc.desc: UnregisterCaptureStatusListener04 fun
1357 * @tc.type: FUNC
1358 */
1359HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener04, Function | SmallTest | Level1)
1360{
1361    sptr<DisplayManager::ICaptureStatusListener> listener;
1362    auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
1363    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1364    listener = new DisplayManager::ICaptureStatusListener();
1365    ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
1366    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterCaptureStatusListener(listener));
1367    listener.clear();
1368}
1369
1370/**
1371 * @tc.name: UnregisterCaptureStatusListener05
1372 * @tc.desc: UnregisterCaptureStatusListener05 fun
1373 * @tc.type: FUNC
1374 */
1375HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener05, Function | SmallTest | Level1)
1376{
1377    ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
1378    sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
1379    DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1380    auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
1381    ASSERT_EQ(ret, DMError::DM_OK);
1382    listener.clear();
1383}
1384
1385/**
1386 * @tc.name: UnregisterCaptureStatusListener06
1387 * @tc.desc: UnregisterCaptureStatusListener06 fun
1388 * @tc.type: FUNC
1389 */
1390HWTEST_F(DisplayManagerTest, UnregisterCaptureStatusListener06, Function | SmallTest | Level1)
1391{
1392    ASSERT_FALSE(DisplayManager::GetInstance().pImpl_->captureStatusListeners_.empty());
1393    DisplayManager::GetInstance().pImpl_->captureStatusListeners_.clear();
1394    sptr<DisplayManager::ICaptureStatusListener> listener = new DisplayManager::ICaptureStatusListener();
1395    DisplayManager::GetInstance().RegisterCaptureStatusListener(listener);
1396    auto ret = DisplayManager::GetInstance().UnregisterCaptureStatusListener(listener);
1397    ASSERT_EQ(ret, DMError::DM_OK);
1398    listener.clear();
1399}
1400
1401
1402/**
1403 * @tc.name: RegisterDisplayUpdateListener02
1404 * @tc.desc: RegisterDisplayUpdateListener02 fun
1405 * @tc.type: FUNC
1406 */
1407HWTEST_F(DisplayManagerTest, RegisterDisplayUpdateListener02, Function | SmallTest | Level1)
1408{
1409    sptr<DisplayManager::IDisplayUpdateListener> listener = nullptr;
1410    auto ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
1411    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1412    listener = new DisplayManager::IDisplayUpdateListener();
1413    ret = DisplayManager::GetInstance().RegisterDisplayUpdateListener(listener);
1414    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterDisplayUpdateListener(listener));
1415    listener.clear();
1416}
1417
1418/**
1419 * @tc.name: IsCaptured02
1420 * @tc.desc: IsCaptured02 fun
1421 * @tc.type: FUNC
1422 */
1423HWTEST_F(DisplayManagerTest, IsCaptured02, Function | SmallTest | Level1)
1424{
1425    auto ret = DisplayManager::GetInstance().IsCaptured();
1426    ASSERT_FALSE(ret);
1427}
1428
1429/**
1430 * @tc.name: isinsideof01
1431 * @tc.desc: isinsideof01 fun
1432 * @tc.type: FUNC
1433 */
1434HWTEST_F(DisplayManagerTest, isinsideof01, Function | SmallTest | Level1)
1435{
1436    DMRect rect = {2, 2, 2, 2};
1437    DMRect rect1 = {2, 2, 2, 2};
1438    ASSERT_EQ(rect.IsInsideOf(rect1), true);
1439}
1440
1441/**
1442 * @tc.name: GetAllDisplayPhysicalResolution01
1443 * @tc.desc: GetAllDisplayPhysicalResolution01 test
1444 * @tc.type: FUNC
1445 */
1446HWTEST_F(DisplayManagerTest, GetAllDisplayPhysicalResolution01, Function | SmallTest | Level1)
1447{
1448    std::vector<DisplayPhysicalResolution> allSize = DisplayManager::GetInstance().GetAllDisplayPhysicalResolution();
1449    ASSERT_TRUE(!allSize.empty());
1450}
1451
1452/**
1453 * @tc.name: ClearDisplayStateCallback01
1454 * @tc.desc: ClearDisplayStateCallback01 test
1455 * @tc.type: FUNC
1456 */
1457HWTEST_F(DisplayManagerTest, ClearDisplayStateCallback01, Function | SmallTest | Level1)
1458{
1459    DisplayManager::GetInstance().pImpl_->ClearDisplayStateCallback();
1460    ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayStateAgent_ == nullptr);
1461}
1462
1463/**
1464 * @tc.name: ClearFoldStatusCallback01
1465 * @tc.desc: ClearFoldStatusCallback01 test
1466 * @tc.type: FUNC
1467 */
1468HWTEST_F(DisplayManagerTest, ClearFoldStatusCallback01, Function | SmallTest | Level1)
1469{
1470    DisplayManager::GetInstance().pImpl_->ClearFoldStatusCallback();
1471    ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldStatusListenerAgent_ == nullptr);
1472}
1473
1474/**
1475 * @tc.name: ClearFoldAngleCallback01
1476 * @tc.desc: ClearFoldAngleCallback01 test
1477 * @tc.type: FUNC
1478 */
1479HWTEST_F(DisplayManagerTest, ClearFoldAngleCallback01, Function | SmallTest | Level1)
1480{
1481    DisplayManager::GetInstance().pImpl_->ClearFoldAngleCallback();
1482    ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->foldAngleListenerAgent_ == nullptr);
1483}
1484
1485/**
1486 * @tc.name: ClearCaptureStatusCallback01
1487 * @tc.desc: ClearCaptureStatusCallback01 test
1488 * @tc.type: FUNC
1489 */
1490HWTEST_F(DisplayManagerTest, ClearCaptureStatusCallback01, Function | SmallTest | Level1)
1491{
1492    DisplayManager::GetInstance().pImpl_->ClearCaptureStatusCallback();
1493    ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->captureStatusListenerAgent_ == nullptr);
1494}
1495
1496/**
1497 * @tc.name: ClearDisplayModeCallback03
1498 * @tc.desc: ClearDisplayModeCallback03 test
1499 * @tc.type: FUNC
1500 */
1501HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback03, Function | SmallTest | Level1)
1502{
1503    DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
1504    ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
1505}
1506
1507/**
1508 * @tc.name: ClearDisplayModeCallback04
1509 * @tc.desc: ClearDisplayModeCallback04 test
1510 * @tc.type: FUNC
1511 */
1512HWTEST_F(DisplayManagerTest, ClearDisplayModeCallback04, Function | SmallTest | Level1)
1513{
1514    sptr<DisplayManager::IDisplayModeListener> listener = new DisplayManager::IDisplayModeListener();
1515    DisplayManager::GetInstance().RegisterDisplayModeListener(listener);
1516    DisplayManager::GetInstance().pImpl_->ClearDisplayModeCallback();
1517    ASSERT_TRUE(DisplayManager::GetInstance().pImpl_->displayModeListenerAgent_ == nullptr);
1518}
1519
1520/**
1521 * @tc.name: GetDisplayByScreenId01
1522 * @tc.desc: GetDisplayByScreenId01 test
1523 * @tc.type: FUNC
1524 */
1525HWTEST_F(DisplayManagerTest, GetDisplayByScreenId01, Function | SmallTest | Level1)
1526{
1527    ScreenId screenId = -1;
1528    auto ret = DisplayManager::GetInstance().pImpl_->GetDisplayByScreenId(screenId);
1529    ASSERT_TRUE(ret == nullptr);
1530}
1531
1532/**
1533 * @tc.name: UnregisterDisplayUpdateListener01
1534 * @tc.desc: UnregisterDisplayUpdateListener01 fun
1535 * @tc.type: FUNC
1536 */
1537HWTEST_F(DisplayManagerTest, UnregisterDisplayUpdateListener01, Function | SmallTest | Level1)
1538{
1539    sptr<DisplayManager::IDisplayUpdateListener> listener;
1540    auto ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1541    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1542    listener = new DisplayManager::IDisplayUpdateListener();
1543    ret = DisplayManager::GetInstance().UnregisterDisplayUpdateListener(listener);
1544    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterDisplayUpdateListener(listener));
1545    listener.clear();
1546}
1547
1548/**
1549 * @tc.name: RegisterAvailableAreaListener01
1550 * @tc.desc: RegisterAvailableAreaListener01 fun
1551 * @tc.type: FUNC
1552 */
1553HWTEST_F(DisplayManagerTest, RegisterAvailableAreaListener01, Function | SmallTest | Level1)
1554{
1555    sptr<DisplayManager::IAvailableAreaListener> listener;
1556    auto ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1557    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1558    listener = new DisplayManager::IAvailableAreaListener();
1559    ret = DisplayManager::GetInstance().RegisterAvailableAreaListener(listener);
1560    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->RegisterAvailableAreaListener(listener));
1561    listener.clear();
1562}
1563
1564/**
1565 * @tc.name: UnregisterAvailableAreaListener01
1566 * @tc.desc: UnregisterAvailableAreaListener01 fun
1567 * @tc.type: FUNC
1568 */
1569HWTEST_F(DisplayManagerTest, UnregisterAvailableAreaListener01, Function | SmallTest | Level1)
1570{
1571    sptr<DisplayManager::IAvailableAreaListener> listener;
1572    auto ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1573    ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1574    listener = new DisplayManager::IAvailableAreaListener();
1575    ret = DisplayManager::GetInstance().UnregisterAvailableAreaListener(listener);
1576    ASSERT_EQ(ret, DisplayManager::GetInstance().pImpl_->UnregisterAvailableAreaListener(listener));
1577    listener.clear();
1578}
1579
1580/**
1581 * @tc.name: GetDisplayInfoSrting01
1582 * @tc.desc: GetDisplayInfoSrting01 fun
1583 * @tc.type: FUNC
1584 */
1585HWTEST_F(DisplayManagerTest, GetDisplayInfoSrting01, Function | SmallTest | Level1)
1586{
1587    sptr<DisplayInfo> displayInfo = nullptr;
1588    auto ret =DisplayManager::GetInstance().pImpl_->GetDisplayInfoSrting(displayInfo);
1589    ASSERT_EQ(displayInfo, nullptr);
1590}
1591
1592/**
1593 * @tc.name: OnRemoteDied01
1594 * @tc.desc: OnRemoteDied01 fun
1595 * @tc.type: FUNC
1596 */
1597HWTEST_F(DisplayManagerTest, OnRemoteDied01, Function | SmallTest | Level1)
1598{
1599    g_dmIsDestroyed = true;
1600    DisplayManager::GetInstance().OnRemoteDied();
1601    ASSERT_EQ(g_dmIsDestroyed, true);
1602}
1603
1604/**
1605 * @tc.name: SetDisplayScale01
1606 * @tc.desc: SetDisplayScale01 test
1607 * @tc.type: FUNC
1608 */
1609HWTEST_F(DisplayManagerTest, SetDisplayScale01, Function | SmallTest | Level1)
1610{
1611    DisplayManager& displayManager = DisplayManager::GetInstance();
1612    ASSERT_NE(displayManager.pImpl_, nullptr);
1613    const float scaleX = 1.0f;
1614    const float scaleY = 1.0f;
1615    const float pivotX = 0.5f;
1616    const float pivotY = 0.5f;
1617    sptr<Display> display = displayManager.GetDefaultDisplay();
1618    ASSERT_NE(display, nullptr);
1619    ScreenId screenId = display->GetScreenId();
1620    displayManager.SetDisplayScale(screenId, scaleX, scaleY, pivotX, pivotY);
1621}
1622
1623/**
1624 * @tc.name: Clear03
1625 * @tc.desc: Clear03 test
1626 * @tc.type: FUNC
1627 */
1628HWTEST_F(DisplayManagerTest, Clear03, Function | SmallTest | Level1)
1629{
1630    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1631    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1632    EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1633    DisplayManager::GetInstance().pImpl_->displayManagerListener_ = nullptr;
1634    sptr<DisplayManager::IDisplayListener> listener = new DmMockDisplayListener();
1635    DisplayManager::GetInstance().RegisterDisplayListener(listener);
1636    auto displayManagerListener = DisplayManager::GetInstance().pImpl_->displayManagerListener_;
1637    ASSERT_NE(displayManagerListener, nullptr);
1638    DisplayManager::GetInstance().pImpl_->Clear();
1639    ASSERT_EQ(DisplayManager::GetInstance().pImpl_->displayManagerListener_, nullptr);
1640}
1641
1642/**
1643 * @tc.name: Clear04
1644 * @tc.desc: Clear04 test
1645 * @tc.type: FUNC
1646 */
1647HWTEST_F(DisplayManagerTest, Clear04, Function | SmallTest | Level1)
1648{
1649    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1650    EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1651    EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
1652    DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_ = nullptr;
1653    sptr<IDisplayPowerEventListener> listener = new DmMockDisplayPowerEventListener();
1654    DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener);
1655    auto powerEventListenerAgent = DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_;
1656    ASSERT_NE(powerEventListenerAgent, nullptr);
1657    DisplayManager::GetInstance().pImpl_->Clear();
1658    ASSERT_EQ(DisplayManager::GetInstance().pImpl_->powerEventListenerAgent_, nullptr);
1659}
1660}
1661} // namespace Rosen
1662} // namespace OHOS