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 ScreenManagerUtTest : public testing::Test {
50 public:
51 static void SetUpTestCase();
52 static void TearDownTestCase();
53 void SetUp() override;
54 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> ScreenManagerUtTest::defaultDisplay_ = nullptr;
67 uint32_t ScreenManagerUtTest::defaultWidth_ = 480;
68 uint32_t ScreenManagerUtTest::defaultHeight_ = 320;
69
SetUpTestCase()70 void ScreenManagerUtTest::SetUpTestCase()
71 {
72 defaultDisplay_ = DisplayManager::GetInstance().GetDefaultDisplay();
73 defaultWidth_ = defaultDisplay_->GetWidth();
74 defaultHeight_ = defaultDisplay_->GetHeight();
75 }
76
TearDownTestCase()77 void ScreenManagerUtTest::TearDownTestCase()
78 {
79 }
80
SetUp()81 void ScreenManagerUtTest::SetUp()
82 {
83 }
84
TearDown()85 void ScreenManagerUtTest::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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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(ScreenManagerUtTest, 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_ERROR_DEVICE_NOT_SUPPORT, ret);
528 }
529
530 /**
531 * @tc.name: SetVirtualScreenFlag02
532 * @tc.desc: SetVirtualScreenFlag02 max flag
533 * @tc.type: FUNC
534 */
535 HWTEST_F(ScreenManagerUtTest, SetVirtualScreenFlag02, Function | SmallTest | Level1)
536 {
537 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
538 defaultDensity_, nullptr, defaultFlags_};
539 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
540 DMError ret = ScreenManager::GetInstance().SetVirtualScreenFlag(screenId, VirtualScreenFlag::MAX);
541 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ret);
542 ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
543 ASSERT_EQ(DMError::DM_OK, ret);
544 }
545
546 /**
547 * @tc.name: GetVirtualScreenFlag01
548 * @tc.desc: GetVirtualScreenFlag01 get cast
549 * @tc.type: FUNC
550 */
551 HWTEST_F(ScreenManagerUtTest, GetVirtualScreenFlag01, Function | SmallTest | Level1)
552 {
553 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
554 defaultDensity_, nullptr, defaultFlags_};
555 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
556 DMError ret = ScreenManager::GetInstance().SetVirtualScreenFlag(screenId, VirtualScreenFlag::CAST);
557 ASSERT_EQ(DMError::DM_ERROR_DEVICE_NOT_SUPPORT, ret);
558 }
559
560 /**
561 * @tc.name: SetVirtualMirrorScreenScaleMode01
562 * @tc.desc: SetVirtualMirrorScreenScaleMode01 fun
563 * @tc.type: FUNC
564 */
565 HWTEST_F(ScreenManagerUtTest, SetVirtualMirrorScreenScaleMode01, Function | SmallTest | Level1)
566 {
567 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
568 defaultDensity_, nullptr, defaultFlags_};
569 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
570 DMError ret = ScreenManager::GetInstance().SetVirtualMirrorScreenScaleMode(screenId,
571 ScreenScaleMode::FILL_MODE);
572 ASSERT_EQ(DMError::DM_ERROR_DEVICE_NOT_SUPPORT, ret);
573 }
574
575 /**
576 * @tc.name: SetVirtualMirrorScreenScaleMode02
577 * @tc.desc: SetVirtualMirrorScreenScaleMode02 fun
578 * @tc.type: FUNC
579 */
580 HWTEST_F(ScreenManagerUtTest, SetVirtualMirrorScreenScaleMode02, Function | SmallTest | Level1)
581 {
582 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
583 defaultDensity_, nullptr, defaultFlags_};
584 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
585 DMError ret = ScreenManager::GetInstance().SetVirtualMirrorScreenScaleMode(screenId,
586 ScreenScaleMode::UNISCALE_MODE);
587 ASSERT_EQ(DMError::DM_ERROR_DEVICE_NOT_SUPPORT, ret);
588 }
589
590 /**
591 * @tc.name: IsCaptured02
592 * @tc.desc: IsCaptured02 fun
593 * @tc.type: FUNC
594 */
595 HWTEST_F(ScreenManagerUtTest, IsCaptured02, Function | SmallTest | Level1)
596 {
597 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
598 defaultDensity_, nullptr, defaultFlags_};
599 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
600 bool isCapture = DisplayManager::GetInstance().IsCaptured();
601 ASSERT_FALSE(isCapture);
602 auto ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
603 ASSERT_EQ(DMError::DM_OK, ret);
604 }
605
606 /**
607 * @tc.name: IsCaptured03
608 * @tc.desc: IsCaptured03 fun
609 * @tc.type: FUNC
610 */
611 HWTEST_F(ScreenManagerUtTest, IsCaptured03, Function | SmallTest | Level1)
612 {
613 VirtualScreenOption defaultOption = {defaultName_, defaultWidth_, defaultHeight_,
614 defaultDensity_, nullptr, defaultFlags_};
615 ScreenId screenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption);
616 auto ret = ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
617 ASSERT_EQ(DMError::DM_OK, ret);
618 bool isCapture = DisplayManager::GetInstance().IsCaptured();
619 ASSERT_FALSE(isCapture);
620 }
621
622 /**
623 * @tc.name: UnregisterScreenListener
624 * @tc.desc: UnregisterScreenListener fun
625 * @tc.type: FUNC
626 */
627 HWTEST_F(ScreenManagerUtTest, UnregisterScreenListener, Function | SmallTest | Level1)
628 {
629 auto ret = ScreenManager::GetInstance().UnregisterScreenListener(nullptr);
630 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
631 }
632
633 /**
634 * @tc.name: RegisterScreenListener
635 * @tc.desc: RegisterScreenListener fun
636 * @tc.type: FUNC
637 */
638 HWTEST_F(ScreenManagerUtTest, RegisterScreenListener, Function | SmallTest | Level1)
639 {
640 auto ret = ScreenManager::GetInstance().RegisterScreenListener(nullptr);
641 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
642 }
643
644 /**
645 * @tc.name: UnregisterVirtualScreenGroupListener
646 * @tc.desc: UnregisterVirtualScreenGroupListener fun
647 * @tc.type: FUNC
648 */
649 HWTEST_F(ScreenManagerUtTest, UnregisterVirtualScreenGroupListener, Function | SmallTest | Level1)
650 {
651 auto ret = ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(nullptr);
652 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
653 }
654
655 /**
656 * @tc.name: MakeUniqueScreen_001
657 * @tc.desc: MakeUniqueScreen_001 fun
658 * @tc.type: FUNC
659 */
660 HWTEST_F(ScreenManagerUtTest, MakeUniqueScreen_001, Function | SmallTest | Level1)
661 {
662 std::vector<ScreenId> screenIds;
663 DMError error = ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
664 ASSERT_EQ(error, DMError::DM_ERROR_INVALID_PARAM);
665 }
666
667 /**
668 * @tc.name: MakeUniqueScreen_002
669 * @tc.desc: MakeUniqueScreen_002 fun
670 * @tc.type: FUNC
671 */
672 HWTEST_F(ScreenManagerUtTest, MakeUniqueScreen_002, Function | SmallTest | Level1)
673 {
674 std::vector<ScreenId> screenIds;
675 for (uint32_t i = 0; i < 33; ++i){ // MAX_SCREEN_SIZE + 1
676 screenIds.emplace_back(i);
677 }
678 DMError error = ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
679 ASSERT_EQ(error, DMError::DM_ERROR_INVALID_PARAM);
680 }
681
682 /**
683 * @tc.name: MakeUniqueScreen_003
684 * @tc.desc: MakeUniqueScreen_003 fun
685 * @tc.type: FUNC
686 */
687 HWTEST_F(ScreenManagerUtTest, MakeUniqueScreen_003, Function | SmallTest | Level1)
688 {
689 std::vector<ScreenId> screenIds;
690 for (uint32_t i = 0; i < 32; ++i){ // MAX_SCREEN_SIZE
691 screenIds.emplace_back(i);
692 }
693 DMError error = ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
694 ASSERT_NE(error, DMError::DM_ERROR_INVALID_PARAM);
695 }
696
697 /**
698 * @tc.name: MakeMirror_001
699 * @tc.desc: MakeMirror_001 fun
700 * @tc.type: FUNC
701 */
702 HWTEST_F(ScreenManagerUtTest, MakeMirror_001, Function | SmallTest | Level1)
703 {
704 std::vector<ScreenId> mirrorScreenId;
705 for (uint32_t i = 0; i < 33; ++i){ // MAX_SCREEN_SIZE + 1
706 mirrorScreenId.emplace_back(i);
707 }
708 ScreenId ScreenGroupId;
709 DMError error = ScreenManager::GetInstance().MakeMirror(1, mirrorScreenId, ScreenGroupId);
710 ASSERT_EQ(error, DMError::DM_ERROR_INVALID_PARAM);
711 }
712
713 /**
714 * @tc.name: StopExpand
715 * @tc.desc: StopExpand fun
716 * @tc.type: FUNC
717 */
718 HWTEST_F(ScreenManagerUtTest, StopExpand, Function | SmallTest | Level1)
719 {
720 std::vector<ScreenId> expandScreenIds;
721 for (uint32_t i = 0; i < 33; ++i){ // MAX_SCREEN_SIZE + 1
722 expandScreenIds.emplace_back(i);
723 }
724 DMError error = ScreenManager::GetInstance().StopExpand(expandScreenIds);
725 ASSERT_EQ(error, DMError::DM_OK);
726 }
727
728 /**
729 * @tc.name: GetScreenInfoSrting
730 * @tc.desc: GetScreenInfoSrting fun
731 * @tc.type: FUNC
732 */
733 HWTEST_F(ScreenManagerUtTest, GetScreenInfoSrting, Function | SmallTest | Level1)
734 {
735 sptr<ScreenInfo> screenInfo = nullptr;
736 auto result =ScreenManager::GetInstance().pImpl_->GetScreenInfoSrting(screenInfo);
737 EXPECT_EQ(result, "");
738 }
739 }
740 } // namespace Rosen
741 } // namespace OHOS