1 /*
2  * Copyright (c) 2021-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 "screen_manager.h"
20 #include "screen_manager_utils.h"
21 #include "mock_display_manager_adapter.h"
22 #include "singleton_mocker.h"
23 #include "screen_manager.cpp"
24 #include "window_manager_hilog.h"
25 #include "scene_board_judgement.h"
26 
27 using namespace testing;
28 using namespace testing::ext;
29 
30 namespace OHOS {
31 namespace Rosen {
32 using Mocker = SingletonMocker<ScreenManagerAdapter, MockScreenManagerAdapter>;
33 class DmMockScreenListener : public ScreenManager::IScreenListener {
34 public:
OnConnect(ScreenId)35     void OnConnect(ScreenId) override {}
OnDisconnect(ScreenId)36     void OnDisconnect(ScreenId) override {}
OnChange(ScreenId)37     void OnChange(ScreenId) override {}
38 };
39 
40 class TestScreenGroupListener : public ScreenManager::IScreenGroupListener {
41 public:
OnChange(const std::vector<ScreenId> &,ScreenGroupChangeEvent)42     void OnChange(const std::vector<ScreenId>&, ScreenGroupChangeEvent) override {};
43 };
44 
45 class TestIVirtualScreenGroupListener : public ScreenManager::IVirtualScreenGroupListener {
46 public:
OnMirrorChange(const ChangeInfo & info)47     void OnMirrorChange(const ChangeInfo& info) override {};
48 };
49 class ScreenManagerTest : public testing::Test {
50 public:
51     static void SetUpTestCase();
52     static void TearDownTestCase();
53     virtual void SetUp() override;
54     virtual void TearDown() override;
55 
56     const std::string defaultName_ = "virtualScreen01";
57     const float defaultDensity_ = 2.0;
58     const int32_t defaultFlags_ = 0;
59     const ScreenId testVirtualScreenId_ = 2;
60     const uint32_t testVirtualScreenWidth_ = 1920;
61     const uint32_t testVirtualScreenHeight_ = 1080;
62     static sptr<Display> defaultDisplay_;
63     static uint32_t defaultWidth_;
64     static uint32_t defaultHeight_;
65 };
66 sptr<Display> ScreenManagerTest::defaultDisplay_ = nullptr;
67 uint32_t ScreenManagerTest::defaultWidth_ = 480;
68 uint32_t ScreenManagerTest::defaultHeight_ = 320;
69 
SetUpTestCase()70 void ScreenManagerTest::SetUpTestCase()
71 {
72     defaultDisplay_ = DisplayManager::GetInstance().GetDefaultDisplay();
73     defaultWidth_ = defaultDisplay_->GetWidth();
74     defaultHeight_ = defaultDisplay_->GetHeight();
75 }
76 
TearDownTestCase()77 void ScreenManagerTest::TearDownTestCase()
78 {
79 }
80 
SetUp()81 void ScreenManagerTest::SetUp()
82 {
83 }
84 
TearDown()85 void ScreenManagerTest::TearDown()
86 {
87 }
88 
89 namespace {
90 /**
91  * @tc.name: CreateAndDestroy01
92  * @tc.desc: CreateVirtualScreen with invalid option and return invalid screen id
93  * @tc.type: FUNC
94  */
95 HWTEST_F(ScreenManagerTest, CreateAndDestroy01, Function | SmallTest | Level1)
96 {
97     VirtualScreenOption wrongOption = {defaultName_, defaultWidth_, defaultHeight_,
98                                        defaultDensity_, nullptr, defaultFlags_};
99     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
100     EXPECT_CALL(m->Mock(), CreateVirtualScreen(_, _)).Times(1).WillOnce(Return(SCREEN_ID_INVALID));
101     EXPECT_CALL(m->Mock(), DestroyVirtualScreen(_)).Times(1).WillOnce(Return(DMError::DM_ERROR_INVALID_PARAM));
102     ScreenId id = ScreenManager::GetInstance().CreateVirtualScreen(wrongOption);
103     DMError ret = ScreenManager::GetInstance().DestroyVirtualScreen(id);
104     ASSERT_EQ(SCREEN_ID_INVALID, id);
105     ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ret);
106 }
107 
108 /**
109  * @tc.name: CreateAndDestroy02
110  * @tc.desc: CreateVirtualScreen with valid option and return valid screen id
111  * @tc.type: FUNC
112  */
113 HWTEST_F(ScreenManagerTest, CreateAndDestroy02, Function | SmallTest | Level1)
114 {
115     ScreenManagerUtils utils;
116     ASSERT_TRUE(utils.CreateSurface());
117     VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
118                                          defaultDensity_, utils.psurface_, defaultFlags_};
119     ScreenId validId = 0;
120     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
121     EXPECT_CALL(m->Mock(), CreateVirtualScreen(_, _)).Times(1).WillOnce(Return(validId));
122     EXPECT_CALL(m->Mock(), DestroyVirtualScreen(_)).Times(1).WillOnce(Return(DMError::DM_OK));
123     ScreenId id = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
124     DMError ret = ScreenManager::GetInstance().DestroyVirtualScreen(id);
125     ASSERT_EQ(validId, id);
126     ASSERT_EQ(DMError::DM_OK, ret);
127 }
128 
129 /**
130  * @tc.name: MakeExpand_001
131  * @tc.desc: Create a virtual screen as expansion of default screen, return default screen id
132  * @tc.type: FUNC
133  */
134 HWTEST_F(ScreenManagerTest, MakeExpand_001, Function | SmallTest | Level1)
135 {
136     ScreenManagerUtils utils;
137     ASSERT_TRUE(utils.CreateSurface());
138     VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
139                                          defaultDensity_, utils.psurface_, defaultFlags_};
140     ScreenId validId = 0; // default srceenId(0)
141     ScreenId virtualScreenId = 1; // VirtualScreen is the second screen(1)
142     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
143     EXPECT_CALL(m->Mock(), CreateVirtualScreen(_, _)).Times(1).WillOnce(Return(virtualScreenId));
144     EXPECT_CALL(m->Mock(), DestroyVirtualScreen(_)).Times(1).WillOnce(Return(DMError::DM_OK));
145     EXPECT_CALL(m->Mock(), MakeExpand(_, _, _)).Times(1).WillOnce(Return(DMError::DM_OK));
146     ScreenId vScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
147     std::vector<ExpandOption> options = {{validId, 0, 0}, {vScreenId, defaultWidth_, 0}};
148     ScreenId expansionId;
149     ScreenManager::GetInstance().MakeExpand(options, expansionId);
150     ASSERT_EQ(expansionId, validId);
151     DMError ret = ScreenManager::GetInstance().DestroyVirtualScreen(vScreenId);
152     ASSERT_EQ(vScreenId, virtualScreenId);
153     ASSERT_EQ(DMError::DM_OK, ret);
154 }
155 
156 /**
157  * @tc.name: MakeExpand_002
158  * @tc.desc: Makepand with empty ExpandOption, return SCREEN_ID_INVALID
159  * @tc.type: FUNC
160  */
161 HWTEST_F(ScreenManagerTest, MakeExpand_002, Function | SmallTest | Level1)
162 {
163     ScreenId invalidId = SCREEN_ID_INVALID;
164     std::vector<ExpandOption> options = {};
165     ScreenId expansionId = SCREEN_ID_INVALID;
166     ScreenManager::GetInstance().MakeExpand(options, expansionId);
167     ASSERT_EQ(expansionId, invalidId);
168 }
169 
170 /**
171  * @tc.name: MakeExpand_003
172  * @tc.desc: Makepand with ExpandOption.size() > MAX_SCREEN_SIZE, return SCREEN_ID_INVALID
173  * @tc.type: FUNC
174  */
175 HWTEST_F(ScreenManagerTest, MakeExpand_003, Function | SmallTest | Level1)
176 {
177     std::vector<ExpandOption> options = {};
178     for (uint32_t i = 0; i < 33; ++i){ // MAX_SCREEN_SIZE + 1
179         ExpandOption option;
180         option.screenId_ = i;
181         options.emplace_back(option);
182     }
183     ScreenId screemGroupId;
184     DMError error = ScreenManager::GetInstance().MakeExpand(options, screemGroupId);
185     EXPECT_EQ(error, DMError::DM_ERROR_INVALID_PARAM);
186 }
187 
188 /**
189  * @tc.name: SetSurface01
190  * @tc.desc: SetVirtualScreenSurface with valid option and return success
191  * @tc.type: FUNC
192  */
193 HWTEST_F(ScreenManagerTest, SetSurface01, Function | SmallTest | Level1)
194 {
195     ScreenManagerUtils utils;
196     ASSERT_TRUE(utils.CreateSurface());
197     VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
198                                          defaultDensity_, nullptr, defaultFlags_};
199     ScreenId validId = 0;
200     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
201     EXPECT_CALL(m->Mock(), CreateVirtualScreen(_, _)).Times(1).WillOnce(Return(validId));
202     EXPECT_CALL(m->Mock(), SetVirtualScreenSurface(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
203     EXPECT_CALL(m->Mock(), DestroyVirtualScreen(_)).Times(1).WillOnce(Return(DMError::DM_OK));
204     ScreenId id = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
205     DMError surfaceRes = ScreenManager::GetInstance().SetVirtualScreenSurface(id, utils.psurface_);
206     DMError destroyRes = ScreenManager::GetInstance().DestroyVirtualScreen(id);
207     ASSERT_EQ(validId, id);
208     ASSERT_EQ(DMError::DM_OK, surfaceRes);
209     ASSERT_EQ(DMError::DM_OK, destroyRes);
210 }
211 
212 /**
213  * @tc.name: SetSurface02
214  * @tc.desc: SetVirtualScreenSurface with invalid option and return failed
215  * @tc.type: FUNC
216  */
217 HWTEST_F(ScreenManagerTest, SetSurface02, Function | SmallTest | Level1)
218 {
219     ScreenManagerUtils utils;
220     ASSERT_TRUE(utils.CreateSurface());
221     VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
222                                          defaultDensity_, nullptr, defaultFlags_};
223     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
224     EXPECT_CALL(m->Mock(), CreateVirtualScreen(_, _)).Times(1).WillOnce(Return(SCREEN_ID_INVALID));
225     EXPECT_CALL(m->Mock(), SetVirtualScreenSurface(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_INVALID_PARAM));
226     EXPECT_CALL(m->Mock(), DestroyVirtualScreen(_)).Times(1).WillOnce(Return(DMError::DM_ERROR_INVALID_PARAM));
227     ScreenId id = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
228     DMError surfaceRes = ScreenManager::GetInstance().SetVirtualScreenSurface(id, utils.psurface_);
229     DMError destroyRes = ScreenManager::GetInstance().DestroyVirtualScreen(id);
230     ASSERT_EQ(SCREEN_ID_INVALID, id);
231     ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, surfaceRes);
232     ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, destroyRes);
233 }
234 
235 /**
236  * @tc.name: OnScreenConnect01
237  * @tc.desc: OnScreenConnect
238  * @tc.type: FUNC
239  */
240 HWTEST_F(ScreenManagerTest, OnScreenConnect01, Function | SmallTest | Level1)
241 {
242     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
243     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
244     sptr<ScreenManager::IScreenListener> listener = new DmMockScreenListener();
245     ScreenManager::GetInstance().RegisterScreenListener(listener);
246     auto screenManagerListener = ScreenManager::GetInstance().pImpl_->screenManagerListener_;
247     ASSERT_NE(screenManagerListener, nullptr);
248     screenManagerListener->OnScreenConnect(nullptr);
249     sptr<ScreenInfo> screenInfo = new ScreenInfo();
250     screenInfo->SetScreenId(SCREEN_ID_INVALID);
251     screenManagerListener->OnScreenConnect(screenInfo);
252     screenInfo->SetScreenId(0);
253     screenManagerListener->OnScreenConnect(screenInfo);
254     ASSERT_NE(screenManagerListener->pImpl_, nullptr);
255     screenManagerListener->pImpl_ = nullptr;
256     screenManagerListener->OnScreenConnect(screenInfo);
257     ScreenManager::GetInstance().pImpl_->screenManagerListener_ = nullptr;
258 }
259 
260 /**
261  * @tc.name: OnScreenDisconnect01
262  * @tc.desc: OnScreenDisconnect
263  * @tc.type: FUNC
264  */
265 HWTEST_F(ScreenManagerTest, OnScreenDisconnect01, Function | SmallTest | Level1)
266 {
267     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
268     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
269     sptr<ScreenManager::IScreenListener> listener = new DmMockScreenListener();
270     ScreenManager::GetInstance().RegisterScreenListener(listener);
271     auto screenManagerListener = ScreenManager::GetInstance().pImpl_->screenManagerListener_;
272     ASSERT_NE(screenManagerListener, nullptr);
273     screenManagerListener->OnScreenDisconnect(SCREEN_ID_INVALID);
274     ASSERT_NE(screenManagerListener->pImpl_, nullptr);
275     screenManagerListener->OnScreenDisconnect(0);
276     screenManagerListener->pImpl_ = nullptr;
277     screenManagerListener->OnScreenDisconnect(0);
278     ScreenManager::GetInstance().pImpl_->screenManagerListener_ = nullptr;
279 }
280 
281 /**
282  * @tc.name: OnScreenChange01
283  * @tc.desc: OnScreenChange
284  * @tc.type: FUNC
285  */
286 HWTEST_F(ScreenManagerTest, OnScreenChange01, Function | SmallTest | Level1)
287 {
288     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
289     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
290     sptr<ScreenManager::IScreenListener> listener = new DmMockScreenListener();
291     ScreenManager::GetInstance().RegisterScreenListener(listener);
292     auto screenManagerListener = ScreenManager::GetInstance().pImpl_->screenManagerListener_;
293     ASSERT_NE(screenManagerListener, nullptr);
294     screenManagerListener->OnScreenChange(nullptr, ScreenChangeEvent::UPDATE_ORIENTATION);
295     ASSERT_NE(screenManagerListener->pImpl_, nullptr);
296     sptr<ScreenInfo> screenInfo = new ScreenInfo();
297     screenManagerListener->OnScreenChange(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
298     screenManagerListener->pImpl_ = nullptr;
299     screenManagerListener->OnScreenChange(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
300     ScreenManager::GetInstance().pImpl_->screenManagerListener_ = nullptr;
301 }
302 
303 /**
304  * @tc.name: OnScreenGroupChange01
305  * @tc.desc: OnScreenGroupChange
306  * @tc.type: FUNC
307  */
308 HWTEST_F(ScreenManagerTest, OnScreenGroupChange01, Function | SmallTest | Level1)
309 {
310     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
311     EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
312     sptr<ScreenManager::IScreenListener> listener = new DmMockScreenListener();
313     ScreenManager::GetInstance().RegisterScreenListener(listener);
314     auto screenManagerListener = ScreenManager::GetInstance().pImpl_->screenManagerListener_;
315     ASSERT_NE(screenManagerListener, nullptr);
316     std::string trigger;
317     std::vector<sptr<ScreenInfo>> screenInfos;
318     ScreenGroupChangeEvent groupEvent = ScreenGroupChangeEvent::CHANGE_GROUP;
319     screenManagerListener->OnScreenGroupChange(trigger, screenInfos, groupEvent);
320     ASSERT_NE(screenManagerListener->pImpl_, nullptr);
321     sptr<ScreenInfo> screenInfo = new ScreenInfo();
322     screenInfo->SetScreenId(1);
323     sptr<ScreenInfo> screenInfo2 = new ScreenInfo();
324     screenInfos.emplace_back(screenInfo);
325     screenInfos.emplace_back(screenInfo2);
326     screenManagerListener->OnScreenGroupChange(trigger, screenInfos, groupEvent);
327     screenManagerListener->pImpl_ = nullptr;
328     screenManagerListener->OnScreenGroupChange(trigger, screenInfos, groupEvent);
329     ScreenManager::GetInstance().pImpl_->screenManagerListener_ = nullptr;
330 }
331 /**
332  * @tc.name: RemoveVirtualScreenFromGroup
333  * @tc.desc: for interface coverage & check func RemoveVirtualScreenFromGroup
334  * @tc.type: FUNC
335  */
336 HWTEST_F(ScreenManagerTest, RemoveVirtualScreenFromGroup, Function | SmallTest | Level1)
337 {
338     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
339     std::vector<ScreenId> testScreens(33, 1);
340     auto result = ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(testScreens);
341     ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, result);
342 
343     testScreens.clear();
344     result = ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(testScreens);
345     ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, result);
346 
347     testScreens.emplace_back(static_cast<ScreenId>(1));
348     EXPECT_CALL(m->Mock(), RemoveVirtualScreenFromGroup(_)).Times(1);
349     result = ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(testScreens);
350     ASSERT_EQ(DMError::DM_OK, result);
351 }
352 /**
353  * @tc.name: SetScreenRotationLocked
354  * @tc.desc: for interface coverage & check SetScreenRotationLocked
355  * @tc.type: FUNC
356  */
357 HWTEST_F(ScreenManagerTest, SetScreenRotationLocked, Function | SmallTest | Level1)
358 {
359     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
360 
361     EXPECT_CALL(m->Mock(), SetScreenRotationLocked(_)).Times(1);
362     auto result = ScreenManager::GetInstance().SetScreenRotationLocked(true);
363     ASSERT_EQ(DMError::DM_OK, result);
364 }
365 
366 /**
367  * @tc.name: IsScreenRotationLocked
368  * @tc.desc: for interface coverage & check IsScreenRotationLocked
369  * @tc.type: FUNC
370  */
371 HWTEST_F(ScreenManagerTest, IsScreenRotationLocked, Function | SmallTest | Level1)
372 {
373     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
374 
375     EXPECT_CALL(m->Mock(), IsScreenRotationLocked(_)).Times(1).WillOnce(Return(DMError::DM_OK));
376     bool result;
377     DMError ret;
378     ret = ScreenManager::GetInstance().IsScreenRotationLocked(result);
379     ASSERT_EQ(DMError::DM_OK, ret);
380     EXPECT_CALL(m->Mock(), IsScreenRotationLocked(_)).Times(1).WillOnce(Return(DMError::DM_ERROR_NULLPTR));
381     ret = ScreenManager::GetInstance().IsScreenRotationLocked(result);
382     ASSERT_TRUE(DMError::DM_OK != ret);
383 }
384 
385 /**
386  * @tc.name: RegisterScreenGroupListener
387  * @tc.desc: for interface coverage and
388  *           check RegisterScreenGroupListener & UnregisterScreenGroupListener
389  * @tc.type: FUNC
390  */
391 HWTEST_F(ScreenManagerTest, RegisterScreenGroupListener, Function | SmallTest | Level1)
392 {
393     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
394     auto& screenManager = ScreenManager::GetInstance();
395     auto result = screenManager.RegisterScreenGroupListener(nullptr);
396     ASSERT_TRUE(DMError::DM_OK != result);
397 
398     sptr<ScreenManager::IScreenGroupListener> listener = new (std::nothrow)TestScreenGroupListener();
399     if (screenManager.pImpl_->screenManagerListener_ == nullptr) {
400         EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
401     }
402     result = screenManager.RegisterScreenGroupListener(listener);
403     ASSERT_EQ(DMError::DM_OK, result);
404 
405     result = screenManager.UnregisterScreenGroupListener(nullptr);
406     ASSERT_TRUE(DMError::DM_OK != result);
407 
408     auto sizeScreen = screenManager.pImpl_->screenListeners_.size();
409     auto sizeScreenGroup = screenManager.pImpl_->screenGroupListeners_.size();
410     auto sizeVirtualScreen = screenManager.pImpl_->virtualScreenGroupListeners_.size();
411     if (sizeScreenGroup > 1) {
412         result = screenManager.UnregisterScreenGroupListener(listener);
413         ASSERT_EQ(DMError::DM_OK, result);
414     } else if (sizeScreenGroup == 1) {
415         if (sizeScreen == 0 && sizeVirtualScreen == 0) {
416             EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
417         }
418         result = screenManager.UnregisterScreenGroupListener(listener);
419         ASSERT_EQ(DMError::DM_OK, result);
420     }
421 }
422 /**
423  * @tc.name: RegisterVirtualScreenGroupListener
424  * @tc.desc: for interface coverage and
425  *           check RegisterVirtualScreenGroupListener & UnregisterVirtualScreenGroupListener
426  * @tc.type: FUNC
427  */
428 HWTEST_F(ScreenManagerTest, RegisterVirtualScreenGroupListener, Function | SmallTest | Level1)
429 {
430     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
431     auto& screenManager = ScreenManager::GetInstance();
432     auto result = screenManager.RegisterVirtualScreenGroupListener(nullptr);
433     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, result);
434 
435     sptr<ScreenManager::IVirtualScreenGroupListener> listener = new (std::nothrow)TestIVirtualScreenGroupListener();
436     if (screenManager.pImpl_->screenManagerListener_ == nullptr) {
437         EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
438     }
439     result = screenManager.RegisterVirtualScreenGroupListener(listener);
440     ASSERT_EQ(DMError::DM_OK, result);
441 
442     result = screenManager.UnregisterVirtualScreenGroupListener(nullptr);
443     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, result);
444 
445     auto sizeScreen = screenManager.pImpl_->screenListeners_.size();
446     auto sizeScreenGroup = screenManager.pImpl_->screenGroupListeners_.size();
447     auto sizeVirtualScreen = screenManager.pImpl_->virtualScreenGroupListeners_.size();
448 
449     if (sizeVirtualScreen > 1) {
450         result = screenManager.UnregisterVirtualScreenGroupListener(listener);
451         ASSERT_EQ(DMError::DM_OK, result);
452     } else if (sizeVirtualScreen == 1) {
453         if (sizeScreen == 0 && sizeScreenGroup == 0) {
454             EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
455         }
456         result = screenManager.UnregisterVirtualScreenGroupListener(listener);
457         ASSERT_EQ(DMError::DM_OK, result);
458     }
459 }
460 
461 /**
462  * @tc.name: StopExpand_001
463  * @tc.desc: StopExpand_001 id
464  * @tc.type: FUNC
465  */
466 HWTEST_F(ScreenManagerTest, StopExpand_001, Function | SmallTest | Level1)
467 {
468     std::vector<ScreenId> screenIds;
469     ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().StopExpand(screenIds));
470     std::vector<ScreenId> expandScreenIds {0, 1, 2, 3, 4, 5};
471     DMError err = SingletonContainer::Get<ScreenManagerAdapter>().StopExpand(expandScreenIds);
472     ASSERT_EQ(DMError::DM_OK, err);
473 }
474 
475 /**
476  * @tc.name: StopMirror
477  * @tc.desc: StopMirror id
478  * @tc.type: FUNC
479  */
480 HWTEST_F(ScreenManagerTest, StopMirror, Function | SmallTest | Level1)
481 {
482     ScreenManagerUtils utils;
483     ASSERT_TRUE(utils.CreateSurface());
484     std::vector<ScreenId> screenIds;
485     ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().StopMirror(screenIds));
486     std::vector<ScreenId> mirrorScreenIds1 {0, 1, 2, 3, 4, 5};
487     DMError err = SingletonContainer::Get<ScreenManagerAdapter>().StopMirror(mirrorScreenIds1);
488     ASSERT_EQ(DMError::DM_OK, err);
489     std::vector<ScreenId> mirrorScreenIds2 {};
490     err = SingletonContainer::Get<ScreenManagerAdapter>().StopMirror(mirrorScreenIds2);
491     ASSERT_EQ(DMError::DM_OK, err);
492 }
493 
494 /**
495  * @tc.name: RegisterVirtualScreenGroupListener02
496  * @tc.desc: RegisterVirtualScreenGroupListener02 fun
497  * @tc.type: FUNC
498  */
499 HWTEST_F(ScreenManagerTest, RegisterVirtualScreenGroupListener02, Function | SmallTest | Level1)
500 {
501     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
502     auto& screenManager = ScreenManager::GetInstance();
503     auto result = screenManager.RegisterVirtualScreenGroupListener(nullptr);
504     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, result);
505     sptr<ScreenManager::IVirtualScreenGroupListener> listener = new (std::nothrow)TestIVirtualScreenGroupListener();
506     if (screenManager.pImpl_->screenManagerListener_ == nullptr) {
507         EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
508     }
509     result = ScreenManager::GetInstance().RegisterVirtualScreenGroupListener(listener);
510     ASSERT_EQ(DMError::DM_OK, result);
511 }
512 
513 /**
514  * @tc.name: SetVirtualScreenFlag01
515  * @tc.desc: SetVirtualScreenFlag01 cast flag
516  * @tc.type: FUNC
517  */
518 HWTEST_F(ScreenManagerTest, SetVirtualScreenFlag01, Function | SmallTest | Level1)
519 {
520     VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
521                                          defaultDensity_, nullptr, defaultFlags_};
522     ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
523     DMError ret = ScreenManager::GetInstance().SetVirtualScreenFlag(screenId, VirtualScreenFlag::CAST);
524     if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
525         ASSERT_EQ(DMError::DM_ERROR_DEVICE_NOT_SUPPORT, ret);
526     } else {
527         ASSERT_EQ(DMError::DM_OK, ret);
528         ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
529         ASSERT_EQ(DMError::DM_OK, ret);
530     }
531 }
532 
533 /**
534  * @tc.name: SetVirtualScreenFlag02
535  * @tc.desc: SetVirtualScreenFlag02 max flag
536  * @tc.type: FUNC
537  */
538 HWTEST_F(ScreenManagerTest, SetVirtualScreenFlag02, Function | SmallTest | Level1)
539 {
540     VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
541                                          defaultDensity_, nullptr, defaultFlags_};
542     ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
543     DMError ret = ScreenManager::GetInstance().SetVirtualScreenFlag(screenId, VirtualScreenFlag::MAX);
544     ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ret);
545     ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
546     ASSERT_EQ(DMError::DM_OK, ret);
547 }
548 
549 /**
550  * @tc.name: GetVirtualScreenFlag01
551  * @tc.desc: GetVirtualScreenFlag01 get cast
552  * @tc.type: FUNC
553  */
554 HWTEST_F(ScreenManagerTest, GetVirtualScreenFlag01, Function | SmallTest | Level1)
555 {
556     VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
557                                          defaultDensity_, nullptr, defaultFlags_};
558     ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
559     DMError ret = ScreenManager::GetInstance().SetVirtualScreenFlag(screenId, VirtualScreenFlag::CAST);
560     if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
561         ASSERT_EQ(DMError::DM_ERROR_DEVICE_NOT_SUPPORT, ret);
562     } else {
563         ASSERT_EQ(DMError::DM_OK, ret);
564         VirtualScreenFlag screenFlag = ScreenManager::GetInstance().GetVirtualScreenFlag(screenId);
565         ASSERT_EQ(VirtualScreenFlag::CAST, screenFlag);
566         ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
567         ASSERT_EQ(DMError::DM_OK, ret);
568     }
569 }
570 
571 /**
572  * @tc.name: SetVirtualMirrorScreenScaleMode01
573  * @tc.desc: SetVirtualMirrorScreenScaleMode01 fun
574  * @tc.type: FUNC
575  */
576 HWTEST_F(ScreenManagerTest, SetVirtualMirrorScreenScaleMode01, Function | SmallTest | Level1)
577 {
578     VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
579                                          defaultDensity_, nullptr, defaultFlags_};
580     ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
581     DMError ret = ScreenManager::GetInstance().SetVirtualMirrorScreenScaleMode(screenId,
582         ScreenScaleMode::FILL_MODE);
583     if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
584         ASSERT_EQ(DMError::DM_ERROR_DEVICE_NOT_SUPPORT, ret);
585     } else {
586         ASSERT_EQ(DMError::DM_OK, ret);
587         ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
588         ASSERT_EQ(DMError::DM_OK, ret);
589     }
590 }
591 
592 /**
593  * @tc.name: SetVirtualMirrorScreenScaleMode02
594  * @tc.desc: SetVirtualMirrorScreenScaleMode02 fun
595  * @tc.type: FUNC
596  */
597 HWTEST_F(ScreenManagerTest, SetVirtualMirrorScreenScaleMode02, Function | SmallTest | Level1)
598 {
599     VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
600                                          defaultDensity_, nullptr, defaultFlags_};
601     ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
602     DMError ret = ScreenManager::GetInstance().SetVirtualMirrorScreenScaleMode(screenId,
603         ScreenScaleMode::UNISCALE_MODE);
604     if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
605         ASSERT_EQ(DMError::DM_ERROR_DEVICE_NOT_SUPPORT, ret);
606     } else {
607         ASSERT_EQ(DMError::DM_OK, ret);
608         ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
609         ASSERT_EQ(DMError::DM_OK, ret);
610     }
611 }
612 
613 /**
614  * @tc.name: IsCaptured02
615  * @tc.desc: IsCaptured02 fun
616  * @tc.type: FUNC
617  */
618 HWTEST_F(ScreenManagerTest, IsCaptured02, Function | SmallTest | Level1)
619 {
620     VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
621                                          defaultDensity_, nullptr, defaultFlags_};
622     ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
623     bool isCapture = DisplayManager::GetInstance().IsCaptured();
624     if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
625         ASSERT_FALSE(isCapture);
626     } else {
627         ASSERT_TRUE(isCapture);
628         auto ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
629         ASSERT_EQ(DMError::DM_OK, ret);
630     }
631 }
632 
633 /**
634  * @tc.name: IsCaptured03
635  * @tc.desc: IsCaptured03 fun
636  * @tc.type: FUNC
637  */
638 HWTEST_F(ScreenManagerTest, IsCaptured03, Function | SmallTest | Level1)
639 {
640     VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
641                                          defaultDensity_, nullptr, defaultFlags_};
642     ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
643     auto ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
644     ASSERT_EQ(DMError::DM_OK, ret);
645     bool isCapture = DisplayManager::GetInstance().IsCaptured();
646     ASSERT_FALSE(isCapture);
647 }
648 
649 /**
650  * @tc.name: UnregisterScreenListener
651  * @tc.desc: UnregisterScreenListener fun
652  * @tc.type: FUNC
653  */
654 HWTEST_F(ScreenManagerTest, UnregisterScreenListener, Function | SmallTest | Level1)
655 {
656     auto ret = ScreenManager::GetInstance().UnregisterScreenListener(nullptr);
657     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
658 }
659 
660 /**
661  * @tc.name: RegisterScreenListener
662  * @tc.desc: RegisterScreenListener fun
663  * @tc.type: FUNC
664  */
665 HWTEST_F(ScreenManagerTest, RegisterScreenListener, Function | SmallTest | Level1)
666 {
667     auto ret = ScreenManager::GetInstance().RegisterScreenListener(nullptr);
668     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
669 }
670 
671 /**
672  * @tc.name: UnregisterVirtualScreenGroupListener
673  * @tc.desc: UnregisterVirtualScreenGroupListener fun
674  * @tc.type: FUNC
675  */
676 HWTEST_F(ScreenManagerTest, UnregisterVirtualScreenGroupListener, Function | SmallTest | Level1)
677 {
678     auto ret = ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(nullptr);
679     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
680 }
681 
682 /**
683  * @tc.name: MakeUniqueScreen_001
684  * @tc.desc: MakeUniqueScreen_001 fun
685  * @tc.type: FUNC
686  */
687 HWTEST_F(ScreenManagerTest, MakeUniqueScreen_001, Function | SmallTest | Level1)
688 {
689     std::vector<ScreenId> screenIds;
690     DMError error = ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
691     ASSERT_EQ(error, DMError::DM_ERROR_INVALID_PARAM);
692 }
693 
694 /**
695  * @tc.name: MakeUniqueScreen_002
696  * @tc.desc: MakeUniqueScreen_002 fun
697  * @tc.type: FUNC
698  */
699 HWTEST_F(ScreenManagerTest, MakeUniqueScreen_002, Function | SmallTest | Level1)
700 {
701     std::vector<ScreenId> screenIds;
702     for (uint32_t i = 0; i < 33; ++i){ // MAX_SCREEN_SIZE + 1
703         screenIds.emplace_back(i);
704     }
705     DMError error = ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
706     ASSERT_EQ(error, DMError::DM_ERROR_INVALID_PARAM);
707 }
708 
709 /**
710  * @tc.name: MakeUniqueScreen_003
711  * @tc.desc: MakeUniqueScreen_003 fun
712  * @tc.type: FUNC
713  */
714 HWTEST_F(ScreenManagerTest, MakeUniqueScreen_003, Function | SmallTest | Level1)
715 {
716     std::vector<ScreenId> screenIds;
717     for (uint32_t i = 0; i < 32; ++i){ // MAX_SCREEN_SIZE
718         screenIds.emplace_back(i);
719     }
720     DMError error = ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
721     ASSERT_NE(error, DMError::DM_ERROR_INVALID_PARAM);
722 }
723 
724 /**
725  * @tc.name: MakeMirror_001
726  * @tc.desc: MakeMirror_001 fun
727  * @tc.type: FUNC
728  */
729 HWTEST_F(ScreenManagerTest, MakeMirror_001, Function | SmallTest | Level1)
730 {
731     std::vector<ScreenId> mirrorScreenId;
732     for (uint32_t i = 0; i < 33; ++i){ // MAX_SCREEN_SIZE + 1
733         mirrorScreenId.emplace_back(i);
734     }
735     ScreenId ScreenGroupId;
736     DMError error = ScreenManager::GetInstance().MakeMirror(1, mirrorScreenId, ScreenGroupId);
737     ASSERT_EQ(error, DMError::DM_ERROR_INVALID_PARAM);
738 }
739 
740 /**
741  * @tc.name: StopExpand
742  * @tc.desc: StopExpand fun
743  * @tc.type: FUNC
744  */
745 HWTEST_F(ScreenManagerTest, StopExpand, Function | SmallTest | Level1)
746 {
747     std::vector<ScreenId> expandScreenIds;
748     for (uint32_t i = 0; i < 33; ++i){ // MAX_SCREEN_SIZE + 1
749         expandScreenIds.emplace_back(i);
750     }
751     DMError error = ScreenManager::GetInstance().StopExpand(expandScreenIds);
752     ASSERT_EQ(error, DMError::DM_OK);
753 }
754 
755 /**
756  * @tc.name: GetScreenInfoSrting
757  * @tc.desc: GetScreenInfoSrting fun
758  * @tc.type: FUNC
759  */
760 HWTEST_F(ScreenManagerTest, GetScreenInfoSrting, Function | SmallTest | Level1)
761 {
762     sptr<ScreenInfo> screenInfo = nullptr;
763     auto result =ScreenManager::GetInstance().pImpl_->GetScreenInfoSrting(screenInfo);
764     EXPECT_EQ(result, "");
765 }
766 }
767 } // namespace Rosen
768 } // namespace OHOS