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     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
533     sleep(TEST_SLEEP_S);
534     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
535     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
536     std::vector<sptr<Screen>> screens;
537     ScreenManager::GetInstance().GetAllScreens(screens);
538     sleep(TEST_SLEEP_S);
539     sptr<Screen> defaultScreen = screens.front();
540     ASSERT_TRUE(defaultScreen);
541     std::vector<ExpandOption> options = {{defaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
542     ScreenId expansionGroup;
543     ScreenManager::GetInstance().MakeExpand(options, expansionGroup);
544     sleep(TEST_SLEEP_S);
545     if (SCREEN_ID_INVALID != expansionGroup) {
546         ASSERT_NE(SCREEN_ID_INVALID, expansionGroup);
547     }
548 
549     CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
550         virtualScreenId, group, screenGroupChangeListener);
551     CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
552     DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
553     sleep(TEST_SLEEP_S);
554     ASSERT_EQ(DMError::DM_OK, res);
555     CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
556     CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
557         virtualScreenId, group, screenGroupChangeListener);
558     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
559     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
560     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
561     ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
562 }
563 
564 /**
565  * @tc.name: ScreenManager09
566  * @tc.desc: Create a virtual screen as expansion of default screen, create windowNode on virtual screen,
567  *           and destroy virtual screen
568  * @tc.type: FUNC
569  */
570 HWTEST_F(ScreenManagerTest, ScreenManager09, Function | MediumTest | Level2)
571 {
572     (void)system("param set rosen.uni.partialrender.enabled 0");
573 
574     DisplayTestUtils utils;
575     ASSERT_TRUE(utils.CreateSurface());
576     defaultOption_.surface_ = utils.psurface_;
577     defaultOption_.isForShot_ = false;
578     CHECK_TEST_INIT_SCREEN_STATE
579     if (group == nullptr) {
580         return;
581     }
582     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
583     sleep(TEST_SLEEP_S);
584     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
585     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
586     sleep(TEST_SLEEP_S);
587     std::vector<ExpandOption> options = {{defaultScreenId_, 0, 0}, {virtualScreenId, defaultWidth_, 0}};
588     ScreenId expansionId;
589     ScreenManager::GetInstance().MakeExpand(options, expansionId);
590     sleep(TEST_SLEEP_S);
591     CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
592         virtualScreenId, group, screenGroupChangeListener);
593     CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
594     sleep(TEST_SLEEP_S);
595     ASSERT_NE(SCREEN_ID_INVALID, expansionId);
596     DisplayId virtualDisplayId = DisplayManager::GetInstance().GetDisplayByScreen(virtualScreenId)->GetId();
597     ASSERT_NE(DISPLAY_ID_INVALID, virtualDisplayId);
598     sptr<Window> window = CreateWindowByDisplayId(virtualDisplayId);
599     if (window == nullptr) {
600         return;
601     }
602     ASSERT_NE(nullptr, window);
603     ASSERT_EQ(true, DrawWindowColor(window, COLOR_RED));
604     sleep(TEST_SLEEP_S);
605     DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
606     sleep(TEST_SLEEP_S);
607     ASSERT_EQ(DMError::DM_OK, res);
608     CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
609     CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
610         virtualScreenId, group, screenGroupChangeListener);
611     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
612     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
613     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
614     ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
615     sleep(TEST_SLEEP_S);
616     window->Show();
617     sleep(TEST_SLEEP_S_LONG);
618     window->Destroy();
619 
620     (void)system("param set rosen.uni.partialrender.enabled 4");
621 }
622 
623 /**
624  * @tc.name: ScreenManager10
625  * @tc.desc: Create a virtual screen and destroy it for 10 times, it's not for shot.
626  * @tc.type: FUNC
627  */
628 HWTEST_F(ScreenManagerTest, ScreenManager10, Function | MediumTest | Level2)
629 {
630     DisplayTestUtils utils;
631     ASSERT_TRUE(utils.CreateSurface());
632     defaultOption_.surface_ = utils.psurface_;
633     defaultOption_.isForShot_ = false;
634     for (uint32_t i = 0; i < execTimes_; i++) {
635         CHECK_TEST_INIT_SCREEN_STATE
636         if (group == nullptr) {
637             return;
638         }
639         ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
640         sleep(TEST_SLEEP_S);
641         CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
642         CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
643         DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
644         sleep(TEST_SLEEP_S);
645         ASSERT_EQ(DMError::DM_OK, res);
646         CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
647         CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
648         ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
649         sleep(TEST_SLEEP_S);
650     }
651 }
652 
653 /**
654  * @tc.name: ScreenManager11
655  * @tc.desc: Create a virtual screen , mirror and destroy it for 10 times, it's not for shot.
656  * @tc.type: FUNC
657  * @tc.require: issueI5M2SK
658  */
659 HWTEST_F(ScreenManagerTest, ScreenManager11, Function | MediumTest | Level2)
660 {
661     DisplayTestUtils utils;
662     ASSERT_TRUE(utils.CreateSurface());
663     defaultOption_.surface_ = utils.psurface_;
664     defaultOption_.isForShot_ = false;
665     for (uint32_t i = 0; i < 10; i++) {
666         sleep(TEST_SLEEP_S);
667         CHECK_TEST_INIT_SCREEN_STATE
668         if (group == nullptr) {
669             return;
670         }
671         ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
672         sleep(TEST_SLEEP_S);
673         CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
674         CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
675 
676         std::vector<ScreenId> mirrorIds;
677         mirrorIds.push_back(virtualScreenId);
678         ScreenId mirrorGroup;
679         ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorIds, mirrorGroup);
680         sleep(TEST_SLEEP_S);
681         ASSERT_EQ(mirrorGroup, groupId);
682         CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::ADD_TO_GROUP,
683             virtualScreenId, group, screenGroupChangeListener);
684         CheckScreenGroupStateForMirror(ScreenGroupChangeEvent::ADD_TO_GROUP, mirrorIds,
685             virtualScreenGroupChangeListener);
686         CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
687 
688         auto screen = ScreenManager::GetInstance().GetScreenById(virtualScreenId);
689         ASSERT_TRUE(screen);
690         ASSERT_EQ(virtualScreenId, screen->GetId());
691         ASSERT_NE(SCREEN_ID_INVALID, screen->GetParentId());
692         DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
693         sleep(TEST_SLEEP_S);
694         ASSERT_EQ(DMError::DM_OK, res);
695         CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
696         CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
697             virtualScreenId, group, screenGroupChangeListener);
698         CheckScreenGroupStateForMirror(ScreenGroupChangeEvent::REMOVE_FROM_GROUP, mirrorIds,
699             virtualScreenGroupChangeListener);
700         CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
701         ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
702         ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
703         ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
704     }
705 }
706 
707 /**
708  * @tc.name: ScreenManager12
709  * @tc.desc: Create a virtual screen as expansion of default screen cancel Make mirror, and destroy virtual screen
710  * @tc.type: FUNC
711  * @tc.require: issueI5M2SK
712  */
713 HWTEST_F(ScreenManagerTest, ScreenManager12, Function | MediumTest | Level2)
714 {
715     DisplayTestUtils utils;
716     ASSERT_TRUE(utils.CreateSurface());
717     defaultOption_.surface_ = utils.psurface_;
718     defaultOption_.isForShot_ = false;
719     CHECK_TEST_INIT_SCREEN_STATE
720     if (group == nullptr) {
721         return;
722     }
723     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
724     sleep(TEST_SLEEP_S);
725     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
726     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
727 
728     std::vector<ScreenId> mirrorIds;
729     mirrorIds.push_back(virtualScreenId);
730     ScreenId mirrorGroup;
731     ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorIds, mirrorGroup);
732     ASSERT_EQ(mirrorGroup, groupId);
733     CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::ADD_TO_GROUP,
734         virtualScreenId, group, screenGroupChangeListener);
735     CheckScreenGroupStateForMirror(ScreenGroupChangeEvent::ADD_TO_GROUP, mirrorIds,
736         virtualScreenGroupChangeListener);
737     CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
738 
739     ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(mirrorIds);
740     CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
741         virtualScreenId, group, screenGroupChangeListener);
742     CheckScreenGroupStateForMirror(ScreenGroupChangeEvent::REMOVE_FROM_GROUP, mirrorIds,
743         virtualScreenGroupChangeListener);
744     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
745 
746     DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
747     sleep(TEST_SLEEP_S);
748     ASSERT_EQ(DMError::DM_OK, res);
749     CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
750     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
751     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
752     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
753     ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
754 }
755 
756 /**
757  * @tc.name: ScreenManager13
758  * @tc.desc: Create a virtual screen as expansion of default screen cancel MakeExpand, and destroy virtual screen
759  * @tc.type: FUNC
760  */
761 HWTEST_F(ScreenManagerTest, ScreenManager13, Function | MediumTest | Level2)
762 {
763     DisplayTestUtils utils;
764     ASSERT_TRUE(utils.CreateSurface());
765     defaultOption_.surface_ = utils.psurface_;
766     defaultOption_.isForShot_ = false;
767     CHECK_TEST_INIT_SCREEN_STATE
768     if (group == nullptr) {
769         return;
770     }
771     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
772     sleep(TEST_SLEEP_S);
773     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
774     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
775 
776     std::vector<sptr<Screen>> screens;
777     ScreenManager::GetInstance().GetAllScreens(screens);
778     sleep(TEST_SLEEP_S);
779     sptr<Screen> defaultScreen = screens.front();
780     ASSERT_TRUE(defaultScreen);
781     std::vector<ExpandOption> options = {{defaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
782     ScreenId expansionGroup;
783     ScreenManager::GetInstance().MakeExpand(options, expansionGroup);
784     sleep(TEST_SLEEP_S);
785     ASSERT_NE(SCREEN_ID_INVALID, expansionGroup);
786     CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
787         virtualScreenId, group, screenGroupChangeListener);
788     CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
789 
790     std::vector<ScreenId> cancelScreens;
791     cancelScreens.emplace_back(virtualScreenId);
792     ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(cancelScreens);
793     CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
794         virtualScreenId, group, screenGroupChangeListener);
795     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
796 
797     DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
798     sleep(TEST_SLEEP_S);
799     ASSERT_EQ(DMError::DM_OK, res);
800     CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
801     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
802     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
803     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
804     ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
805 }
806 
807 /**
808  * @tc.name: ScreenManager14
809  * @tc.desc: Create a virtual screen, make expand to make mirror, and destroy virtual screen
810  * @tc.type: FUNC
811  */
812 HWTEST_F(ScreenManagerTest, ScreenManager14, Function | MediumTest | Level2)
813 {
814     DisplayTestUtils utils;
815     ASSERT_TRUE(utils.CreateSurface());
816     defaultOption_.surface_ = utils.psurface_;
817     defaultOption_.isForShot_ = false;
818     CHECK_TEST_INIT_SCREEN_STATE
819     if (group == nullptr) {
820         return;
821     }
822     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
823     sleep(TEST_SLEEP_S);
824 
825     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
826     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
827 
828     std::vector<sptr<Screen>> screens;
829     ScreenManager::GetInstance().GetAllScreens(screens);
830     sptr<Screen> defaultScreen = screens.front();
831     ASSERT_TRUE(defaultScreen);
832     std::vector<ExpandOption> options = {{defaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
833     ScreenId expansionGroup;
834     ScreenManager::GetInstance().MakeExpand(options, expansionGroup);
835     sleep(TEST_SLEEP_S);
836     ASSERT_EQ(expansionGroup, groupId);
837     CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
838         virtualScreenId, group, screenGroupChangeListener);
839     CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
840 
841     std::vector<ScreenId> mirrorScreens;
842     mirrorScreens.emplace_back(virtualScreenId);
843     ScreenId mirrorGroup;
844     ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorScreens, mirrorGroup);
845     ASSERT_EQ(mirrorGroup, groupId);
846     CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::CHANGE_GROUP,
847         virtualScreenId, group, screenGroupChangeListener);
848     CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
849 
850     DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
851     sleep(TEST_SLEEP_S);
852     ASSERT_EQ(DMError::DM_OK, res);
853     CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
854     CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
855         virtualScreenId, group, screenGroupChangeListener);
856     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
857 
858     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
859     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
860     ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
861 }
862 
863 /**
864  * @tc.name: ScreenManager15
865  * @tc.desc: Create a virtual screen, make mirror to make expand, and destroy virtual screen
866  * @tc.type: FUNC
867  * @tc.require: issueI5M2SK
868  */
869 HWTEST_F(ScreenManagerTest, ScreenManager15, Function | MediumTest | Level2)
870 {
871     DisplayTestUtils utils;
872     ASSERT_TRUE(utils.CreateSurface());
873     defaultOption_.surface_ = utils.psurface_;
874     defaultOption_.isForShot_ = false;
875 
876     CHECK_TEST_INIT_SCREEN_STATE
877     if (group == nullptr) {
878         return;
879     }
880     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
881     sleep(TEST_SLEEP_S);
882     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
883     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
884 
885     std::vector<ScreenId> mirrorScreens;
886     mirrorScreens.emplace_back(virtualScreenId);
887     ScreenId mirrorGroup;
888     ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorScreens, mirrorGroup);
889     sleep(TEST_SLEEP_S);
890     ASSERT_EQ(mirrorGroup, groupId);
891     CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::ADD_TO_GROUP,
892         virtualScreenId, group, screenGroupChangeListener);
893     CheckScreenGroupStateForMirror(ScreenGroupChangeEvent::ADD_TO_GROUP, mirrorScreens,
894         virtualScreenGroupChangeListener);
895     CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
896 
897     std::vector<sptr<Screen>> screens;
898     ScreenManager::GetInstance().GetAllScreens(screens);
899     sptr<Screen> defaultScreen = screens.front();
900     ASSERT_TRUE(defaultScreen);
901     std::vector<ExpandOption> options = {{defaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
902     ScreenId expansionGroup;
903     ScreenManager::GetInstance().MakeExpand(options, expansionGroup);
904     sleep(TEST_SLEEP_S);
905     ASSERT_EQ(expansionGroup, groupId);
906     CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::CHANGE_GROUP,
907         virtualScreenId, group, screenGroupChangeListener);
908     CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
909 
910     DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
911     sleep(TEST_SLEEP_S);
912     ASSERT_EQ(DMError::DM_OK, res);
913     CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
914     CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
915         virtualScreenId, group, screenGroupChangeListener);
916     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
917 
918     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
919     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
920     ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
921 }
922 
923 /**
924  * @tc.name: ScreenManager16
925  * @tc.desc: Screen orientation.
926  * @tc.type: FUNC
927  * @tc.require: issueI5NDLK
928  */
929 HWTEST_F(ScreenManagerTest, ScreenManager16, Function | MediumTest | Level2)
930 {
931     std::vector<sptr<Screen>> screens;
932     ScreenManager::GetInstance().GetAllScreens(screens);
933     ASSERT_GE(screens.size(), 1);
934     auto display = DisplayManager::GetInstance().GetDefaultDisplay();
935     ASSERT_NE(display, nullptr);
936     uint32_t orientation = static_cast<uint32_t>(Orientation::VERTICAL);
937     uint32_t end = static_cast<uint32_t>(Orientation::REVERSE_HORIZONTAL);
938     sptr<ScreenChangeListener> screenListener = new ScreenChangeListener();
939     ASSERT_NE(screenListener, nullptr);
940     ScreenManager::GetInstance().RegisterScreenListener(screenListener);
941     for (; orientation <= end; ++orientation) {
942         screens[0]->SetOrientation(static_cast<Orientation>(orientation));
943         ScreenId screenId = screenListener->changeFuture_.GetResult(TIME_OUT);
944         ASSERT_EQ(screenId, screens[0]->GetId());
945         usleep(1E6);
946         if (SceneBoardJudgement::IsSceneBoardEnabled()) {
947             ASSERT_EQ(static_cast<uint32_t>(screens[0]->GetOrientation()),
948             static_cast<uint32_t>(Orientation::UNSPECIFIED));
949         } else {
950             ASSERT_NE(static_cast<uint32_t>(screens[0]->GetOrientation()),
951             static_cast<uint32_t>(Orientation::UNSPECIFIED));
952         }
953         ASSERT_EQ(static_cast<uint32_t>(display->GetOrientation()), orientation);
954         sleep(TEST_SLEEP_S);
955     }
956     screens[0]->SetOrientation(Orientation::UNSPECIFIED);
957     ASSERT_EQ(static_cast<uint32_t>(screens[0]->GetOrientation()), static_cast<uint32_t>(Orientation::UNSPECIFIED));
958     ASSERT_EQ(static_cast<uint32_t>(display->GetOrientation()), static_cast<uint32_t>(Orientation::UNSPECIFIED));
959     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
960 }
961 
962 /**
963  * @tc.name: ScreenManager17
964  * @tc.desc: Create VirtualScreen for 10 times but do not destroy it
965  * @tc.type: FUNC
966  */
967 HWTEST_F(ScreenManagerTest, ScreenManager17, Function | MediumTest | Level2)
968 {
969     DisplayTestUtils utils;
970     defaultOption_.isForShot_ = false;
971     for (uint32_t i = 0; i < execTimes_; i++) {
972         ASSERT_TRUE(utils.CreateSurface());
973         defaultOption_.surface_ = utils.psurface_;
974         ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
975         sleep(TEST_SLEEP_S);
976         ASSERT_NE(SCREEN_ID_INVALID, virtualScreenId);
977     }
978 }
979 
980 /**
981  * @tc.name: ScreenManager18
982  * @tc.desc: Set screen rotation lock, and check whether screen rotation lock is Locked.
983  * @tc.type: FUNC
984  */
985 HWTEST_F(ScreenManagerTest, ScreenManager18, Function | SmallTest | Level1)
986 {
987     bool originalLockStatus;
988     ScreenManager::GetInstance().IsScreenRotationLocked(originalLockStatus);
989     ScreenManager::GetInstance().SetScreenRotationLocked(!originalLockStatus);
990     sleep(TEST_SLEEP_S);
991     bool modifiedLockedStatus;
992     ScreenManager::GetInstance().IsScreenRotationLocked(modifiedLockedStatus);
993     ScreenManager::GetInstance().SetScreenRotationLocked(originalLockStatus);
994     sleep(TEST_SLEEP_S);
995     ASSERT_EQ(!originalLockStatus, modifiedLockedStatus);
996 }
997 
998 /**
999  * @tc.name: VirtualExpandScreen01
1000  * @tc.desc: Create virtual expand screen and rotate.
1001  * @tc.type: FUNC
1002  */
1003 HWTEST_F(ScreenManagerTest, VirtualExpandScreen01, Function | MediumTest | Level1)
1004 {
1005     (void)system("param set rosen.uni.partialrender.enabled 0");
1006 
1007     DisplayTestUtils utils;
1008     ASSERT_TRUE(utils.CreateSurface());
1009     defaultOption_.surface_ = utils.psurface_;
1010     defaultOption_.isForShot_ = true;
1011 
1012     CHECK_TEST_INIT_SCREEN_STATE
1013     if (group == nullptr) {
1014         return;
1015     }
1016     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1017     sleep(TEST_SLEEP_S);
1018 
1019     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1020     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1021     sleep(TEST_SLEEP_S);
1022     std::vector<ExpandOption> options = {{defaultScreenId_, 0, 0}, {virtualScreenId, defaultWidth_, 0}};
1023     ScreenId expansionId;
1024     ScreenManager::GetInstance().MakeExpand(options, expansionId);
1025     sleep(TEST_SLEEP_S);
1026 
1027     CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
1028         virtualScreenId, group, screenGroupChangeListener);
1029     CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
1030     sleep(TEST_SLEEP_S);
1031     ASSERT_NE(SCREEN_ID_INVALID, expansionId);
1032     DisplayId virtualDisplayId = DisplayManager::GetInstance().GetDisplayByScreen(virtualScreenId)->GetId();
1033     ASSERT_NE(DISPLAY_ID_INVALID, virtualDisplayId);
1034 
1035     sptr<Window> window = CreateWindowByDisplayId(virtualDisplayId);
1036     if (window == nullptr) {
1037         return;
1038     }
1039     ASSERT_NE(nullptr, window);
1040     ASSERT_EQ(true, DrawWindowColor(window, COLOR_RED));
1041     window->Show();
1042     sleep(TEST_SLEEP_S_LONG);
1043 
1044     CheckStateDisplay(virtualDisplayId, virtualScreenId);
1045     window->Destroy();
1046     DMError res = ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1047     sleep(TEST_SLEEP_S);
1048     ASSERT_EQ(DMError::DM_OK, res);
1049 
1050     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
1051     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
1052     ScreenManager::GetInstance().UnregisterVirtualScreenGroupListener(virtualScreenGroupChangeListener);
1053     sleep(TEST_SLEEP_S);
1054 
1055     (void)system("param set rosen.uni.partialrender.enabled 4");
1056 }
1057 
1058 HWTEST_F(ScreenManagerTest, ResizeVirtualScreen01, Function | MediumTest | Level1)
1059 {
1060     DisplayTestUtils utils;
1061     ASSERT_TRUE(utils.CreateSurface());
1062     defaultOption_.surface_ = utils.psurface_;
1063     defaultOption_.isForShot_ = true;
1064 
1065     CHECK_TEST_INIT_SCREEN_STATE
1066     if (group == nullptr) {
1067         return;
1068     }
1069     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1070     sleep(TEST_SLEEP_S);
1071 
1072     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1073     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1074     sleep(TEST_SLEEP_S);
1075     std::vector<ExpandOption> options = {{defaultDisplayId_, 0, 0}, {virtualScreenId, defaultWidth_, 0}};
1076     ScreenId expansionId;
1077     ScreenManager::GetInstance().MakeExpand(options, expansionId);
1078     sleep(TEST_SLEEP_S);
1079 
1080     DMError res = ScreenManager::GetInstance().ResizeVirtualScreen(virtualScreenId,
1081         resizeScreenWidthTestOne_, resizeScreenHeightTestOne_);
1082     sleep(TEST_SLEEP_S);
1083     ASSERT_EQ(DMError::DM_OK, res);
1084 
1085     auto screen = ScreenManager::GetInstance().GetScreenById(virtualScreenId);
1086     ASSERT_TRUE(screen);
1087     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1088         ASSERT_EQ(resizeScreenWidthTestOne_, screen->GetWidth());
1089         ASSERT_EQ(resizeScreenHeightTestOne_, screen->GetHeight());
1090     } else {
1091         ASSERT_EQ(resizeScreenWidthTestThree_, screen->GetWidth());
1092         ASSERT_EQ(resizeScreenHeightTestThree_, screen->GetHeight());
1093     }
1094     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1095 }
1096 
1097 HWTEST_F(ScreenManagerTest, ResizeVirtualScreen02, Function | MediumTest | Level1)
1098 {
1099     DisplayTestUtils utils;
1100     ASSERT_TRUE(utils.CreateSurface());
1101     defaultOption_.surface_ = utils.psurface_;
1102     defaultOption_.isForShot_ = true;
1103 
1104     CHECK_TEST_INIT_SCREEN_STATE
1105     if (group == nullptr) {
1106         return;
1107     }
1108     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1109     sleep(TEST_SLEEP_S);
1110 
1111     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1112     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1113     sleep(TEST_SLEEP_S);
1114     std::vector<ExpandOption> options = {{defaultDisplayId_, 0, 0}, {virtualScreenId, defaultWidth_, 0}};
1115     ScreenId expansionId;
1116     ScreenManager::GetInstance().MakeExpand(options, expansionId);
1117     sleep(TEST_SLEEP_S);
1118 
1119     DMError res = ScreenManager::GetInstance().ResizeVirtualScreen(virtualScreenId,
1120         resizeScreenWidthTestTwo_, resizeScreenHeightTestTwo_);
1121     sleep(TEST_SLEEP_S);
1122     ASSERT_EQ(DMError::DM_OK, res);
1123 
1124     auto screen = ScreenManager::GetInstance().GetScreenById(virtualScreenId);
1125     ASSERT_TRUE(screen);
1126     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1127         ASSERT_EQ(resizeScreenWidthTestTwo_, screen->GetWidth());
1128         ASSERT_EQ(resizeScreenHeightTestTwo_, screen->GetHeight());
1129     } else {
1130         ASSERT_EQ(resizeScreenWidthTestThree_, screen->GetWidth());
1131         ASSERT_EQ(resizeScreenHeightTestThree_, screen->GetHeight());
1132     }
1133     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1134 }
1135 
1136 HWTEST_F(ScreenManagerTest, ResizeVirtualScreen03, Function | MediumTest | Level1)
1137 {
1138     DisplayTestUtils utils;
1139     ASSERT_TRUE(utils.CreateSurface());
1140     defaultOption_.surface_ = utils.psurface_;
1141     defaultOption_.isForShot_ = true;
1142 
1143     CHECK_TEST_INIT_SCREEN_STATE
1144     if (group == nullptr) {
1145         return;
1146     }
1147     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1148     sleep(TEST_SLEEP_S);
1149 
1150     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1151     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1152     sleep(TEST_SLEEP_S);
1153     std::vector<ExpandOption> options = {{defaultDisplayId_, 0, 0}, {virtualScreenId, defaultWidth_, 0}};
1154     ScreenId expansionId;
1155     ScreenManager::GetInstance().MakeExpand(options, expansionId);
1156     sleep(TEST_SLEEP_S);
1157 
1158     DMError res = ScreenManager::GetInstance().ResizeVirtualScreen(virtualScreenId + 1,
1159         resizeScreenWidthTestOne_, resizeScreenHeightTestOne_);
1160     sleep(TEST_SLEEP_S);
1161     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1162         ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1163     } else {
1164         ASSERT_EQ(DMError::DM_OK, res);
1165     }
1166     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1167 }
1168 
1169 HWTEST_F(ScreenManagerTest, SetVirtualScreenRefreshRate01, Function | MediumTest | Level1)
1170 {
1171     DisplayTestUtils utils;
1172     ASSERT_TRUE(utils.CreateSurface());
1173     defaultOption_.surface_ = utils.psurface_;
1174     defaultOption_.isForShot_ = true;
1175 
1176     CHECK_TEST_INIT_SCREEN_STATE
1177     if (group == nullptr) {
1178         return;
1179     }
1180     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1181     sleep(TEST_SLEEP_S);
1182 
1183     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1184     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1185     sleep(TEST_SLEEP_S);
1186 
1187     std::vector<ScreenId> screenIds;
1188     screenIds.push_back(virtualScreenId);
1189     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1190     sleep(TEST_SLEEP_S);
1191 
1192     DMError res = ScreenManager::GetInstance().SetVirtualScreenRefreshRate(virtualScreenId, refreshIntervalTwo_);
1193     sleep(TEST_SLEEP_S);
1194     ASSERT_EQ(DMError::DM_OK, res);
1195 
1196     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1197 }
1198 
1199 HWTEST_F(ScreenManagerTest, SetVirtualScreenRefreshRate02, Function | MediumTest | Level1)
1200 {
1201     DisplayTestUtils utils;
1202     ASSERT_TRUE(utils.CreateSurface());
1203     defaultOption_.surface_ = utils.psurface_;
1204     defaultOption_.isForShot_ = true;
1205 
1206     CHECK_TEST_INIT_SCREEN_STATE
1207     if (group == nullptr) {
1208         return;
1209     }
1210     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1211     sleep(TEST_SLEEP_S);
1212 
1213     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1214     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1215     sleep(TEST_SLEEP_S);
1216 
1217     std::vector<ScreenId> screenIds;
1218     screenIds.push_back(virtualScreenId);
1219     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1220     sleep(TEST_SLEEP_S);
1221 
1222     DMError res = ScreenManager::GetInstance().SetVirtualScreenRefreshRate(virtualScreenId, refreshIntervalZero_);
1223     sleep(TEST_SLEEP_S);
1224     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1225         ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1226     } else {
1227         ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
1228     }
1229     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1230 }
1231 
1232 HWTEST_F(ScreenManagerTest, SetVirtualScreenRefreshRate03, Function | MediumTest | Level1)
1233 {
1234     DisplayTestUtils utils;
1235     ASSERT_TRUE(utils.CreateSurface());
1236     defaultOption_.surface_ = utils.psurface_;
1237     defaultOption_.isForShot_ = true;
1238 
1239     CHECK_TEST_INIT_SCREEN_STATE
1240     if (group == nullptr) {
1241         return;
1242     }
1243     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1244     sleep(TEST_SLEEP_S);
1245 
1246     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1247     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1248     sleep(TEST_SLEEP_S);
1249 
1250     std::vector<ScreenId> screenIds;
1251     screenIds.push_back(virtualScreenId);
1252     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1253     sleep(TEST_SLEEP_S);
1254 
1255     DMError res = ScreenManager::GetInstance().SetVirtualScreenRefreshRate(virtualScreenId, refreshIntervalMax_);
1256     sleep(TEST_SLEEP_S);
1257     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1258         ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1259     } else {
1260         ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
1261     }
1262 
1263     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1264 }
1265 
1266 HWTEST_F(ScreenManagerTest, SetVirtualScreenRefreshRate04, Function | MediumTest | Level1)
1267 {
1268     DMError res = ScreenManager::GetInstance().SetVirtualScreenRefreshRate(defaultScreenId_, refreshIntervalTwo_);
1269     sleep(TEST_SLEEP_S);
1270     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1271         ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1272     } else {
1273         ASSERT_NE(DMError::DM_ERROR_INVALID_PARAM, res);
1274     }
1275 }
1276 
1277 /**
1278  * @tc.name: SetVirtualScreenMaxRefreshRate01
1279  * @tc.desc: Create a virtual screen and set its refresh rate to 0
1280  * @tc.type: FUNC
1281  * @tc.require: issueIATA2N
1282  */
1283 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate01, Function | MediumTest | Level1)
1284 {
1285     DisplayTestUtils utils;
1286     ASSERT_TRUE(utils.CreateSurface());
1287     defaultOption_.surface_ = utils.psurface_;
1288     defaultOption_.isForShot_ = true;
1289 
1290     CHECK_TEST_INIT_SCREEN_STATE
1291     if (group == nullptr) {
1292         return;
1293     }
1294     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1295     sleep(TEST_SLEEP_S);
1296 
1297     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1298     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1299     sleep(TEST_SLEEP_S);
1300 
1301     std::vector<ScreenId> screenIds;
1302     screenIds.push_back(virtualScreenId);
1303     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1304     sleep(TEST_SLEEP_S);
1305     uint32_t refreshRate = 0;
1306     uint32_t actualRefreshRate = 0;
1307     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1308         refreshRate, actualRefreshRate);
1309     sleep(TEST_SLEEP_S);
1310     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1311         ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1312     } else {
1313         ASSERT_EQ(DMError::DM_ERROR_DEVICE_NOT_SUPPORT, res);
1314     }
1315     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1316 }
1317 
1318 /**
1319  * @tc.name: SetVirtualScreenMaxRefreshRate02
1320  * @tc.desc: Create a virtual screen and set its refresh rate to 31
1321  * @tc.type: FUNC
1322  * @tc.require: issueIATA2N
1323  */
1324 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate02, Function | MediumTest | Level1)
1325 {
1326     DisplayTestUtils utils;
1327     ASSERT_TRUE(utils.CreateSurface());
1328     defaultOption_.surface_ = utils.psurface_;
1329     defaultOption_.isForShot_ = true;
1330 
1331     CHECK_TEST_INIT_SCREEN_STATE
1332     if (group == nullptr) {
1333         return;
1334     }
1335     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1336     sleep(TEST_SLEEP_S);
1337 
1338     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1339     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1340     sleep(TEST_SLEEP_S);
1341 
1342     std::vector<ScreenId> screenIds;
1343     screenIds.push_back(virtualScreenId);
1344     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1345     sleep(TEST_SLEEP_S);
1346     uint32_t refreshRate = 31;
1347     uint32_t actualRefreshRate = 0;
1348     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1349         refreshRate, actualRefreshRate);
1350     sleep(TEST_SLEEP_S);
1351     ASSERT_EQ(DMError::DM_ERROR_DEVICE_NOT_SUPPORT, res);
1352     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1353 }
1354 
1355 /**
1356  * @tc.name: SetVirtualScreenMaxRefreshRate03
1357  * @tc.desc: Create a virtual screen and set its refresh rate to 120
1358  * @tc.type: FUNC
1359  * @tc.require: issueIATA2N
1360  */
1361 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate03, Function | MediumTest | Level1)
1362 {
1363     DisplayTestUtils utils;
1364     ASSERT_TRUE(utils.CreateSurface());
1365     defaultOption_.surface_ = utils.psurface_;
1366     defaultOption_.isForShot_ = true;
1367 
1368     CHECK_TEST_INIT_SCREEN_STATE
1369     if (group == nullptr) {
1370         return;
1371     }
1372     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1373     sleep(TEST_SLEEP_S);
1374 
1375     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1376     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1377     sleep(TEST_SLEEP_S);
1378 
1379     std::vector<ScreenId> screenIds;
1380     screenIds.push_back(virtualScreenId);
1381     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1382     sleep(TEST_SLEEP_S);
1383     uint32_t refreshRate = 120;
1384     uint32_t actualRefreshRate = 0;
1385     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1386         refreshRate, actualRefreshRate);
1387     sleep(TEST_SLEEP_S);
1388     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1389         ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1390     } else {
1391         ASSERT_EQ(DMError::DM_ERROR_DEVICE_NOT_SUPPORT, res);
1392     }
1393     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1394 }
1395 }
1396 } // namespace Rosen
1397 } // namespace OHOS
1398