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
18 #include "common_test_utils.h"
19 #include "display_test_utils.h"
20 #include "display_manager_proxy.h"
21 #include "future.h"
22 #include "screen.h"
23 #include "scene_board_judgement.h"
24 #include "surface_draw.h"
25 #include "virtual_screen_group_change_listener_future.h"
26 #include "window.h"
27 #include "window_option.h"
28 #include "window_manager_hilog.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Rosen {
35 namespace {
36 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "ScreenManagerTest"};
37 constexpr uint32_t COLOR_RED = 0xffff0000;
38 }
39 class ScreenGroupChangeListener;
40 class ScreenManagerTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 virtual void SetUp() override;
45 virtual void TearDown() override;
46 sptr<Window> CreateWindowByDisplayId(DisplayId displayId);
47 bool DrawWindowColor(const sptr<Window>& window, uint32_t color);
48 void CheckScreenStateInGroup(bool, sptr<ScreenGroup>, ScreenId, sptr<Screen>, ScreenId);
49 void CheckScreenGroupState(ScreenCombination, ScreenGroupChangeEvent event, ScreenId,
50 sptr<ScreenGroup>, sptr<ScreenGroupChangeListener>);
51 void CheckScreenGroupStateForMirror(ScreenGroupChangeEvent event, std::vector<ScreenId> mirrorIds,
52 sptr<VirtualScreenGroupChangeListenerFuture> virtualScreenGroupChangeListener);
53 void CheckStateDisplay(DisplayId displayId, ScreenId virtualScreenId);
54 static sptr<Display> defaultDisplay_;
55 static DisplayId defaultDisplayId_;
56 static ScreenId defaultScreenId_;
57 static std::string defaultName_;
58 static uint32_t defaultWidth_;
59 static uint32_t defaultHeight_;
60 static float defaultDensity_;
61 static int32_t defaultFlags_;
62 static VirtualScreenOption defaultOption_;
63 static uint32_t waitCount_;
64 const uint32_t sleepUs_ = 10 * 1000;
65 const uint32_t maxWaitCount_ = 20;
66 const uint32_t execTimes_ = 10;
67 const uint32_t acquireFrames_ = 1;
68 const uint32_t resizeScreenWidthTestOne_ = 1000;
69 const uint32_t resizeScreenHeightTestOne_ = 1000;
70 const uint32_t resizeScreenWidthTestTwo_ = 1;
71 const uint32_t resizeScreenHeightTestTwo_ = 1;
72 const uint32_t resizeScreenWidthTestThree_ = 720;
73 const uint32_t resizeScreenHeightTestThree_ = 1280;
74 const uint32_t refreshIntervalZero_ = 0;
75 const uint32_t refreshIntervalTwo_ = 2;
76 const uint32_t refreshIntervalMax_ = 10000;
77 static constexpr uint32_t TEST_SLEEP_S = 1; // test sleep time
78 static constexpr uint32_t TEST_SLEEP_S_LONG = 10; // test sleep for 10 seconds
79 static constexpr long TIME_OUT = 1000;
80 };
81
82 class ScreenChangeListener : public ScreenManager::IScreenListener {
83 public:
OnConnect(ScreenId screenId)84 virtual void OnConnect(ScreenId screenId) override
85 {
86 WLOGI("OnConnect, screenId:%{public}" PRIu64"", screenId);
87 connectFuture_.SetValue(screenId);
88 }
OnDisconnect(ScreenId screenId)89 virtual void OnDisconnect(ScreenId screenId) override
90 {
91 WLOGI("OnDisconnect, screenId:%{public}" PRIu64"", screenId);
92 disconnectFuture_.SetValue(screenId);
93 }
OnChange(ScreenId screenId)94 virtual void OnChange(ScreenId screenId) override
95 {
96 WLOGI("OnChange, screenId:%{public}" PRIu64"", screenId);
97 changeFuture_.SetValue(screenId);
98 }
99 RunnableFuture<ScreenId> connectFuture_;
100 RunnableFuture<ScreenId> disconnectFuture_;
101 RunnableFuture<ScreenId> changeFuture_;
102 };
103
104 class ScreenGroupChangeListener : public ScreenManager::IScreenGroupListener {
105 public:
OnChange(const std::vector<ScreenId> & screenIds,ScreenGroupChangeEvent event)106 virtual void OnChange(const std::vector<ScreenId>& screenIds, ScreenGroupChangeEvent event) override
107 {
108 for (auto screenId : screenIds) {
109 changeFuture_.SetValue(std::make_pair(screenId, event));
110 usleep(10 * 1000); // wait 10000 us
111 }
112 }
113 RunnableFuture<std::pair<ScreenId, ScreenGroupChangeEvent>> changeFuture_;
114 };
115
116 sptr<Display> ScreenManagerTest::defaultDisplay_ = nullptr;
117 DisplayId ScreenManagerTest::defaultDisplayId_ = DISPLAY_ID_INVALID;
118 ScreenId ScreenManagerTest::defaultScreenId_ = INVALID_SCREEN_ID;
119 std::string ScreenManagerTest::defaultName_ = "virtualScreen01";
120 uint32_t ScreenManagerTest::defaultWidth_ = 2560;
121 uint32_t ScreenManagerTest::defaultHeight_ = 1600;
122 float ScreenManagerTest::defaultDensity_ = 2.0;
123 int32_t ScreenManagerTest::defaultFlags_ = 0;
124 VirtualScreenOption ScreenManagerTest::defaultOption_ = {
125 defaultName_, defaultWidth_, defaultHeight_, defaultDensity_, nullptr, defaultFlags_
126 };
127 uint32_t ScreenManagerTest::waitCount_ = 0;
128
SetUpTestCase()129 void ScreenManagerTest::SetUpTestCase()
130 {
131 defaultDisplay_ = DisplayManager::GetInstance().GetDefaultDisplay();
132 ASSERT_TRUE(defaultDisplay_);
133 defaultDisplayId_ = defaultDisplay_->GetId();
134 defaultScreenId_ = defaultDisplay_->GetScreenId();
135 defaultWidth_ = defaultDisplay_->GetWidth();
136 defaultHeight_ = defaultDisplay_->GetHeight();
137 defaultOption_.width_ = defaultWidth_;
138 defaultOption_.height_ = defaultHeight_;
139
140 CommonTestUtils::InjectTokenInfoByHapName(0, "com.ohos.systemui", 0);
141
142 const char** perms = new const char *[1];
143 perms[0] = "ohos.permission.CAPTURE_SCREEN";
144 CommonTestUtils::SetAceessTokenPermission("DisplayManagerServiceTest", perms, 1);
145 }
146
TearDownTestCase()147 void ScreenManagerTest::TearDownTestCase()
148 {
149 }
150
SetUp()151 void ScreenManagerTest::SetUp()
152 {
153 }
154
TearDown()155 void ScreenManagerTest::TearDown()
156 {
157 sleep(TEST_SLEEP_S);
158 }
159
160
DrawWindowColor(const sptr<Window> & window,uint32_t color)161 bool ScreenManagerTest::DrawWindowColor(const sptr<Window>& window, uint32_t color)
162 {
163 auto surfaceNode = window->GetSurfaceNode();
164 if (surfaceNode == nullptr) {
165 WLOGFE("Failed to GetSurfaceNode!");
166 return false;
167 }
168 Rect rect = window->GetRequestRect();
169 uint32_t windowWidth = rect.width_;
170 uint32_t windowHeight = rect.height_;
171 WLOGI("windowWidth: %{public}u, windowHeight: %{public}u", windowWidth, windowHeight);
172 SurfaceDraw::DrawColor(surfaceNode, windowWidth, windowHeight, color);
173 return true;
174 }
175
CreateWindowByDisplayId(DisplayId displayId)176 sptr<Window> ScreenManagerTest::CreateWindowByDisplayId(DisplayId displayId)
177 {
178 sptr<WindowOption> option = new WindowOption();
179 if (option == nullptr) {
180 return nullptr;
181 }
182 Rect displayRect = {0, 0, 640, 480};
183 option->SetDisplayId(displayId);
184 option->SetWindowRect(displayRect);
185 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
186 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
187 option->SetWindowName("VirtualWindow01");
188 sptr<Window> window = Window::Create(option->GetWindowName(), option);
189 return window;
190 }
191
CheckStateDisplay(DisplayId virtualDisplayId,ScreenId virtualScreenId)192 void ScreenManagerTest::CheckStateDisplay(DisplayId virtualDisplayId, ScreenId virtualScreenId)
193 {
194 const std::string rsCmd = "snapshot_display -i " + std::to_string(virtualDisplayId);
195 (void)system(rsCmd.c_str());
196
197 auto screen = ScreenManager::GetInstance().GetScreenById(virtualScreenId);
198 ASSERT_TRUE(screen);
199 auto display = DisplayManager::GetInstance().GetDisplayByScreen(virtualScreenId);
200 ASSERT_TRUE(display);
201
202 uint32_t orientation = static_cast<uint32_t>(Orientation::VERTICAL);
203 uint32_t end = static_cast<uint32_t>(Orientation::REVERSE_HORIZONTAL);
204 sptr<ScreenChangeListener> screenListener = new ScreenChangeListener();
205 ASSERT_TRUE(screenListener);
206
207 for (; orientation <= end; ++orientation) {
208 screen->SetOrientation(static_cast<Orientation>(orientation));
209 screenListener->changeFuture_.GetResult(TIME_OUT);
210 usleep(1E6);
211 ASSERT_EQ(static_cast<uint32_t>(screen->GetOrientation()), orientation);
212 ASSERT_EQ(static_cast<uint32_t>(display->GetOrientation()), orientation);
213 (void)system(rsCmd.c_str());
214 sleep(TEST_SLEEP_S);
215 }
216 screen->SetOrientation(Orientation::UNSPECIFIED);
217 ASSERT_EQ(static_cast<uint32_t>(screen->GetOrientation()), static_cast<uint32_t>(Orientation::UNSPECIFIED));
218 ASSERT_EQ(static_cast<uint32_t>(display->GetOrientation()), static_cast<uint32_t>(Orientation::UNSPECIFIED));
219 }
220
221 #define CHECK_TEST_INIT_SCREEN_STATE \
222 std::vector<sptr<Screen>> allScreens; \
223 ScreenManager::GetInstance().GetAllScreens(allScreens); \
224 ASSERT_LT(0, allScreens.size()); \
225 ScreenId groupId = SCREEN_ID_INVALID; \
226 for (auto screen : allScreens) { \
227 if (screen->IsGroup()) { \
228 groupId = screen->GetId(); \
229 if (screen->GetParentId() == SCREEN_ID_INVALID) { \
230 ASSERT_EQ(SCREEN_ID_INVALID, screen->GetParentId()); \
231 } \
232 } \
233 } \
234 if (SCREEN_ID_INVALID != groupId) { \
235 ASSERT_NE(SCREEN_ID_INVALID, groupId); \
236 } \
237 auto group = ScreenManager::GetInstance().GetScreenGroup(groupId); \
238 if (group != nullptr) { \
239 if (groupId == group->GetId()) { \
240 ASSERT_EQ(groupId, group->GetId()); \
241 } \
242 ASSERT_NE(nullptr, group); \
243 } \
244 sptr<ScreenChangeListener> screenListener = new ScreenChangeListener(); \
245 sptr<ScreenGroupChangeListener> screenGroupChangeListener = new ScreenGroupChangeListener(); \
246 sptr<VirtualScreenGroupChangeListenerFuture> virtualScreenGroupChangeListener \
247 = new VirtualScreenGroupChangeListenerFuture(); \
248 ScreenManager::GetInstance().RegisterScreenListener(screenListener); \
249 ScreenManager::GetInstance().RegisterScreenGroupListener(screenGroupChangeListener); \
250 ScreenManager::GetInstance().RegisterVirtualScreenGroupListener(virtualScreenGroupChangeListener); \
251
252 #define CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN \
253 auto virtualScreen = ScreenManager::GetInstance().GetScreenById(virtualScreenId); \
254 ASSERT_NE(nullptr, virtualScreen); \
255 ASSERT_EQ(virtualScreenId, virtualScreen->GetId()); \
256 ScreenId screenId = screenListener->connectFuture_.GetResult(TIME_OUT); \
257 screenListener->connectFuture_.Reset(SCREEN_ID_INVALID); \
258 ASSERT_EQ(virtualScreenId, screenId); \
259
CheckScreenStateInGroup(bool isInGroup,sptr<ScreenGroup> group,ScreenId groupId,sptr<Screen> virtualScreen,ScreenId virtualScreenId)260 void ScreenManagerTest::CheckScreenStateInGroup(
261 bool isInGroup, sptr<ScreenGroup> group, ScreenId groupId, sptr<Screen> virtualScreen, ScreenId virtualScreenId)
262 {
263 if (group == nullptr) {
264 GTEST_LOG_(INFO) << "group is nullptr";
265 return;
266 }
267 auto childIds = group->GetChildIds();
268 ASSERT_LT(0, childIds.size());
269 auto iter = std::find(childIds.begin(), childIds.end(), virtualScreenId);
270 if (isInGroup) {
271 ASSERT_EQ(groupId, virtualScreen->GetParentId());
272 } else {
273 if (virtualScreen->GetParentId() == SCREEN_ID_INVALID) {
274 ASSERT_EQ(SCREEN_ID_INVALID, virtualScreen->GetParentId());
275 }
276 }
277 if (isInGroup) {
278 if (childIds.end() != iter) {
279 ASSERT_NE(childIds.end(), iter);
280 }
281 } else {
282 if (childIds.end() == iter) {
283 ASSERT_EQ(childIds.end(), iter);
284 }
285 }
286 }
287
CheckScreenGroupState(ScreenCombination combination,ScreenGroupChangeEvent event,ScreenId virtualScreenId,sptr<ScreenGroup> group,sptr<ScreenGroupChangeListener> screenGroupChangeListener)288 void ScreenManagerTest::CheckScreenGroupState(ScreenCombination combination, ScreenGroupChangeEvent event,
289 ScreenId virtualScreenId, sptr<ScreenGroup> group, sptr<ScreenGroupChangeListener> screenGroupChangeListener)
290 {
291 if (group == nullptr) {
292 GTEST_LOG_(INFO) << "group is nullptr";
293 return;
294 }
295 auto pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
296 screenGroupChangeListener->changeFuture_.Reset(
297 std::make_pair(SCREEN_ID_INVALID, ScreenGroupChangeEvent::REMOVE_FROM_GROUP));
298 if (virtualScreenId == pair.first) {
299 ASSERT_EQ(virtualScreenId, pair.first);
300 }
301 if (pair.second == event) {
302 ASSERT_EQ(event, pair.second);
303 }
304 if (combination == group->GetCombination()) {
305 ASSERT_EQ(combination, group->GetCombination());
306 }
307 }
308
CheckScreenGroupStateForMirror(ScreenGroupChangeEvent event,std::vector<ScreenId> mirrorIds,sptr<VirtualScreenGroupChangeListenerFuture> virtualScreenGroupChangeListener)309 void ScreenManagerTest::CheckScreenGroupStateForMirror(ScreenGroupChangeEvent event, std::vector<ScreenId> mirrorIds,
310 sptr<VirtualScreenGroupChangeListenerFuture> virtualScreenGroupChangeListener)
311 {
312 auto info = virtualScreenGroupChangeListener->mirrorChangeFuture_.GetResult(TIME_OUT);
313 virtualScreenGroupChangeListener->mirrorChangeFuture_.Reset({ScreenGroupChangeEvent::CHANGE_GROUP, "", {}});
314 ASSERT_EQ(info.event, event);
315 ASSERT_EQ(info.ids, mirrorIds);
316 ASSERT_GE(info.trigger.size(), 0UL);
317 }
318
319 #define CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN \
320 { \
321 auto screenId = screenListener->disconnectFuture_.GetResult(TIME_OUT); \
322 screenListener->disconnectFuture_.Reset(SCREEN_ID_INVALID); \
323 if (virtualScreenId == screenId) { \
324 ASSERT_EQ(virtualScreenId, screenId); \
325 } \
326 }
327
328 namespace {
329
330 /**
331 * @tc.name: CreateVirtualScreenTenTimes
332 * @tc.desc: Create VirtualScreen for 10 times but do not destroy it
333 * @tc.type: FUNC
334 */
335 HWTEST_F(ScreenManagerTest, CreateVirtualScreenTenTimes, TestSize.Level1)
336 {
337 DisplayTestUtils utils;
338 defaultOption_.isForShot_ = false;
339 for (uint32_t i = 0; i < execTimes_; i++) {
340 EXPECT_TRUE(utils.CreateSurface());
341 defaultOption_.surface_ = utils.psurface_;
342 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
343 sleep(TEST_SLEEP_S);
344 EXPECT_NE(SCREEN_ID_INVALID, virtualScreenId);
345 }
346 }
347
348 /**
349 * @tc.name: ScreenManager01
350 * @tc.desc: Create a virtual screen and destroy it
351 * @tc.type: FUNC
352 */
353 HWTEST_F(ScreenManagerTest, ScreenManager01, TestSize.Level1)
354 {
355 DisplayTestUtils utils;
356 ASSERT_TRUE(utils.CreateSurface());
357 defaultOption_.surface_ = utils.psurface_;
358 defaultOption_.isForShot_ = false;
359 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
360 sleep(TEST_SLEEP_S);
361 ASSERT_NE(SCREEN_ID_INVALID, virtualScreenId);
362 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
363 sleep(TEST_SLEEP_S);
364 ASSERT_EQ(DMError::DM_OK, res);
365 }
366
367 /**
368 * @tc.name: ScreenManager02
369 * @tc.desc: Create a virtual screen as mirror of default screen, and destroy virtual screen
370 * @tc.type: FUNC
371 */
372 HWTEST_F(ScreenManagerTest, ScreenManager02, TestSize.Level1)
373 {
374 DisplayTestUtils utils;
375 ASSERT_TRUE(utils.CreateSurface());
376 defaultOption_.surface_ = utils.psurface_;
377 defaultOption_.isForShot_ = false;
378 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
379 ScreenId screenGroupId;
380 sleep(TEST_SLEEP_S);
381 std::vector<ScreenId> mirrorIds;
382 mirrorIds.push_back(virtualScreenId);
383 ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorIds, screenGroupId);
384 sleep(TEST_SLEEP_S);
385 ASSERT_NE(SCREEN_ID_INVALID, virtualScreenId);
386 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
387 sleep(TEST_SLEEP_S);
388 ASSERT_EQ(DMError::DM_OK, res);
389 }
390
391 /**
392 * @tc.name: ScreenManager03
393 * @tc.desc: Create a virtual screen and destroy it for 10 times
394 * @tc.type: FUNC
395 */
396 HWTEST_F(ScreenManagerTest, ScreenManager03, TestSize.Level1)
397 {
398 DisplayTestUtils utils;
399 defaultOption_.isForShot_ = false;
400 for (uint32_t i = 0; i < execTimes_; i++) {
401 ASSERT_TRUE(utils.CreateSurface());
402 defaultOption_.surface_ = utils.psurface_;
403 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
404 sleep(TEST_SLEEP_S);
405 ASSERT_NE(SCREEN_ID_INVALID, virtualScreenId);
406 ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId));
407 sleep(TEST_SLEEP_S);
408 }
409 }
410
411 /**
412 * @tc.name: ScreenManager04
413 * @tc.desc: Create a virtual screen as mirror of default screen, and destroy virtual screen for 10 times
414 * @tc.type: FUNC
415 */
416 HWTEST_F(ScreenManagerTest, ScreenManager04, TestSize.Level1)
417 {
418 DisplayTestUtils utils;
419 defaultOption_.isForShot_ = false;
420 for (uint32_t i = 0; i < execTimes_; i++) {
421 ASSERT_TRUE(utils.CreateSurface());
422 defaultOption_.surface_ = utils.psurface_;
423 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
424 ScreenId screenGroupId;
425 sleep(TEST_SLEEP_S);
426 std::vector<ScreenId> mirrorIds;
427 mirrorIds.push_back(virtualScreenId);
428 ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorIds, screenGroupId);
429 sleep(TEST_SLEEP_S);
430 ASSERT_NE(SCREEN_ID_INVALID, virtualScreenId);
431 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
432 sleep(TEST_SLEEP_S);
433 ASSERT_EQ(DMError::DM_OK, res);
434 sleep(TEST_SLEEP_S);
435 }
436 }
437
438 /**
439 * @tc.name: ScreenManager05
440 * @tc.desc: Compare the length and width for recording screen
441 * @tc.type: FUNC
442 */
443 HWTEST_F(ScreenManagerTest, ScreenManager05, TestSize.Level1)
444 {
445 DisplayTestUtils utils;
446 utils.SetDefaultWH(defaultDisplay_);
447 ASSERT_TRUE(utils.CreateSurface());
448 defaultOption_.surface_ = utils.psurface_;
449 defaultOption_.isForShot_ = true;
450 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
451 ScreenId screenGroupId;
452 sleep(TEST_SLEEP_S);
453
454 ASSERT_NE(SCREEN_ID_INVALID, virtualScreenId);
455 uint32_t lastCount = -1u;
456 std::vector<ScreenId> mirrorIds;
457 mirrorIds.push_back(virtualScreenId);
458 ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorIds, screenGroupId);
459 sleep(TEST_SLEEP_S);
460
461 while (utils.successCount_ < acquireFrames_ && waitCount_ <= maxWaitCount_) {
462 if (lastCount != utils.successCount_) {
463 lastCount = utils.successCount_;
464 }
465 ASSERT_EQ(0, utils.failCount_);
466 waitCount_++;
467 sleep(TEST_SLEEP_S);
468 }
469 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
470 sleep(TEST_SLEEP_S);
471 ASSERT_EQ(DMError::DM_OK, res);
472 ASSERT_GT(utils.successCount_, 0);
473 ASSERT_GT(maxWaitCount_, waitCount_);
474 waitCount_ = 0;
475 }
476
477 /**
478 * @tc.name: ScreenManager06
479 * @tc.desc: Compare the length and width for recording screen, set VirtualScreen Surface before make mirror.
480 * @tc.type: FUNC
481 */
482 HWTEST_F(ScreenManagerTest, ScreenManager06, TestSize.Level1)
483 {
484 DisplayTestUtils utils;
485 utils.SetDefaultWH(defaultDisplay_);
486 defaultOption_.surface_ = nullptr;
487 defaultOption_.isForShot_ = true;
488 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
489 ScreenId screenGroupId;
490 sleep(TEST_SLEEP_S);
491 ASSERT_NE(SCREEN_ID_INVALID, virtualScreenId);
492
493 ASSERT_TRUE(utils.CreateSurface());
494 ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().SetVirtualScreenSurface(virtualScreenId, utils.psurface_));
495
496 uint32_t lastCount = -1u;
497 std::vector<ScreenId> mirrorIds;
498 mirrorIds.push_back(virtualScreenId);
499 ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorIds, screenGroupId);
500 sleep(TEST_SLEEP_S);
501
502 while (utils.successCount_ < acquireFrames_ && waitCount_ <= maxWaitCount_) {
503 if (lastCount != utils.successCount_) {
504 lastCount = utils.successCount_;
505 }
506 ASSERT_EQ(0, utils.failCount_);
507 waitCount_++;
508 sleep(TEST_SLEEP_S);
509 }
510 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
511 sleep(TEST_SLEEP_S);
512 ASSERT_EQ(DMError::DM_OK, res);
513 ASSERT_GT(utils.successCount_, 0);
514 ASSERT_GT(maxWaitCount_, waitCount_);
515 waitCount_ = 0;
516 }
517
518 /**
519 * @tc.name: ScreenManager07
520 * @tc.desc: Get and set screenMode
521 * @tc.type: FUNC
522 */
523 HWTEST_F(ScreenManagerTest, ScreenManager07, TestSize.Level1)
524 {
525 sptr<Screen> screen = ScreenManager::GetInstance().GetScreenById(defaultScreenId_);
526 ASSERT_TRUE(screen);
527 auto modes = screen->GetSupportedModes();
528 auto defaultModeId = screen->GetModeId();
529 ASSERT_GT(modes.size(), 0);
530 for (uint32_t modeIdx = 0; modeIdx < modes.size(); modeIdx++) {
531 ASSERT_EQ(DMError::DM_OK, screen->SetScreenActiveMode(modeIdx));
532 sleep(TEST_SLEEP_S);
533 ASSERT_EQ(modeIdx, screen->GetModeId());
534 sleep(TEST_SLEEP_S);
535 }
536 ASSERT_EQ(DMError::DM_OK, screen->SetScreenActiveMode(defaultModeId));
537 }
538
539 /**
540 * @tc.name: ScreenManager08
541 * @tc.desc: Create a virtual screen as expansion of default screen, and destroy virtual screen
542 * @tc.type: FUNC
543 */
544 HWTEST_F(ScreenManagerTest, ScreenManager08, TestSize.Level1)
545 {
546 DisplayTestUtils utils;
547 ASSERT_TRUE(utils.CreateSurface());
548 defaultOption_.surface_ = utils.psurface_;
549 defaultOption_.isForShot_ = false;
550 CHECK_TEST_INIT_SCREEN_STATE
551 if (group == nullptr) {
552 return;
553 }
554 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
555 sleep(TEST_SLEEP_S);
556 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
557 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
558 std::vector<sptr<Screen>> screens;
559 ScreenManager::GetInstance().GetAllScreens(screens);
560 sleep(TEST_SLEEP_S);
561 sptr<Screen> defaultScreen = screens.front();
562 ASSERT_TRUE(defaultScreen);
563 std::vector<ExpandOption> options = {{defaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
564 ScreenId expansionGroup;
565 ScreenManager::GetInstance().MakeExpand(options, expansionGroup);
566 sleep(TEST_SLEEP_S);
567 if (SCREEN_ID_INVALID != expansionGroup) {
568 ASSERT_NE(SCREEN_ID_INVALID, expansionGroup);
569 }
570
571 CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
572 virtualScreenId, group, screenGroupChangeListener);
573 CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
574 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
575 sleep(TEST_SLEEP_S);
576 ASSERT_EQ(DMError::DM_OK, res);
577 CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
578 CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
579 virtualScreenId, group, screenGroupChangeListener);
580 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
581 ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
582 ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
583 ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
584 }
585
586 /**
587 * @tc.name: ScreenManager09
588 * @tc.desc: Create a virtual screen as expansion of default screen, create windowNode on virtual screen,
589 * and destroy virtual screen
590 * @tc.type: FUNC
591 */
592 HWTEST_F(ScreenManagerTest, ScreenManager09, TestSize.Level1)
593 {
594 (void)system("param set rosen.uni.partialrender.enabled 0");
595
596 DisplayTestUtils utils;
597 ASSERT_TRUE(utils.CreateSurface());
598 defaultOption_.surface_ = utils.psurface_;
599 defaultOption_.isForShot_ = false;
600 CHECK_TEST_INIT_SCREEN_STATE
601 if (group == nullptr) {
602 return;
603 }
604 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
605 sleep(TEST_SLEEP_S);
606 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
607 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
608 sleep(TEST_SLEEP_S);
609 std::vector<ExpandOption> options = {{defaultScreenId_, 0, 0}, {virtualScreenId, defaultWidth_, 0}};
610 ScreenId expansionId;
611 ScreenManager::GetInstance().MakeExpand(options, expansionId);
612 sleep(TEST_SLEEP_S);
613 CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
614 virtualScreenId, group, screenGroupChangeListener);
615 CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
616 sleep(TEST_SLEEP_S);
617 ASSERT_NE(SCREEN_ID_INVALID, expansionId);
618 DisplayId virtualDisplayId = DisplayManager::GetInstance().GetDisplayByScreen(virtualScreenId)->GetId();
619 ASSERT_NE(DISPLAY_ID_INVALID, virtualDisplayId);
620 sptr<Window> window = CreateWindowByDisplayId(virtualDisplayId);
621 if (window == nullptr) {
622 return;
623 }
624 ASSERT_NE(nullptr, window);
625 ASSERT_EQ(true, DrawWindowColor(window, COLOR_RED));
626 sleep(TEST_SLEEP_S);
627 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
628 sleep(TEST_SLEEP_S);
629 ASSERT_EQ(DMError::DM_OK, res);
630 CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
631 CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
632 virtualScreenId, group, screenGroupChangeListener);
633 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
634 ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
635 ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
636 ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
637 sleep(TEST_SLEEP_S);
638 window->Show();
639 sleep(TEST_SLEEP_S_LONG);
640 window->Destroy();
641
642 (void)system("param set rosen.uni.partialrender.enabled 4");
643 }
644
645 /**
646 * @tc.name: ScreenManager10
647 * @tc.desc: Create a virtual screen and destroy it for 10 times, it's not for shot.
648 * @tc.type: FUNC
649 */
650 HWTEST_F(ScreenManagerTest, ScreenManager10, TestSize.Level1)
651 {
652 DisplayTestUtils utils;
653 ASSERT_TRUE(utils.CreateSurface());
654 defaultOption_.surface_ = utils.psurface_;
655 defaultOption_.isForShot_ = false;
656 for (uint32_t i = 0; i < execTimes_; i++) {
657 CHECK_TEST_INIT_SCREEN_STATE
658 if (group == nullptr) {
659 return;
660 }
661 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
662 sleep(TEST_SLEEP_S);
663 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
664 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
665 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
666 sleep(TEST_SLEEP_S);
667 ASSERT_EQ(DMError::DM_OK, res);
668 CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
669 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
670 ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
671 sleep(TEST_SLEEP_S);
672 }
673 }
674
675 /**
676 * @tc.name: ScreenManager11
677 * @tc.desc: Create a virtual screen , mirror and destroy it for 10 times, it's not for shot.
678 * @tc.type: FUNC
679 * @tc.require: issueI5M2SK
680 */
681 HWTEST_F(ScreenManagerTest, ScreenManager11, TestSize.Level1)
682 {
683 DisplayTestUtils utils;
684 ASSERT_TRUE(utils.CreateSurface());
685 defaultOption_.surface_ = utils.psurface_;
686 defaultOption_.isForShot_ = false;
687 for (uint32_t i = 0; i < 10; i++) {
688 sleep(TEST_SLEEP_S);
689 CHECK_TEST_INIT_SCREEN_STATE
690 if (group == nullptr) {
691 return;
692 }
693 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
694 sleep(TEST_SLEEP_S);
695 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
696 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
697
698 std::vector<ScreenId> mirrorIds;
699 mirrorIds.push_back(virtualScreenId);
700 ScreenId mirrorGroup;
701 ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorIds, mirrorGroup);
702 sleep(TEST_SLEEP_S);
703 ASSERT_EQ(mirrorGroup, groupId);
704 CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::ADD_TO_GROUP,
705 virtualScreenId, group, screenGroupChangeListener);
706 CheckScreenGroupStateForMirror(ScreenGroupChangeEvent::ADD_TO_GROUP, mirrorIds,
707 virtualScreenGroupChangeListener);
708 CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
709
710 auto screen = ScreenManager::GetInstance().GetScreenById(virtualScreenId);
711 ASSERT_TRUE(screen);
712 ASSERT_EQ(virtualScreenId, screen->GetId());
713 ASSERT_NE(SCREEN_ID_INVALID, screen->GetParentId());
714 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
715 sleep(TEST_SLEEP_S);
716 ASSERT_EQ(DMError::DM_OK, res);
717 CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
718 CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
719 virtualScreenId, group, screenGroupChangeListener);
720 CheckScreenGroupStateForMirror(ScreenGroupChangeEvent::REMOVE_FROM_GROUP, mirrorIds,
721 virtualScreenGroupChangeListener);
722 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
723 ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
724 ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
725 ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
726 }
727 }
728
729 /**
730 * @tc.name: ScreenManager12
731 * @tc.desc: Create a virtual screen as expansion of default screen cancel Make mirror, and destroy virtual screen
732 * @tc.type: FUNC
733 * @tc.require: issueI5M2SK
734 */
735 HWTEST_F(ScreenManagerTest, ScreenManager12, TestSize.Level1)
736 {
737 DisplayTestUtils utils;
738 ASSERT_TRUE(utils.CreateSurface());
739 defaultOption_.surface_ = utils.psurface_;
740 defaultOption_.isForShot_ = false;
741 CHECK_TEST_INIT_SCREEN_STATE
742 if (group == nullptr) {
743 return;
744 }
745 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
746 sleep(TEST_SLEEP_S);
747 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
748 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
749
750 std::vector<ScreenId> mirrorIds;
751 mirrorIds.push_back(virtualScreenId);
752 ScreenId mirrorGroup;
753 ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorIds, mirrorGroup);
754 ASSERT_EQ(mirrorGroup, groupId);
755 CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::ADD_TO_GROUP,
756 virtualScreenId, group, screenGroupChangeListener);
757 CheckScreenGroupStateForMirror(ScreenGroupChangeEvent::ADD_TO_GROUP, mirrorIds,
758 virtualScreenGroupChangeListener);
759 CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
760
761 ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(mirrorIds);
762 CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
763 virtualScreenId, group, screenGroupChangeListener);
764 CheckScreenGroupStateForMirror(ScreenGroupChangeEvent::REMOVE_FROM_GROUP, mirrorIds,
765 virtualScreenGroupChangeListener);
766 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
767
768 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
769 sleep(TEST_SLEEP_S);
770 ASSERT_EQ(DMError::DM_OK, res);
771 CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
772 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
773 ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
774 ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
775 ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
776 }
777
778 /**
779 * @tc.name: ScreenManager13
780 * @tc.desc: Create a virtual screen as expansion of default screen cancel MakeExpand, and destroy virtual screen
781 * @tc.type: FUNC
782 */
783 HWTEST_F(ScreenManagerTest, ScreenManager13, TestSize.Level1)
784 {
785 DisplayTestUtils utils;
786 ASSERT_TRUE(utils.CreateSurface());
787 defaultOption_.surface_ = utils.psurface_;
788 defaultOption_.isForShot_ = false;
789 CHECK_TEST_INIT_SCREEN_STATE
790 if (group == nullptr) {
791 return;
792 }
793 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
794 sleep(TEST_SLEEP_S);
795 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
796 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
797
798 std::vector<sptr<Screen>> screens;
799 ScreenManager::GetInstance().GetAllScreens(screens);
800 sleep(TEST_SLEEP_S);
801 sptr<Screen> defaultScreen = screens.front();
802 ASSERT_TRUE(defaultScreen);
803 std::vector<ExpandOption> options = {{defaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
804 ScreenId expansionGroup;
805 ScreenManager::GetInstance().MakeExpand(options, expansionGroup);
806 sleep(TEST_SLEEP_S);
807 ASSERT_NE(SCREEN_ID_INVALID, expansionGroup);
808 CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
809 virtualScreenId, group, screenGroupChangeListener);
810 CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
811
812 std::vector<ScreenId> cancelScreens;
813 cancelScreens.emplace_back(virtualScreenId);
814 ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(cancelScreens);
815 CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
816 virtualScreenId, group, screenGroupChangeListener);
817 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
818
819 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
820 sleep(TEST_SLEEP_S);
821 ASSERT_EQ(DMError::DM_OK, res);
822 CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
823 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
824 ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
825 ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
826 ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
827 }
828
829 /**
830 * @tc.name: ScreenManager14
831 * @tc.desc: Create a virtual screen, make expand to make mirror, and destroy virtual screen
832 * @tc.type: FUNC
833 */
834 HWTEST_F(ScreenManagerTest, ScreenManager14, TestSize.Level1)
835 {
836 DisplayTestUtils utils;
837 ASSERT_TRUE(utils.CreateSurface());
838 defaultOption_.surface_ = utils.psurface_;
839 defaultOption_.isForShot_ = false;
840 CHECK_TEST_INIT_SCREEN_STATE
841 if (group == nullptr) {
842 return;
843 }
844 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
845 sleep(TEST_SLEEP_S);
846
847 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
848 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
849
850 std::vector<sptr<Screen>> screens;
851 ScreenManager::GetInstance().GetAllScreens(screens);
852 sptr<Screen> defaultScreen = screens.front();
853 ASSERT_TRUE(defaultScreen);
854 std::vector<ExpandOption> options = {{defaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
855 ScreenId expansionGroup;
856 ScreenManager::GetInstance().MakeExpand(options, expansionGroup);
857 sleep(TEST_SLEEP_S);
858 ASSERT_EQ(expansionGroup, groupId);
859 CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
860 virtualScreenId, group, screenGroupChangeListener);
861 CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
862
863 std::vector<ScreenId> mirrorScreens;
864 mirrorScreens.emplace_back(virtualScreenId);
865 ScreenId mirrorGroup;
866 ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorScreens, mirrorGroup);
867 ASSERT_EQ(mirrorGroup, groupId);
868 CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::CHANGE_GROUP,
869 virtualScreenId, group, screenGroupChangeListener);
870 CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
871
872 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
873 sleep(TEST_SLEEP_S);
874 ASSERT_EQ(DMError::DM_OK, res);
875 CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
876 CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
877 virtualScreenId, group, screenGroupChangeListener);
878 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
879
880 ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
881 ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
882 ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
883 }
884
885 /**
886 * @tc.name: ScreenManager15
887 * @tc.desc: Create a virtual screen, make mirror to make expand, and destroy virtual screen
888 * @tc.type: FUNC
889 * @tc.require: issueI5M2SK
890 */
891 HWTEST_F(ScreenManagerTest, ScreenManager15, TestSize.Level1)
892 {
893 DisplayTestUtils utils;
894 ASSERT_TRUE(utils.CreateSurface());
895 defaultOption_.surface_ = utils.psurface_;
896 defaultOption_.isForShot_ = false;
897
898 CHECK_TEST_INIT_SCREEN_STATE
899 if (group == nullptr) {
900 return;
901 }
902 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
903 sleep(TEST_SLEEP_S);
904 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
905 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
906
907 std::vector<ScreenId> mirrorScreens;
908 mirrorScreens.emplace_back(virtualScreenId);
909 ScreenId mirrorGroup;
910 ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorScreens, mirrorGroup);
911 sleep(TEST_SLEEP_S);
912 ASSERT_EQ(mirrorGroup, groupId);
913 CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::ADD_TO_GROUP,
914 virtualScreenId, group, screenGroupChangeListener);
915 CheckScreenGroupStateForMirror(ScreenGroupChangeEvent::ADD_TO_GROUP, mirrorScreens,
916 virtualScreenGroupChangeListener);
917 CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
918
919 std::vector<sptr<Screen>> screens;
920 ScreenManager::GetInstance().GetAllScreens(screens);
921 sptr<Screen> defaultScreen = screens.front();
922 ASSERT_TRUE(defaultScreen);
923 std::vector<ExpandOption> options = {{defaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
924 ScreenId expansionGroup;
925 ScreenManager::GetInstance().MakeExpand(options, expansionGroup);
926 sleep(TEST_SLEEP_S);
927 ASSERT_EQ(expansionGroup, groupId);
928 CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::CHANGE_GROUP,
929 virtualScreenId, group, screenGroupChangeListener);
930 CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
931
932 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
933 sleep(TEST_SLEEP_S);
934 ASSERT_EQ(DMError::DM_OK, res);
935 CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
936 CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
937 virtualScreenId, group, screenGroupChangeListener);
938 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
939
940 ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
941 ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
942 ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
943 }
944
945 /**
946 * @tc.name: ScreenManager16
947 * @tc.desc: Screen orientation.
948 * @tc.type: FUNC
949 * @tc.require: issueI5NDLK
950 */
951 HWTEST_F(ScreenManagerTest, ScreenManager16, TestSize.Level1)
952 {
953 std::vector<sptr<Screen>> screens;
954 ScreenManager::GetInstance().GetAllScreens(screens);
955 ASSERT_GE(screens.size(), 1);
956 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
957 ASSERT_NE(display, nullptr);
958 uint32_t orientation = static_cast<uint32_t>(Orientation::VERTICAL);
959 uint32_t end = static_cast<uint32_t>(Orientation::REVERSE_HORIZONTAL);
960 sptr<ScreenChangeListener> screenListener = new ScreenChangeListener();
961 ASSERT_NE(screenListener, nullptr);
962 ScreenManager::GetInstance().RegisterScreenListener(screenListener);
963 for (; orientation <= end; ++orientation) {
964 screens[0]->SetOrientation(static_cast<Orientation>(orientation));
965 ScreenId screenId = screenListener->changeFuture_.GetResult(TIME_OUT);
966 ASSERT_EQ(screenId, screens[0]->GetId());
967 usleep(1E6);
968 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
969 ASSERT_EQ(static_cast<uint32_t>(screens[0]->GetOrientation()),
970 static_cast<uint32_t>(Orientation::UNSPECIFIED));
971 } else {
972 ASSERT_NE(static_cast<uint32_t>(screens[0]->GetOrientation()),
973 static_cast<uint32_t>(Orientation::UNSPECIFIED));
974 }
975 ASSERT_EQ(static_cast<uint32_t>(display->GetOrientation()), orientation);
976 sleep(TEST_SLEEP_S);
977 }
978 screens[0]->SetOrientation(Orientation::UNSPECIFIED);
979 ASSERT_EQ(static_cast<uint32_t>(screens[0]->GetOrientation()), static_cast<uint32_t>(Orientation::UNSPECIFIED));
980 ASSERT_EQ(static_cast<uint32_t>(display->GetOrientation()), static_cast<uint32_t>(Orientation::UNSPECIFIED));
981 ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
982 }
983
984 /**
985 * @tc.name: ScreenManager18
986 * @tc.desc: Set screen rotation lock, and check whether screen rotation lock is Locked.
987 * @tc.type: FUNC
988 */
989 HWTEST_F(ScreenManagerTest, ScreenManager18, TestSize.Level1)
990 {
991 bool originalLockStatus;
992 ScreenManager::GetInstance().IsScreenRotationLocked(originalLockStatus);
993 ScreenManager::GetInstance().SetScreenRotationLocked(!originalLockStatus);
994 sleep(TEST_SLEEP_S);
995 bool modifiedLockedStatus;
996 ScreenManager::GetInstance().IsScreenRotationLocked(modifiedLockedStatus);
997 ScreenManager::GetInstance().SetScreenRotationLocked(originalLockStatus);
998 sleep(TEST_SLEEP_S);
999 ASSERT_EQ(!originalLockStatus, modifiedLockedStatus);
1000 }
1001
1002 /**
1003 * @tc.name: VirtualExpandScreen01
1004 * @tc.desc: Create virtual expand screen and rotate.
1005 * @tc.type: FUNC
1006 */
1007 HWTEST_F(ScreenManagerTest, VirtualExpandScreen01, TestSize.Level1)
1008 {
1009 (void)system("param set rosen.uni.partialrender.enabled 0");
1010
1011 DisplayTestUtils utils;
1012 ASSERT_TRUE(utils.CreateSurface());
1013 defaultOption_.surface_ = utils.psurface_;
1014 defaultOption_.isForShot_ = true;
1015
1016 CHECK_TEST_INIT_SCREEN_STATE
1017 if (group == nullptr) {
1018 return;
1019 }
1020 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1021 sleep(TEST_SLEEP_S);
1022
1023 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1024 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1025 sleep(TEST_SLEEP_S);
1026 std::vector<ExpandOption> options = {{defaultScreenId_, 0, 0}, {virtualScreenId, defaultWidth_, 0}};
1027 ScreenId expansionId;
1028 ScreenManager::GetInstance().MakeExpand(options, expansionId);
1029 sleep(TEST_SLEEP_S);
1030
1031 CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
1032 virtualScreenId, group, screenGroupChangeListener);
1033 CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
1034 sleep(TEST_SLEEP_S);
1035 ASSERT_NE(SCREEN_ID_INVALID, expansionId);
1036 DisplayId virtualDisplayId = DisplayManager::GetInstance().GetDisplayByScreen(virtualScreenId)->GetId();
1037 ASSERT_NE(DISPLAY_ID_INVALID, virtualDisplayId);
1038
1039 sptr<Window> window = CreateWindowByDisplayId(virtualDisplayId);
1040 if (window == nullptr) {
1041 return;
1042 }
1043 ASSERT_NE(nullptr, window);
1044 ASSERT_EQ(true, DrawWindowColor(window, COLOR_RED));
1045 window->Show();
1046 sleep(TEST_SLEEP_S_LONG);
1047
1048 CheckStateDisplay(virtualDisplayId, virtualScreenId);
1049 window->Destroy();
1050 DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1051 sleep(TEST_SLEEP_S);
1052 ASSERT_EQ(DMError::DM_OK, res);
1053
1054 ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
1055 ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
1056 ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
1057 sleep(TEST_SLEEP_S);
1058
1059 (void)system("param set rosen.uni.partialrender.enabled 4");
1060 }
1061
1062 HWTEST_F(ScreenManagerTest, ResizeVirtualScreen01, TestSize.Level1)
1063 {
1064 DisplayTestUtils utils;
1065 ASSERT_TRUE(utils.CreateSurface());
1066 defaultOption_.surface_ = utils.psurface_;
1067 defaultOption_.isForShot_ = true;
1068
1069 CHECK_TEST_INIT_SCREEN_STATE
1070 if (group == nullptr) {
1071 return;
1072 }
1073 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1074 sleep(TEST_SLEEP_S);
1075
1076 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1077 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1078 sleep(TEST_SLEEP_S);
1079 std::vector<ExpandOption> options = {{defaultDisplayId_, 0, 0}, {virtualScreenId, defaultWidth_, 0}};
1080 ScreenId expansionId;
1081 ScreenManager::GetInstance().MakeExpand(options, expansionId);
1082 sleep(TEST_SLEEP_S);
1083
1084 DMError res = ScreenManager::GetInstance().ResizeVirtualScreen(virtualScreenId,
1085 resizeScreenWidthTestOne_, resizeScreenHeightTestOne_);
1086 sleep(TEST_SLEEP_S);
1087 ASSERT_EQ(DMError::DM_OK, res);
1088
1089 auto screen = ScreenManager::GetInstance().GetScreenById(virtualScreenId);
1090 ASSERT_TRUE(screen);
1091 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1092 ASSERT_EQ(resizeScreenWidthTestOne_, screen->GetWidth());
1093 ASSERT_EQ(resizeScreenHeightTestOne_, screen->GetHeight());
1094 } else {
1095 ASSERT_EQ(resizeScreenWidthTestThree_, screen->GetWidth());
1096 ASSERT_EQ(resizeScreenHeightTestThree_, screen->GetHeight());
1097 }
1098 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1099 }
1100
1101 HWTEST_F(ScreenManagerTest, ResizeVirtualScreen02, TestSize.Level1)
1102 {
1103 DisplayTestUtils utils;
1104 ASSERT_TRUE(utils.CreateSurface());
1105 defaultOption_.surface_ = utils.psurface_;
1106 defaultOption_.isForShot_ = true;
1107
1108 CHECK_TEST_INIT_SCREEN_STATE
1109 if (group == nullptr) {
1110 return;
1111 }
1112 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1113 sleep(TEST_SLEEP_S);
1114
1115 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1116 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1117 sleep(TEST_SLEEP_S);
1118 std::vector<ExpandOption> options = {{defaultDisplayId_, 0, 0}, {virtualScreenId, defaultWidth_, 0}};
1119 ScreenId expansionId;
1120 ScreenManager::GetInstance().MakeExpand(options, expansionId);
1121 sleep(TEST_SLEEP_S);
1122
1123 DMError res = ScreenManager::GetInstance().ResizeVirtualScreen(virtualScreenId,
1124 resizeScreenWidthTestTwo_, resizeScreenHeightTestTwo_);
1125 sleep(TEST_SLEEP_S);
1126 ASSERT_EQ(DMError::DM_OK, res);
1127
1128 auto screen = ScreenManager::GetInstance().GetScreenById(virtualScreenId);
1129 ASSERT_TRUE(screen);
1130 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1131 ASSERT_EQ(resizeScreenWidthTestTwo_, screen->GetWidth());
1132 ASSERT_EQ(resizeScreenHeightTestTwo_, screen->GetHeight());
1133 } else {
1134 ASSERT_EQ(resizeScreenWidthTestThree_, screen->GetWidth());
1135 ASSERT_EQ(resizeScreenHeightTestThree_, screen->GetHeight());
1136 }
1137 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1138 }
1139
1140 HWTEST_F(ScreenManagerTest, ResizeVirtualScreen03, TestSize.Level1)
1141 {
1142 DisplayTestUtils utils;
1143 ASSERT_TRUE(utils.CreateSurface());
1144 defaultOption_.surface_ = utils.psurface_;
1145 defaultOption_.isForShot_ = true;
1146
1147 CHECK_TEST_INIT_SCREEN_STATE
1148 if (group == nullptr) {
1149 return;
1150 }
1151 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1152 sleep(TEST_SLEEP_S);
1153
1154 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1155 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1156 sleep(TEST_SLEEP_S);
1157 std::vector<ExpandOption> options = {{defaultDisplayId_, 0, 0}, {virtualScreenId, defaultWidth_, 0}};
1158 ScreenId expansionId;
1159 ScreenManager::GetInstance().MakeExpand(options, expansionId);
1160 sleep(TEST_SLEEP_S);
1161
1162 DMError res = ScreenManager::GetInstance().ResizeVirtualScreen(virtualScreenId + 1,
1163 resizeScreenWidthTestOne_, resizeScreenHeightTestOne_);
1164 sleep(TEST_SLEEP_S);
1165 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1166 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1167 } else {
1168 ASSERT_EQ(DMError::DM_OK, res);
1169 }
1170 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1171 }
1172
1173 HWTEST_F(ScreenManagerTest, SetVirtualScreenRefreshRate01, TestSize.Level1)
1174 {
1175 DisplayTestUtils utils;
1176 ASSERT_TRUE(utils.CreateSurface());
1177 defaultOption_.surface_ = utils.psurface_;
1178 defaultOption_.isForShot_ = true;
1179
1180 CHECK_TEST_INIT_SCREEN_STATE
1181 if (group == nullptr) {
1182 return;
1183 }
1184 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1185 sleep(TEST_SLEEP_S);
1186
1187 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1188 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1189 sleep(TEST_SLEEP_S);
1190
1191 std::vector<ScreenId> screenIds;
1192 screenIds.push_back(virtualScreenId);
1193 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1194 sleep(TEST_SLEEP_S);
1195
1196 DMError res = ScreenManager::GetInstance().SetVirtualScreenRefreshRate(virtualScreenId, refreshIntervalTwo_);
1197 sleep(TEST_SLEEP_S);
1198 ASSERT_EQ(DMError::DM_OK, res);
1199
1200 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1201 }
1202
1203 HWTEST_F(ScreenManagerTest, SetVirtualScreenRefreshRate02, TestSize.Level1)
1204 {
1205 DisplayTestUtils utils;
1206 ASSERT_TRUE(utils.CreateSurface());
1207 defaultOption_.surface_ = utils.psurface_;
1208 defaultOption_.isForShot_ = true;
1209
1210 CHECK_TEST_INIT_SCREEN_STATE
1211 if (group == nullptr) {
1212 return;
1213 }
1214 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1215 sleep(TEST_SLEEP_S);
1216
1217 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1218 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1219 sleep(TEST_SLEEP_S);
1220
1221 std::vector<ScreenId> screenIds;
1222 screenIds.push_back(virtualScreenId);
1223 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1224 sleep(TEST_SLEEP_S);
1225
1226 DMError res = ScreenManager::GetInstance().SetVirtualScreenRefreshRate(virtualScreenId, refreshIntervalZero_);
1227 sleep(TEST_SLEEP_S);
1228 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1229 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1230 } else {
1231 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
1232 }
1233
1234 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1235 }
1236
1237 HWTEST_F(ScreenManagerTest, SetVirtualScreenRefreshRate03, TestSize.Level1)
1238 {
1239 DisplayTestUtils utils;
1240 ASSERT_TRUE(utils.CreateSurface());
1241 defaultOption_.surface_ = utils.psurface_;
1242 defaultOption_.isForShot_ = true;
1243
1244 CHECK_TEST_INIT_SCREEN_STATE
1245 if (group == nullptr) {
1246 return;
1247 }
1248 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1249 sleep(TEST_SLEEP_S);
1250
1251 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1252 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1253 sleep(TEST_SLEEP_S);
1254
1255 std::vector<ScreenId> screenIds;
1256 screenIds.push_back(virtualScreenId);
1257 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1258 sleep(TEST_SLEEP_S);
1259
1260 DMError res = ScreenManager::GetInstance().SetVirtualScreenRefreshRate(virtualScreenId, refreshIntervalMax_);
1261 sleep(TEST_SLEEP_S);
1262 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1263 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1264 } else {
1265 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
1266 }
1267
1268 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1269 }
1270
1271 HWTEST_F(ScreenManagerTest, SetVirtualScreenRefreshRate04, TestSize.Level1)
1272 {
1273 DMError res = ScreenManager::GetInstance().SetVirtualScreenRefreshRate(defaultScreenId_, refreshIntervalTwo_);
1274 sleep(TEST_SLEEP_S);
1275 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1276 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1277 } else {
1278 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
1279 }
1280 }
1281
1282 /**
1283 * @tc.name: SetVirtualScreenMaxRefreshRate01
1284 * @tc.desc: Create a virtual screen and set its refresh rate to 0
1285 * @tc.type: FUNC
1286 * @tc.require: issueIATA2N
1287 */
1288 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate01, TestSize.Level1)
1289 {
1290 DisplayTestUtils utils;
1291 ASSERT_TRUE(utils.CreateSurface());
1292 defaultOption_.surface_ = utils.psurface_;
1293 defaultOption_.isForShot_ = true;
1294
1295 CHECK_TEST_INIT_SCREEN_STATE
1296 if (group == nullptr) {
1297 return;
1298 }
1299 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1300 sleep(TEST_SLEEP_S);
1301
1302 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1303 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1304 sleep(TEST_SLEEP_S);
1305
1306 std::vector<ScreenId> screenIds;
1307 screenIds.push_back(virtualScreenId);
1308 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1309 sleep(TEST_SLEEP_S);
1310 uint32_t refreshRate = 0;
1311 uint32_t actualRefreshRate = 0;
1312 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1313 refreshRate, actualRefreshRate);
1314 sleep(TEST_SLEEP_S);
1315 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1316 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1317 } else {
1318 ASSERT_EQ(DMError::DM_OK, res);
1319 }
1320 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1321 }
1322
1323 /**
1324 * @tc.name: SetVirtualScreenMaxRefreshRate02
1325 * @tc.desc: Create a virtual screen and set its refresh rate to 31
1326 * @tc.type: FUNC
1327 * @tc.require: issueIATA2N
1328 */
1329 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate02, TestSize.Level1)
1330 {
1331 DisplayTestUtils utils;
1332 ASSERT_TRUE(utils.CreateSurface());
1333 defaultOption_.surface_ = utils.psurface_;
1334 defaultOption_.isForShot_ = true;
1335
1336 CHECK_TEST_INIT_SCREEN_STATE
1337 if (group == nullptr) {
1338 return;
1339 }
1340 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1341 sleep(TEST_SLEEP_S);
1342
1343 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1344 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1345 sleep(TEST_SLEEP_S);
1346
1347 std::vector<ScreenId> screenIds;
1348 screenIds.push_back(virtualScreenId);
1349 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1350 sleep(TEST_SLEEP_S);
1351 uint32_t refreshRate = 31;
1352 uint32_t actualRefreshRate = 0;
1353 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1354 refreshRate, actualRefreshRate);
1355 sleep(TEST_SLEEP_S);
1356 ASSERT_EQ(DMError::DM_OK, res);
1357 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1358 }
1359
1360 /**
1361 * @tc.name: SetVirtualScreenMaxRefreshRate03
1362 * @tc.desc: Create a virtual screen and set its refresh rate to 120
1363 * @tc.type: FUNC
1364 * @tc.require: issueIATA2N
1365 */
1366 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate03, TestSize.Level1)
1367 {
1368 DisplayTestUtils utils;
1369 ASSERT_TRUE(utils.CreateSurface());
1370 defaultOption_.surface_ = utils.psurface_;
1371 defaultOption_.isForShot_ = true;
1372
1373 CHECK_TEST_INIT_SCREEN_STATE
1374 if (group == nullptr) {
1375 return;
1376 }
1377 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1378 sleep(TEST_SLEEP_S);
1379
1380 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1381 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1382 sleep(TEST_SLEEP_S);
1383
1384 std::vector<ScreenId> screenIds;
1385 screenIds.push_back(virtualScreenId);
1386 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1387 sleep(TEST_SLEEP_S);
1388 uint32_t refreshRate = 120;
1389 uint32_t actualRefreshRate = 0;
1390 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1391 refreshRate, actualRefreshRate);
1392 sleep(TEST_SLEEP_S);
1393 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1394 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1395 } else {
1396 ASSERT_EQ(DMError::DM_OK, res);
1397 }
1398 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1399 }
1400
1401 /**
1402 * @tc.name: SetVirtualScreenMaxRefreshRate04
1403 * @tc.desc: Create a virtual screen and set its refresh rate to 61
1404 * @tc.type: FUNC
1405 * @tc.require: issueIATA2N
1406 */
1407 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate04, TestSize.Level1)
1408 {
1409 DisplayTestUtils utils;
1410 ASSERT_TRUE(utils.CreateSurface());
1411 defaultOption_.surface_ = utils.psurface_;
1412 defaultOption_.isForShot_ = true;
1413
1414 CHECK_TEST_INIT_SCREEN_STATE
1415 if (group == nullptr) {
1416 return;
1417 }
1418 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1419 sleep(TEST_SLEEP_S);
1420
1421 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1422 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1423 sleep(TEST_SLEEP_S);
1424
1425 std::vector<ScreenId> screenIds;
1426 screenIds.push_back(virtualScreenId);
1427 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1428 sleep(TEST_SLEEP_S);
1429 uint32_t refreshRate = 61;
1430 uint32_t actualRefreshRate = 0;
1431 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1432 refreshRate, actualRefreshRate);
1433 sleep(TEST_SLEEP_S);
1434 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
1435 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1436 }
1437
1438 /**
1439 * @tc.name: SetVirtualScreenMaxRefreshRate05
1440 * @tc.desc: Create a virtual screen and set its refresh rate to 1
1441 * @tc.type: FUNC
1442 * @tc.require: issueIATA2N
1443 */
1444 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate05, TestSize.Level1)
1445 {
1446 DisplayTestUtils utils;
1447 ASSERT_TRUE(utils.CreateSurface());
1448 defaultOption_.surface_ = utils.psurface_;
1449 defaultOption_.isForShot_ = true;
1450
1451 CHECK_TEST_INIT_SCREEN_STATE
1452 if (group == nullptr) {
1453 return;
1454 }
1455 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1456 sleep(TEST_SLEEP_S);
1457
1458 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1459 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1460 sleep(TEST_SLEEP_S);
1461
1462 std::vector<ScreenId> screenIds;
1463 screenIds.push_back(virtualScreenId);
1464 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1465 sleep(TEST_SLEEP_S);
1466 uint32_t refreshRate = 1;
1467 uint32_t actualRefreshRate = 0;
1468 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1469 refreshRate, actualRefreshRate);
1470 sleep(TEST_SLEEP_S);
1471 ASSERT_EQ(DMError::DM_OK, res);
1472 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1473 }
1474
1475 /**
1476 * @tc.name: SetVirtualScreenMaxRefreshRate06
1477 * @tc.desc: Create a virtual screen and set its refresh rate to 18
1478 * @tc.type: FUNC
1479 * @tc.require: issueIATA2N
1480 */
1481 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate06, TestSize.Level1)
1482 {
1483 DisplayTestUtils utils;
1484 ASSERT_TRUE(utils.CreateSurface());
1485 defaultOption_.surface_ = utils.psurface_;
1486 defaultOption_.isForShot_ = true;
1487
1488 CHECK_TEST_INIT_SCREEN_STATE
1489 if (group == nullptr) {
1490 return;
1491 }
1492 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1493 sleep(TEST_SLEEP_S);
1494
1495 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1496 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1497 sleep(TEST_SLEEP_S);
1498
1499 std::vector<ScreenId> screenIds;
1500 screenIds.push_back(virtualScreenId);
1501 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1502 sleep(TEST_SLEEP_S);
1503 uint32_t refreshRate = 18;
1504 uint32_t actualRefreshRate = 0;
1505 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1506 refreshRate, actualRefreshRate);
1507 sleep(TEST_SLEEP_S);
1508 ASSERT_EQ(DMError::DM_OK, res);
1509 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1510 }
1511
1512 /**
1513 * @tc.name: SetVirtualScreenMaxRefreshRate07
1514 * @tc.desc: Create a virtual screen and set its refresh rate to 24
1515 * @tc.type: FUNC
1516 * @tc.require: issueIATA2N
1517 */
1518 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate07, TestSize.Level1)
1519 {
1520 DisplayTestUtils utils;
1521 ASSERT_TRUE(utils.CreateSurface());
1522 defaultOption_.surface_ = utils.psurface_;
1523 defaultOption_.isForShot_ = true;
1524
1525 CHECK_TEST_INIT_SCREEN_STATE
1526 if (group == nullptr) {
1527 return;
1528 }
1529 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1530 sleep(TEST_SLEEP_S);
1531
1532 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1533 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1534 sleep(TEST_SLEEP_S);
1535
1536 std::vector<ScreenId> screenIds;
1537 screenIds.push_back(virtualScreenId);
1538 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1539 sleep(TEST_SLEEP_S);
1540 uint32_t refreshRate = 24;
1541 uint32_t actualRefreshRate = 0;
1542 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1543 refreshRate, actualRefreshRate);
1544 sleep(TEST_SLEEP_S);
1545 ASSERT_EQ(DMError::DM_OK, res);
1546 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1547 }
1548
1549 /**
1550 * @tc.name: SetVirtualScreenMaxRefreshRate08
1551 * @tc.desc: Create a virtual screen and set its refresh rate to 27
1552 * @tc.type: FUNC
1553 * @tc.require: issueIATA2N
1554 */
1555 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate08, TestSize.Level1)
1556 {
1557 DisplayTestUtils utils;
1558 ASSERT_TRUE(utils.CreateSurface());
1559 defaultOption_.surface_ = utils.psurface_;
1560 defaultOption_.isForShot_ = true;
1561
1562 CHECK_TEST_INIT_SCREEN_STATE
1563 if (group == nullptr) {
1564 return;
1565 }
1566 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1567 sleep(TEST_SLEEP_S);
1568
1569 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1570 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1571 sleep(TEST_SLEEP_S);
1572
1573 std::vector<ScreenId> screenIds;
1574 screenIds.push_back(virtualScreenId);
1575 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1576 sleep(TEST_SLEEP_S);
1577 uint32_t refreshRate = 27;
1578 uint32_t actualRefreshRate = 0;
1579 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1580 refreshRate, actualRefreshRate);
1581 sleep(TEST_SLEEP_S);
1582 ASSERT_EQ(DMError::DM_OK, res);
1583 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1584 }
1585
1586 /**
1587 * @tc.name: SetVirtualScreenMaxRefreshRate09
1588 * @tc.desc: Create a virtual screen and set its refresh rate to 37
1589 * @tc.type: FUNC
1590 * @tc.require: issueIATA2N
1591 */
1592 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate09, TestSize.Level1)
1593 {
1594 DisplayTestUtils utils;
1595 ASSERT_TRUE(utils.CreateSurface());
1596 defaultOption_.surface_ = utils.psurface_;
1597 defaultOption_.isForShot_ = true;
1598
1599 CHECK_TEST_INIT_SCREEN_STATE
1600 if (group == nullptr) {
1601 return;
1602 }
1603 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1604 sleep(TEST_SLEEP_S);
1605
1606 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1607 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1608 sleep(TEST_SLEEP_S);
1609
1610 std::vector<ScreenId> screenIds;
1611 screenIds.push_back(virtualScreenId);
1612 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1613 sleep(TEST_SLEEP_S);
1614 uint32_t refreshRate = 37;
1615 uint32_t actualRefreshRate = 0;
1616 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1617 refreshRate, actualRefreshRate);
1618 sleep(TEST_SLEEP_S);
1619 ASSERT_EQ(DMError::DM_OK, res);
1620 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1621 }
1622
1623 /**
1624 * @tc.name: SetVirtualScreenMaxRefreshRate10
1625 * @tc.desc: Create a virtual screen and set its refresh rate to 47
1626 * @tc.type: FUNC
1627 * @tc.require: issueIATA2N
1628 */
1629 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate10, TestSize.Level1)
1630 {
1631 DisplayTestUtils utils;
1632 ASSERT_TRUE(utils.CreateSurface());
1633 defaultOption_.surface_ = utils.psurface_;
1634 defaultOption_.isForShot_ = true;
1635
1636 CHECK_TEST_INIT_SCREEN_STATE
1637 if (group == nullptr) {
1638 return;
1639 }
1640 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1641 sleep(TEST_SLEEP_S);
1642
1643 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1644 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1645 sleep(TEST_SLEEP_S);
1646
1647 std::vector<ScreenId> screenIds;
1648 screenIds.push_back(virtualScreenId);
1649 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1650 sleep(TEST_SLEEP_S);
1651 uint32_t refreshRate = 47;
1652 uint32_t actualRefreshRate = 0;
1653 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1654 refreshRate, actualRefreshRate);
1655 sleep(TEST_SLEEP_S);
1656 ASSERT_EQ(DMError::DM_OK, res);
1657 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1658 }
1659
1660 /**
1661 * @tc.name: SetVirtualScreenMaxRefreshRate11
1662 * @tc.desc: Create a virtual screen and set its refresh rate to 57
1663 * @tc.type: FUNC
1664 * @tc.require: issueIATA2N
1665 */
1666 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate11, TestSize.Level1)
1667 {
1668 DisplayTestUtils utils;
1669 ASSERT_TRUE(utils.CreateSurface());
1670 defaultOption_.surface_ = utils.psurface_;
1671 defaultOption_.isForShot_ = true;
1672
1673 CHECK_TEST_INIT_SCREEN_STATE
1674 if (group == nullptr) {
1675 return;
1676 }
1677 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1678 sleep(TEST_SLEEP_S);
1679
1680 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1681 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1682 sleep(TEST_SLEEP_S);
1683
1684 std::vector<ScreenId> screenIds;
1685 screenIds.push_back(virtualScreenId);
1686 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1687 sleep(TEST_SLEEP_S);
1688 uint32_t refreshRate = 57;
1689 uint32_t actualRefreshRate = 0;
1690 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1691 refreshRate, actualRefreshRate);
1692 sleep(TEST_SLEEP_S);
1693 ASSERT_EQ(DMError::DM_OK, res);
1694 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1695 }
1696
1697 /**
1698 * @tc.name: SetVirtualScreenMaxRefreshRate12
1699 * @tc.desc: Create a virtual screen and set its refresh rate to 44
1700 * @tc.type: FUNC
1701 * @tc.require: issueIATA2N
1702 */
1703 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate12, TestSize.Level1)
1704 {
1705 DisplayTestUtils utils;
1706 ASSERT_TRUE(utils.CreateSurface());
1707 defaultOption_.surface_ = utils.psurface_;
1708 defaultOption_.isForShot_ = true;
1709
1710 CHECK_TEST_INIT_SCREEN_STATE
1711 if (group == nullptr) {
1712 return;
1713 }
1714 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1715 sleep(TEST_SLEEP_S);
1716
1717 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1718 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1719 sleep(TEST_SLEEP_S);
1720
1721 std::vector<ScreenId> screenIds;
1722 screenIds.push_back(virtualScreenId);
1723 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1724 sleep(TEST_SLEEP_S);
1725 uint32_t refreshRate = 44;
1726 uint32_t actualRefreshRate = 0;
1727 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1728 refreshRate, actualRefreshRate);
1729 sleep(TEST_SLEEP_S);
1730 ASSERT_EQ(DMError::DM_OK, res);
1731 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1732 }
1733
1734 /**
1735 * @tc.name: SetVirtualScreenMaxRefreshRate13
1736 * @tc.desc: Create a virtual screen and set its refresh rate to 34
1737 * @tc.type: FUNC
1738 * @tc.require: issueIATA2N
1739 */
1740 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate13, TestSize.Level1)
1741 {
1742 DisplayTestUtils utils;
1743 ASSERT_TRUE(utils.CreateSurface());
1744 defaultOption_.surface_ = utils.psurface_;
1745 defaultOption_.isForShot_ = true;
1746
1747 CHECK_TEST_INIT_SCREEN_STATE
1748 if (group == nullptr) {
1749 return;
1750 }
1751 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1752 sleep(TEST_SLEEP_S);
1753
1754 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1755 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1756 sleep(TEST_SLEEP_S);
1757
1758 std::vector<ScreenId> screenIds;
1759 screenIds.push_back(virtualScreenId);
1760 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1761 sleep(TEST_SLEEP_S);
1762 uint32_t refreshRate = 34;
1763 uint32_t actualRefreshRate = 0;
1764 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1765 refreshRate, actualRefreshRate);
1766 sleep(TEST_SLEEP_S);
1767 ASSERT_EQ(DMError::DM_OK, res);
1768 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1769 }
1770
1771 /**
1772 * @tc.name: SetVirtualScreenMaxRefreshRate14
1773 * @tc.desc: Get main screen and set its refresh rate to 34
1774 * @tc.type: FUNC
1775 * @tc.require: issueIATA2N
1776 */
1777 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate14, TestSize.Level1)
1778 {
1779 DisplayTestUtils utils;
1780 ASSERT_TRUE(utils.CreateSurface());
1781 defaultOption_.surface_ = utils.psurface_;
1782 defaultOption_.isForShot_ = true;
1783
1784 CHECK_TEST_INIT_SCREEN_STATE
1785 if (group == nullptr) {
1786 return;
1787 }
1788 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1789 sleep(TEST_SLEEP_S);
1790
1791 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1792 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1793 sleep(TEST_SLEEP_S);
1794
1795 std::vector<ScreenId> screenIds;
1796 screenIds.push_back(virtualScreenId);
1797 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1798 sleep(TEST_SLEEP_S);
1799 uint32_t refreshRate = 34;
1800 uint32_t actualRefreshRate = 0;
1801 ScreenId mainID = 0;
1802 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(mainID,
1803 refreshRate, actualRefreshRate);
1804 sleep(TEST_SLEEP_S);
1805 ASSERT_EQ(DMError::DM_OK, res);
1806 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1807 }
1808
1809
1810 /**
1811 * @tc.name: SetVirtualScreenMaxRefreshRate15
1812 * @tc.desc: Create a virtual screen and set its refresh rate to 1
1813 * @tc.type: FUNC
1814 * @tc.require: issueIATA2N
1815 */
1816 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate15, TestSize.Level1)
1817 {
1818 DisplayTestUtils utils;
1819 ASSERT_TRUE(utils.CreateSurface());
1820 defaultOption_.surface_ = utils.psurface_;
1821 defaultOption_.isForShot_ = true;
1822
1823 CHECK_TEST_INIT_SCREEN_STATE
1824 if (group == nullptr) {
1825 return;
1826 }
1827 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1828 sleep(TEST_SLEEP_S);
1829
1830 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1831 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1832 sleep(TEST_SLEEP_S);
1833
1834 std::vector<ScreenId> screenIds;
1835 screenIds.push_back(virtualScreenId);
1836 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1837 sleep(TEST_SLEEP_S);
1838 uint32_t refreshRate = 1;
1839 uint32_t actualRefreshRate = 0;
1840 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1841 refreshRate, actualRefreshRate);
1842 sleep(TEST_SLEEP_S);
1843 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
1844 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1845 }
1846
1847 /**
1848 * @tc.name: SetVirtualScreenMaxRefreshRate16
1849 * @tc.desc: Create a virtual screen and set its refresh rate to 11
1850 * @tc.type: FUNC
1851 * @tc.require: issueIATA2N
1852 */
1853 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate16, TestSize.Level1)
1854 {
1855 DisplayTestUtils utils;
1856 ASSERT_TRUE(utils.CreateSurface());
1857 defaultOption_.surface_ = utils.psurface_;
1858 defaultOption_.isForShot_ = true;
1859
1860 CHECK_TEST_INIT_SCREEN_STATE
1861 if (group == nullptr) {
1862 return;
1863 }
1864 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1865 sleep(TEST_SLEEP_S);
1866
1867 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1868 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1869 sleep(TEST_SLEEP_S);
1870
1871 std::vector<ScreenId> screenIds;
1872 screenIds.push_back(virtualScreenId);
1873 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1874 sleep(TEST_SLEEP_S);
1875 uint32_t refreshRate = 11;
1876 uint32_t actualRefreshRate = 0;
1877 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1878 refreshRate, actualRefreshRate);
1879 sleep(TEST_SLEEP_S);
1880 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
1881 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1882 }
1883
1884 /**
1885 * @tc.name: SetVirtualScreenMaxRefreshRate17
1886 * @tc.desc: Create a virtual screen and set its refresh rate to 21
1887 * @tc.type: FUNC
1888 * @tc.require: issueIATA2N
1889 */
1890 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate17, TestSize.Level1)
1891 {
1892 DisplayTestUtils utils;
1893 ASSERT_TRUE(utils.CreateSurface());
1894 defaultOption_.surface_ = utils.psurface_;
1895 defaultOption_.isForShot_ = true;
1896
1897 CHECK_TEST_INIT_SCREEN_STATE
1898 if (group == nullptr) {
1899 return;
1900 }
1901 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1902 sleep(TEST_SLEEP_S);
1903
1904 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1905 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1906 sleep(TEST_SLEEP_S);
1907
1908 std::vector<ScreenId> screenIds;
1909 screenIds.push_back(virtualScreenId);
1910 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1911 sleep(TEST_SLEEP_S);
1912 uint32_t refreshRate = 21;
1913 uint32_t actualRefreshRate = 0;
1914 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1915 refreshRate, actualRefreshRate);
1916 sleep(TEST_SLEEP_S);
1917 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
1918 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1919 }
1920
1921 /**
1922 * @tc.name: SetVirtualScreenMaxRefreshRate18
1923 * @tc.desc: Create a virtual screen and set its refresh rate to 41
1924 * @tc.type: FUNC
1925 * @tc.require: issueIATA2N
1926 */
1927 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate18, TestSize.Level1)
1928 {
1929 DisplayTestUtils utils;
1930 ASSERT_TRUE(utils.CreateSurface());
1931 defaultOption_.surface_ = utils.psurface_;
1932 defaultOption_.isForShot_ = true;
1933
1934 CHECK_TEST_INIT_SCREEN_STATE
1935 if (group == nullptr) {
1936 return;
1937 }
1938 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1939 sleep(TEST_SLEEP_S);
1940
1941 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1942 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1943 sleep(TEST_SLEEP_S);
1944
1945 std::vector<ScreenId> screenIds;
1946 screenIds.push_back(virtualScreenId);
1947 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1948 sleep(TEST_SLEEP_S);
1949 uint32_t refreshRate = 71;
1950 uint32_t actualRefreshRate = 0;
1951 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1952 refreshRate, actualRefreshRate);
1953 sleep(TEST_SLEEP_S);
1954 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
1955 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1956 }
1957
1958 /**
1959 * @tc.name: SetVirtualScreenMaxRefreshRate19
1960 * @tc.desc: Create a virtual screen and set its refresh rate to 51
1961 * @tc.type: FUNC
1962 * @tc.require: issueIATA2N
1963 */
1964 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate19, TestSize.Level1)
1965 {
1966 DisplayTestUtils utils;
1967 ASSERT_TRUE(utils.CreateSurface());
1968 defaultOption_.surface_ = utils.psurface_;
1969 defaultOption_.isForShot_ = true;
1970
1971 CHECK_TEST_INIT_SCREEN_STATE
1972 if (group == nullptr) {
1973 return;
1974 }
1975 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1976 sleep(TEST_SLEEP_S);
1977
1978 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1979 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1980 sleep(TEST_SLEEP_S);
1981
1982 std::vector<ScreenId> screenIds;
1983 screenIds.push_back(virtualScreenId);
1984 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1985 sleep(TEST_SLEEP_S);
1986 uint32_t refreshRate = 51;
1987 uint32_t actualRefreshRate = 0;
1988 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1989 refreshRate, actualRefreshRate);
1990 sleep(TEST_SLEEP_S);
1991 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
1992 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1993 }
1994
1995 /**
1996 * @tc.name: SetVirtualScreenMaxRefreshRate20
1997 * @tc.desc: Create a virtual screen and set its refresh rate to 61
1998 * @tc.type: FUNC
1999 * @tc.require: issueIATA2N
2000 */
2001 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate20, TestSize.Level1)
2002 {
2003 DisplayTestUtils utils;
2004 ASSERT_TRUE(utils.CreateSurface());
2005 defaultOption_.surface_ = utils.psurface_;
2006 defaultOption_.isForShot_ = true;
2007
2008 CHECK_TEST_INIT_SCREEN_STATE
2009 if (group == nullptr) {
2010 return;
2011 }
2012 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
2013 sleep(TEST_SLEEP_S);
2014
2015 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
2016 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
2017 sleep(TEST_SLEEP_S);
2018
2019 std::vector<ScreenId> screenIds;
2020 screenIds.push_back(virtualScreenId);
2021 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
2022 sleep(TEST_SLEEP_S);
2023 uint32_t refreshRate = 61;
2024 uint32_t actualRefreshRate = 0;
2025 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
2026 refreshRate, actualRefreshRate);
2027 sleep(TEST_SLEEP_S);
2028 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
2029 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
2030 }
2031
2032 /**
2033 * @tc.name: SetVirtualScreenMaxRefreshRate21
2034 * @tc.desc: Create a virtual screen and set its refresh rate to 71
2035 * @tc.type: FUNC
2036 * @tc.require: issueIATA2N
2037 */
2038 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate21, TestSize.Level1)
2039 {
2040 DisplayTestUtils utils;
2041 ASSERT_TRUE(utils.CreateSurface());
2042 defaultOption_.surface_ = utils.psurface_;
2043 defaultOption_.isForShot_ = true;
2044
2045 CHECK_TEST_INIT_SCREEN_STATE
2046 if (group == nullptr) {
2047 return;
2048 }
2049 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
2050 sleep(TEST_SLEEP_S);
2051
2052 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
2053 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
2054 sleep(TEST_SLEEP_S);
2055
2056 std::vector<ScreenId> screenIds;
2057 screenIds.push_back(virtualScreenId);
2058 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
2059 sleep(TEST_SLEEP_S);
2060 uint32_t refreshRate = 71;
2061 uint32_t actualRefreshRate = 0;
2062 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
2063 refreshRate, actualRefreshRate);
2064 sleep(TEST_SLEEP_S);
2065 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
2066 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
2067 }
2068
2069 /**
2070 * @tc.name: SetVirtualScreenMaxRefreshRate22
2071 * @tc.desc: Create a virtual screen and set its refresh rate to 81
2072 * @tc.type: FUNC
2073 * @tc.require: issueIATA2N
2074 */
2075 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate22, TestSize.Level1)
2076 {
2077 DisplayTestUtils utils;
2078 ASSERT_TRUE(utils.CreateSurface());
2079 defaultOption_.surface_ = utils.psurface_;
2080 defaultOption_.isForShot_ = true;
2081
2082 CHECK_TEST_INIT_SCREEN_STATE
2083 if (group == nullptr) {
2084 return;
2085 }
2086 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
2087 sleep(TEST_SLEEP_S);
2088
2089 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
2090 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
2091 sleep(TEST_SLEEP_S);
2092
2093 std::vector<ScreenId> screenIds;
2094 screenIds.push_back(virtualScreenId);
2095 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
2096 sleep(TEST_SLEEP_S);
2097 uint32_t refreshRate = 81;
2098 uint32_t actualRefreshRate = 0;
2099 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
2100 refreshRate, actualRefreshRate);
2101 sleep(TEST_SLEEP_S);
2102 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
2103 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
2104 }
2105
2106 /**
2107 * @tc.name: SetVirtualScreenMaxRefreshRate23
2108 * @tc.desc: Create a virtual screen and set its refresh rate to 91
2109 * @tc.type: FUNC
2110 * @tc.require: issueIATA2N
2111 */
2112 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate23, TestSize.Level1)
2113 {
2114 DisplayTestUtils utils;
2115 ASSERT_TRUE(utils.CreateSurface());
2116 defaultOption_.surface_ = utils.psurface_;
2117 defaultOption_.isForShot_ = true;
2118
2119 CHECK_TEST_INIT_SCREEN_STATE
2120 if (group == nullptr) {
2121 return;
2122 }
2123 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
2124 sleep(TEST_SLEEP_S);
2125
2126 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
2127 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
2128 sleep(TEST_SLEEP_S);
2129
2130 std::vector<ScreenId> screenIds;
2131 screenIds.push_back(virtualScreenId);
2132 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
2133 sleep(TEST_SLEEP_S);
2134 uint32_t refreshRate = 91;
2135 uint32_t actualRefreshRate = 0;
2136 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
2137 refreshRate, actualRefreshRate);
2138 sleep(TEST_SLEEP_S);
2139 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
2140 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
2141 }
2142
2143 /**
2144 * @tc.name: SetVirtualScreenMaxRefreshRate24
2145 * @tc.desc: Create a virtual screen and set its refresh rate to 101
2146 * @tc.type: FUNC
2147 * @tc.require: issueIATA2N
2148 */
2149 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate24, TestSize.Level1)
2150 {
2151 DisplayTestUtils utils;
2152 ASSERT_TRUE(utils.CreateSurface());
2153 defaultOption_.surface_ = utils.psurface_;
2154 defaultOption_.isForShot_ = true;
2155
2156 CHECK_TEST_INIT_SCREEN_STATE
2157 if (group == nullptr) {
2158 return;
2159 }
2160 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
2161 sleep(TEST_SLEEP_S);
2162
2163 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
2164 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
2165 sleep(TEST_SLEEP_S);
2166
2167 std::vector<ScreenId> screenIds;
2168 screenIds.push_back(virtualScreenId);
2169 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
2170 sleep(TEST_SLEEP_S);
2171 uint32_t refreshRate = 101;
2172 uint32_t actualRefreshRate = 0;
2173 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
2174 refreshRate, actualRefreshRate);
2175 sleep(TEST_SLEEP_S);
2176 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
2177 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
2178 }
2179
2180 /**
2181 * @tc.name: SetVirtualScreenMaxRefreshRate25
2182 * @tc.desc: Create a virtual screen and set its refresh rate to 111
2183 * @tc.type: FUNC
2184 * @tc.require: issueIATA2N
2185 */
2186 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate25, TestSize.Level1)
2187 {
2188 DisplayTestUtils utils;
2189 ASSERT_TRUE(utils.CreateSurface());
2190 defaultOption_.surface_ = utils.psurface_;
2191 defaultOption_.isForShot_ = true;
2192
2193 CHECK_TEST_INIT_SCREEN_STATE
2194 if (group == nullptr) {
2195 return;
2196 }
2197 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
2198 sleep(TEST_SLEEP_S);
2199
2200 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
2201 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
2202 sleep(TEST_SLEEP_S);
2203
2204 std::vector<ScreenId> screenIds;
2205 screenIds.push_back(virtualScreenId);
2206 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
2207 sleep(TEST_SLEEP_S);
2208 uint32_t refreshRate = 111;
2209 uint32_t actualRefreshRate = 0;
2210 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
2211 refreshRate, actualRefreshRate);
2212 sleep(TEST_SLEEP_S);
2213 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
2214 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
2215 }
2216
2217 /**
2218 * @tc.name: SetVirtualScreenMaxRefreshRate26
2219 * @tc.desc: Create a virtual screen and set its refresh rate to 121
2220 * @tc.type: FUNC
2221 * @tc.require: issueIATA2N
2222 */
2223 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate26, TestSize.Level1)
2224 {
2225 DisplayTestUtils utils;
2226 ASSERT_TRUE(utils.CreateSurface());
2227 defaultOption_.surface_ = utils.psurface_;
2228 defaultOption_.isForShot_ = true;
2229
2230 CHECK_TEST_INIT_SCREEN_STATE
2231 if (group == nullptr) {
2232 return;
2233 }
2234 ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
2235 sleep(TEST_SLEEP_S);
2236
2237 CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
2238 CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
2239 sleep(TEST_SLEEP_S);
2240
2241 std::vector<ScreenId> screenIds;
2242 screenIds.push_back(virtualScreenId);
2243 ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
2244 sleep(TEST_SLEEP_S);
2245 uint32_t refreshRate = 121;
2246 uint32_t actualRefreshRate = 0;
2247 DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
2248 refreshRate, actualRefreshRate);
2249 sleep(TEST_SLEEP_S);
2250 ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
2251 ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
2252 }
2253 }
2254 } // namespace Rosen
2255 } // namespace OHOS
2256