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_change_utils.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
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 namespace {
30 constexpr uint32_t SLEEP_TIME_IN_US = 100000; // 100ms
31 }
32 class MultiScreenChangeUtilsTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp() override;
37 void TearDown() override;
38 void SetAceessTokenPermission(const std::string processName);
39 static MultiScreenChangeUtils& multiSCU_;
40 static ScreenSessionManager& ssm_;
41 };
42
43 ScreenSessionManager& MultiScreenChangeUtilsTest::ssm_ =
44 ScreenSessionManager::GetInstance();
45
SetUpTestCase()46 void MultiScreenChangeUtilsTest::SetUpTestCase()
47 {
48 CommonTestUtils::InjectTokenInfoByHapName(0, "com.ohos.systemui", 0);
49 const char** perms = new const char *[1];
50 perms[0] = "ohos.permission.CAPTURE_SCREEN";
51 CommonTestUtils::SetAceessTokenPermission("foundation", perms, 1);
52 }
53
TearDownTestCase()54 void MultiScreenChangeUtilsTest::TearDownTestCase()
55 {
56 usleep(SLEEP_TIME_IN_US);
57 }
58
SetUp()59 void MultiScreenChangeUtilsTest::SetUp()
60 {
61 }
62
TearDown()63 void MultiScreenChangeUtilsTest::TearDown()
64 {
65 }
66
67 namespace {
68
69 /**
70 * @tc.name: ScreenPropertyChangeNotify
71 * @tc.desc: ScreenPropertyChangeNotify func
72 * @tc.type: FUNC
73 */
74 HWTEST_F(MultiScreenChangeUtilsTest, ScreenPropertyChangeNotify, TestSize.Level1)
75 {
76 sptr<ScreenSession> innerScreen = nullptr;
77 sptr<ScreenSession> externalScreen = nullptr;
78 multiSCU_.ScreenPropertyChangeNotify(innerScreen, externalScreen);
79
80 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
81 VirtualScreenOption virtualOption;
82 virtualOption.name_ = "createVirtualOption";
83 ScreenId screenId = ssm_.CreateVirtualScreen(
84 virtualOption, displayManagerAgent->AsObject());
85 innerScreen = ssm_.GetScreenSession(screenId);
86 multiSCU_.ScreenPropertyChangeNotify(innerScreen, externalScreen);
87 ASSERT_NE(innerScreen, nullptr);
88
89 externalScreen = ssm_.GetOrCreateScreenSession(0);
90 innerScreen = nullptr;
91 multiSCU_.ScreenPropertyChangeNotify(innerScreen, externalScreen);
92 ASSERT_NE(externalScreen, nullptr);
93
94 innerScreen = ssm_.GetScreenSession(screenId);
95 multiSCU_.ScreenPropertyChangeNotify(innerScreen, externalScreen);
96 ASSERT_NE(innerScreen, nullptr);
97 }
98
99 /**
100 * @tc.name: ScreenDensityChangeNotify
101 * @tc.desc: ScreenDensityChangeNotify func
102 * @tc.type: FUNC
103 */
104 HWTEST_F(MultiScreenChangeUtilsTest, ScreenDensityChangeNotify, TestSize.Level1)
105 {
106 sptr<ScreenSession> innerScreen = nullptr;
107 sptr<ScreenSession> externalScreen = nullptr;
108 multiSCU_.ScreenDensityChangeNotify(innerScreen, externalScreen);
109
110 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
111 VirtualScreenOption virtualOption;
112 virtualOption.name_ = "createVirtualOption";
113 ScreenId screenId = ssm_.CreateVirtualScreen(
114 virtualOption, displayManagerAgent->AsObject());
115 innerScreen = ssm_.GetScreenSession(screenId);
116 multiSCU_.ScreenDensityChangeNotify(innerScreen, externalScreen);
117 ASSERT_NE(innerScreen, nullptr);
118
119 externalScreen = ssm_.GetOrCreateScreenSession(0);
120 innerScreen = nullptr;
121 multiSCU_.ScreenDensityChangeNotify(innerScreen, externalScreen);
122 ASSERT_NE(externalScreen, nullptr);
123
124 innerScreen = ssm_.GetScreenSession(screenId);
125 multiSCU_.ScreenDensityChangeNotify(innerScreen, externalScreen);
126 ASSERT_NE(innerScreen, nullptr);
127 }
128
129 /**
130 * @tc.name: ScreenExtendPositionChange
131 * @tc.desc: ScreenExtendPositionChange func
132 * @tc.type: FUNC
133 */
134 HWTEST_F(MultiScreenChangeUtilsTest, ScreenExtendPositionChange, TestSize.Level1)
135 {
136 sptr<ScreenSession> innerScreen = nullptr;
137 sptr<ScreenSession> externalScreen = nullptr;
138 multiSCU_.ScreenExtendPositionChange(innerScreen, externalScreen);
139
140 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
141 VirtualScreenOption virtualOption;
142 virtualOption.name_ = "createVirtualOption";
143 ScreenId screenId = ssm_.CreateVirtualScreen(
144 virtualOption, displayManagerAgent->AsObject());
145 innerScreen = ssm_.GetScreenSession(screenId);
146 multiSCU_.ScreenExtendPositionChange(innerScreen, externalScreen);
147 ASSERT_NE(innerScreen, nullptr);
148
149 externalScreen = ssm_.GetOrCreateScreenSession(0);
150 innerScreen = nullptr;
151 multiSCU_.ScreenExtendPositionChange(innerScreen, externalScreen);
152 ASSERT_NE(externalScreen, nullptr);
153
154 innerScreen = ssm_.GetScreenSession(screenId);
155 multiSCU_.ScreenExtendPositionChange(innerScreen, externalScreen);
156 ASSERT_NE(innerScreen, nullptr);
157 }
158
159 /**
160 * @tc.name: SetScreenAvailableStatus
161 * @tc.desc: SetScreenAvailableStatus func
162 * @tc.type: FUNC
163 */
164 HWTEST_F(MultiScreenChangeUtilsTest, SetScreenAvailableStatus, TestSize.Level1)
165 {
166 sptr<ScreenSession> screenSession = nullptr;
167 bool isScreenAvailable = true;
168 multiSCU_.SetScreenAvailableStatus(screenSession, isScreenAvailable);
169 screenSession = new ScreenSession();
170 multiSCU_.SetScreenAvailableStatus(screenSession, isScreenAvailable);
171 ASSERT_EQ(isScreenAvailable, true);
172 }
173
174 /**
175 * @tc.name: ScreenMainPositionChange
176 * @tc.desc: ScreenMainPositionChange func
177 * @tc.type: FUNC
178 */
179 HWTEST_F(MultiScreenChangeUtilsTest, ScreenMainPositionChange, TestSize.Level1)
180 {
181 sptr<ScreenSession> innerScreen = nullptr;
182 sptr<ScreenSession> externalScreen = nullptr;
183 multiSCU_.ScreenMainPositionChange(innerScreen, externalScreen);
184
185 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
186 VirtualScreenOption virtualOption;
187 virtualOption.name_ = "createVirtualOption";
188 ScreenId screenId = ssm_.CreateVirtualScreen(
189 virtualOption, displayManagerAgent->AsObject());
190 innerScreen = ssm_.GetScreenSession(screenId);
191 multiSCU_.ScreenMainPositionChange(innerScreen, externalScreen);
192 ASSERT_NE(innerScreen, nullptr);
193
194 externalScreen = ssm_.GetOrCreateScreenSession(0);
195 innerScreen = nullptr;
196 multiSCU_.ScreenMainPositionChange(innerScreen, externalScreen);
197 ASSERT_NE(externalScreen, nullptr);
198
199 innerScreen = ssm_.GetScreenSession(screenId);
200 multiSCU_.ScreenMainPositionChange(innerScreen, externalScreen);
201 ASSERT_NE(innerScreen, nullptr);
202 }
203
204 /**
205 * @tc.name: SetExternalScreenOffScreenRendering
206 * @tc.desc: SetExternalScreenOffScreenRendering func
207 * @tc.type: FUNC
208 */
209 HWTEST_F(MultiScreenChangeUtilsTest, SetExternalScreenOffScreenRendering, TestSize.Level1)
210 {
211 sptr<ScreenSession> innerScreen = nullptr;
212 sptr<ScreenSession> externalScreen = nullptr;
213 multiSCU_.SetExternalScreenOffScreenRendering(innerScreen, externalScreen);
214
215 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
216 VirtualScreenOption virtualOption;
217 virtualOption.name_ = "createVirtualOption";
218 ScreenId screenId = ssm_.CreateVirtualScreen(
219 virtualOption, displayManagerAgent->AsObject());
220 innerScreen = ssm_.GetScreenSession(screenId);
221 multiSCU_.SetExternalScreenOffScreenRendering(innerScreen, externalScreen);
222 ASSERT_NE(innerScreen, nullptr);
223
224 externalScreen = ssm_.GetOrCreateScreenSession(0);
225 innerScreen = nullptr;
226 multiSCU_.SetExternalScreenOffScreenRendering(innerScreen, externalScreen);
227 ASSERT_NE(externalScreen, nullptr);
228
229 innerScreen = ssm_.GetScreenSession(screenId);
230 multiSCU_.SetExternalScreenOffScreenRendering(innerScreen, externalScreen);
231 ASSERT_NE(innerScreen, nullptr);
232 }
233
234 /**
235 * @tc.name: ScreenCombinationChange
236 * @tc.desc: ScreenCombinationChange func
237 * @tc.type: FUNC
238 */
239 HWTEST_F(MultiScreenChangeUtilsTest, ScreenCombinationChange, TestSize.Level1)
240 {
241 sptr<ScreenSession> innerScreen = nullptr;
242 sptr<ScreenSession> externalScreen = nullptr;
243 ScreenCombination externalCombination = ScreenCombination::SCREEN_MIRROR;
244 multiSCU_.ScreenCombinationChange(innerScreen, externalScreen, externalCombination);
245
246 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
247 VirtualScreenOption virtualOption;
248 virtualOption.name_ = "createVirtualOption";
249 ScreenId screenId = ssm_.CreateVirtualScreen(
250 virtualOption, displayManagerAgent->AsObject());
251 innerScreen = ssm_.GetScreenSession(screenId);
252 multiSCU_.ScreenCombinationChange(innerScreen, externalScreen, externalCombination);
253 ASSERT_NE(innerScreen, nullptr);
254
255 externalScreen = ssm_.GetOrCreateScreenSession(0);
256 innerScreen = nullptr;
257 multiSCU_.ScreenCombinationChange(innerScreen, externalScreen, externalCombination);
258 ASSERT_NE(externalScreen, nullptr);
259
260 innerScreen = ssm_.GetScreenSession(screenId);
261 multiSCU_.ScreenCombinationChange(innerScreen, externalScreen, externalCombination);
262 ASSERT_NE(innerScreen, nullptr);
263 }
264
265 /**
266 * @tc.name: ScreenSerialNumberChange
267 * @tc.desc: ScreenSerialNumberChange func
268 * @tc.type: FUNC
269 */
270 HWTEST_F(MultiScreenChangeUtilsTest, ScreenSerialNumberChange, TestSize.Level1)
271 {
272 sptr<ScreenSession> innerScreen = nullptr;
273 sptr<ScreenSession> externalScreen = nullptr;
274 multiSCU_.ScreenSerialNumberChange(innerScreen, externalScreen);
275
276 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
277 VirtualScreenOption virtualOption;
278 virtualOption.name_ = "createVirtualOption";
279 ScreenId screenId = ssm_.CreateVirtualScreen(
280 virtualOption, displayManagerAgent->AsObject());
281 innerScreen = ssm_.GetScreenSession(screenId);
282 multiSCU_.ScreenSerialNumberChange(innerScreen, externalScreen);
283 ASSERT_NE(innerScreen, nullptr);
284
285 externalScreen = ssm_.GetOrCreateScreenSession(0);
286 innerScreen = nullptr;
287 multiSCU_.ScreenSerialNumberChange(innerScreen, externalScreen);
288 ASSERT_NE(externalScreen, nullptr);
289
290 innerScreen = ssm_.GetScreenSession(screenId);
291 multiSCU_.ScreenSerialNumberChange(innerScreen, externalScreen);
292 ASSERT_NE(innerScreen, nullptr);
293 }
294
295 /**
296 * @tc.name: ScreenActiveModesChange
297 * @tc.desc: ScreenActiveModesChange func
298 * @tc.type: FUNC
299 */
300 HWTEST_F(MultiScreenChangeUtilsTest, ScreenActiveModesChange, TestSize.Level1)
301 {
302 sptr<ScreenSession> innerScreen = nullptr;
303 sptr<ScreenSession> externalScreen = nullptr;
304 multiSCU_.ScreenActiveModesChange(innerScreen, externalScreen);
305
306 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
307 VirtualScreenOption virtualOption;
308 virtualOption.name_ = "createVirtualOption";
309 ScreenId screenId = ssm_.CreateVirtualScreen(
310 virtualOption, displayManagerAgent->AsObject());
311 innerScreen = ssm_.GetScreenSession(screenId);
312 multiSCU_.ScreenActiveModesChange(innerScreen, externalScreen);
313 ASSERT_NE(innerScreen, nullptr);
314
315 externalScreen = ssm_.GetOrCreateScreenSession(0);
316 innerScreen = nullptr;
317 multiSCU_.ScreenActiveModesChange(innerScreen, externalScreen);
318 ASSERT_NE(externalScreen, nullptr);
319
320 innerScreen = ssm_.GetScreenSession(screenId);
321 multiSCU_.ScreenActiveModesChange(innerScreen, externalScreen);
322 ASSERT_NE(innerScreen, nullptr);
323 }
324
325 /**
326 * @tc.name: ScreenRSIdChange
327 * @tc.desc: ScreenRSIdChange func
328 * @tc.type: FUNC
329 */
330 HWTEST_F(MultiScreenChangeUtilsTest, ScreenRSIdChange, TestSize.Level1)
331 {
332 sptr<ScreenSession> innerScreen = nullptr;
333 sptr<ScreenSession> externalScreen = nullptr;
334 multiSCU_.ScreenRSIdChange(innerScreen, externalScreen);
335
336 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
337 VirtualScreenOption virtualOption;
338 virtualOption.name_ = "createVirtualOption";
339 ScreenId screenId = ssm_.CreateVirtualScreen(
340 virtualOption, displayManagerAgent->AsObject());
341 innerScreen = ssm_.GetScreenSession(screenId);
342 multiSCU_.ScreenRSIdChange(innerScreen, externalScreen);
343 ASSERT_NE(innerScreen, nullptr);
344
345 externalScreen = ssm_.GetOrCreateScreenSession(0);
346 innerScreen = nullptr;
347 multiSCU_.ScreenRSIdChange(innerScreen, externalScreen);
348 ASSERT_NE(externalScreen, nullptr);
349
350 innerScreen = ssm_.GetScreenSession(screenId);
351 multiSCU_.ScreenRSIdChange(innerScreen, externalScreen);
352 ASSERT_NE(innerScreen, nullptr);
353 }
354
355 /**
356 * @tc.name: ScreenNameChange
357 * @tc.desc: ScreenNameChange func
358 * @tc.type: FUNC
359 */
360 HWTEST_F(MultiScreenChangeUtilsTest, ScreenNameChange, TestSize.Level1)
361 {
362 sptr<ScreenSession> innerScreen = nullptr;
363 sptr<ScreenSession> externalScreen = nullptr;
364 multiSCU_.ScreenNameChange(innerScreen, externalScreen);
365
366 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
367 VirtualScreenOption virtualOption;
368 virtualOption.name_ = "createVirtualOption";
369 ScreenId screenId = ssm_.CreateVirtualScreen(
370 virtualOption, displayManagerAgent->AsObject());
371 innerScreen = ssm_.GetScreenSession(screenId);
372 multiSCU_.ScreenNameChange(innerScreen, externalScreen);
373 ASSERT_NE(innerScreen, nullptr);
374
375 externalScreen = ssm_.GetOrCreateScreenSession(0);
376 innerScreen = nullptr;
377 multiSCU_.ScreenNameChange(innerScreen, externalScreen);
378 ASSERT_NE(externalScreen, nullptr);
379
380 innerScreen = ssm_.GetScreenSession(screenId);
381 multiSCU_.ScreenNameChange(innerScreen, externalScreen);
382 ASSERT_NE(innerScreen, nullptr);
383 }
384
385 /**
386 * @tc.name: ScreenPropertyChange
387 * @tc.desc: ScreenPropertyChange func
388 * @tc.type: FUNC
389 */
390 HWTEST_F(MultiScreenChangeUtilsTest, ScreenPropertyChange, TestSize.Level1)
391 {
392 sptr<ScreenSession> innerScreen = nullptr;
393 sptr<ScreenSession> externalScreen = nullptr;
394 multiSCU_.ScreenPropertyChange(innerScreen, externalScreen);
395
396 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
397 VirtualScreenOption virtualOption;
398 virtualOption.name_ = "createVirtualOption";
399 ScreenId screenId = ssm_.CreateVirtualScreen(
400 virtualOption, displayManagerAgent->AsObject());
401 innerScreen = ssm_.GetScreenSession(screenId);
402 multiSCU_.ScreenPropertyChange(innerScreen, externalScreen);
403 ASSERT_NE(innerScreen, nullptr);
404
405 externalScreen = ssm_.GetOrCreateScreenSession(0);
406 innerScreen = nullptr;
407 multiSCU_.ScreenPropertyChange(innerScreen, externalScreen);
408 ASSERT_NE(externalScreen, nullptr);
409
410 innerScreen = ssm_.GetScreenSession(screenId);
411 multiSCU_.ScreenPropertyChange(innerScreen, externalScreen);
412 ASSERT_NE(innerScreen, nullptr);
413 }
414
415 /**
416 * @tc.name: ExchangeScreenSupportedRefreshRate
417 * @tc.desc: ExchangeScreenSupportedRefreshRate func
418 * @tc.type: FUNC
419 */
420 HWTEST_F(MultiScreenChangeUtilsTest, ExchangeScreenSupportedRefreshRate, TestSize.Level1)
421 {
422 sptr<ScreenSession> innerScreen = nullptr;
423 sptr<ScreenSession> externalScreen = nullptr;
424 multiSCU_.ExchangeScreenSupportedRefreshRate(innerScreen, externalScreen);
425
426 sptr<IDisplayManagerAgent> displayManagerAgent = sptr<DisplayManagerAgentDefault>::MakeSptr();
427 VirtualScreenOption virtualOption;
428 virtualOption.name_ = "createVirtualOption";
429 ScreenId screenId = ssm_.CreateVirtualScreen(
430 virtualOption, displayManagerAgent->AsObject());
431 innerScreen = ssm_.GetScreenSession(screenId);
432 multiSCU_.ExchangeScreenSupportedRefreshRate(innerScreen, externalScreen);
433 ASSERT_NE(innerScreen, nullptr);
434
435 externalScreen = ssm_.GetOrCreateScreenSession(0);
436 innerScreen = nullptr;
437 multiSCU_.ExchangeScreenSupportedRefreshRate(innerScreen, externalScreen);
438 ASSERT_NE(externalScreen, nullptr);
439
440 innerScreen = ssm_.GetScreenSession(screenId);
441 multiSCU_.ExchangeScreenSupportedRefreshRate(innerScreen, externalScreen);
442 ASSERT_NE(innerScreen, nullptr);
443 }
444
445 /**
446 * @tc.name: ExchangeScreenSupportedRefreshRate01
447 * @tc.desc: ExchangeScreenSupportedRefreshRate func
448 * @tc.type: FUNC
449 */
450 HWTEST_F(MultiScreenChangeUtilsTest, ExchangeScreenSupportedRefreshRate01, TestSize.Level1)
451 {
452 sptr<ScreenSession> innerScreen = nullptr;
453 sptr<ScreenSession> externalScreen = nullptr;
454 multiSCU_.ExchangeScreenSupportedRefreshRate(innerScreen, externalScreen);
455
456 sptr<IDisplayManagerAgent> displayManagerAgent = sptr<DisplayManagerAgentDefault>::MakeSptr();
457 VirtualScreenOption virtualOption;
458 virtualOption.name_ = "createVirtualOption";
459 ScreenId screenId = ssm_.CreateVirtualScreen(
460 virtualOption, displayManagerAgent->AsObject());
461 ssm_.GetOrCreatePhysicalScreenSession(screenId);
462 innerScreen = ssm_.GetScreenSession(screenId);
463 multiSCU_.ExchangeScreenSupportedRefreshRate(innerScreen, externalScreen);
464 ASSERT_NE(innerScreen, nullptr);
465
466 ssm_.GetOrCreatePhysicalScreenSession(0);
467 externalScreen = ssm_.GetOrCreateScreenSession(0);
468 innerScreen = nullptr;
469 multiSCU_.ExchangeScreenSupportedRefreshRate(innerScreen, externalScreen);
470 ASSERT_NE(externalScreen, nullptr);
471
472 innerScreen = ssm_.GetScreenSession(screenId);
473 multiSCU_.ExchangeScreenSupportedRefreshRate(innerScreen, externalScreen);
474 ASSERT_NE(innerScreen, nullptr);
475 }
476
477 /**
478 * @tc.name: ScreenPhysicalInfoChange
479 * @tc.desc: ScreenPhysicalInfoChange func
480 * @tc.type: FUNC
481 */
482 HWTEST_F(MultiScreenChangeUtilsTest, ScreenPhysicalInfoChange, TestSize.Level1)
483 {
484 sptr<ScreenSession> innerScreen = nullptr;
485 sptr<ScreenSession> externalScreen = nullptr;
486 multiSCU_.ScreenPhysicalInfoChange(innerScreen, externalScreen);
487
488 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
489 VirtualScreenOption virtualOption;
490 virtualOption.name_ = "createVirtualOption";
491 ScreenId screenId = ssm_.CreateVirtualScreen(
492 virtualOption, displayManagerAgent->AsObject());
493 innerScreen = ssm_.GetScreenSession(screenId);
494 multiSCU_.ScreenPhysicalInfoChange(innerScreen, externalScreen);
495 ASSERT_NE(innerScreen, nullptr);
496
497 externalScreen = ssm_.GetOrCreateScreenSession(0);
498 innerScreen = nullptr;
499 multiSCU_.ScreenPhysicalInfoChange(innerScreen, externalScreen);
500 ASSERT_NE(externalScreen, nullptr);
501
502 innerScreen = ssm_.GetScreenSession(screenId);
503 multiSCU_.ScreenPhysicalInfoChange(innerScreen, externalScreen);
504 ASSERT_NE(innerScreen, nullptr);
505 }
506
507 /**
508 * @tc.name: CreateMirrorSession
509 * @tc.desc: CreateMirrorSession func
510 * @tc.type: FUNC
511 */
512 HWTEST_F(MultiScreenChangeUtilsTest, CreateMirrorSession, TestSize.Level1)
513 {
514 sptr<ScreenSession> innerScreen = nullptr;
515 sptr<ScreenSession> externalScreen = nullptr;
516 multiSCU_.CreateMirrorSession(innerScreen, externalScreen);
517
518 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
519 VirtualScreenOption virtualOption;
520 virtualOption.name_ = "createVirtualOption";
521 ScreenId screenId = ssm_.CreateVirtualScreen(
522 virtualOption, displayManagerAgent->AsObject());
523 innerScreen = ssm_.GetScreenSession(screenId);
524 multiSCU_.CreateMirrorSession(innerScreen, externalScreen);
525 ASSERT_NE(innerScreen, nullptr);
526
527 externalScreen = ssm_.GetOrCreateScreenSession(0);
528 innerScreen = nullptr;
529 multiSCU_.CreateMirrorSession(innerScreen, externalScreen);
530 ASSERT_NE(externalScreen, nullptr);
531
532 innerScreen = ssm_.GetScreenSession(screenId);
533 multiSCU_.CreateMirrorSession(innerScreen, externalScreen);
534 ASSERT_NE(innerScreen, nullptr);
535 }
536
537 /**
538 * @tc.name: CreateExtendSession
539 * @tc.desc: CreateExtendSession func
540 * @tc.type: FUNC
541 */
542 HWTEST_F(MultiScreenChangeUtilsTest, CreateExtendSession, TestSize.Level1)
543 {
544 sptr<ScreenSession> screenSession = nullptr;
545 multiSCU_.CreateExtendSession(screenSession);
546
547 screenSession = new ScreenSession();
548 ASSERT_NE(screenSession, nullptr);
549 multiSCU_.CreateExtendSession(screenSession);
550 }
551 }
552 } // namespace Rosen
553 } // namespace OHOS
554