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