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_power_change_manager.h"
19 #include "screen_session_manager/include/screen_session_manager.h"
20 #include "display_manager_agent_default.h"
21 #include "zidl/screen_session_manager_client_interface.h"
22 #include "common_test_utils.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 MultiScreenPowerChangeManagerTest : 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 MultiScreenPowerChangeManager& multiSPCM_;
41 static ScreenSessionManager& ssm_;
42 };
43
44 MultiScreenPowerChangeManager& MultiScreenPowerChangeManagerTest::multiSPCM_ =
45 MultiScreenPowerChangeManager::GetInstance();
46
47 ScreenSessionManager& MultiScreenPowerChangeManagerTest::ssm_ =
48 ScreenSessionManager::GetInstance();
49
SetUpTestCase()50 void MultiScreenPowerChangeManagerTest::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 MultiScreenPowerChangeManagerTest::TearDownTestCase()
59 {
60 usleep(SLEEP_TIME_IN_US);
61 }
62
SetUp()63 void MultiScreenPowerChangeManagerTest::SetUp()
64 {
65 }
66
TearDown()67 void MultiScreenPowerChangeManagerTest::TearDown()
68 {
69 }
70
71 namespace {
72 /**
73 * @tc.name: InitMultiScreenPowerChangeMap
74 * @tc.desc: InitMultiScreenPowerChangeMap func
75 * @tc.type: FUNC
76 */
77 HWTEST_F(MultiScreenPowerChangeManagerTest, InitMultiScreenPowerChangeMap, TestSize.Level1)
78 {
79 multiSPCM_.handleScreenPowerChangeMap_.clear();
80 ASSERT_TRUE(multiSPCM_.handleScreenPowerChangeMap_.empty());
81 multiSPCM_.InitMultiScreenPowerChangeMap();
82 ASSERT_FALSE(multiSPCM_.handleScreenPowerChangeMap_.empty());
83 multiSPCM_.InitMultiScreenPowerChangeMap();
84 }
85
86 /**
87 * @tc.name: OnMultiScreenPowerChangeRequest
88 * @tc.desc: OnMultiScreenPowerChangeRequest func
89 * @tc.type: FUNC
90 */
91 HWTEST_F(MultiScreenPowerChangeManagerTest, OnMultiScreenPowerChangeRequest, TestSize.Level1)
92 {
93 sptr<ScreenSession> innerScreen = nullptr;
94 sptr<ScreenSession> externalScreen = nullptr;
95 MultiScreenPowerSwitchType switchStatus = MultiScreenPowerSwitchType::SCREEN_SWITCH_ON;
96 auto ret = multiSPCM_.OnMultiScreenPowerChangeRequest(innerScreen, externalScreen, switchStatus);
97 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
98
99 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
100 VirtualScreenOption virtualOption;
101 virtualOption.name_ = "createVirtualOption";
102 ScreenId screenId = ssm_.CreateVirtualScreen(
103 virtualOption, displayManagerAgent->AsObject());
104 externalScreen = ssm_.GetScreenSession(screenId);
105 ret = multiSPCM_.OnMultiScreenPowerChangeRequest(innerScreen, externalScreen, switchStatus);
106 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
107
108 innerScreen = ssm_.GetDefaultScreenSession();
109 externalScreen = nullptr;
110 ret = multiSPCM_.OnMultiScreenPowerChangeRequest(innerScreen, externalScreen, switchStatus);
111 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
112
113 externalScreen = ssm_.GetScreenSession(screenId);
114 ret = multiSPCM_.OnMultiScreenPowerChangeRequest(innerScreen, externalScreen, switchStatus);
115 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
116
117 switchStatus = MultiScreenPowerSwitchType::SCREEN_SWITCH_OFF;
118 ret = multiSPCM_.OnMultiScreenPowerChangeRequest(innerScreen, externalScreen, switchStatus);
119 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
120
121 switchStatus = MultiScreenPowerSwitchType::SCREEN_SWITCH_EXTERNAL;
122 ret = multiSPCM_.OnMultiScreenPowerChangeRequest(innerScreen, externalScreen, switchStatus);
123 ASSERT_NE(ret, DMError::DM_ERROR_INVALID_CALLING);
124 ssm_.DestroyVirtualScreen(screenId);
125 }
126
127 /**
128 * @tc.name: HandleScreenOnChange
129 * @tc.desc: HandleScreenOnChange func
130 * @tc.type: FUNC
131 */
132 HWTEST_F(MultiScreenPowerChangeManagerTest, HandleScreenOnChange, TestSize.Level1)
133 {
134 sptr<ScreenSession> innerScreen = nullptr;
135 sptr<ScreenSession> externalScreen = nullptr;
136 auto ret = multiSPCM_.HandleScreenOnChange(innerScreen, externalScreen);
137 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
138
139 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
140 VirtualScreenOption virtualOption;
141 virtualOption.name_ = "createVirtualOption";
142 ScreenId screenId = ssm_.CreateVirtualScreen(
143 virtualOption, displayManagerAgent->AsObject());
144 externalScreen = ssm_.GetScreenSession(screenId);
145 ret = multiSPCM_.HandleScreenOnChange(innerScreen, externalScreen);
146 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
147
148 innerScreen = ssm_.GetOrCreateScreenSession(0);
149 externalScreen = nullptr;
150 ret = multiSPCM_.HandleScreenOnChange(innerScreen, externalScreen);
151 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
152
153 externalScreen = ssm_.GetScreenSession(screenId);
154 ret = multiSPCM_.HandleScreenOnChange(innerScreen, externalScreen);
155 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
156 ssm_.DestroyVirtualScreen(screenId);
157 }
158
159 /**
160 * @tc.name: HandleScreenOffChange
161 * @tc.desc: HandleScreenOffChange func
162 * @tc.type: FUNC
163 */
164 HWTEST_F(MultiScreenPowerChangeManagerTest, HandleScreenOffChange, TestSize.Level1)
165 {
166 sptr<ScreenSession> innerScreen = nullptr;
167 sptr<ScreenSession> externalScreen = nullptr;
168 auto ret = multiSPCM_.HandleScreenOffChange(innerScreen, externalScreen);
169 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
170
171 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
172 VirtualScreenOption virtualOption;
173 virtualOption.name_ = "createVirtualOption";
174 ScreenId screenId = ssm_.CreateVirtualScreen(
175 virtualOption, displayManagerAgent->AsObject());
176 externalScreen = ssm_.GetScreenSession(screenId);
177 ret = multiSPCM_.HandleScreenOffChange(innerScreen, externalScreen);
178 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
179
180 innerScreen = ssm_.GetOrCreateScreenSession(0);
181 externalScreen = nullptr;
182 ret = multiSPCM_.HandleScreenOffChange(innerScreen, externalScreen);
183 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
184
185 externalScreen = ssm_.GetScreenSession(screenId);
186 ret = multiSPCM_.HandleScreenOffChange(innerScreen, externalScreen);
187 ASSERT_NE(ret, DMError::DM_ERROR_NULLPTR);
188 ssm_.DestroyVirtualScreen(screenId);
189 }
190
191 /**
192 * @tc.name: InitRecoveryMultiScreenModeChangeMap
193 * @tc.desc: InitRecoveryMultiScreenModeChangeMap func
194 * @tc.type: FUNC
195 */
196 HWTEST_F(MultiScreenPowerChangeManagerTest, InitRecoveryMultiScreenModeChangeMap, TestSize.Level1)
197 {
198 ASSERT_FALSE(multiSPCM_.handleScreenPowerChangeMap_.empty());
199 multiSPCM_.handleScreenPowerChangeMap_.clear();
200 ASSERT_TRUE(multiSPCM_.handleScreenPowerChangeMap_.empty());
201 multiSPCM_.InitRecoveryMultiScreenModeChangeMap();
202 }
203
204 /**
205 * @tc.name: InitMultiScreenModeOffChangeMap
206 * @tc.desc: InitMultiScreenModeOffChangeMap func
207 * @tc.type: FUNC
208 */
209 HWTEST_F(MultiScreenPowerChangeManagerTest, InitMultiScreenModeOffChangeMap, TestSize.Level1)
210 {
211 multiSPCM_.handleScreenPowerChangeMap_.clear();
212 ASSERT_TRUE(multiSPCM_.handleScreenPowerChangeMap_.empty());
213 multiSPCM_.InitMultiScreenModeOffChangeMap();
214 }
215
216 /**
217 * @tc.name: HandleScreenOnlyExternalModeChange
218 * @tc.desc: HandleScreenOnlyExternalModeChange func
219 * @tc.type: FUNC
220 */
221 HWTEST_F(MultiScreenPowerChangeManagerTest, HandleScreenOnlyExternalModeChange, TestSize.Level1)
222 {
223 sptr<ScreenSession> innerScreen = nullptr;
224 sptr<ScreenSession> externalScreen = nullptr;
225 auto ret = multiSPCM_.HandleScreenOnlyExternalModeChange(innerScreen, externalScreen);
226 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
227
228 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
229 VirtualScreenOption virtualOption;
230 virtualOption.name_ = "createVirtualOption";
231 ScreenId screenId = ssm_.CreateVirtualScreen(
232 virtualOption, displayManagerAgent->AsObject());
233 externalScreen = ssm_.GetScreenSession(screenId);
234 ret = multiSPCM_.HandleScreenOnlyExternalModeChange(innerScreen, externalScreen);
235 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
236
237 innerScreen = ssm_.GetOrCreateScreenSession(0);
238 externalScreen = nullptr;
239 ret = multiSPCM_.HandleScreenOnlyExternalModeChange(innerScreen, externalScreen);
240 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
241
242 externalScreen = ssm_.GetScreenSession(screenId);
243 ret = multiSPCM_.HandleScreenOnlyExternalModeChange(innerScreen, externalScreen);
244 ASSERT_NE(ret, DMError::DM_ERROR_NULLPTR);
245 ssm_.DestroyVirtualScreen(screenId);
246 }
247
248 /**
249 * @tc.name: ScreenDisplayNodeRemove
250 * @tc.desc: ScreenDisplayNodeRemove func
251 * @tc.type: FUNC
252 */
253 HWTEST_F(MultiScreenPowerChangeManagerTest, ScreenDisplayNodeRemove, TestSize.Level1)
254 {
255 sptr<ScreenSession> screenScreen = new ScreenSession();
256 ASSERT_NE(nullptr, screenScreen);
257 multiSPCM_.ScreenDisplayNodeRemove(screenScreen);
258 }
259
260 /**
261 * @tc.name: HandleInnerMirrorExternalMainChange
262 * @tc.desc: HandleInnerMirrorExternalMainChange func
263 * @tc.type: FUNC
264 */
265 HWTEST_F(MultiScreenPowerChangeManagerTest, HandleInnerMirrorExternalMainChange, TestSize.Level1)
266 {
267 sptr<ScreenSession> innerScreen = nullptr;
268 sptr<ScreenSession> externalScreen = nullptr;
269 auto ret = multiSPCM_.HandleInnerMirrorExternalMainChange(innerScreen, externalScreen);
270 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
271
272 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
273 VirtualScreenOption virtualOption;
274 virtualOption.name_ = "createVirtualOption";
275 ScreenId screenId = ssm_.CreateVirtualScreen(
276 virtualOption, displayManagerAgent->AsObject());
277 innerScreen = ssm_.GetScreenSession(screenId);
278
279 sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
280 VirtualScreenOption virtualOption1;
281 virtualOption1.name_ = "createVirtualOption";
282 ScreenId screenId1 = ssm_.CreateVirtualScreen(
283 virtualOption1, displayManagerAgent1->AsObject());
284 externalScreen = ssm_.GetScreenSession(screenId1);
285 innerScreen->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
286 externalScreen->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
287 sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
288 ssm_.SetClient(ssmClient);
289 ret = multiSPCM_.HandleInnerMirrorExternalMainChange(innerScreen, externalScreen);
290 ASSERT_EQ(DMError::DM_OK, ret);
291 ssm_.DestroyVirtualScreen(screenId);
292 ssm_.DestroyVirtualScreen(screenId1);
293 }
294
295 /**
296 * @tc.name: HandleInnerMainExternalExtendChange
297 * @tc.desc: HandleInnerMainExternalExtendChange func
298 * @tc.type: FUNC
299 */
300 HWTEST_F(MultiScreenPowerChangeManagerTest, HandleInnerMainExternalExtendChange, TestSize.Level1)
301 {
302 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
303 VirtualScreenOption virtualOption;
304 virtualOption.name_ = "createVirtualOption";
305 ScreenId screenId = ssm_.CreateVirtualScreen(
306 virtualOption, displayManagerAgent->AsObject());
307 sptr<ScreenSession> innerScreen = ssm_.GetScreenSession(screenId);
308
309 sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
310 VirtualScreenOption virtualOption1;
311 virtualOption1.name_ = "createVirtualOption";
312 ScreenId screenId1 = ssm_.CreateVirtualScreen(
313 virtualOption1, displayManagerAgent1->AsObject());
314 sptr<ScreenSession> externalScreen = ssm_.GetScreenSession(screenId1);
315
316 innerScreen->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
317 externalScreen->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
318 sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
319 ssm_.SetClient(ssmClient);
320 auto ret = multiSPCM_.HandleInnerMainExternalExtendChange(innerScreen, externalScreen);
321 ASSERT_EQ(DMError::DM_OK, ret);
322 ssm_.DestroyVirtualScreen(screenId);
323 ssm_.DestroyVirtualScreen(screenId1);
324 }
325
326 /**
327 * @tc.name: HandleInnerMainExternalMirrorChange
328 * @tc.desc: HandleInnerMainExternalMirrorChange func
329 * @tc.type: FUNC
330 */
331 HWTEST_F(MultiScreenPowerChangeManagerTest, HandleInnerMainExternalMirrorChange, TestSize.Level1)
332 {
333 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
334 VirtualScreenOption virtualOption;
335 virtualOption.name_ = "createVirtualOption";
336 ScreenId screenId = ssm_.CreateVirtualScreen(
337 virtualOption, displayManagerAgent->AsObject());
338 sptr<ScreenSession> innerScreen = ssm_.GetScreenSession(screenId);
339
340 sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
341 VirtualScreenOption virtualOption1;
342 virtualOption1.name_ = "createVirtualOption";
343 ScreenId screenId1 = ssm_.CreateVirtualScreen(
344 virtualOption1, displayManagerAgent1->AsObject());
345 sptr<ScreenSession> externalScreen = ssm_.GetScreenSession(screenId1);
346 innerScreen->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
347 externalScreen->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
348 sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
349 ssm_.SetClient(ssmClient);
350 auto ret = multiSPCM_.HandleInnerMainExternalMirrorChange(innerScreen, externalScreen);
351 ASSERT_EQ(DMError::DM_OK, ret);
352 ssm_.DestroyVirtualScreen(screenId);
353 ssm_.DestroyVirtualScreen(screenId1);
354 }
355
356 /**
357 * @tc.name: HandleInnerExtendExternalMainChange
358 * @tc.desc: HandleInnerExtendExternalMainChange func
359 * @tc.type: FUNC
360 */
361 HWTEST_F(MultiScreenPowerChangeManagerTest, HandleInnerExtendExternalMainChange, TestSize.Level1)
362 {
363 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
364 VirtualScreenOption virtualOption;
365 virtualOption.name_ = "createVirtualOption";
366 ScreenId screenId = ssm_.CreateVirtualScreen(
367 virtualOption, displayManagerAgent->AsObject());
368 sptr<ScreenSession> innerScreen = ssm_.GetScreenSession(screenId);
369
370 sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
371 VirtualScreenOption virtualOption1;
372 virtualOption1.name_ = "createVirtualOption";
373 ScreenId screenId1 = ssm_.CreateVirtualScreen(
374 virtualOption1, displayManagerAgent1->AsObject());
375 sptr<ScreenSession> externalScreen = ssm_.GetScreenSession(screenId1);
376 innerScreen->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
377 externalScreen->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
378 sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
379 ssm_.SetClient(ssmClient);
380 auto ret = multiSPCM_.HandleInnerExtendExternalMainChange(innerScreen, externalScreen);
381 ASSERT_EQ(DMError::DM_OK, ret);
382 ssm_.DestroyVirtualScreen(screenId);
383 ssm_.DestroyVirtualScreen(screenId1);
384 }
385
386 /**
387 * @tc.name: HandleRecoveryInnerMainExternalExtendChange
388 * @tc.desc: HandleRecoveryInnerMainExternalExtendChange func
389 * @tc.type: FUNC
390 */
391 HWTEST_F(MultiScreenPowerChangeManagerTest, HandleRecoveryInnerMainExternalExtendChange, TestSize.Level1)
392 {
393 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
394 VirtualScreenOption virtualOption;
395 virtualOption.name_ = "createVirtualOption";
396 ScreenId screenId = ssm_.CreateVirtualScreen(
397 virtualOption, displayManagerAgent->AsObject());
398 sptr<ScreenSession> innerScreen = ssm_.GetScreenSession(screenId);
399
400 sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
401 VirtualScreenOption virtualOption1;
402 virtualOption1.name_ = "createVirtualOption";
403 ScreenId screenId1 = ssm_.CreateVirtualScreen(
404 virtualOption1, displayManagerAgent1->AsObject());
405 sptr<ScreenSession> externalScreen = ssm_.GetScreenSession(screenId1);
406 innerScreen->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
407 externalScreen->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
408 sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
409 ssm_.SetClient(ssmClient);
410 auto ret = multiSPCM_.HandleRecoveryInnerMainExternalExtendChange(innerScreen, externalScreen);
411 ASSERT_EQ(DMError::DM_OK, ret);
412 ssm_.DestroyVirtualScreen(screenId);
413 ssm_.DestroyVirtualScreen(screenId1);
414 }
415
416 /**
417 * @tc.name: HandleRecoveryInnerMainExternalMirrorChange
418 * @tc.desc: HandleRecoveryInnerMainExternalMirrorChange func
419 * @tc.type: FUNC
420 */
421 HWTEST_F(MultiScreenPowerChangeManagerTest, HandleRecoveryInnerMainExternalMirrorChange, TestSize.Level1)
422 {
423 sptr<ScreenSession> innerScreen = new ScreenSession();
424 sptr<ScreenSession> externalScreen = new ScreenSession();
425 auto ret = multiSPCM_.HandleRecoveryInnerMainExternalMirrorChange(innerScreen, externalScreen);
426 ASSERT_NE(ret, DMError::DM_ERROR_NULLPTR);
427 }
428
429 /**
430 * @tc.name: HandleRecoveryInnerExtendExternalMainChange
431 * @tc.desc: HandleRecoveryInnerExtendExternalMainChange func
432 * @tc.type: FUNC
433 */
434 HWTEST_F(MultiScreenPowerChangeManagerTest, HandleRecoveryInnerExtendExternalMainChange, TestSize.Level1)
435 {
436 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
437 VirtualScreenOption virtualOption;
438 virtualOption.name_ = "createVirtualOption";
439 ScreenId screenId = ssm_.CreateVirtualScreen(
440 virtualOption, displayManagerAgent->AsObject());
441 sptr<ScreenSession> innerScreen = ssm_.GetScreenSession(screenId);
442
443 sptr<IDisplayManagerAgent> displayManagerAgent1 = new DisplayManagerAgentDefault();
444 VirtualScreenOption virtualOption1;
445 virtualOption1.name_ = "createVirtualOption";
446 ScreenId screenId1 = ssm_.CreateVirtualScreen(
447 virtualOption1, displayManagerAgent1->AsObject());
448 sptr<ScreenSession> externalScreen = ssm_.GetScreenSession(screenId1);
449 innerScreen->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
450 externalScreen->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
451 sptr<IScreenSessionManagerClient> ssmClient = new ScreenSessionManagerClientTest();
452 ssm_.SetClient(ssmClient);
453 auto ret = multiSPCM_.HandleRecoveryInnerExtendExternalMainChange(innerScreen, externalScreen);
454 ASSERT_EQ(DMError::DM_OK, ret);
455 ssm_.DestroyVirtualScreen(screenId);
456 ssm_.DestroyVirtualScreen(screenId1);
457 }
458
459 /**
460 * @tc.name: ScreenToExtendChange
461 * @tc.desc: ScreenToExtendChange func
462 * @tc.type: FUNC
463 */
464 HWTEST_F(MultiScreenPowerChangeManagerTest, ScreenToExtendChange, TestSize.Level1)
465 {
466 sptr<IScreenSessionManagerClient> ssmClient = ScreenSessionManager::GetInstance().GetClientProxy();
467 sptr<ScreenSession> screenSession = nullptr;
468 multiSPCM_.ScreenToExtendChange(ssmClient, screenSession);
469
470 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
471 VirtualScreenOption virtualOption;
472 virtualOption.name_ = "createVirtualOption";
473 ScreenId screenId = ssm_.CreateVirtualScreen(
474 virtualOption, displayManagerAgent->AsObject());
475 screenSession = ssm_.GetScreenSession(screenId);
476 multiSPCM_.ScreenToExtendChange(ssmClient, screenSession);
477 ASSERT_NE(ssmClient, nullptr);
478 }
479
480 /**
481 * @tc.name: CreateExternalScreenDisplayNodeOnly
482 * @tc.desc: CreateExternalScreenDisplayNodeOnly func
483 * @tc.type: FUNC
484 */
485 HWTEST_F(MultiScreenPowerChangeManagerTest, CreateExternalScreenDisplayNodeOnly, TestSize.Level1)
486 {
487 sptr<ScreenSession> innerScreen = new ScreenSession();
488 sptr<ScreenSession> externalScreen = new ScreenSession();
489 ScreenCombination combination = ScreenCombination::SCREEN_MIRROR;
490 ASSERT_NE(nullptr, innerScreen);
491 ASSERT_NE(nullptr, externalScreen);
492 multiSPCM_.CreateExternalScreenDisplayNodeOnly(innerScreen, externalScreen, combination);
493 combination = ScreenCombination::SCREEN_EXPAND;
494 multiSPCM_.CreateExternalScreenDisplayNodeOnly(innerScreen, externalScreen, combination);
495 ASSERT_NE(nullptr, innerScreen);
496 }
497
498 /**
499 * @tc.name: OnRecoveryScreenModeByPowerChange
500 * @tc.desc: OnRecoveryScreenModeByPowerChange func
501 * @tc.type: FUNC
502 */
503 HWTEST_F(MultiScreenPowerChangeManagerTest, OnRecoveryScreenModeByPowerChange, TestSize.Level1)
504 {
505 sptr<ScreenSession> innerScreen = nullptr;
506 sptr<ScreenSession> externalScreen = nullptr;
507 auto ret = multiSPCM_.OnRecoveryScreenModeByPowerChange(innerScreen, externalScreen);
508 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
509
510 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
511 VirtualScreenOption virtualOption;
512 virtualOption.name_ = "createVirtualOption";
513 ScreenId screenId = ssm_.CreateVirtualScreen(
514 virtualOption, displayManagerAgent->AsObject());
515 externalScreen = ssm_.GetScreenSession(screenId);
516 ret = multiSPCM_.OnRecoveryScreenModeByPowerChange(innerScreen, externalScreen);
517 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
518
519 innerScreen = ssm_.GetDefaultScreenSession();
520 externalScreen = nullptr;
521 ret = multiSPCM_.OnRecoveryScreenModeByPowerChange(innerScreen, externalScreen);
522 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
523
524 externalScreen = ssm_.GetScreenSession(screenId);
525 ret = multiSPCM_.OnRecoveryScreenModeByPowerChange(innerScreen, externalScreen);
526 }
527
528 /**
529 * @tc.name: HandleRecoveryInnerMirrorExternalMainChange
530 * @tc.desc: HandleRecoveryInnerMirrorExternalMainChange func
531 * @tc.type: FUNC
532 */
533 HWTEST_F(MultiScreenPowerChangeManagerTest, HandleRecoveryInnerMirrorExternalMainChange, TestSize.Level1)
534 {
535 sptr<ScreenSession> innerScreen = new ScreenSession();
536 sptr<ScreenSession> externalScreen = new ScreenSession();
537 auto ret = multiSPCM_.HandleRecoveryInnerMirrorExternalMainChange(innerScreen, externalScreen);
538 ASSERT_EQ(ret, DMError::DM_OK);
539 }
540 }
541 } // namespace Rosen
542 } // namespace OHOS