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
27using namespace testing;
28using namespace testing::ext;
29
30namespace OHOS {
31namespace Rosen {
32using Mocker = SingletonMocker<ScreenManagerAdapter, MockScreenManagerAdapter>;
33class DmMockScreenListener : public ScreenManager::IScreenListener {
34public:
35    void OnConnect(ScreenId) override {}
36    void OnDisconnect(ScreenId) override {}
37    void OnChange(ScreenId) override {}
38};
39
40class TestScreenGroupListener : public ScreenManager::IScreenGroupListener {
41public:
42    void OnChange(const std::vector<ScreenId>&, ScreenGroupChangeEvent) override {};
43};
44
45class TestIVirtualScreenGroupListener : public ScreenManager::IVirtualScreenGroupListener {
46public:
47    void OnMirrorChange(const ChangeInfo& info) override {};
48};
49class ScreenManagerTest : public testing::Test {
50public:
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};
66sptr<Display> ScreenManagerTest::defaultDisplay_ = nullptr;
67uint32_t ScreenManagerTest::defaultWidth_ = 480;
68uint32_t ScreenManagerTest::defaultHeight_ = 320;
69
70void ScreenManagerTest::SetUpTestCase()
71{
72    defaultDisplay_ = DisplayManager::GetInstance().GetDefaultDisplay();
73    defaultWidth_ = defaultDisplay_->GetWidth();
74    defaultHeight_ = defaultDisplay_->GetHeight();
75}
76
77void ScreenManagerTest::TearDownTestCase()
78{
79}
80
81void ScreenManagerTest::SetUp()
82{
83}
84
85void ScreenManagerTest::TearDown()
86{
87}
88
89namespace {
90/**
91 * @tc.name: CreateAndDestroy01
92 * @tc.desc: CreateVirtualScreen with invalid option and return invalid screen id
93 * @tc.type: FUNC
94 */
95HWTEST_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 */
113HWTEST_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 */
134HWTEST_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 */
161HWTEST_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 */
175HWTEST_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 */
193HWTEST_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 */
217HWTEST_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 */
240HWTEST_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 */
265HWTEST_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 */
286HWTEST_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 */
308HWTEST_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 */
336HWTEST_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 */
357HWTEST_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 */
371HWTEST_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 */
391HWTEST_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 */
428HWTEST_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 */
466HWTEST_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 */
480HWTEST_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 */
499HWTEST_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 */
518HWTEST_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 */
538HWTEST_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 */
554HWTEST_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 */
576HWTEST_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 */
597HWTEST_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 */
618HWTEST_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 */
638HWTEST_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 */
654HWTEST_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 */
665HWTEST_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 */
676HWTEST_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 */
687HWTEST_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 */
699HWTEST_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 */
714HWTEST_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 */
729HWTEST_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 */
745HWTEST_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 */
760HWTEST_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