• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2025 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 "multi_screen_mode_change_manager.h"
19 #include "screen_session_manager/include/screen_session_manager.h"
20 #include "display_manager_agent_default.h"
21 #include "common_test_utils.h"
22 #include "modifier_render_thread/rs_modifiers_draw_thread.h"
23 #include "test_client.h"
24 
25 using namespace testing;
26 using namespace testing::ext;
27 
28 namespace OHOS {
29 namespace Rosen {
30 namespace {
31 constexpr uint32_t SLEEP_TIME_IN_US = 100000; // 100ms
32 }
33 class MultiScreenModeChangeManagerTest : public testing::Test {
34 public:
35     static void SetUpTestCase();
36     static void TearDownTestCase();
37     void SetUp() override;
38     void TearDown() override;
39     void SetAceessTokenPermission(const std::string processName);
40     static MultiScreenModeChangeManager& multiSMCM_;
41     static ScreenSessionManager& ssm_;
42 };
43 
44 MultiScreenModeChangeManager& MultiScreenModeChangeManagerTest::multiSMCM_ =
45     MultiScreenModeChangeManager::GetInstance();
46 
47 ScreenSessionManager& MultiScreenModeChangeManagerTest::ssm_ =
48     ScreenSessionManager::GetInstance();
49 
SetUpTestCase()50 void MultiScreenModeChangeManagerTest::SetUpTestCase()
51 {
52     CommonTestUtils::InjectTokenInfoByHapName(0, "com.ohos.systemui", 0);
53     const char** perms = new const char *[1];
54     perms[0] = "ohos.permission.CAPTURE_SCREEN";
55     CommonTestUtils::SetAceessTokenPermission("foundation", perms, 1);
56 }
57 
TearDownTestCase()58 void MultiScreenModeChangeManagerTest::TearDownTestCase()
59 {
60 #ifdef RS_ENABLE_VK
61     RSModifiersDrawThread::Destroy();
62 #endif
63     usleep(SLEEP_TIME_IN_US);
64 }
65 
SetUp()66 void MultiScreenModeChangeManagerTest::SetUp()
67 {
68 }
69 
TearDown()70 void MultiScreenModeChangeManagerTest::TearDown()
71 {
72 }
73 
74 namespace {
75 
76 /**
77  * @tc.name: InitMultiScreenModeChangeMap
78  * @tc.desc: InitMultiScreenModeChangeMap func
79  * @tc.type: FUNC
80  */
81 HWTEST_F(MultiScreenModeChangeManagerTest, InitMultiScreenModeChangeMap, TestSize.Level1)
82 {
83     multiSMCM_.InitMultiScreenModeChangeMap();
84     multiSMCM_.handleMultiScreenModeChangeMap_.clear();
85     multiSMCM_.InitMultiScreenModeChangeMap();
86     ASSERT_FALSE(multiSMCM_.handleMultiScreenModeChangeMap_.empty());
87 }
88 
89 /**
90  * @tc.name: OnMultiScreenModeChangeRequest
91  * @tc.desc: OnMultiScreenModeChangeRequest func
92  * @tc.type: FUNC
93  */
94 HWTEST_F(MultiScreenModeChangeManagerTest, OnMultiScreenModeChangeRequest, TestSize.Level1)
95 {
96     sptr<ScreenSession> innerScreen = nullptr;
97     sptr<ScreenSession> externalScreen = nullptr;
98     std::string operateType = "mirror";
99     auto ret = multiSMCM_.OnMultiScreenModeChangeRequest(innerScreen, externalScreen, operateType);
100     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
101 
102     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
103     VirtualScreenOption virtualOption;
104     virtualOption.name_ = "createVirtualOption";
105     ScreenId screenId = ssm_.CreateVirtualScreen(
106         virtualOption, displayManagerAgent->AsObject());
107     externalScreen = ssm_.GetScreenSession(screenId);
108     ret = multiSMCM_.OnMultiScreenModeChangeRequest(innerScreen, externalScreen, operateType);
109     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
110 
111     innerScreen = ssm_.GetOrCreateScreenSession(0);
112     externalScreen = nullptr;
113     ret = multiSMCM_.OnMultiScreenModeChangeRequest(innerScreen, externalScreen, operateType);
114     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
115 
116     externalScreen = ssm_.GetScreenSession(screenId);
117     ret = multiSMCM_.OnMultiScreenModeChangeRequest(innerScreen, externalScreen, operateType);
118     ASSERT_EQ(ret, DMError::DM_ERROR_INVALID_CALLING);
119     ssm_.DestroyVirtualScreen(screenId);
120 }
121 
122 /**
123  * @tc.name: InitMultiScreenInnerMainExternalExtendModeModeChangeMap
124  * @tc.desc: InitMultiScreenInnerMainExternalExtendModeModeChangeMap
125  * @tc.type: FUNC
126  */
127 HWTEST_F(MultiScreenModeChangeManagerTest, InitMultiScreenInnerMainExternalExtendModeModeChangeMap, TestSize.Level1)
128 {
129     ASSERT_FALSE(multiSMCM_.handleMultiScreenInnerMainExternalExtendModeChangeMap_.empty());
130     multiSMCM_.handleMultiScreenInnerMainExternalExtendModeChangeMap_.clear();
131     ASSERT_TRUE(multiSMCM_.handleMultiScreenInnerMainExternalExtendModeChangeMap_.empty());
132     multiSMCM_.InitMultiScreenInnerMainExternalExtendModeModeChangeMap();
133     ASSERT_FALSE(multiSMCM_.handleMultiScreenInnerMainExternalExtendModeChangeMap_.empty());
134     multiSMCM_.InitMultiScreenInnerMainExternalExtendModeModeChangeMap();
135 }
136 
137 /**
138  * @tc.name: InitMultiScreenInnerMainExternalMirrorModeModeChangeMap
139  * @tc.desc: InitMultiScreenInnerMainExternalMirrorModeModeChangeMap
140  * @tc.type: FUNC
141  */
142 HWTEST_F(MultiScreenModeChangeManagerTest, InitMultiScreenInnerMainExternalMirrorModeModeChangeMap, TestSize.Level1)
143 {
144     ASSERT_FALSE(multiSMCM_.handleMultiScreenInnerMainExternalMirrorModeChangeMap_.empty());
145     multiSMCM_.handleMultiScreenInnerMainExternalMirrorModeChangeMap_.clear();
146     ASSERT_TRUE(multiSMCM_.handleMultiScreenInnerMainExternalMirrorModeChangeMap_.empty());
147     multiSMCM_.InitMultiScreenInnerMainExternalMirrorModeModeChangeMap();
148     ASSERT_FALSE(multiSMCM_.handleMultiScreenInnerMainExternalMirrorModeChangeMap_.empty());
149     multiSMCM_.InitMultiScreenInnerMainExternalMirrorModeModeChangeMap();
150 }
151 
152 /**
153  * @tc.name: InitMultiScreenInnerExtendExternalMainModeModeChangeMap
154  * @tc.desc: InitMultiScreenInnerExtendExternalMainModeModeChangeMap
155  * @tc.type: FUNC
156  */
157 HWTEST_F(MultiScreenModeChangeManagerTest, InitMultiScreenInnerExtendExternalMainModeModeChangeMap, TestSize.Level1)
158 {
159     ASSERT_FALSE(multiSMCM_.handleMultiScreenInnerExtendExternalMainModeChangeMap_.empty());
160     multiSMCM_.handleMultiScreenInnerExtendExternalMainModeChangeMap_.clear();
161     ASSERT_TRUE(multiSMCM_.handleMultiScreenInnerExtendExternalMainModeChangeMap_.empty());
162     multiSMCM_.InitMultiScreenInnerExtendExternalMainModeModeChangeMap();
163     ASSERT_FALSE(multiSMCM_.handleMultiScreenInnerExtendExternalMainModeChangeMap_.empty());
164     multiSMCM_.InitMultiScreenInnerExtendExternalMainModeModeChangeMap();
165 }
166 
167 /**
168  * @tc.name: InitMultiScreenInnerMirrorExternalMainModeModeChangeMap
169  * @tc.desc: InitMultiScreenInnerMirrorExternalMainModeModeChangeMap
170  * @tc.type: FUNC
171  */
172 HWTEST_F(MultiScreenModeChangeManagerTest, InitMultiScreenInnerMirrorExternalMainModeModeChangeMap, TestSize.Level1)
173 {
174     ASSERT_FALSE(multiSMCM_.handleMultiScreenInnerMirrorExternalMainModeChangeMap_.empty());
175     multiSMCM_.handleMultiScreenInnerMirrorExternalMainModeChangeMap_.clear();
176     ASSERT_TRUE(multiSMCM_.handleMultiScreenInnerMirrorExternalMainModeChangeMap_.empty());
177     multiSMCM_.InitMultiScreenInnerMirrorExternalMainModeModeChangeMap();
178     ASSERT_FALSE(multiSMCM_.handleMultiScreenInnerMirrorExternalMainModeChangeMap_.empty());
179     multiSMCM_.InitMultiScreenInnerMirrorExternalMainModeModeChangeMap();
180 }
181 
182 /**
183  * @tc.name: HandleInnerMainExternalExtendChange
184  * @tc.desc: HandleInnerMainExternalExtendChange func
185  * @tc.type: FUNC
186  */
187 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerMainExternalExtendChange, TestSize.Level1)
188 {
189     sptr<ScreenSession> innerScreen = nullptr;
190     sptr<ScreenSession> externalScreen = nullptr;
191     ScreenCombination innerTargetCombination = ScreenCombination::SCREEN_MAIN;
192     ScreenCombination externalTargetCombination = ScreenCombination::SCREEN_MIRROR;
193     auto ret = multiSMCM_.HandleInnerMainExternalExtendChange(innerScreen, innerTargetCombination, externalScreen,
194         externalTargetCombination);
195     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
196 
197     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
198     VirtualScreenOption virtualOption;
199     virtualOption.name_ = "createVirtualOption";
200     ScreenId screenId = ssm_.CreateVirtualScreen(
201         virtualOption, displayManagerAgent->AsObject());
202     externalScreen = ssm_.GetScreenSession(screenId);
203     ret = multiSMCM_.HandleInnerMainExternalExtendChange(innerScreen, innerTargetCombination, externalScreen,
204         externalTargetCombination);
205     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
206 
207     innerScreen = ssm_.GetDefaultScreenSession();
208     externalScreen = nullptr;
209     ret = multiSMCM_.HandleInnerMainExternalExtendChange(innerScreen, innerTargetCombination, externalScreen,
210         externalTargetCombination);
211     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
212 
213     externalScreen = ssm_.GetScreenSession(screenId);
214     ret = multiSMCM_.HandleInnerMainExternalExtendChange(innerScreen, innerTargetCombination, externalScreen,
215         externalTargetCombination);
216     /* HandleInnerMainExternalExtendToInnerMainExternalMirror ssmClient null */
217     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
218 
219     /* failed to find inner main external extend function handler! */
220     innerTargetCombination = ScreenCombination::SCREEN_EXTEND;
221     externalTargetCombination = ScreenCombination::SCREEN_MIRROR;
222     ret = multiSMCM_.HandleInnerMainExternalExtendChange(innerScreen, innerTargetCombination, externalScreen,
223         externalTargetCombination);
224     ASSERT_EQ(ret, DMError::DM_ERROR_INVALID_CALLING);
225     ssm_.DestroyVirtualScreen(screenId);
226 }
227 
228 /**
229  * @tc.name: HandleInnerMainExternalMirrorChange
230  * @tc.desc: HandleInnerMainExternalMirrorChange func
231  * @tc.type: FUNC
232  */
233 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerMainExternalMirrorChange, TestSize.Level1)
234 {
235     sptr<ScreenSession> innerScreen = nullptr;
236     sptr<ScreenSession> externalScreen = nullptr;
237     ScreenCombination innerTargetCombination = ScreenCombination::SCREEN_MAIN;
238     ScreenCombination externalTargetCombination = ScreenCombination::SCREEN_EXTEND;
239     auto ret = multiSMCM_.HandleInnerMainExternalMirrorChange(innerScreen, innerTargetCombination, externalScreen,
240         externalTargetCombination);
241     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
242 
243     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
244     VirtualScreenOption virtualOption;
245     virtualOption.name_ = "createVirtualOption";
246     ScreenId screenId = ssm_.CreateVirtualScreen(
247         virtualOption, displayManagerAgent->AsObject());
248     externalScreen = ssm_.GetScreenSession(screenId);
249     ret = multiSMCM_.HandleInnerMainExternalMirrorChange(innerScreen, innerTargetCombination, externalScreen,
250         externalTargetCombination);
251     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
252 
253     innerScreen = ssm_.GetDefaultScreenSession();
254     externalScreen = nullptr;
255     ret = multiSMCM_.HandleInnerMainExternalMirrorChange(innerScreen, innerTargetCombination, externalScreen,
256         externalTargetCombination);
257     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
258 
259     /* ssmClient null */
260     externalScreen = ssm_.GetScreenSession(screenId);
261     ret = multiSMCM_.HandleInnerMainExternalMirrorChange(innerScreen, innerTargetCombination, externalScreen,
262         externalTargetCombination);
263     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
264 
265     /* failed to find inner main external mirror function handler */
266     innerTargetCombination = ScreenCombination::SCREEN_MAIN;
267     externalTargetCombination = ScreenCombination::SCREEN_MIRROR;
268     ret = multiSMCM_.HandleInnerMainExternalMirrorChange(innerScreen, innerTargetCombination, externalScreen,
269         externalTargetCombination);
270     ASSERT_EQ(ret, DMError::DM_ERROR_INVALID_CALLING);
271     ssm_.DestroyVirtualScreen(screenId);
272 }
273 
274 /**
275  * @tc.name: HandleInnerExtendExternalMainChange
276  * @tc.desc: HandleInnerExtendExternalMainChange func
277  * @tc.type: FUNC
278  */
279 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerExtendExternalMainChange, TestSize.Level1)
280 {
281     sptr<ScreenSession> innerScreen = nullptr;
282     sptr<ScreenSession> externalScreen = nullptr;
283     ScreenCombination innerTargetCombination = ScreenCombination::SCREEN_MAIN;
284     ScreenCombination externalTargetCombination = ScreenCombination::SCREEN_MIRROR;
285     auto ret = multiSMCM_.HandleInnerExtendExternalMainChange(innerScreen, innerTargetCombination, externalScreen,
286         externalTargetCombination);
287     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
288 
289     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
290     VirtualScreenOption virtualOption;
291     virtualOption.name_ = "createVirtualOption";
292     ScreenId screenId = ssm_.CreateVirtualScreen(
293         virtualOption, displayManagerAgent->AsObject());
294     externalScreen = ssm_.GetScreenSession(screenId);
295     ret = multiSMCM_.HandleInnerExtendExternalMainChange(innerScreen, innerTargetCombination, externalScreen,
296         externalTargetCombination);
297     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
298 
299     innerScreen = ssm_.GetDefaultScreenSession();
300     externalScreen = nullptr;
301     ret = multiSMCM_.HandleInnerExtendExternalMainChange(innerScreen, innerTargetCombination, externalScreen,
302         externalTargetCombination);
303     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
304 
305     externalScreen = ssm_.GetScreenSession(screenId);
306     ret = multiSMCM_.HandleInnerExtendExternalMainChange(innerScreen, innerTargetCombination, externalScreen,
307         externalTargetCombination);
308     /* HandleInnerExtendExternalMainToInnerMainExternalMirror ssmclient null */
309     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
310 
311     /* failed to find inner mirror external main function handler! */
312     innerTargetCombination = ScreenCombination::SCREEN_EXTEND;
313     externalTargetCombination = ScreenCombination::SCREEN_MAIN;
314     ret = multiSMCM_.HandleInnerExtendExternalMainChange(innerScreen, innerTargetCombination, externalScreen,
315         externalTargetCombination);
316     ASSERT_EQ(ret, DMError::DM_ERROR_INVALID_CALLING);
317     ssm_.DestroyVirtualScreen(screenId);
318 }
319 
320 /**
321  * @tc.name: HandleInnerMirrorExternalMainChange
322  * @tc.desc: HandleInnerMirrorExternalMainChange func
323  * @tc.type: FUNC
324  */
325 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerMirrorExternalMainChange, TestSize.Level1)
326 {
327     sptr<ScreenSession> innerScreen = nullptr;
328     sptr<ScreenSession> externalScreen = nullptr;
329     ScreenCombination innerTargetCombination = ScreenCombination::SCREEN_MAIN;
330     ScreenCombination externalTargetCombination = ScreenCombination::SCREEN_MIRROR;
331     auto ret = multiSMCM_.HandleInnerMirrorExternalMainChange(innerScreen, innerTargetCombination, externalScreen,
332         externalTargetCombination);
333     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
334 
335     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
336     VirtualScreenOption virtualOption;
337     virtualOption.name_ = "createVirtualOption";
338     ScreenId screenId = ssm_.CreateVirtualScreen(
339         virtualOption, displayManagerAgent->AsObject());
340     externalScreen = ssm_.GetScreenSession(screenId);
341     ret = multiSMCM_.HandleInnerMirrorExternalMainChange(innerScreen, innerTargetCombination, externalScreen,
342         externalTargetCombination);
343     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
344 
345     innerScreen = ssm_.GetDefaultScreenSession();
346     externalScreen = nullptr;
347     ret = multiSMCM_.HandleInnerMirrorExternalMainChange(innerScreen, innerTargetCombination, externalScreen,
348         externalTargetCombination);
349     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
350 
351     externalScreen = ssm_.GetScreenSession(screenId);
352     ret = multiSMCM_.HandleInnerMirrorExternalMainChange(innerScreen, innerTargetCombination, externalScreen,
353         externalTargetCombination);
354     /* HandleInnerMirrorExternalMainToInnerMainExternalMirror ssmClient null */
355     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
356 
357     /* failed to find inner mirror external main function handler! */
358     innerTargetCombination = ScreenCombination::SCREEN_MIRROR;
359     externalTargetCombination = ScreenCombination::SCREEN_MAIN;
360     ret = multiSMCM_.HandleInnerMirrorExternalMainChange(innerScreen, innerTargetCombination, externalScreen,
361         externalTargetCombination);
362     ASSERT_EQ(ret, DMError::DM_ERROR_INVALID_CALLING);
363     ssm_.DestroyVirtualScreen(screenId);
364 }
365 
366 /**
367  * @tc.name: NotifyClientCreateExtendSessionOnly
368  * @tc.desc: NotifyClientCreateExtendSessionOnly
369  * @tc.type: FUNC
370  */
371 HWTEST_F(MultiScreenModeChangeManagerTest, NotifyClientCreateExtendSessionOnly, TestSize.Level1)
372 {
373     sptr<IScreenSessionManagerClient> ssmClient = nullptr;
374     sptr<ScreenSession> screenSession = nullptr;
375     multiSMCM_.NotifyClientCreateExtendSessionOnly(ssmClient, screenSession);
376 
377     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
378     VirtualScreenOption virtualOption;
379     virtualOption.name_ = "createVirtualOption";
380     ScreenId screenId = ssm_.CreateVirtualScreen(
381         virtualOption, displayManagerAgent->AsObject());
382     screenSession = ssm_.GetScreenSession(screenId);
383     multiSMCM_.NotifyClientCreateExtendSessionOnly(ssmClient, screenSession);
384     ASSERT_FALSE(screenSession->GetIsExtend());
385 
386     screenSession = nullptr;
387     ssmClient = new ScreenSessionManagerClientTest();
388     multiSMCM_.NotifyClientCreateExtendSessionOnly(ssmClient, screenSession);
389 
390     screenSession = ssm_.GetScreenSession(screenId);
391     multiSMCM_.NotifyClientCreateExtendSessionOnly(ssmClient, screenSession);
392     ASSERT_TRUE(screenSession->GetIsExtend());
393     ssm_.DestroyVirtualScreen(screenId);
394 }
395 
396 /**
397  * @tc.name: NotifyClientCreateMirrorSessionOnly
398  * @tc.desc: NotifyClientCreateMirrorSessionOnly
399  * @tc.type: FUNC
400  */
401 HWTEST_F(MultiScreenModeChangeManagerTest, NotifyClientCreateMirrorSessionOnly, TestSize.Level1)
402 {
403     sptr<IScreenSessionManagerClient> ssmClient = nullptr;
404     sptr<ScreenSession> screenSession = nullptr;
405     sptr<ScreenSession> mainSession = nullptr;
406     multiSMCM_.NotifyClientCreateMirrorSessionOnly(ssmClient, screenSession, mainSession);
407 
408     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
409     VirtualScreenOption virtualOption;
410     virtualOption.name_ = "createVirtualOption";
411     ScreenId screenId = ssm_.CreateVirtualScreen(
412         virtualOption, displayManagerAgent->AsObject());
413     screenSession = ssm_.GetScreenSession(screenId);
414     multiSMCM_.NotifyClientCreateMirrorSessionOnly(ssmClient, screenSession, mainSession);
415     ASSERT_FALSE(screenSession->GetIsExtend());
416 
417     mainSession = ssm_.GetDefaultScreenSession();
418     multiSMCM_.NotifyClientCreateMirrorSessionOnly(ssmClient, screenSession, mainSession);
419     ASSERT_FALSE(screenSession->GetIsExtend());
420 
421     screenSession = nullptr;
422     multiSMCM_.NotifyClientCreateMirrorSessionOnly(ssmClient, screenSession, mainSession);
423 
424     screenSession = nullptr;
425     ssmClient = new ScreenSessionManagerClientTest();
426     multiSMCM_.NotifyClientCreateMirrorSessionOnly(ssmClient, screenSession, mainSession);
427 
428     screenSession = ssm_.GetScreenSession(screenId);
429     multiSMCM_.NotifyClientCreateMirrorSessionOnly(ssmClient, screenSession, mainSession);
430     ASSERT_TRUE(screenSession->GetIsExtend());
431     ssm_.DestroyVirtualScreen(screenId);
432 }
433 
434 /**
435  * @tc.name: ScreenChangeToMirrorMode
436  * @tc.desc: ScreenChangeToMirrorMode
437  * @tc.type: FUNC
438  */
439 HWTEST_F(MultiScreenModeChangeManagerTest, ScreenChangeToMirrorMode, TestSize.Level1)
440 {
441     sptr<IScreenSessionManagerClient> ssmClient = nullptr;
442     sptr<ScreenSession> screenSession = nullptr;
443     sptr<ScreenSession> mainSession = nullptr;
444     multiSMCM_.ScreenChangeToMirrorMode(ssmClient, screenSession, mainSession);
445 
446     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
447     VirtualScreenOption virtualOption;
448     virtualOption.name_ = "createVirtualOption";
449     ScreenId screenId = ssm_.CreateVirtualScreen(
450         virtualOption, displayManagerAgent->AsObject());
451     screenSession = ssm_.GetScreenSession(screenId);
452     multiSMCM_.ScreenChangeToMirrorMode(ssmClient, screenSession, mainSession);
453 
454     mainSession = ssm_.GetDefaultScreenSession();
455     multiSMCM_.ScreenChangeToMirrorMode(ssmClient, screenSession, mainSession);
456     ssmClient = new ScreenSessionManagerClientTest();
457     multiSMCM_.ScreenChangeToMirrorMode(ssmClient, screenSession, mainSession);
458     ASSERT_EQ(ScreenCombination::SCREEN_MIRROR, screenSession->GetScreenCombination());
459     ssm_.DestroyVirtualScreen(screenId);
460 }
461 
462 /**
463  * @tc.name: ScreenDisplayNodeChangeNotify
464  * @tc.desc: ScreenDisplayNodeChangeNotify
465  * @tc.type: FUNC
466  */
467 HWTEST_F(MultiScreenModeChangeManagerTest, ScreenDisplayNodeChangeNotify, TestSize.Level1)
468 {
469     sptr<IScreenSessionManagerClient> ssmClient = nullptr;
470     sptr<ScreenSession> innerSession = ssm_.GetDefaultScreenSession();
471 
472     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
473     VirtualScreenOption virtualOption;
474     virtualOption.name_ = "createVirtualOption";
475     ScreenId screenId = ssm_.CreateVirtualScreen(
476         virtualOption, displayManagerAgent->AsObject());
477     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId);
478     ssmClient = new ScreenSessionManagerClientTest();
479     auto ret = multiSMCM_.ScreenDisplayNodeChangeNotify(ssmClient, innerSession, externalSession);
480     ASSERT_EQ(DMError::DM_OK, ret);
481     ssm_.DestroyVirtualScreen(screenId);
482 }
483 
484 /**
485  * @tc.name: HandleInnerMainExternalExtendToInnerMainExternalMirrorChange
486  * @tc.desc: HandleInnerMainExternalExtendToInnerMainExternalMirrorChange
487  * @tc.type: FUNC
488  */
489 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerMainExternalExtendToInnerMainExternalMirrorChange,
490     TestSize.Level1)
491 {
492     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
493     VirtualScreenOption virtualOption;
494     virtualOption.name_ = "createVirtualOption";
495     ScreenId screenId = ssm_.CreateVirtualScreen(
496         virtualOption, displayManagerAgent->AsObject());
497     sptr<ScreenSession> innerSession = ssm_.GetScreenSession(screenId);
498 
499     sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
500     VirtualScreenOption virtualOption1;
501     virtualOption1.name_ = "createVirtualOption";
502     ScreenId screenId1 = ssm_.CreateVirtualScreen(
503         virtualOption1, displayManagerAgent1->AsObject());
504     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId1);
505 
506     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
507     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
508     DMError ret = multiSMCM_.HandleInnerMainExternalExtendToInnerMainExternalMirrorChange(innerSession,
509         externalSession);
510     ASSERT_EQ(DMError::DM_OK, ret);
511 
512     innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
513     ret = multiSMCM_.HandleInnerMainExternalExtendToInnerMainExternalMirrorChange(innerSession, externalSession);
514     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
515 
516 
517     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
518     ret = multiSMCM_.HandleInnerMainExternalExtendToInnerMainExternalMirrorChange(innerSession, externalSession);
519     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
520 
521     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
522     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
523     sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
524     ssm_.SetClient(ssmClient);
525     ret = multiSMCM_.HandleInnerMainExternalExtendToInnerMainExternalMirrorChange(innerSession, externalSession);
526     ASSERT_EQ(DMError::DM_OK, ret);
527     ssm_.DestroyVirtualScreen(screenId);
528     ssm_.DestroyVirtualScreen(screenId1);
529 }
530 
531 /**
532  * @tc.name: HandleInnerMainExternalExtendToInnerExtendExternalMainChange
533  * @tc.desc: HandleInnerMainExternalExtendToInnerExtendExternalMainChange
534  * @tc.type: FUNC
535  */
536 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerMainExternalExtendToInnerExtendExternalMainChange,
537     TestSize.Level1)
538 {
539     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
540     VirtualScreenOption virtualOption;
541     virtualOption.name_ = "createVirtualOption";
542     ScreenId screenId = ssm_.CreateVirtualScreen(
543         virtualOption, displayManagerAgent->AsObject());
544     sptr<ScreenSession> innerSession = ssm_.GetScreenSession(screenId);
545 
546     sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
547     VirtualScreenOption virtualOption1;
548     virtualOption1.name_ = "createVirtualOption";
549     ScreenId screenId1 = ssm_.CreateVirtualScreen(
550         virtualOption1, displayManagerAgent1->AsObject());
551     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId1);
552 
553     ssm_.clientProxy_ = nullptr;
554     innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
555     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
556     DMError ret = multiSMCM_.HandleInnerMainExternalExtendToInnerExtendExternalMainChange(innerSession,
557         externalSession);
558     ASSERT_EQ(DMError::DM_OK, ret);
559 
560     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
561     ret = multiSMCM_.HandleInnerMainExternalExtendToInnerExtendExternalMainChange(innerSession, externalSession);
562     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
563 
564     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
565     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
566     ret = multiSMCM_.HandleInnerMainExternalExtendToInnerExtendExternalMainChange(innerSession, externalSession);
567     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
568 
569     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
570     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
571     sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
572     ssm_.SetClient(ssmClient);
573     ret = multiSMCM_.HandleInnerMainExternalExtendToInnerExtendExternalMainChange(innerSession, externalSession);
574     ASSERT_EQ(DMError::DM_OK, ret);
575     ssm_.DestroyVirtualScreen(screenId);
576     ssm_.DestroyVirtualScreen(screenId1);
577 }
578 
579 /**
580  * @tc.name: HandleInnerMainExternalExtendToInnerMirrorExternalMainChange
581  * @tc.desc: HandleInnerMainExternalExtendToInnerMirrorExternalMainChange
582  * @tc.type: FUNC
583  */
584 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerMainExternalExtendToInnerMirrorExternalMainChange,
585     TestSize.Level1)
586 {
587     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
588     VirtualScreenOption virtualOption;
589     virtualOption.name_ = "createVirtualOption";
590     ScreenId screenId = ssm_.CreateVirtualScreen(
591         virtualOption, displayManagerAgent->AsObject());
592     sptr<ScreenSession> innerSession = ssm_.GetScreenSession(screenId);
593 
594     sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
595     VirtualScreenOption virtualOption1;
596     virtualOption1.name_ = "createVirtualOption";
597     ScreenId screenId1 = ssm_.CreateVirtualScreen(
598         virtualOption1, displayManagerAgent1->AsObject());
599     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId1);
600 
601     ssm_.clientProxy_ = nullptr;
602     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
603     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
604     DMError ret = multiSMCM_.HandleInnerMainExternalExtendToInnerMirrorExternalMainChange(innerSession,
605         externalSession);
606     ASSERT_EQ(DMError::DM_OK, ret);
607 
608     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
609     ret = multiSMCM_.HandleInnerMainExternalExtendToInnerMirrorExternalMainChange(innerSession, externalSession);
610     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
611 
612     innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
613     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
614     ret = multiSMCM_.HandleInnerMainExternalExtendToInnerMirrorExternalMainChange(innerSession, externalSession);
615     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
616 
617     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
618     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
619     sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
620     ssm_.SetClient(ssmClient);
621     ret = multiSMCM_.HandleInnerMainExternalExtendToInnerMirrorExternalMainChange(innerSession, externalSession);
622     ASSERT_EQ(DMError::DM_OK, ret);
623     ssm_.DestroyVirtualScreen(screenId);
624     ssm_.DestroyVirtualScreen(screenId1);
625 }
626 
627 /**
628  * @tc.name: HandleInnerMainExternalMirrorToInnerMainExternalExtendChange
629  * @tc.desc: HandleInnerMainExternalMirrorToInnerMainExternalExtendChange
630  * @tc.type: FUNC
631  */
632 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerMainExternalMirrorToInnerMainExternalExtendChange,
633     TestSize.Level1)
634 {
635     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
636     VirtualScreenOption virtualOption;
637     virtualOption.name_ = "createVirtualOption";
638     ScreenId screenId = ssm_.CreateVirtualScreen(
639         virtualOption, displayManagerAgent->AsObject());
640     sptr<ScreenSession> innerSession = ssm_.GetScreenSession(screenId);
641 
642     sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
643     VirtualScreenOption virtualOption1;
644     virtualOption1.name_ = "createVirtualOption";
645     ScreenId screenId1 = ssm_.CreateVirtualScreen(
646         virtualOption1, displayManagerAgent1->AsObject());
647     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId1);
648 
649     ssm_.clientProxy_ = nullptr;
650     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
651     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
652     DMError ret = multiSMCM_.HandleInnerMainExternalMirrorToInnerMainExternalExtendChange(innerSession,
653         externalSession);
654     ASSERT_EQ(DMError::DM_OK, ret);
655 
656     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
657     ret = multiSMCM_.HandleInnerMainExternalMirrorToInnerMainExternalExtendChange(innerSession, externalSession);
658     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
659 
660     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
661     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
662     ret = multiSMCM_.HandleInnerMainExternalMirrorToInnerMainExternalExtendChange(innerSession, externalSession);
663     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
664 
665     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
666     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
667     sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
668     ssm_.SetClient(ssmClient);
669     ret = multiSMCM_.HandleInnerMainExternalMirrorToInnerMainExternalExtendChange(innerSession, externalSession);
670     ASSERT_EQ(DMError::DM_OK, ret);
671     ssm_.DestroyVirtualScreen(screenId);
672     ssm_.DestroyVirtualScreen(screenId1);
673 }
674 
675 /**
676  * @tc.name: HandleInnerMainExternalMirrorToInnerMirrorExternalMainChange
677  * @tc.desc: HandleInnerMainExternalMirrorToInnerMirrorExternalMainChange
678  * @tc.type: FUNC
679  */
680 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerMainExternalMirrorToInnerMirrorExternalMainChange,
681     TestSize.Level1)
682 {
683     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
684     VirtualScreenOption virtualOption;
685     virtualOption.name_ = "createVirtualOption";
686     ScreenId screenId = ssm_.CreateVirtualScreen(
687         virtualOption, displayManagerAgent->AsObject());
688     sptr<ScreenSession> innerSession = ssm_.GetScreenSession(screenId);
689 
690     sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
691     VirtualScreenOption virtualOption1;
692     virtualOption1.name_ = "createVirtualOption";
693     ScreenId screenId1 = ssm_.CreateVirtualScreen(
694         virtualOption1, displayManagerAgent1->AsObject());
695     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId1);
696 
697     ssm_.clientProxy_ = nullptr;
698     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
699     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
700     DMError ret = multiSMCM_.HandleInnerMainExternalMirrorToInnerMirrorExternalMainChange(innerSession,
701         externalSession);
702     ASSERT_EQ(DMError::DM_OK, ret);
703 
704     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
705     ret = multiSMCM_.HandleInnerMainExternalMirrorToInnerMirrorExternalMainChange(innerSession, externalSession);
706     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
707 
708     innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
709     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
710     ret = multiSMCM_.HandleInnerMainExternalMirrorToInnerMirrorExternalMainChange(innerSession, externalSession);
711     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
712 
713     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
714     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
715     sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
716     ssm_.SetClient(ssmClient);
717     ret = multiSMCM_.HandleInnerMainExternalMirrorToInnerMirrorExternalMainChange(innerSession, externalSession);
718     ASSERT_EQ(DMError::DM_OK, ret);
719     ssm_.DestroyVirtualScreen(screenId);
720     ssm_.DestroyVirtualScreen(screenId1);
721 }
722 
723 /**
724  * @tc.name: HandleInnerMainExternalMirrorToInnerExtendExternalMainChange
725  * @tc.desc: HandleInnerMainExternalMirrorToInnerExtendExternalMainChange
726  * @tc.type: FUNC
727  */
728 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerMainExternalMirrorToInnerExtendExternalMainChange,
729     TestSize.Level1)
730 {
731     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
732     VirtualScreenOption virtualOption;
733     virtualOption.name_ = "createVirtualOption";
734     ScreenId screenId = ssm_.CreateVirtualScreen(
735         virtualOption, displayManagerAgent->AsObject());
736     sptr<ScreenSession> innerSession = ssm_.GetScreenSession(screenId);
737 
738     sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
739     VirtualScreenOption virtualOption1;
740     virtualOption1.name_ = "createVirtualOption";
741     ScreenId screenId1 = ssm_.CreateVirtualScreen(
742         virtualOption1, displayManagerAgent1->AsObject());
743     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId1);
744 
745     ssm_.clientProxy_ = nullptr;
746     innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
747     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
748     DMError ret = multiSMCM_.HandleInnerMainExternalMirrorToInnerExtendExternalMainChange(innerSession,
749         externalSession);
750     ASSERT_EQ(DMError::DM_OK, ret);
751 
752     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
753     ret = multiSMCM_.HandleInnerMainExternalMirrorToInnerExtendExternalMainChange(innerSession, externalSession);
754     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
755 
756     innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
757     ret = multiSMCM_.HandleInnerMainExternalMirrorToInnerExtendExternalMainChange(innerSession, externalSession);
758     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
759 
760     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
761     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
762     sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
763     ssm_.SetClient(ssmClient);
764     ret = multiSMCM_.HandleInnerMainExternalMirrorToInnerExtendExternalMainChange(innerSession, externalSession);
765     ASSERT_EQ(DMError::DM_OK, ret);
766     ssm_.DestroyVirtualScreen(screenId);
767     ssm_.DestroyVirtualScreen(screenId1);
768 }
769 
770 /**
771  * @tc.name: HandleInnerExtendExternalMainToInnerMirrorExternalMainChange
772  * @tc.desc: HandleInnerExtendExternalMainToInnerMirrorExternalMainChange
773  * @tc.type: FUNC
774  */
775 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerExtendExternalMainToInnerMirrorExternalMainChange,
776     TestSize.Level1)
777 {
778     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
779     VirtualScreenOption virtualOption;
780     virtualOption.name_ = "createVirtualOption";
781     ScreenId screenId = ssm_.CreateVirtualScreen(
782         virtualOption, displayManagerAgent->AsObject());
783     sptr<ScreenSession> innerSession = ssm_.GetScreenSession(screenId);
784 
785     sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
786     VirtualScreenOption virtualOption1;
787     virtualOption1.name_ = "createVirtualOption";
788     ScreenId screenId1 = ssm_.CreateVirtualScreen(
789         virtualOption1, displayManagerAgent1->AsObject());
790     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId1);
791 
792     ssm_.clientProxy_ = nullptr;
793     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
794     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
795     DMError ret = multiSMCM_.HandleInnerExtendExternalMainToInnerMirrorExternalMainChange(innerSession,
796         externalSession);
797     ASSERT_EQ(DMError::DM_OK, ret);
798 
799     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
800     ret = multiSMCM_.HandleInnerExtendExternalMainToInnerMirrorExternalMainChange(innerSession, externalSession);
801     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
802 
803     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
804     ret = multiSMCM_.HandleInnerExtendExternalMainToInnerMirrorExternalMainChange(innerSession, externalSession);
805     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
806 
807     innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
808     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
809     sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
810     ssm_.SetClient(ssmClient);
811     ret = multiSMCM_.HandleInnerExtendExternalMainToInnerMirrorExternalMainChange(innerSession, externalSession);
812     ASSERT_EQ(DMError::DM_OK, ret);
813     ssm_.DestroyVirtualScreen(screenId);
814     ssm_.DestroyVirtualScreen(screenId1);
815 }
816 
817 /**
818  * @tc.name: HandleInnerExtendExternalMainToInnerMainExternalExtendChange
819  * @tc.desc: HandleInnerExtendExternalMainToInnerMainExternalExtendChange
820  * @tc.type: FUNC
821  */
822 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerExtendExternalMainToInnerMainExternalExtendChange,
823     TestSize.Level1)
824 {
825     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
826     VirtualScreenOption virtualOption;
827     virtualOption.name_ = "createVirtualOption";
828     ScreenId screenId = ssm_.CreateVirtualScreen(
829         virtualOption, displayManagerAgent->AsObject());
830     sptr<ScreenSession> innerSession = ssm_.GetScreenSession(screenId);
831 
832     sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
833     VirtualScreenOption virtualOption1;
834     virtualOption1.name_ = "createVirtualOption";
835     ScreenId screenId1 = ssm_.CreateVirtualScreen(
836         virtualOption1, displayManagerAgent1->AsObject());
837     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId1);
838 
839     ssm_.clientProxy_ = nullptr;
840     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
841     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
842     DMError ret = multiSMCM_.HandleInnerExtendExternalMainToInnerMainExternalExtendChange(innerSession,
843         externalSession);
844     ASSERT_EQ(DMError::DM_OK, ret);
845 
846     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
847     ret = multiSMCM_.HandleInnerExtendExternalMainToInnerMainExternalExtendChange(innerSession, externalSession);
848     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
849 
850     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
851     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
852     ret = multiSMCM_.HandleInnerExtendExternalMainToInnerMainExternalExtendChange(innerSession, externalSession);
853     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
854 
855     innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
856     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
857     sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
858     ssm_.SetClient(ssmClient);
859     ret = multiSMCM_.HandleInnerExtendExternalMainToInnerMainExternalExtendChange(innerSession, externalSession);
860     ASSERT_EQ(DMError::DM_OK, ret);
861     ssm_.DestroyVirtualScreen(screenId);
862     ssm_.DestroyVirtualScreen(screenId1);
863 }
864 
865 /**
866  * @tc.name: HandleInnerExtendExternalMainToInnerMainExternalMirrorChange
867  * @tc.desc: HandleInnerExtendExternalMainToInnerMainExternalMirrorChange
868  * @tc.type: FUNC
869  */
870 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerExtendExternalMainToInnerMainExternalMirrorChange,
871     TestSize.Level1)
872 {
873     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
874     VirtualScreenOption virtualOption;
875     virtualOption.name_ = "createVirtualOption";
876     ScreenId screenId = ssm_.CreateVirtualScreen(
877         virtualOption, displayManagerAgent->AsObject());
878     sptr<ScreenSession> innerSession = ssm_.GetScreenSession(screenId);
879 
880     sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
881     VirtualScreenOption virtualOption1;
882     virtualOption1.name_ = "createVirtualOption";
883     ScreenId screenId1 = ssm_.CreateVirtualScreen(
884         virtualOption1, displayManagerAgent1->AsObject());
885     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId1);
886 
887     ssm_.clientProxy_ = nullptr;
888     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
889     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
890     DMError ret = multiSMCM_.HandleInnerExtendExternalMainToInnerMainExternalMirrorChange(innerSession,
891         externalSession);
892     ASSERT_EQ(DMError::DM_OK, ret);
893 
894     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
895     ret = multiSMCM_.HandleInnerExtendExternalMainToInnerMainExternalMirrorChange(innerSession, externalSession);
896     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
897 
898     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
899     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
900     ret = multiSMCM_.HandleInnerExtendExternalMainToInnerMainExternalMirrorChange(innerSession, externalSession);
901     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
902 
903     innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
904     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
905     sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
906     ssm_.SetClient(ssmClient);
907     ret = multiSMCM_.HandleInnerExtendExternalMainToInnerMainExternalMirrorChange(innerSession, externalSession);
908     ASSERT_EQ(DMError::DM_OK, ret);
909     ssm_.DestroyVirtualScreen(screenId);
910     ssm_.DestroyVirtualScreen(screenId1);
911 }
912 
913 /**
914  * @tc.name: HandleInnerMirrorExternalMainToInnerExtendExternalMainChange
915  * @tc.desc: HandleInnerMirrorExternalMainToInnerExtendExternalMainChange
916  * @tc.type: FUNC
917  */
918 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerMirrorExternalMainToInnerExtendExternalMainChange,
919     TestSize.Level1)
920 {
921     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
922     VirtualScreenOption virtualOption;
923     virtualOption.name_ = "createVirtualOption";
924     ScreenId screenId = ssm_.CreateVirtualScreen(
925         virtualOption, displayManagerAgent->AsObject());
926     sptr<ScreenSession> innerSession = ssm_.GetScreenSession(screenId);
927 
928     sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
929     VirtualScreenOption virtualOption1;
930     virtualOption1.name_ = "createVirtualOption";
931     ScreenId screenId1 = ssm_.CreateVirtualScreen(
932         virtualOption1, displayManagerAgent1->AsObject());
933     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId1);
934 
935     ssm_.clientProxy_ = nullptr;
936     innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
937     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
938     DMError ret = multiSMCM_.HandleInnerMirrorExternalMainToInnerExtendExternalMainChange(innerSession,
939         externalSession);
940     ASSERT_EQ(DMError::DM_OK, ret);
941 
942     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
943     ret = multiSMCM_.HandleInnerMirrorExternalMainToInnerExtendExternalMainChange(innerSession, externalSession);
944     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
945 
946     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
947     ret = multiSMCM_.HandleInnerMirrorExternalMainToInnerExtendExternalMainChange(innerSession, externalSession);
948     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
949 
950     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
951     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
952     sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
953     ssm_.SetClient(ssmClient);
954     ret = multiSMCM_.HandleInnerMirrorExternalMainToInnerExtendExternalMainChange(innerSession, externalSession);
955     ASSERT_EQ(DMError::DM_OK, ret);
956     ssm_.DestroyVirtualScreen(screenId);
957     ssm_.DestroyVirtualScreen(screenId1);
958 }
959 
960 /**
961  * @tc.name: HandleInnerMirrorExternalMainToInnerMainExternalMirrorChange
962  * @tc.desc: HandleInnerMirrorExternalMainToInnerMainExternalMirrorChange
963  * @tc.type: FUNC
964  */
965 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerMirrorExternalMainToInnerMainExternalMirrorChange,
966     TestSize.Level1)
967 {
968     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
969     VirtualScreenOption virtualOption;
970     virtualOption.name_ = "createVirtualOption";
971     ScreenId screenId = ssm_.CreateVirtualScreen(
972         virtualOption, displayManagerAgent->AsObject());
973     sptr<ScreenSession> innerSession = ssm_.GetScreenSession(screenId);
974 
975     sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
976     VirtualScreenOption virtualOption1;
977     virtualOption1.name_ = "createVirtualOption";
978     ScreenId screenId1 = ssm_.CreateVirtualScreen(
979         virtualOption1, displayManagerAgent1->AsObject());
980     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId1);
981 
982     ssm_.clientProxy_ = nullptr;
983     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
984     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
985     DMError ret = multiSMCM_.HandleInnerMirrorExternalMainToInnerMainExternalMirrorChange(innerSession,
986         externalSession);
987     ASSERT_EQ(DMError::DM_OK, ret);
988 
989     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
990     ret = multiSMCM_.HandleInnerMirrorExternalMainToInnerMainExternalMirrorChange(innerSession, externalSession);
991     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
992 
993     innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
994     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
995     ret = multiSMCM_.HandleInnerMirrorExternalMainToInnerMainExternalMirrorChange(innerSession, externalSession);
996     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
997 
998     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
999     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1000     sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
1001     ssm_.SetClient(ssmClient);
1002     ret = multiSMCM_.HandleInnerMirrorExternalMainToInnerMainExternalMirrorChange(innerSession, externalSession);
1003     ASSERT_EQ(DMError::DM_OK, ret);
1004     ssm_.DestroyVirtualScreen(screenId);
1005     ssm_.DestroyVirtualScreen(screenId1);
1006 }
1007 
1008 /**
1009  * @tc.name: HandleInnerMirrorExternalMainToInnerMainExternalExtendChange
1010  * @tc.desc: HandleInnerMirrorExternalMainToInnerMainExternalExtendChange
1011  * @tc.type: FUNC
1012  */
1013 HWTEST_F(MultiScreenModeChangeManagerTest, HandleInnerMirrorExternalMainToInnerMainExternalExtendChange,
1014     TestSize.Level1)
1015 {
1016     sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1017     VirtualScreenOption virtualOption;
1018     virtualOption.name_ = "createVirtualOption";
1019     ScreenId screenId = ssm_.CreateVirtualScreen(
1020         virtualOption, displayManagerAgent->AsObject());
1021     sptr<ScreenSession> innerSession = ssm_.GetScreenSession(screenId);
1022 
1023     sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
1024     VirtualScreenOption virtualOption1;
1025     virtualOption1.name_ = "createVirtualOption";
1026     ScreenId screenId1 = ssm_.CreateVirtualScreen(
1027         virtualOption1, displayManagerAgent1->AsObject());
1028     sptr<ScreenSession> externalSession = ssm_.GetScreenSession(screenId1);
1029 
1030     ssm_.clientProxy_ = nullptr;
1031     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1032     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
1033     DMError ret = multiSMCM_.HandleInnerMirrorExternalMainToInnerMainExternalExtendChange(innerSession,
1034         externalSession);
1035     ASSERT_EQ(DMError::DM_OK, ret);
1036 
1037     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1038     ret = multiSMCM_.HandleInnerMirrorExternalMainToInnerMainExternalExtendChange(innerSession, externalSession);
1039     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
1040 
1041     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1042     externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
1043     ret = multiSMCM_.HandleInnerMirrorExternalMainToInnerMainExternalExtendChange(innerSession, externalSession);
1044     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
1045 
1046     innerSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1047     externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1048     sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
1049     ssm_.SetClient(ssmClient);
1050     ret = multiSMCM_.HandleInnerMirrorExternalMainToInnerMainExternalExtendChange(innerSession, externalSession);
1051     ASSERT_EQ(DMError::DM_OK, ret);
1052     ssm_.DestroyVirtualScreen(screenId);
1053     ssm_.DestroyVirtualScreen(screenId1);
1054 }
1055 }
1056 } // namespace Rosen
1057 } // namespace OHOS
1058