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:
84     virtual void OnConnect(ScreenId screenId) override
85     {
86         WLOGI("OnConnect, screenId:%{public}" PRIu64"", screenId);
87         connectFuture_.SetValue(screenId);
88     }
89     virtual void OnDisconnect(ScreenId screenId) override
90     {
91         WLOGI("OnDisconnect, screenId:%{public}" PRIu64"", screenId);
92         disconnectFuture_.SetValue(screenId);
93     }
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:
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  */
HWTEST_F(ScreenManagerTest, ScreenManager01, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager02, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager03, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager04, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager05, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager06, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager07, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager08, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager09, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager10, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager11, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager12, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager13, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager14, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager15, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager16, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager17, Function | MediumTest | Level2)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  */
HWTEST_F(ScreenManagerTest, ScreenManager18, Function | SmallTest | Level1)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  */
HWTEST_F(ScreenManagerTest, VirtualExpandScreen01, Function | MediumTest | Level1)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 
HWTEST_F(ScreenManagerTest, ResizeVirtualScreen01, Function | MediumTest | Level1)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 
HWTEST_F(ScreenManagerTest, ResizeVirtualScreen02, Function | MediumTest | Level1)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 
HWTEST_F(ScreenManagerTest, ResizeVirtualScreen03, Function | MediumTest | Level1)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 
HWTEST_F(ScreenManagerTest, SetVirtualScreenRefreshRate01, Function | MediumTest | Level1)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 
HWTEST_F(ScreenManagerTest, SetVirtualScreenRefreshRate02, Function | MediumTest | Level1)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 
HWTEST_F(ScreenManagerTest, SetVirtualScreenRefreshRate03, Function | MediumTest | Level1)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 
HWTEST_F(ScreenManagerTest, SetVirtualScreenRefreshRate04, Function | MediumTest | Level1)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  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate01, Function | MediumTest | Level1)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     ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
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  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate02, Function | MediumTest | Level1)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_OK, 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  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate03, Function | MediumTest | Level1)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     ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1389     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1390 }
1391 
1392 /**
1393  * @tc.name: SetVirtualScreenMaxRefreshRate04
1394  * @tc.desc: Create a virtual screen and set its refresh rate to 61
1395  * @tc.type: FUNC
1396  * @tc.require: issueIATA2N
1397  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate04, Function | MediumTest | Level1)1398 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate04, Function | MediumTest | Level1)
1399 {
1400     DisplayTestUtils utils;
1401     ASSERT_TRUE(utils.CreateSurface());
1402     defaultOption_.surface_ = utils.psurface_;
1403     defaultOption_.isForShot_ = true;
1404 
1405     CHECK_TEST_INIT_SCREEN_STATE
1406     if (group == nullptr) {
1407         return;
1408     }
1409     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1410     sleep(TEST_SLEEP_S);
1411 
1412     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1413     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1414     sleep(TEST_SLEEP_S);
1415 
1416     std::vector<ScreenId> screenIds;
1417     screenIds.push_back(virtualScreenId);
1418     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1419     sleep(TEST_SLEEP_S);
1420     uint32_t refreshRate = 61;
1421     uint32_t actualRefreshRate = 0;
1422     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1423         refreshRate, actualRefreshRate);
1424     sleep(TEST_SLEEP_S);
1425     ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
1426     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1427 }
1428 
1429 /**
1430  * @tc.name: SetVirtualScreenMaxRefreshRate05
1431  * @tc.desc: Create a virtual screen and set its refresh rate to 1
1432  * @tc.type: FUNC
1433  * @tc.require: issueIATA2N
1434  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate05, Function | MediumTest | Level1)1435 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate05, Function | MediumTest | Level1)
1436 {
1437     DisplayTestUtils utils;
1438     ASSERT_TRUE(utils.CreateSurface());
1439     defaultOption_.surface_ = utils.psurface_;
1440     defaultOption_.isForShot_ = true;
1441 
1442     CHECK_TEST_INIT_SCREEN_STATE
1443     if (group == nullptr) {
1444         return;
1445     }
1446     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1447     sleep(TEST_SLEEP_S);
1448 
1449     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1450     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1451     sleep(TEST_SLEEP_S);
1452 
1453     std::vector<ScreenId> screenIds;
1454     screenIds.push_back(virtualScreenId);
1455     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1456     sleep(TEST_SLEEP_S);
1457     uint32_t refreshRate = 1;
1458     uint32_t actualRefreshRate = 0;
1459     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1460         refreshRate, actualRefreshRate);
1461     sleep(TEST_SLEEP_S);
1462     ASSERT_EQ(DMError::DM_OK, res);
1463     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1464 }
1465 
1466 /**
1467  * @tc.name: SetVirtualScreenMaxRefreshRate06
1468  * @tc.desc: Create a virtual screen and set its refresh rate to 18
1469  * @tc.type: FUNC
1470  * @tc.require: issueIATA2N
1471  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate06, Function | MediumTest | Level1)1472 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate06, Function | MediumTest | Level1)
1473 {
1474     DisplayTestUtils utils;
1475     ASSERT_TRUE(utils.CreateSurface());
1476     defaultOption_.surface_ = utils.psurface_;
1477     defaultOption_.isForShot_ = true;
1478 
1479     CHECK_TEST_INIT_SCREEN_STATE
1480     if (group == nullptr) {
1481         return;
1482     }
1483     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1484     sleep(TEST_SLEEP_S);
1485 
1486     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1487     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1488     sleep(TEST_SLEEP_S);
1489 
1490     std::vector<ScreenId> screenIds;
1491     screenIds.push_back(virtualScreenId);
1492     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1493     sleep(TEST_SLEEP_S);
1494     uint32_t refreshRate = 18;
1495     uint32_t actualRefreshRate = 0;
1496     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1497         refreshRate, actualRefreshRate);
1498     sleep(TEST_SLEEP_S);
1499     ASSERT_EQ(DMError::DM_OK, res);
1500     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1501 }
1502 
1503 /**
1504  * @tc.name: SetVirtualScreenMaxRefreshRate07
1505  * @tc.desc: Create a virtual screen and set its refresh rate to 24
1506  * @tc.type: FUNC
1507  * @tc.require: issueIATA2N
1508  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate07, Function | MediumTest | Level1)1509 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate07, Function | MediumTest | Level1)
1510 {
1511     DisplayTestUtils utils;
1512     ASSERT_TRUE(utils.CreateSurface());
1513     defaultOption_.surface_ = utils.psurface_;
1514     defaultOption_.isForShot_ = true;
1515 
1516     CHECK_TEST_INIT_SCREEN_STATE
1517     if (group == nullptr) {
1518         return;
1519     }
1520     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1521     sleep(TEST_SLEEP_S);
1522 
1523     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1524     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1525     sleep(TEST_SLEEP_S);
1526 
1527     std::vector<ScreenId> screenIds;
1528     screenIds.push_back(virtualScreenId);
1529     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1530     sleep(TEST_SLEEP_S);
1531     uint32_t refreshRate = 24;
1532     uint32_t actualRefreshRate = 0;
1533     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1534         refreshRate, actualRefreshRate);
1535     sleep(TEST_SLEEP_S);
1536     ASSERT_EQ(DMError::DM_OK, res);
1537     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1538 }
1539 
1540 /**
1541  * @tc.name: SetVirtualScreenMaxRefreshRate08
1542  * @tc.desc: Create a virtual screen and set its refresh rate to 27
1543  * @tc.type: FUNC
1544  * @tc.require: issueIATA2N
1545  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate08, Function | MediumTest | Level1)1546 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate08, Function | MediumTest | Level1)
1547 {
1548     DisplayTestUtils utils;
1549     ASSERT_TRUE(utils.CreateSurface());
1550     defaultOption_.surface_ = utils.psurface_;
1551     defaultOption_.isForShot_ = true;
1552 
1553     CHECK_TEST_INIT_SCREEN_STATE
1554     if (group == nullptr) {
1555         return;
1556     }
1557     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1558     sleep(TEST_SLEEP_S);
1559 
1560     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1561     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1562     sleep(TEST_SLEEP_S);
1563 
1564     std::vector<ScreenId> screenIds;
1565     screenIds.push_back(virtualScreenId);
1566     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1567     sleep(TEST_SLEEP_S);
1568     uint32_t refreshRate = 27;
1569     uint32_t actualRefreshRate = 0;
1570     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1571         refreshRate, actualRefreshRate);
1572     sleep(TEST_SLEEP_S);
1573     ASSERT_EQ(DMError::DM_OK, res);
1574     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1575 }
1576 
1577 /**
1578  * @tc.name: SetVirtualScreenMaxRefreshRate09
1579  * @tc.desc: Create a virtual screen and set its refresh rate to 37
1580  * @tc.type: FUNC
1581  * @tc.require: issueIATA2N
1582  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate09, Function | MediumTest | Level1)1583 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate09, Function | MediumTest | Level1)
1584 {
1585     DisplayTestUtils utils;
1586     ASSERT_TRUE(utils.CreateSurface());
1587     defaultOption_.surface_ = utils.psurface_;
1588     defaultOption_.isForShot_ = true;
1589 
1590     CHECK_TEST_INIT_SCREEN_STATE
1591     if (group == nullptr) {
1592         return;
1593     }
1594     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1595     sleep(TEST_SLEEP_S);
1596 
1597     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1598     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1599     sleep(TEST_SLEEP_S);
1600 
1601     std::vector<ScreenId> screenIds;
1602     screenIds.push_back(virtualScreenId);
1603     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1604     sleep(TEST_SLEEP_S);
1605     uint32_t refreshRate = 37;
1606     uint32_t actualRefreshRate = 0;
1607     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1608         refreshRate, actualRefreshRate);
1609     sleep(TEST_SLEEP_S);
1610     ASSERT_EQ(DMError::DM_OK, res);
1611     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1612 }
1613 
1614 /**
1615  * @tc.name: SetVirtualScreenMaxRefreshRate10
1616  * @tc.desc: Create a virtual screen and set its refresh rate to 47
1617  * @tc.type: FUNC
1618  * @tc.require: issueIATA2N
1619  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate10, Function | MediumTest | Level1)1620 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate10, Function | MediumTest | Level1)
1621 {
1622     DisplayTestUtils utils;
1623     ASSERT_TRUE(utils.CreateSurface());
1624     defaultOption_.surface_ = utils.psurface_;
1625     defaultOption_.isForShot_ = true;
1626 
1627     CHECK_TEST_INIT_SCREEN_STATE
1628     if (group == nullptr) {
1629         return;
1630     }
1631     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1632     sleep(TEST_SLEEP_S);
1633 
1634     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1635     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1636     sleep(TEST_SLEEP_S);
1637 
1638     std::vector<ScreenId> screenIds;
1639     screenIds.push_back(virtualScreenId);
1640     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1641     sleep(TEST_SLEEP_S);
1642     uint32_t refreshRate = 47;
1643     uint32_t actualRefreshRate = 0;
1644     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1645         refreshRate, actualRefreshRate);
1646     sleep(TEST_SLEEP_S);
1647     ASSERT_EQ(DMError::DM_OK, res);
1648     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1649 }
1650 
1651 /**
1652  * @tc.name: SetVirtualScreenMaxRefreshRate11
1653  * @tc.desc: Create a virtual screen and set its refresh rate to 57
1654  * @tc.type: FUNC
1655  * @tc.require: issueIATA2N
1656  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate11, Function | MediumTest | Level1)1657 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate11, Function | MediumTest | Level1)
1658 {
1659     DisplayTestUtils utils;
1660     ASSERT_TRUE(utils.CreateSurface());
1661     defaultOption_.surface_ = utils.psurface_;
1662     defaultOption_.isForShot_ = true;
1663 
1664     CHECK_TEST_INIT_SCREEN_STATE
1665     if (group == nullptr) {
1666         return;
1667     }
1668     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1669     sleep(TEST_SLEEP_S);
1670 
1671     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1672     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1673     sleep(TEST_SLEEP_S);
1674 
1675     std::vector<ScreenId> screenIds;
1676     screenIds.push_back(virtualScreenId);
1677     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1678     sleep(TEST_SLEEP_S);
1679     uint32_t refreshRate = 57;
1680     uint32_t actualRefreshRate = 0;
1681     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1682         refreshRate, actualRefreshRate);
1683     sleep(TEST_SLEEP_S);
1684     ASSERT_EQ(DMError::DM_OK, res);
1685     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1686 }
1687 
1688 /**
1689  * @tc.name: SetVirtualScreenMaxRefreshRate12
1690  * @tc.desc: Create a virtual screen and set its refresh rate to 44
1691  * @tc.type: FUNC
1692  * @tc.require: issueIATA2N
1693  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate12, Function | MediumTest | Level1)1694 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate12, Function | MediumTest | Level1)
1695 {
1696     DisplayTestUtils utils;
1697     ASSERT_TRUE(utils.CreateSurface());
1698     defaultOption_.surface_ = utils.psurface_;
1699     defaultOption_.isForShot_ = true;
1700 
1701     CHECK_TEST_INIT_SCREEN_STATE
1702     if (group == nullptr) {
1703         return;
1704     }
1705     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1706     sleep(TEST_SLEEP_S);
1707 
1708     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1709     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1710     sleep(TEST_SLEEP_S);
1711 
1712     std::vector<ScreenId> screenIds;
1713     screenIds.push_back(virtualScreenId);
1714     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1715     sleep(TEST_SLEEP_S);
1716     uint32_t refreshRate = 44;
1717     uint32_t actualRefreshRate = 0;
1718     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1719         refreshRate, actualRefreshRate);
1720     sleep(TEST_SLEEP_S);
1721     ASSERT_EQ(DMError::DM_OK, res);
1722     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1723 }
1724 
1725 /**
1726  * @tc.name: SetVirtualScreenMaxRefreshRate13
1727  * @tc.desc: Create a virtual screen and set its refresh rate to 34
1728  * @tc.type: FUNC
1729  * @tc.require: issueIATA2N
1730  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate13, Function | MediumTest | Level1)1731 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate13, Function | MediumTest | Level1)
1732 {
1733     DisplayTestUtils utils;
1734     ASSERT_TRUE(utils.CreateSurface());
1735     defaultOption_.surface_ = utils.psurface_;
1736     defaultOption_.isForShot_ = true;
1737 
1738     CHECK_TEST_INIT_SCREEN_STATE
1739     if (group == nullptr) {
1740         return;
1741     }
1742     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1743     sleep(TEST_SLEEP_S);
1744 
1745     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1746     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1747     sleep(TEST_SLEEP_S);
1748 
1749     std::vector<ScreenId> screenIds;
1750     screenIds.push_back(virtualScreenId);
1751     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1752     sleep(TEST_SLEEP_S);
1753     uint32_t refreshRate = 34;
1754     uint32_t actualRefreshRate = 0;
1755     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(virtualScreenId,
1756         refreshRate, actualRefreshRate);
1757     sleep(TEST_SLEEP_S);
1758     ASSERT_EQ(DMError::DM_OK, res);
1759     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1760 }
1761 
1762 /**
1763  * @tc.name: SetVirtualScreenMaxRefreshRate14
1764  * @tc.desc: Get main screen and set its refresh rate to 34
1765  * @tc.type: FUNC
1766  * @tc.require: issueIATA2N
1767  */
HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate14, Function | MediumTest | Level1)1768 HWTEST_F(ScreenManagerTest, SetVirtualScreenMaxRefreshRate14, Function | MediumTest | Level1)
1769 {
1770     DisplayTestUtils utils;
1771     ASSERT_TRUE(utils.CreateSurface());
1772     defaultOption_.surface_ = utils.psurface_;
1773     defaultOption_.isForShot_ = true;
1774 
1775     CHECK_TEST_INIT_SCREEN_STATE
1776     if (group == nullptr) {
1777         return;
1778     }
1779     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
1780     sleep(TEST_SLEEP_S);
1781 
1782     CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
1783     CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
1784     sleep(TEST_SLEEP_S);
1785 
1786     std::vector<ScreenId> screenIds;
1787     screenIds.push_back(virtualScreenId);
1788     ScreenManager::GetInstance().MakeUniqueScreen(screenIds);
1789     sleep(TEST_SLEEP_S);
1790     uint32_t refreshRate = 34;
1791     uint32_t actualRefreshRate = 0;
1792     ScreenId mainID = 0;
1793     DMError res = ScreenManager::GetInstance().SetVirtualScreenMaxRefreshRate(mainID,
1794         refreshRate, actualRefreshRate);
1795     sleep(TEST_SLEEP_S);
1796     ASSERT_NE(DMError::DM_OK, res);
1797     ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId);
1798 }
1799 }
1800 } // namespace Rosen
1801 } // namespace OHOS
1802