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
30using namespace testing;
31using namespace testing::ext;
32
33namespace OHOS {
34namespace Rosen {
35namespace {
36constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "ScreenManagerTest"};
37constexpr uint32_t COLOR_RED = 0xffff0000;
38}
39class ScreenGroupChangeListener;
40class ScreenManagerTest : public testing::Test {
41public:
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
82class ScreenChangeListener : public ScreenManager::IScreenListener {
83public:
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
104class ScreenGroupChangeListener : public ScreenManager::IScreenGroupListener {
105public:
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
116sptr<Display> ScreenManagerTest::defaultDisplay_ = nullptr;
117DisplayId ScreenManagerTest::defaultDisplayId_ = DISPLAY_ID_INVALID;
118ScreenId ScreenManagerTest::defaultScreenId_ = INVALID_SCREEN_ID;
119std::string ScreenManagerTest::defaultName_ = "virtualScreen01";
120uint32_t ScreenManagerTest::defaultWidth_ = 2560;
121uint32_t ScreenManagerTest::defaultHeight_ = 1600;
122float ScreenManagerTest::defaultDensity_ = 2.0;
123int32_t ScreenManagerTest::defaultFlags_ = 0;
124VirtualScreenOption ScreenManagerTest::defaultOption_ = {
125    defaultName_, defaultWidth_, defaultHeight_, defaultDensity_, nullptr, defaultFlags_
126};
127uint32_t ScreenManagerTest::waitCount_ = 0;
128
129void 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
147void ScreenManagerTest::TearDownTestCase()
148{
149}
150
151void ScreenManagerTest::SetUp()
152{
153}
154
155void ScreenManagerTest::TearDown()
156{
157    sleep(TEST_SLEEP_S);
158}
159
160
161bool 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
176sptr<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
192void 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
260void 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
288void 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
309void 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
328namespace {
329/**
330 * @tc.name: ScreenManager01
331 * @tc.desc: Create a virtual screen and destroy it
332 * @tc.type: FUNC
333 */
334HWTEST_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 */
353HWTEST_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 */
377HWTEST_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 */
397HWTEST_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 */
424HWTEST_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 */
463HWTEST_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 */
504HWTEST_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 */
525HWTEST_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 */
573HWTEST_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 */
631HWTEST_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 */
662HWTEST_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 */
716HWTEST_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 */
764HWTEST_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 */
815HWTEST_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 */
872HWTEST_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 */
932HWTEST_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 */
970HWTEST_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 */
988HWTEST_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 */
1006HWTEST_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
1061HWTEST_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
1100HWTEST_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
1139HWTEST_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
1172HWTEST_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
1202HWTEST_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
1236HWTEST_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
1270HWTEST_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 */
1287HWTEST_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 */
1324HWTEST_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 */
1361HWTEST_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 */
1398HWTEST_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 */
1435HWTEST_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 */
1472HWTEST_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 */
1509HWTEST_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 */
1546HWTEST_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 */
1583HWTEST_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 */
1620HWTEST_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 */
1657HWTEST_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 */
1694HWTEST_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 */
1731HWTEST_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 */
1768HWTEST_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