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 /**
333 * @tc.name: RemoveVirtualScreenFromGroup
334 * @tc.desc: for interface coverage & check func RemoveVirtualScreenFromGroup
335 * @tc.type: FUNC
336 */
337 HWTEST_F(ScreenManagerTest, RemoveVirtualScreenFromGroup, Function | SmallTest | Level1)
338 {
339 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
340 std::vector<ScreenId> testScreens(33, 1);
341 auto result = ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(testScreens);
342 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, result);
343
344 testScreens.clear();
345 result = ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(testScreens);
346 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, result);
347
348 testScreens.emplace_back(static_cast<ScreenId>(1));
349 EXPECT_CALL(m->Mock(), RemoveVirtualScreenFromGroup(_)).Times(1);
350 result = ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(testScreens);
351 ASSERT_EQ(DMError::DM_OK, result);
352 }
353
354 /**
355 * @tc.name: SetScreenRotationLocked
356 * @tc.desc: for interface coverage & check SetScreenRotationLocked
357 * @tc.type: FUNC
358 */
359 HWTEST_F(ScreenManagerTest, SetScreenRotationLocked, Function | SmallTest | Level1)
360 {
361 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
362
363 EXPECT_CALL(m->Mock(), SetScreenRotationLocked(_)).Times(1);
364 auto result = ScreenManager::GetInstance().SetScreenRotationLocked(true);
365 ASSERT_EQ(DMError::DM_OK, result);
366 }
367
368 /**
369 * @tc.name: IsScreenRotationLocked
370 * @tc.desc: for interface coverage & check IsScreenRotationLocked
371 * @tc.type: FUNC
372 */
373 HWTEST_F(ScreenManagerTest, IsScreenRotationLocked, Function | SmallTest | Level1)
374 {
375 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
376
377 EXPECT_CALL(m->Mock(), IsScreenRotationLocked(_)).Times(1).WillOnce(Return(DMError::DM_OK));
378 bool result;
379 DMError ret;
380 ret = ScreenManager::GetInstance().IsScreenRotationLocked(result);
381 ASSERT_EQ(DMError::DM_OK, ret);
382 EXPECT_CALL(m->Mock(), IsScreenRotationLocked(_)).Times(1).WillOnce(Return(DMError::DM_ERROR_NULLPTR));
383 ret = ScreenManager::GetInstance().IsScreenRotationLocked(result);
384 ASSERT_TRUE(DMError::DM_OK != ret);
385 }
386
387 /**
388 * @tc.name: RegisterScreenGroupListener
389 * @tc.desc: for interface coverage and
390 * check RegisterScreenGroupListener & UnregisterScreenGroupListener
391 * @tc.type: FUNC
392 */
393 HWTEST_F(ScreenManagerTest, RegisterScreenGroupListener, Function | SmallTest | Level1)
394 {
395 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
396 auto& screenManager = ScreenManager::GetInstance();
397 auto result = screenManager.RegisterScreenGroupListener(nullptr);
398 ASSERT_TRUE(DMError::DM_OK != result);
399
400 sptr<ScreenManager::IScreenGroupListener> listener = new (std::nothrow)TestScreenGroupListener();
401 if (screenManager.pImpl_->screenManagerListener_ == nullptr) {
402 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
403 }
404 result = screenManager.RegisterScreenGroupListener(listener);
405 ASSERT_EQ(DMError::DM_OK, result);
406
407 result = screenManager.UnregisterScreenGroupListener(nullptr);
408 ASSERT_TRUE(DMError::DM_OK != result);
409
410 auto sizeScreen = screenManager.pImpl_->screenListeners_.size();
411 auto sizeScreenGroup = screenManager.pImpl_->screenGroupListeners_.size();
412 auto sizeVirtualScreen = screenManager.pImpl_->virtualScreenGroupListeners_.size();
413 if (sizeScreenGroup > 1) {
414 result = screenManager.UnregisterScreenGroupListener(listener);
415 ASSERT_EQ(DMError::DM_OK, result);
416 } else if (sizeScreenGroup == 1) {
417 if (sizeScreen == 0 && sizeVirtualScreen == 0) {
418 EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
419 }
420 result = screenManager.UnregisterScreenGroupListener(listener);
421 ASSERT_EQ(DMError::DM_OK, result);
422 }
423 }
424
425 /**
426 * @tc.name: RegisterVirtualScreenGroupListener
427 * @tc.desc: for interface coverage and
428 * check RegisterVirtualScreenGroupListener & UnregisterVirtualScreenGroupListener
429 * @tc.type: FUNC
430 */
431 HWTEST_F(ScreenManagerTest, RegisterVirtualScreenGroupListener, Function | SmallTest | Level1)
432 {
433 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
434 auto& screenManager = ScreenManager::GetInstance();
435 auto result = screenManager.RegisterVirtualScreenGroupListener(nullptr);
436 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, result);
437
438 sptr<ScreenManager::IVirtualScreenGroupListener> listener = new (std::nothrow)TestIVirtualScreenGroupListener();
439 if (screenManager.pImpl_->screenManagerListener_ == nullptr) {
440 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
441 }
442 result = screenManager.RegisterVirtualScreenGroupListener(listener);
443 ASSERT_EQ(DMError::DM_OK, result);
444
445 result = screenManager.UnregisterVirtualScreenGroupListener(nullptr);
446 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, result);
447
448 auto sizeScreen = screenManager.pImpl_->screenListeners_.size();
449 auto sizeScreenGroup = screenManager.pImpl_->screenGroupListeners_.size();
450 auto sizeVirtualScreen = screenManager.pImpl_->virtualScreenGroupListeners_.size();
451
452 if (sizeVirtualScreen > 1) {
453 result = screenManager.UnregisterVirtualScreenGroupListener(listener);
454 ASSERT_EQ(DMError::DM_OK, result);
455 } else if (sizeVirtualScreen == 1) {
456 if (sizeScreen == 0 && sizeScreenGroup == 0) {
457 EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
458 }
459 result = screenManager.UnregisterVirtualScreenGroupListener(listener);
460 ASSERT_EQ(DMError::DM_OK, result);
461 }
462 }
463
464 /**
465 * @tc.name: StopExpand_001
466 * @tc.desc: StopExpand_001 id
467 * @tc.type: FUNC
468 */
469 HWTEST_F(ScreenManagerTest, StopExpand_001, Function | SmallTest | Level1)
470 {
471 std::vector<ScreenId> screenIds;
472 ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().StopExpand(screenIds));
473 std::vector<ScreenId> expandScreenIds {0, 1, 2, 3, 4, 5};
474 DMError err = SingletonContainer::Get<ScreenManagerAdapter>().StopExpand(expandScreenIds);
475 ASSERT_EQ(DMError::DM_OK, err);
476 }
477
478 /**
479 * @tc.name: StopMirror
480 * @tc.desc: StopMirror id
481 * @tc.type: FUNC
482 */
483 HWTEST_F(ScreenManagerTest, StopMirror, Function | SmallTest | Level1)
484 {
485 ScreenManagerUtils utils;
486 ASSERT_TRUE(utils.CreateSurface());
487 std::vector<ScreenId> screenIds;
488 ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().StopMirror(screenIds));
489 std::vector<ScreenId> mirrorScreenIds1 {0, 1, 2, 3, 4, 5};
490 DMError err = SingletonContainer::Get<ScreenManagerAdapter>().StopMirror(mirrorScreenIds1);
491 ASSERT_EQ(DMError::DM_OK, err);
492 std::vector<ScreenId> mirrorScreenIds2 {};
493 err = SingletonContainer::Get<ScreenManagerAdapter>().StopMirror(mirrorScreenIds2);
494 ASSERT_EQ(DMError::DM_OK, err);
495 }
496
497 /**
498 * @tc.name: RegisterVirtualScreenGroupListener02
499 * @tc.desc: RegisterVirtualScreenGroupListener02 fun
500 * @tc.type: FUNC
501 */
502 HWTEST_F(ScreenManagerTest, RegisterVirtualScreenGroupListener02, Function | SmallTest | Level1)
503 {
504 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
505 auto& screenManager = ScreenManager::GetInstance();
506 auto result = screenManager.RegisterVirtualScreenGroupListener(nullptr);
507 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, result);
508 sptr<ScreenManager::IVirtualScreenGroupListener> listener = new (std::nothrow)TestIVirtualScreenGroupListener();
509 if (screenManager.pImpl_->screenManagerListener_ == nullptr) {
510 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
511 }
512 result = ScreenManager::GetInstance().RegisterVirtualScreenGroupListener(listener);
513 ASSERT_EQ(DMError::DM_OK, result);
514 }
515
516 /**
517 * @tc.name: SetVirtualScreenFlag01
518 * @tc.desc: SetVirtualScreenFlag01 cast flag
519 * @tc.type: FUNC
520 */
521 HWTEST_F(ScreenManagerTest, SetVirtualScreenFlag01, Function | SmallTest | Level1)
522 {
523 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
524 defaultDensity_, nullptr, defaultFlags_};
525 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
526 DMError ret = ScreenManager::GetInstance().SetVirtualScreenFlag(screenId, VirtualScreenFlag::CAST);
527 ASSERT_EQ(DMError::DM_OK, ret);
528 ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
529 ASSERT_EQ(DMError::DM_OK, ret);
530 }
531
532 /**
533 * @tc.name: SetVirtualScreenFlag02
534 * @tc.desc: SetVirtualScreenFlag02 max flag
535 * @tc.type: FUNC
536 */
537 HWTEST_F(ScreenManagerTest, SetVirtualScreenFlag02, Function | SmallTest | Level1)
538 {
539 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
540 defaultDensity_, nullptr, defaultFlags_};
541 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
542 DMError ret = ScreenManager::GetInstance().SetVirtualScreenFlag(screenId, VirtualScreenFlag::MAX);
543 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ret);
544 ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
545 ASSERT_EQ(DMError::DM_OK, ret);
546 }
547
548 /**
549 * @tc.name: GetVirtualScreenFlag01
550 * @tc.desc: GetVirtualScreenFlag01 get cast
551 * @tc.type: FUNC
552 */
553 HWTEST_F(ScreenManagerTest, GetVirtualScreenFlag01, Function | SmallTest | Level1)
554 {
555 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
556 defaultDensity_, nullptr, defaultFlags_};
557 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
558 DMError ret = ScreenManager::GetInstance().SetVirtualScreenFlag(screenId, VirtualScreenFlag::CAST);
559 ASSERT_EQ(DMError::DM_OK, ret);
560 VirtualScreenFlag screenFlag = ScreenManager::GetInstance().GetVirtualScreenFlag(screenId);
561 ASSERT_EQ(VirtualScreenFlag::CAST, screenFlag);
562 ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
563 ASSERT_EQ(DMError::DM_OK, ret);
564 }
565
566 /**
567 * @tc.name: SetVirtualMirrorScreenScaleMode01
568 * @tc.desc: SetVirtualMirrorScreenScaleMode01 fun
569 * @tc.type: FUNC
570 */
571 HWTEST_F(ScreenManagerTest, SetVirtualMirrorScreenScaleMode01, Function | SmallTest | Level1)
572 {
573 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
574 defaultDensity_, nullptr, defaultFlags_};
575 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
576 DMError ret = ScreenManager::GetInstance().SetVirtualMirrorScreenScaleMode(screenId,
577 ScreenScaleMode::FILL_MODE);
578 ASSERT_EQ(DMError::DM_OK, ret);
579 ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
580 ASSERT_EQ(DMError::DM_OK, ret);
581 }
582
583 /**
584 * @tc.name: SetVirtualMirrorScreenScaleMode02
585 * @tc.desc: SetVirtualMirrorScreenScaleMode02 fun
586 * @tc.type: FUNC
587 */
588 HWTEST_F(ScreenManagerTest, SetVirtualMirrorScreenScaleMode02, Function | SmallTest | Level1)
589 {
590 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
591 defaultDensity_, nullptr, defaultFlags_};
592 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
593 DMError ret = ScreenManager::GetInstance().SetVirtualMirrorScreenScaleMode(screenId,
594 ScreenScaleMode::UNISCALE_MODE);
595 ASSERT_EQ(DMError::DM_OK, ret);
596 ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
597 ASSERT_EQ(DMError::DM_OK, ret);
598 }
599
600 /**
601 * @tc.name: IsCaptured02
602 * @tc.desc: IsCaptured02 fun
603 * @tc.type: FUNC
604 */
605 HWTEST_F(ScreenManagerTest, IsCaptured02, Function | SmallTest | Level1)
606 {
607 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
608 defaultDensity_, nullptr, defaultFlags_};
609 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
610 bool isCapture = DisplayManager::GetInstance().IsCaptured();
611 ASSERT_TRUE(isCapture);
612 auto ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
613 ASSERT_EQ(DMError::DM_OK, ret);
614 }
615
616 /**
617 * @tc.name: IsCaptured03
618 * @tc.desc: IsCaptured03 fun
619 * @tc.type: FUNC
620 */
621 HWTEST_F(ScreenManagerTest, IsCaptured03, Function | SmallTest | Level1)
622 {
623 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
624 defaultDensity_, nullptr, defaultFlags_};
625 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
626 auto ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
627 ASSERT_EQ(DMError::DM_OK, ret);
628 bool isCapture = DisplayManager::GetInstance().IsCaptured();
629 ASSERT_FALSE(isCapture);
630 }
631
632 /**
633 * @tc.name: UnregisterScreenListener
634 * @tc.desc: UnregisterScreenListener fun
635 * @tc.type: FUNC
636 */
637 HWTEST_F(ScreenManagerTest, UnregisterScreenListener, Function | SmallTest | Level1)
638 {
639 auto ret = ScreenManager::GetInstance().UnregisterScreenListener(nullptr);
640 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
641 }
642
643 /**
644 * @tc.name: RegisterScreenListener
645 * @tc.desc: RegisterScreenListener fun
646 * @tc.type: FUNC
647 */
648 HWTEST_F(ScreenManagerTest, RegisterScreenListener, Function | SmallTest | Level1)
649 {
650 auto ret = ScreenManager::GetInstance().RegisterScreenListener(nullptr);
651 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
652 }
653
654 /**
655 * @tc.name: UnregisterVirtualScreenGroupListener
656 * @tc.desc: UnregisterVirtualScreenGroupListener fun
657 * @tc.type: FUNC
658 */
659 HWTEST_F(ScreenManagerTest, UnregisterVirtualScreenGroupListener, Function | SmallTest | Level1)
660 {
661 auto ret = ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(nullptr);
662 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
663 }
664
665 /**
666 * @tc.name: MakeUniqueScreen_001
667 * @tc.desc: MakeUniqueScreen_001 fun
668 * @tc.type: FUNC
669 */
670 HWTEST_F(ScreenManagerTest, MakeUniqueScreen_001, Function | SmallTest | Level1)
671 {
672 std::vector<ScreenId> screenIds;
673 DMError error = ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
674 ASSERT_EQ(error, DMError::DM_ERROR_INVALID_PARAM);
675 }
676
677 /**
678 * @tc.name: MakeUniqueScreen_002
679 * @tc.desc: MakeUniqueScreen_002 fun
680 * @tc.type: FUNC
681 */
682 HWTEST_F(ScreenManagerTest, MakeUniqueScreen_002, Function | SmallTest | Level1)
683 {
684 std::vector<ScreenId> screenIds;
685 for (uint32_t i = 0; i < 33; ++i){ // MAX_SCREEN_SIZE + 1
686 screenIds.emplace_back(i);
687 }
688 DMError error = ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
689 ASSERT_EQ(error, DMError::DM_ERROR_INVALID_PARAM);
690 }
691
692 /**
693 * @tc.name: MakeUniqueScreen_003
694 * @tc.desc: MakeUniqueScreen_003 fun
695 * @tc.type: FUNC
696 */
697 HWTEST_F(ScreenManagerTest, MakeUniqueScreen_003, Function | SmallTest | Level1)
698 {
699 std::vector<ScreenId> screenIds;
700 for (uint32_t i = 0; i < 32; ++i){ // MAX_SCREEN_SIZE
701 screenIds.emplace_back(i);
702 }
703 DMError error = ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
704 ASSERT_NE(error, DMError::DM_ERROR_INVALID_PARAM);
705 }
706
707 /**
708 * @tc.name: MakeMirror_001
709 * @tc.desc: MakeMirror_001 fun
710 * @tc.type: FUNC
711 */
712 HWTEST_F(ScreenManagerTest, MakeMirror_001, Function | SmallTest | Level1)
713 {
714 std::vector<ScreenId> mirrorScreenId;
715 for (uint32_t i = 0; i < 33; ++i){ // MAX_SCREEN_SIZE + 1
716 mirrorScreenId.emplace_back(i);
717 }
718 ScreenId ScreenGroupId;
719 DMError error = ScreenManager::GetInstance().MakeMirror(1, mirrorScreenId, ScreenGroupId);
720 ASSERT_EQ(error, DMError::DM_ERROR_INVALID_PARAM);
721 }
722
723 /**
724 * @tc.name: StopExpand
725 * @tc.desc: StopExpand fun
726 * @tc.type: FUNC
727 */
728 HWTEST_F(ScreenManagerTest, StopExpand, Function | SmallTest | Level1)
729 {
730 std::vector<ScreenId> expandScreenIds;
731 for (uint32_t i = 0; i < 33; ++i){ // MAX_SCREEN_SIZE + 1
732 expandScreenIds.emplace_back(i);
733 }
734 DMError error = ScreenManager::GetInstance().StopExpand(expandScreenIds);
735 ASSERT_EQ(error, DMError::DM_OK);
736 }
737
738 /**
739 * @tc.name: GetScreenInfoSrting
740 * @tc.desc: GetScreenInfoSrting fun
741 * @tc.type: FUNC
742 */
743 HWTEST_F(ScreenManagerTest, GetScreenInfoSrting, Function | SmallTest | Level1)
744 {
745 sptr<ScreenInfo> screenInfo = nullptr;
746 auto result =ScreenManager::GetInstance().pImpl_->GetScreenInfoSrting(screenInfo);
747 EXPECT_EQ(result, "");
748 }
749
750 /**
751 * @tc.name: SetScreenSkipProtectedWindow
752 * @tc.desc: SetScreenSkipProtectedWindow fun
753 * @tc.type: FUNC
754 */
755 HWTEST_F(ScreenManagerTest, SetScreenSkipProtectedWindow, Function | SmallTest | Level1)
756 {
757 const std::vector<ScreenId> screenIds;
758 bool isEnable = true;
759 auto result = ScreenManager::GetInstance().SetScreenSkipProtectedWindow(screenIds, isEnable);
760 EXPECT_EQ(result, DMError::DM_ERROR_INVALID_PARAM);
761 }
762 }
763 } // namespace Rosen
764 } // namespace OHOS