1 /*
2 * Copyright (c) 2023 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 #include <parameter.h>
18 #include <parameters.h>
19
20 #include "display_manager_agent_default.h"
21 #include "screen_session_manager/include/screen_session_manager.h"
22 #include "screen_scene_config.h"
23 #include "screen_setting_helper.h"
24 #include "fold_screen_state_internel.h"
25 #include "mock/mock_accesstoken_kit.h"
26 #include "window_manager_hilog.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Rosen {
33 namespace {
34 constexpr uint32_t SLEEP_TIME_IN_US = 100000; // 100ms
35 constexpr uint32_t M_STATUS_WIDTH = 1008;
36 constexpr uint32_t F_STATUS_WIDTH = 2048;
37 constexpr uint32_t G_STATUS_WIDTH = 3184;
38 const ScreenId SCREENID = 1000;
39 constexpr uint32_t EXCEPTION_DPI = 10;
40 constexpr uint32_t PC_MODE_DPI = 304;
41 }
42 namespace {
43 std::string g_errLog;
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)44 void MyLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char* tag,
45 const char* msg)
46 {
47 g_errLog += msg;
48 }
49 }
50 class ScreenSessionManagerTest : public testing::Test {
51 public:
52 static void SetUpTestCase();
53 static void TearDownTestCase();
54 void SetUp() override;
55 void TearDown() override;
56
57 static sptr<ScreenSessionManager> ssm_;
58 };
59
60 sptr<ScreenSessionManager> ScreenSessionManagerTest::ssm_ = nullptr;
61
SetUpTestCase()62 void ScreenSessionManagerTest::SetUpTestCase()
63 {
64 ssm_ = new ScreenSessionManager();
65 }
66
TearDownTestCase()67 void ScreenSessionManagerTest::TearDownTestCase()
68 {
69 ssm_ = nullptr;
70 }
71
SetUp()72 void ScreenSessionManagerTest::SetUp()
73 {
74 }
75
TearDown()76 void ScreenSessionManagerTest::TearDown()
77 {
78 usleep(SLEEP_TIME_IN_US);
79 }
80
81 namespace {
82 /**
83 * @tc.name: SwitchScrollParam01
84 * @tc.desc: SwitchScrollParam test
85 * @tc.type: FUNC
86 */
87 HWTEST_F(ScreenSessionManagerTest, SwitchScrollParam01, TestSize.Level1)
88 {
89 ScreenSceneConfig::scrollableParams_.clear();
90 vector<FoldDisplayMode> displayModeALL = {
91 FoldDisplayMode::SUB,
92 FoldDisplayMode::MAIN,
93 FoldDisplayMode::FULL,
94 FoldDisplayMode::UNKNOWN,
95 FoldDisplayMode::COORDINATION,
96 };
97 std::map<FoldDisplayMode, std::string> scrollVelocityScaleParam = {
98 pair<FoldDisplayMode, std::string>(FoldDisplayMode::SUB, "1.0"),
99 pair<FoldDisplayMode, std::string>(FoldDisplayMode::MAIN, "1.1"),
100 pair<FoldDisplayMode, std::string>(FoldDisplayMode::FULL, "1.2"),
101 pair<FoldDisplayMode, std::string>(FoldDisplayMode::UNKNOWN, "1.3"),
102 pair<FoldDisplayMode, std::string>(FoldDisplayMode::COORDINATION, "1.4")
103 };
104 std::map<FoldDisplayMode, std::string> scrollFrictionParam = {
105 pair<FoldDisplayMode, std::string>(FoldDisplayMode::SUB, "1.0"),
106 pair<FoldDisplayMode, std::string>(FoldDisplayMode::MAIN, "2.0"),
107 pair<FoldDisplayMode, std::string>(FoldDisplayMode::FULL, "3.0"),
108 pair<FoldDisplayMode, std::string>(FoldDisplayMode::UNKNOWN, "4.0"),
109 pair<FoldDisplayMode, std::string>(FoldDisplayMode::COORDINATION, "5.0"),
110 };
111 ScreenSessionManager* ssm = new ScreenSessionManager();
112 ASSERT_NE(ssm, nullptr);
113 system::SetParameter("persist.scrollable.velocityScale", "0");
114 system::SetParameter("persist.scrollable.friction", "0");
115 std::string ret1, ret2;
116 for (FoldDisplayMode displayMode : displayModeALL) {
117 ScrollableParam scrollableParam;
118 scrollableParam.velocityScale_ = scrollVelocityScaleParam.count(displayMode) ?
119 scrollVelocityScaleParam[displayMode] : "0";
120 scrollableParam.friction_ = scrollFrictionParam.count(displayMode) ?
121 scrollFrictionParam[displayMode] : "0";
122 ScreenSceneConfig::scrollableParams_[displayMode] = scrollableParam;
123 ssm->SwitchScrollParam(displayMode);
124 ret1 = system::GetParameter("persist.scrollable.velocityScale", "0");
125 ret2 = system::GetParameter("persist.scrollable.friction", "0");
126 EXPECT_NE(ret1, "");
127 EXPECT_NE(ret2, "");
128 }
129 }
130
131 /**
132 * @tc.name: SwitchScrollParam02
133 * @tc.desc: SwitchScrollParam test
134 * @tc.type: FUNC
135 */
136 HWTEST_F(ScreenSessionManagerTest, SwitchScrollParam02, TestSize.Level1)
137 {
138 ScreenSceneConfig::scrollableParams_.clear();
139 vector<FoldDisplayMode> displayModeALL = {
140 FoldDisplayMode::SUB,
141 FoldDisplayMode::MAIN,
142 FoldDisplayMode::FULL,
143 FoldDisplayMode::UNKNOWN,
144 FoldDisplayMode::COORDINATION,
145 };
146 std::map<FoldDisplayMode, std::string> scrollVelocityScaleParam = {
147 pair<FoldDisplayMode, std::string>(FoldDisplayMode::FULL, "2.0"),
148 pair<FoldDisplayMode, std::string>(FoldDisplayMode::MAIN, "main"),
149 pair<FoldDisplayMode, std::string>(FoldDisplayMode::UNKNOWN, "!!"),
150 };
151 std::map<FoldDisplayMode, std::string> scrollFrictionParam;
152 ScreenSessionManager* ssm = new ScreenSessionManager();
153 ASSERT_NE(ssm, nullptr);
154 system::SetParameter("persist.scrollable.velocityScale", "0");
155 system::SetParameter("persist.scrollable.friction", "0");
156 std::string ret1, ret2;
157 for (FoldDisplayMode displayMode : displayModeALL) {
158 ScrollableParam scrollableParam;
159 scrollableParam.velocityScale_ = scrollVelocityScaleParam.count(displayMode) ?
160 scrollVelocityScaleParam[displayMode] : "0";
161 scrollableParam.friction_ = scrollFrictionParam.count(displayMode) ?
162 scrollFrictionParam[displayMode] : "0";
163 ScreenSceneConfig::scrollableParams_[displayMode] = scrollableParam;
164 ssm->SwitchScrollParam(displayMode);
165 ret1 = system::GetParameter("persist.scrollable.velocityScale", "0");
166 ret2 = system::GetParameter("persist.scrollable.friction", "0");
167 EXPECT_NE(ret1, "");
168 EXPECT_NE(ret2, "");
169 }
170 }
171
172 /**
173 * @tc.name: WakeUpPictureFrameBlock
174 * @tc.desc: WakeUpPictureFrameBlock test
175 * @tc.type: FUNC
176 */
177 HWTEST_F(ScreenSessionManagerTest, WakeUpPictureFrameBlock, Function | SmallTest | Level3)
178 {
179 ASSERT_NE(ssm_, nullptr);
180 ssm_->pictureFrameReady_ = false;
181 ssm_->pictureFrameBreak_ = false;
182 ssm_->WakeUpPictureFrameBlock(DisplayEvent::SCREEN_LOCK_OFF);
183 ASSERT_EQ(ssm_->pictureFrameReady_, false);
184 ASSERT_EQ(ssm_->pictureFrameBreak_, false);
185 ssm_->WakeUpPictureFrameBlock(DisplayEvent::SCREEN_LOCK_START_DREAM);
186 ASSERT_EQ(ssm_->pictureFrameReady_, true);
187 ssm_->WakeUpPictureFrameBlock(DisplayEvent::SCREEN_LOCK_END_DREAM);
188 ASSERT_EQ(ssm_->pictureFrameBreak_, true);
189 }
190
191 /**
192 * @tc.name: AddVirtualScreenBlockList
193 * @tc.desc: AddVirtualScreenBlockList test
194 * @tc.type: FUNC
195 */
196 HWTEST_F(ScreenSessionManagerTest, AddVirtualScreenBlockList, Function | SmallTest | Level3)
197 {
198 ASSERT_NE(ssm_, nullptr);
199 std::vector<int32_t> persistentIds {0, 1, 2};
200 ASSERT_EQ(DMError::DM_OK, ssm_->AddVirtualScreenBlockList(persistentIds));
201 }
202
203 /**
204 * @tc.name: RemoveVirtualScreenBlockList
205 * @tc.desc: RemoveVirtualScreenBlockList test
206 * @tc.type: FUNC
207 */
208 HWTEST_F(ScreenSessionManagerTest, RemoveVirtualScreenBlockList, Function | SmallTest | Level3)
209 {
210 ASSERT_NE(ssm_, nullptr);
211 std::vector<int32_t> persistentIds {0, 1, 2};
212 ASSERT_EQ(DMError::DM_OK, ssm_->RemoveVirtualScreenBlockList(persistentIds));
213 }
214
215 /**
216 * @tc.name: BlockScreenWaitPictureFrameByCV
217 * @tc.desc: BlockScreenWaitPictureFrameByCV test
218 * @tc.type: FUNC
219 */
220 HWTEST_F(ScreenSessionManagerTest, BlockScreenWaitPictureFrameByCV, Function | SmallTest | Level3)
221 {
222 ASSERT_NE(ssm_, nullptr);
223 ssm_->pictureFrameReady_ = true;
224 ssm_->pictureFrameBreak_ = true;
225 bool result = ssm_->BlockScreenWaitPictureFrameByCV(true);
226 ASSERT_EQ(result, true);
227 result = ssm_->BlockScreenWaitPictureFrameByCV(false);
228 ASSERT_EQ(result, true);
229
230 ASSERT_EQ(ssm_->pictureFrameReady_, false);
231 ASSERT_EQ(ssm_->pictureFrameBreak_, false);
232 }
233
234 /**
235 * @tc.name: DestroyExtendVirtualScreen001
236 * @tc.desc: DestroyExtendVirtualScreen test
237 * @tc.type: FUNC
238 */
239 HWTEST_F(ScreenSessionManagerTest, DestroyExtendVirtualScreen001, TestSize.Level1)
240 {
241 ASSERT_NE(ssm_, nullptr);
242 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
243 ASSERT_NE(displayManagerAgent, nullptr);
244 VirtualScreenOption virtualOption;
245 virtualOption.name_ = "createVirtualOption";
246 auto virtualScreenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
247
248 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(virtualScreenId);
249 ASSERT_NE(screenSession, nullptr);
250 screenSession->SetScreenType(ScreenType::VIRTUAL);
251 ssm_->DestroyExtendVirtualScreen();
252 screenSession->SetIsExtendVirtual(true);
253 ssm_->DestroyExtendVirtualScreen();
254 ssm_->DestroyVirtualScreen(virtualScreenId);
255 }
256
257 /**
258 * @tc.name: CreateExtendVirtualScreen001
259 * @tc.desc: CreateExtendVirtualScreen test
260 * @tc.type: FUNC
261 */
262 HWTEST_F(ScreenSessionManagerTest, CreateExtendVirtualScreen001, TestSize.Level1)
263 {
264 ASSERT_NE(ssm_, nullptr);
265 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
266 ASSERT_NE(displayManagerAgent, nullptr);
267 VirtualScreenOption virtualOption;
268 virtualOption.name_ = "createVirtualOption";
269 auto virtualScreenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
270
271 sptr<ScreenSession> virtualScreenSession = ssm_->GetScreenSession(virtualScreenId);
272 virtualScreenSession->SetScreenType(ScreenType::REAL);
273 ssm_->CreateExtendVirtualScreen(virtualScreenSession->GetRSScreenId());
274 ssm_->DestroyVirtualScreen(virtualScreenId);
275 }
276
277 /**
278 * @tc.name: IsPhysicalExtendScreenInUse001
279 * @tc.desc: CreateExtendVirtualScreen test
280 * @tc.type: FUNC
281 */
282 HWTEST_F(ScreenSessionManagerTest, IsPhysicalExtendScreenInUse001, TestSize.Level1)
283 {
284 ASSERT_NE(ssm_, nullptr);
285 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
286 ASSERT_NE(displayManagerAgent, nullptr);
287 VirtualScreenOption virtualOption;
288 virtualOption.name_ = "createVirtualOption";
289 auto virtualScreenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
290
291 sptr<ScreenSession> virtualScreenSession = ssm_->GetScreenSession(virtualScreenId);
292 ASSERT_NE(virtualScreenSession, nullptr);
293
294 virtualScreenSession->SetScreenType(ScreenType::VIRTUAL);
295 DMError ret = ssm_->IsPhysicalExtendScreenInUse(virtualScreenSession->GetRSScreenId(), 100);
296 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
297
298 VirtualScreenOption physicalOption;
299 physicalOption.name_ = "createPhysicalOption";
300 auto physicalScreenId = ssm_->CreateVirtualScreen(physicalOption, displayManagerAgent->AsObject());
301 sptr<ScreenSession> physicalScreenSession = ssm_->GetScreenSession(physicalScreenId);
302 ASSERT_NE(physicalScreenSession, nullptr);
303
304 physicalScreenSession->SetScreenType(ScreenType::REAL);
305 physicalScreenSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
306 DMError ret1 = ssm_->IsPhysicalExtendScreenInUse(virtualScreenSession->GetRSScreenId(),
307 physicalScreenSession->GetRSScreenId());
308 EXPECT_EQ(ret1, DMError::DM_OK);
309
310 physicalScreenSession->SetScreenType(ScreenType::VIRTUAL);
311 DMError ret2 = ssm_->IsPhysicalExtendScreenInUse(virtualScreenSession->GetRSScreenId(),
312 physicalScreenSession->GetRSScreenId());
313 EXPECT_EQ(ret2, DMError::DM_ERROR_UNKNOWN);
314
315 ssm_->DestroyVirtualScreen(virtualScreenId);
316 ssm_->DestroyVirtualScreen(physicalScreenId);
317 }
318
319 /**
320 * @tc.name: SetForceCloseHdr01
321 * @tc.desc: SetForceCloseHdr test
322 * @tc.type: FUNC
323 */
324 HWTEST_F(ScreenSessionManagerTest, SetForceCloseHdr01, Function | SmallTest | Level3)
325 {
326 g_errLog.clear();
327 LOG_SetCallback(MyLogCallback);
328 ScreenId screenId = 0;
329 bool isForceCloseHdr = true;
330 MockAccesstokenKit::MockIsSACalling(false);
331 MockAccesstokenKit::MockIsSystemApp(false);
332 ssm_->SetForceCloseHdr(screenId, isForceCloseHdr);
333 EXPECT_TRUE(g_errLog.find("permission denied!") != std::string::npos);
334 }
335
336 /**
337 * @tc.name: SetForceCloseHdr02
338 * @tc.desc: SetForceCloseHdr test
339 * @tc.type: FUNC
340 */
341 HWTEST_F(ScreenSessionManagerTest, SetForceCloseHdr02, Function | SmallTest | Level3)
342 {
343 g_errLog.clear();
344 LOG_SetCallback(MyLogCallback);
345 ScreenId screenId = 0;
346 bool isForceCloseHdr = true;
347 MockAccesstokenKit::MockIsSACalling(false);
348 MockAccesstokenKit::MockIsSystemApp(true);
349 ssm_->SetForceCloseHdr(screenId, isForceCloseHdr);
350 EXPECT_TRUE(g_errLog.find("permission denied!") == std::string::npos);
351 }
352
353 /**
354 * @tc.name: SetForceCloseHdr03
355 * @tc.desc: SetForceCloseHdr test
356 * @tc.type: FUNC
357 */
358 HWTEST_F(ScreenSessionManagerTest, SetForceCloseHdr03, Function | SmallTest | Level3)
359 {
360 g_errLog.clear();
361 LOG_SetCallback(MyLogCallback);
362 ScreenId screenId = 0;
363 bool isForceCloseHdr = true;
364 MockAccesstokenKit::MockIsSACalling(true);
365 MockAccesstokenKit::MockIsSystemApp(true);
366 ssm_->SetForceCloseHdr(screenId, isForceCloseHdr);
367 EXPECT_TRUE(g_errLog.find("permission denied!") == std::string::npos);
368 }
369
370 /**
371 * @tc.name: SetDefaultMultiScreenModeWhenSwitchUser01
372 * @tc.desc: SetDefaultMultiScreenModeWhenSwitchUser test
373 * @tc.type: FUNC
374 */
375 HWTEST_F(ScreenSessionManagerTest, SetDefaultMultiScreenModeWhenSwitchUser01, Function | SmallTest | Level3)
376 {
377 g_errLog.clear();
378 LOG_SetCallback(MyLogCallback);
379 MockAccesstokenKit::MockIsSACalling(false);
380 MockAccesstokenKit::MockIsSystemApp(false);
381 ssm_->SetDefaultMultiScreenModeWhenSwitchUser();
382 EXPECT_TRUE(g_errLog.find("permission denied!") != std::string::npos);
383 }
384
385 /**
386 * @tc.name: SetDefaultMultiScreenModeWhenSwitchUser02
387 * @tc.desc: SetDefaultMultiScreenModeWhenSwitchUser test
388 * @tc.type: FUNC
389 */
390 HWTEST_F(ScreenSessionManagerTest, SetDefaultMultiScreenModeWhenSwitchUser02, Function | SmallTest | Level3)
391 {
392 g_errLog.clear();
393 LOG_SetCallback(MyLogCallback);
394 MockAccesstokenKit::MockIsSACalling(false);
395 MockAccesstokenKit::MockIsSystemApp(true);
396 ssm_->SetDefaultMultiScreenModeWhenSwitchUser();
397 EXPECT_TRUE(g_errLog.find("permission denied!") == std::string::npos);
398 }
399
400 /**
401 * @tc.name: SetDefaultMultiScreenModeWhenSwitchUser03
402 * @tc.desc: SetDefaultMultiScreenModeWhenSwitchUser test
403 * @tc.type: FUNC
404 */
405 HWTEST_F(ScreenSessionManagerTest, SetDefaultMultiScreenModeWhenSwitchUser03, Function | SmallTest | Level3)
406 {
407 g_errLog.clear();
408 LOG_SetCallback(MyLogCallback);
409 MockAccesstokenKit::MockIsSACalling(true);
410 MockAccesstokenKit::MockIsSystemApp(true);
411 ssm_->SetDefaultMultiScreenModeWhenSwitchUser();
412 EXPECT_TRUE(g_errLog.find("permission denied!") == std::string::npos);
413 }
414
415 /**
416 * @tc.name: NotifyExtendScreenCreateFinish01
417 * @tc.desc: NotifyExtendScreenCreateFinish test
418 * @tc.type: FUNC
419 */
420 HWTEST_F(ScreenSessionManagerTest, NotifyExtendScreenCreateFinish01, Function | SmallTest | Level3)
421 {
422 g_errLog.clear();
423 LOG_SetCallback(MyLogCallback);
424 MockAccesstokenKit::MockIsSACalling(false);
425 MockAccesstokenKit::MockIsSystemApp(false);
426 ssm_->NotifyExtendScreenCreateFinish();
427 EXPECT_TRUE(g_errLog.find("permission denied!") != std::string::npos);
428 }
429
430 /**
431 * @tc.name: NotifyExtendScreenCreateFinish02
432 * @tc.desc: NotifyExtendScreenCreateFinish test
433 * @tc.type: FUNC
434 */
435 HWTEST_F(ScreenSessionManagerTest, NotifyExtendScreenCreateFinish02, Function | SmallTest | Level3)
436 {
437 g_errLog.clear();
438 LOG_SetCallback(MyLogCallback);
439 MockAccesstokenKit::MockIsSACalling(false);
440 MockAccesstokenKit::MockIsSystemApp(true);
441 ssm_->NotifyExtendScreenCreateFinish();
442 EXPECT_TRUE(g_errLog.find("permission denied!") == std::string::npos);
443 }
444
445 /**
446 * @tc.name: NotifyExtendScreenCreateFinish03
447 * @tc.desc: NotifyExtendScreenCreateFinish test
448 * @tc.type: FUNC
449 */
450 HWTEST_F(ScreenSessionManagerTest, NotifyExtendScreenCreateFinish03, Function | SmallTest | Level3)
451 {
452 g_errLog.clear();
453 LOG_SetCallback(MyLogCallback);
454 MockAccesstokenKit::MockIsSACalling(true);
455 MockAccesstokenKit::MockIsSystemApp(true);
456 ssm_->NotifyExtendScreenCreateFinish();
457 EXPECT_TRUE(g_errLog.find("permission denied!") == std::string::npos);
458 }
459
460 /**
461 * @tc.name: NotifyExtendScreenDestroyFinish01
462 * @tc.desc: NotifyExtendScreenDestroyFinish test
463 * @tc.type: FUNC
464 */
465 HWTEST_F(ScreenSessionManagerTest, NotifyExtendScreenDestroyFinish01, Function | SmallTest | Level3)
466 {
467 g_errLog.clear();
468 LOG_SetCallback(MyLogCallback);
469 MockAccesstokenKit::MockIsSACalling(false);
470 MockAccesstokenKit::MockIsSystemApp(false);
471 ssm_->NotifyExtendScreenDestroyFinish();
472 EXPECT_TRUE(g_errLog.find("permission denied!") != std::string::npos);
473 }
474
475 /**
476 * @tc.name: NotifyExtendScreenDestroyFinish02
477 * @tc.desc: NotifyExtendScreenDestroyFinish test
478 * @tc.type: FUNC
479 */
480 HWTEST_F(ScreenSessionManagerTest, NotifyExtendScreenDestroyFinish02, Function | SmallTest | Level3)
481 {
482 g_errLog.clear();
483 LOG_SetCallback(MyLogCallback);
484 MockAccesstokenKit::MockIsSACalling(false);
485 MockAccesstokenKit::MockIsSystemApp(true);
486 ssm_->NotifyExtendScreenDestroyFinish();
487 EXPECT_TRUE(g_errLog.find("permission denied!") == std::string::npos);
488 }
489
490 /**
491 * @tc.name: NotifyExtendScreenDestroyFinish03
492 * @tc.desc: NotifyExtendScreenDestroyFinish test
493 * @tc.type: FUNC
494 */
495 HWTEST_F(ScreenSessionManagerTest, NotifyExtendScreenDestroyFinish03, Function | SmallTest | Level3)
496 {
497 g_errLog.clear();
498 LOG_SetCallback(MyLogCallback);
499 MockAccesstokenKit::MockIsSACalling(true);
500 MockAccesstokenKit::MockIsSystemApp(true);
501 ssm_->NotifyExtendScreenDestroyFinish();
502 EXPECT_TRUE(g_errLog.find("permission denied!") == std::string::npos);
503 }
504
505 /**
506 * @tc.name: SetFoldStatusExpandAndLocked01
507 * @tc.desc: SetFoldStatusExpandAndLocked test
508 * @tc.type: FUNC
509 */
510 HWTEST_F(ScreenSessionManagerTest, SetFoldStatusExpandAndLocked01, Function | SmallTest | Level3)
511 {
512 g_errLog.clear();
513 LOG_SetCallback(MyLogCallback);
514 MockAccesstokenKit::MockIsSACalling(false);
515 MockAccesstokenKit::MockIsSystemApp(false);
516 bool isLocked = true;
517 ssm_->SetFoldStatusExpandAndLocked(isLocked);
518 EXPECT_TRUE(g_errLog.find("permission denied!") != std::string::npos);
519 }
520
521 /**
522 * @tc.name: SetFoldStatusExpandAndLocked02
523 * @tc.desc: SetFoldStatusExpandAndLocked test
524 * @tc.type: FUNC
525 */
526 HWTEST_F(ScreenSessionManagerTest, SetFoldStatusExpandAndLocked02, Function | SmallTest | Level3)
527 {
528 g_errLog.clear();
529 LOG_SetCallback(MyLogCallback);
530 MockAccesstokenKit::MockIsSACalling(false);
531 MockAccesstokenKit::MockIsSystemApp(true);
532 bool isLocked = true;
533 ssm_->SetFoldStatusExpandAndLocked(isLocked);
534 EXPECT_TRUE(g_errLog.find("permission denied!") == std::string::npos);
535 }
536
537 /**
538 * @tc.name: SetFoldStatusExpandAndLocked03
539 * @tc.desc: SetFoldStatusExpandAndLocked test
540 * @tc.type: FUNC
541 */
542 HWTEST_F(ScreenSessionManagerTest, SetFoldStatusExpandAndLocke03, Function | SmallTest | Level3)
543 {
544 g_errLog.clear();
545 LOG_SetCallback(MyLogCallback);
546 MockAccesstokenKit::MockIsSACalling(true);
547 MockAccesstokenKit::MockIsSystemApp(true);
548 bool isLocked = true;
549 ssm_->SetFoldStatusExpandAndLocked(isLocked);
550 EXPECT_TRUE(g_errLog.find("permission denied!") == std::string::npos);
551 }
552
553 /**
554 * @tc.name: OnBeforeScreenPropertyChange
555 * @tc.desc: OnBeforeScreenPropertyChange
556 * @tc.type: FUNC
557 */
558 HWTEST_F(ScreenSessionManagerTest, OnBeforeScreenPropertyChange, Function | SmallTest | Level3)
559 {
560 ASSERT_NE(ssm_, nullptr);
561 ssm_->OnBeforeScreenPropertyChange(FoldStatus::UNKNOWN);
562 ASSERT_EQ(ssm_->clientProxy_, nullptr);
563 }
564
565 /**
566 * @tc.name: ScbStatusRecoveryWhenSwitchUser
567 * @tc.desc: ScbStatusRecoveryWhenSwitchUser
568 * @tc.type: FUNC
569 */
570 HWTEST_F(ScreenSessionManagerTest, ScbStatusRecoveryWhenSwitchUser, Function | SmallTest | Level3)
571 {
572 ASSERT_NE(ssm_, nullptr);
573 if (FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
574 ScreenId id = ssm_->GetDefaultScreenId();
575 sptr<ScreenSession> screenSession = ssm_->GetOrCreateScreenSession(id);
576 ScreenProperty screenProperty = screenSession->GetScreenProperty();
577 uint32_t currentWidth = screenProperty.GetBounds().rect_.GetWidth();
578 std::vector<int32_t> oldScbPids_ = { 100 };
579 int32_t newScbPid = 101;
580 ssm_->ScbStatusRecoveryWhenSwitchUser(oldScbPids_, newScbPid);
581 FoldDisplayMode mode = ssm_->GetFoldDisplayMode();
582 if (mode == FoldDisplayMode::MAIN) {
583 EXPECT_EQ(currentWidth, M_STATUS_WIDTH);
584 } else if (mode == FoldDisplayMode::FULL) {
585 EXPECT_EQ(currentWidth, F_STATUS_WIDTH);
586 } else {
587 EXPECT_EQ(currentWidth, G_STATUS_WIDTH);
588 }
589 }
590 }
591
592 /**
593 * @tc.name: GetScreenAreaOfDisplayArea
594 * @tc.desc: GetScreenAreaOfDisplayArea
595 * @tc.type: FUNC
596 */
597 HWTEST_F(ScreenSessionManagerTest, GetScreenAreaOfDisplayArea, Function | SmallTest | Level3)
598 {
599 ASSERT_NE(ssm_, nullptr);
600 ssm_->screenSessionMap_.clear();
601 DisplayId displayId = 0;
602 DMRect displayArea = { 0, 0, 1, 1 };
603 ScreenId screenId = 0;
604 DMRect screenArea = DMRect::NONE();
605 sptr<ScreenSession> screenSession = nullptr;
606 auto ret = ssm_->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea);
607 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
608
609 ScreenProperty property = ScreenProperty();
610 screenSession = new (std::nothrow) ScreenSession(0, property, 0);
611 ASSERT_NE(screenSession, nullptr);
612 ssm_->screenSessionMap_.clear();
613 ssm_->screenSessionMap_.insert(std::make_pair(0, screenSession));
614 ret = ssm_->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea);
615 EXPECT_EQ(ret, DMError::DM_ERROR_INVALID_PARAM);
616
617 property.SetOffsetX(0);
618 property.SetOffsetY(0);
619 property.SetCreaseRect({100, 100, 100, 100});
620 property.SetBounds({{0, 0, 100, 100}, 0, 0});
621 property.SetPhyBounds({{0, 100, 0, 100}, 0, 0});
622 displayArea = { 0, 0, 0, 0 };
623 screenSession->screenId_ = 0;
624 ret = ssm_->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea);
625 EXPECT_EQ(ret, DMError::DM_OK);
626 }
627
628 /**
629 * @tc.name: CalculateRotatedDisplay1
630 * @tc.desc: CalculateRotatedDisplay1
631 * @tc.type: FUNC
632 */
633 HWTEST_F(ScreenSessionManagerTest, CalculateRotatedDisplay1, Function | SmallTest | Level3)
634 {
635 if (FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
636 return;
637 }
638
639 ASSERT_NE(ssm_, nullptr);
640 DMRect screenRegion = {0, 0, 100, 200};
641 DMRect displayRegion = {0, 0, 200, 100};
642 DMRect displayArea = {20, 10, 30, 40};
643
644 Rotation rotation = Rotation::ROTATION_0;
645 ssm_->CalculateRotatedDisplay(rotation, screenRegion, displayRegion, displayArea);
646 DMRect expectedRect = {0, 0, 200, 100};
647 EXPECT_EQ(displayRegion, expectedRect);
648 expectedRect = {20, 10, 30, 40};
649 EXPECT_EQ(displayArea, expectedRect);
650
651 rotation = Rotation::ROTATION_90;
652 displayRegion = {0, 0, 200, 100};
653 displayArea = {20, 10, 30, 40};
654 ssm_->CalculateRotatedDisplay(rotation, screenRegion, displayRegion, displayArea);
655 expectedRect = {0, 0, 100, 200};
656 EXPECT_EQ(displayRegion, expectedRect);
657 expectedRect = {10, 150, 40, 30};
658 EXPECT_EQ(displayArea, expectedRect);
659
660 rotation = Rotation::ROTATION_180;
661 displayRegion = {0, 0, 100, 200};
662 displayArea = {20, 10, 30, 40};
663 ssm_->CalculateRotatedDisplay(rotation, screenRegion, displayRegion, displayArea);
664 expectedRect = {0, 0, 100, 200};
665 EXPECT_EQ(displayRegion, expectedRect);
666 expectedRect = {50, 150, 30, 40};
667 EXPECT_EQ(displayArea, expectedRect);
668
669 rotation = Rotation::ROTATION_270;
670 displayRegion = {0, 0, 200, 100};
671 displayArea = {20, 10, 30, 40};
672 ssm_->CalculateRotatedDisplay(rotation, screenRegion, displayRegion, displayArea);
673 expectedRect = {0, 0, 100, 200};
674 EXPECT_EQ(displayRegion, expectedRect);
675 expectedRect = {50, 20, 40, 30};
676 EXPECT_EQ(displayArea, expectedRect);
677 }
678
679 /**
680 * @tc.name: CalculateRotatedDisplay2
681 * @tc.desc: CalculateRotatedDisplay2
682 * @tc.type: FUNC
683 */
684 HWTEST_F(ScreenSessionManagerTest, CalculateRotatedDisplay2, Function | SmallTest | Level3)
685 {
686 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
687 return;
688 }
689
690 ASSERT_NE(ssm_, nullptr);
691 DMRect screenRegion = {0, 0, 100, 200};
692 DMRect displayRegion = {0, 0, 200, 100};
693 DMRect displayArea = {20, 10, 30, 40};
694
695 Rotation rotation = Rotation::ROTATION_90;
696 ssm_->CalculateRotatedDisplay(rotation, screenRegion, displayRegion, displayArea);
697 DMRect expectedRect = {0, 0, 200, 100};
698 EXPECT_EQ(displayRegion, expectedRect);
699 expectedRect = {20, 10, 30, 40};
700 EXPECT_EQ(displayArea, expectedRect);
701
702 rotation = Rotation::ROTATION_180;
703 displayRegion = {0, 0, 200, 100};
704 displayArea = {20, 10, 30, 40};
705 ssm_->CalculateRotatedDisplay(rotation, screenRegion, displayRegion, displayArea);
706 expectedRect = {0, 0, 100, 200};
707 EXPECT_EQ(displayRegion, expectedRect);
708 expectedRect = {10, 150, 40, 30};
709 EXPECT_EQ(displayArea, expectedRect);
710
711 rotation = Rotation::ROTATION_270;
712 displayRegion = {0, 0, 100, 200};
713 displayArea = {20, 10, 30, 40};
714 ssm_->CalculateRotatedDisplay(rotation, screenRegion, displayRegion, displayArea);
715 expectedRect = {0, 0, 100, 200};
716 EXPECT_EQ(displayRegion, expectedRect);
717 expectedRect = {50, 150, 30, 40};
718 EXPECT_EQ(displayArea, expectedRect);
719
720 rotation = Rotation::ROTATION_0;
721 displayRegion = {0, 0, 200, 100};
722 displayArea = {20, 10, 30, 40};
723 ssm_->CalculateRotatedDisplay(rotation, screenRegion, displayRegion, displayArea);
724 expectedRect = {0, 0, 100, 200};
725 EXPECT_EQ(displayRegion, expectedRect);
726 expectedRect = {50, 20, 40, 30};
727 EXPECT_EQ(displayArea, expectedRect);
728 }
729
730 /**
731 * @tc.name: CalculateScreenArea
732 * @tc.desc: CalculateScreenArea
733 * @tc.type: FUNC
734 */
735 HWTEST_F(ScreenSessionManagerTest, CalculateScreenArea, Function | SmallTest | Level3)
736 {
737 if (FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
738 ASSERT_NE(ssm_, nullptr);
739 DMRect displayRegion = DMRect::NONE();
740 DMRect displayArea = {10, 20, 30, 40};
741 DMRect screenRegion = DMRect::NONE();
742 DMRect screenArea = DMRect::NONE();
743 ssm_->CalculateScreenArea(displayRegion, displayArea, screenRegion, screenArea);
744 EXPECT_EQ(screenArea, displayArea);
745 return;
746 }
747
748 ASSERT_NE(ssm_, nullptr);
749 DMRect displayRegion = {0, 0, 50, 100};
750 DMRect displayArea = {10, 20, 30, 40};
751 DMRect screenRegion = {0, 0, 50, 100};
752 DMRect screenArea = DMRect::NONE();
753 ssm_->CalculateScreenArea(displayRegion, displayArea, screenRegion, screenArea);
754 EXPECT_EQ(screenArea, displayArea);
755
756 screenRegion = {0, 0, 100, 200};
757 ssm_->CalculateScreenArea(displayRegion, displayArea, screenRegion, screenArea);
758 DMRect expectedRect = {20, 40, 60, 80};
759 EXPECT_EQ(screenArea, expectedRect);
760 }
761
762 /**
763 * @tc.name: ConvertIntToRotation
764 * @tc.desc: ConvertIntToRotation
765 * @tc.type: FUNC
766 */
767 HWTEST_F(ScreenSessionManagerTest, ConvertIntToRotation, Function | SmallTest | Level3)
768 {
769 ASSERT_NE(ssm_, nullptr);
770 int32_t rotation = 0;
771 Rotation targetRotation = Rotation::ROTATION_0;
772 targetRotation = ssm_->ConvertIntToRotation(rotation);
773 EXPECT_EQ(targetRotation, Rotation::ROTATION_0);
774 rotation = 100;
775 targetRotation = ssm_->ConvertIntToRotation(rotation);
776 EXPECT_EQ(targetRotation, Rotation::ROTATION_0);
777 rotation = 90;
778 targetRotation = ssm_->ConvertIntToRotation(rotation);
779 EXPECT_EQ(targetRotation, Rotation::ROTATION_90);
780 rotation = 180;
781 targetRotation = ssm_->ConvertIntToRotation(rotation);
782 EXPECT_EQ(targetRotation, Rotation::ROTATION_180);
783 rotation = 270;
784 targetRotation = ssm_->ConvertIntToRotation(rotation);
785 EXPECT_EQ(targetRotation, Rotation::ROTATION_270);
786 }
787
788 /**
789 * @tc.name: GetPhysicalScreenIds
790 * @tc.desc: GetPhysicalScreenIds
791 * @tc.type: FUNC
792 */
793 HWTEST_F(ScreenSessionManagerTest, GetPhysicalScreenIds, Function | SmallTest | Level3)
794 {
795 ASSERT_NE(ssm_, nullptr);
796 std::vector<ScreenId> screenIds;
797 auto ret = ssm_->GetPhysicalScreenIds(screenIds);
798 EXPECT_EQ(ret, DMError::DM_OK);
799
800 ScreenId screenId = 11;
801 sptr<ScreenSession> screenSession = nullptr;
802 ssm_->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
803 std::vector<ScreenId> screenIds1;
804 auto ret1 = ssm_->GetPhysicalScreenIds(screenIds1);
805 EXPECT_EQ(ret, DMError::DM_OK);
806 }
807
808 /**
809 * @tc.name: SetVirtualScreenAutoRotation01
810 * @tc.desc: SetVirtualScreenAutoRotation test
811 * @tc.type: FUNC
812 */
813 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenAutoRotation01, Function | SmallTest | Level3)
814 {
815 ScreenId screenId = 0;
816 bool enable = true;
817 MockAccesstokenKit::MockIsSACalling(false);
818 MockAccesstokenKit::MockIsSASystemApp(false);
819 auto ret = ssm_->SetVirtualScreenAutoRotation(screenId, enable);
820 EXPECT_EQ(ret, DMError::DM_ERROR_INVALID_PERMISSION);
821 }
822
823 /**
824 * @tc.name: SetVirtualScreenAutoRotation02
825 * @tc.desc: SetVirtualScreenAutoRotation test
826 * @tc.type: FUNC
827 */
828 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenAutoRotation02, Function | SmallTest | Level3)
829 {
830 ScreenId screenId = 0;
831 bool enable = true;
832 MockAccesstokenKit::MockIsSACalling(false);
833 MockAccesstokenKit::MockIsSASystemApp(true);
834 auto ret = ssm_->SetVirtualScreenAutoRotation(screenId, enable);
835 EXPECT_EQ(ret, DMError::DM_ERROR_INVALID_PARAM);
836 }
837
838 /**
839 * @tc.name: SetVirtualScreenAutoRotation03
840 * @tc.desc: SetVirtualScreenAutoRotation test
841 * @tc.type: FUNC
842 */
843 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenAutoRotation03, Function | SmallTest | Level3)
844 {
845 ScreenId screenId = 0;
846 bool enable = true;
847 MockAccesstokenKit::MockIsSACalling(true);
848 MockAccesstokenKit::MockIsSASystemApp(true);
849 auto ret = ssm_->SetVirtualScreenAutoRotation(screenId, enable);
850 EXPECT_EQ(ret, DMError::DM_ERROR_INVALID_PARAM);
851 }
852
853 /**
854 * @tc.name: CreateScreenProperty
855 * @tc.desc: CreateScreenProperty test
856 * @tc.type: FUNC
857 */
858 HWTEST_F(ScreenSessionManagerTest, CreateScreenProperty, Function | SmallTest | Level3)
859 {
860 ASSERT_NE(ssm_, nullptr);
861 ScreenId screenId = 0;
862 ScreenProperty property = ScreenProperty();
863 EXPECT_EQ(DISPLAY_GROUP_ID_INVALID, property.GetDisplayGroupId());
864 EXPECT_EQ(SCREEN_ID_INVALID, property.GetMainDisplayIdOfGroup());
865
866 ssm_->CreateScreenProperty(screenId, property);
867 EXPECT_EQ(DISPLAY_GROUP_ID_DEFAULT, property.GetDisplayGroupId());
868 EXPECT_EQ(MAIN_SCREEN_ID_DEFAULT, property.GetMainDisplayIdOfGroup());
869
870 property.SetDisplayGroupId(1);
871 property.SetMainDisplayIdOfGroup(1);
872 ssm_->CreateScreenProperty(screenId, property);
873 EXPECT_EQ(1, property.GetDisplayGroupId());
874 EXPECT_EQ(1, property.GetMainDisplayIdOfGroup());
875 }
876
877 /**
878 * @tc.name: InitScreenProperty
879 * @tc.desc: InitScreenProperty test
880 * @tc.type: FUNC
881 */
882 HWTEST_F(ScreenSessionManagerTest, InitScreenProperty, Function | SmallTest | Level3)
883 {
884 ASSERT_NE(ssm_, nullptr);
885 ScreenId screenId = 0;
886 ScreenProperty property = ScreenProperty();
887 RSScreenModeInfo screenModeInfo = RSScreenModeInfo();
888 screenModeInfo.SetScreenWidth(100);
889 screenModeInfo.SetScreenHeight(200);
890 RSScreenCapability screenCapability = RSScreenCapability();
891
892 ssm_->InitScreenProperty(screenId, screenModeInfo, screenCapability, property);
893 EXPECT_EQ(0, property.GetScreenAreaOffsetX());
894 EXPECT_EQ(0, property.GetScreenAreaOffsetY());
895 EXPECT_EQ(100, property.GetScreenAreaWidth());
896 EXPECT_EQ(200, property.GetScreenAreaHeight());
897 }
898
899 /**
900 * @tc.name: InitExtendScreenProperty
901 * @tc.desc: InitExtendScreenProperty test
902 * @tc.type: FUNC
903 */
904 HWTEST_F(ScreenSessionManagerTest, InitExtendScreenProperty, Function | SmallTest | Level3)
905 {
906 ASSERT_NE(ssm_, nullptr);
907 ScreenId screenId = 0;
908 ScreenProperty property = ScreenProperty();
909 property.SetBounds({{0, 0, 4000, 4000}, 0, 0});
910 ScreenSceneConfig::enableConfig_["isSupportOffScreenRendering"] = true;
911 ScreenSceneConfig::offScreenPPIThreshold_ = 100;
912 ScreenSceneConfig::stringConfig_["externalScreenDefaultMode"] = "none";
913
914 ssm_->Init();
915 sptr<ScreenSession> screenSession = ssm_->GetScreenSessionInner(screenId, property);
916 ssm_->InitExtendScreenProperty(screenId, screenSession, property);
917 EXPECT_EQ(3840, screenSession->GetValidWidth());
918
919 property.SetBounds({{0, 0, 1000, 1000}, 0, 0});
920 ssm_->InitExtendScreenProperty(screenId, screenSession, property);
921 EXPECT_EQ(3120, screenSession->GetValidWidth());
922 }
923
924 /**
925 * @tc.name: GetOrCreateScreenSession
926 * @tc.desc: GetOrCreateScreenSession
927 * @tc.type: FUNC
928 */
929 HWTEST_F(ScreenSessionManagerTest, GetOrCreateScreenSession, Function | SmallTest | Level3)
930 {
931 if (FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
932 sptr<ScreenSession> session = ssm_->GetOrCreateScreenSession(SCREENID);
933 EXPECT_NE(session, nullptr);
934 }
935 }
936
937 /**
938 * @tc.name: SetScreenPrivacyWindowTagSwitch001
939 * @tc.desc: SetScreenPrivacyWindowTagSwitch test
940 * @tc.type: FUNC
941 */
942 HWTEST_F(ScreenSessionManagerTest, SetScreenPrivacyWindowTagSwitch001, TestSize.Level1)
943 {
944 MockAccesstokenKit::MockIsSACalling(false);
945 MockAccesstokenKit::MockIsSystemApp(false);
946 ScreenId mainScreenId = 0;
947 std::vector<std::string> privacyWindowTag{"test1", "test2"};
948 auto ret = ssm_->SetScreenPrivacyWindowTagSwitch(mainScreenId, privacyWindowTag, true);
949 EXPECT_EQ(ret, DMError::DM_ERROR_NOT_SYSTEM_APP);
950 }
951
952 /**
953 * @tc.name: SetScreenPrivacyWindowTagSwitch002
954 * @tc.desc: SetScreenPrivacyWindowTagSwitch test
955 * @tc.type: FUNC
956 */
957 HWTEST_F(ScreenSessionManagerTest, SetScreenPrivacyWindowTagSwitch002, TestSize.Level1)
958 {
959 MockAccesstokenKit::MockIsSACalling(true);
960 MockAccesstokenKit::MockIsSystemApp(true);
961 ScreenId mainScreenId = 0;
962 ScreenId invalidScreenId = -1;
963 std::vector<std::string> privacyWindowTag{"test1", "test2"};
964 auto ret = ssm_->SetScreenPrivacyWindowTagSwitch(invalidScreenId, privacyWindowTag, true);
965 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
966 ret = ssm_->SetScreenPrivacyWindowTagSwitch(mainScreenId, privacyWindowTag, true);
967 EXPECT_EQ(ret, DMError::DM_OK);
968 }
969
970 /**
971 * @tc.name: OnVerticalChangeBoundsWhenSwitchUser
972 * @tc.desc: OnVerticalChangeBoundsWhenSwitchUser test
973 * @tc.type: FUNC
974 */
975 HWTEST_F(ScreenSessionManagerTest, OnVerticalChangeBoundsWhenSwitchUser, TestSize.Level1)
976 {
977 ASSERT_NE(ssm_, nullptr);
978 ScreenId screenId = 1050;
979 DMRect area{0, 0, 600, 800};
980 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
981 ASSERT_NE(screenSession, nullptr);
982 ScreenProperty screenProperty = screenSession->GetScreenProperty();
983 auto rotation = screenProperty.GetRotation();
984 constexpr float SECONDARY_ROTATION_90 = 90.0F;
985 screenProperty.SetRotation(SECONDARY_ROTATION_90);
986 RRect bounds = screenProperty.GetBounds();
987 ssm_->OnVerticalChangeBoundsWhenSwitchUser(screenSession);
988 RRect afterbounds = screenProperty.GetBounds();
989 EXPECT_EQ(bounds.rect_.GetHeight(), bounds.rect_.GetWidth());
990 }
991
992 /**
993 * @tc.name: SetLandscapeLockStatus01
994 * @tc.desc: SetLandscapeLockStatus01 test
995 * @tc.type: FUNC
996 */
997 HWTEST_F(ScreenSessionManagerTest, SetLandscapeLockStatus01, TestSize.Level1)
998 {
999 g_errLog.clear();
1000 MockAccesstokenKit::MockIsSACalling(false);
1001 MockAccesstokenKit::MockIsSystemApp(false);
1002 ssm_->SetLandscapeLockStatus(true);
1003 EXPECT_TRUE(g_errLog.find("permission denied!") != std::string::npos);
1004 }
1005
1006 /**
1007 * @tc.name: SynchronizePowerStatusPermissionDenied
1008 * @tc.desc: SynchronizePowerStatus test permission denied.
1009 * @tc.type: FUNC
1010 */
1011 HWTEST_F(ScreenSessionManagerTest, SynchronizePowerStatusPermissionDenied, Function | SmallTest | Level3)
1012 {
1013 g_errLog.clear();
1014 LOG_SetCallback(MyLogCallback);
1015 MockAccesstokenKit::MockIsSACalling(false);
1016 MockAccesstokenKit::MockIsSystemApp(false);
1017 ScreenPowerState state = ScreenPowerState::POWER_ON;
1018 ssm_->SynchronizePowerStatus(state);
1019 EXPECT_TRUE(g_errLog.find("permission denied!") != std::string::npos);
1020 }
1021
1022 /**
1023 * @tc.name: SynchronizePowerStatusNotSupport
1024 * @tc.desc: SynchronizePowerStatus not support state.
1025 * @tc.type: FUNC
1026 */
1027 HWTEST_F(ScreenSessionManagerTest, SynchronizePowerStatusNotSupport, Function | SmallTest | Level3)
1028 {
1029 g_errLog.clear();
1030 LOG_SetCallback(MyLogCallback);
1031 MockAccesstokenKit::MockIsSACalling(true);
1032 MockAccesstokenKit::MockIsSystemApp(true);
1033 ScreenPowerState state = ScreenPowerState::INVALID_STATE;
1034 ssm_->SynchronizePowerStatus(state);
1035 EXPECT_TRUE(g_errLog.find("not support!") != std::string::npos);
1036 }
1037
1038 /**
1039 * @tc.name: SynchronizePowerStatusOk
1040 * @tc.desc: SynchronizePowerStatus test ok.
1041 * @tc.type: FUNC
1042 */
1043 HWTEST_F(ScreenSessionManagerTest, SynchronizePowerStatusOk, Function | SmallTest | Level3)
1044 {
1045 g_errLog.clear();
1046 LOG_SetCallback(MyLogCallback);
1047 MockAccesstokenKit::MockIsSACalling(true);
1048 MockAccesstokenKit::MockIsSystemApp(true);
1049 ScreenPowerState state = ScreenPowerState::POWER_ON;
1050 #define FOLD_ABILITY_ENABLE
1051 #define POWERMGR_DISPLAY_MANAGER_ENABLE
1052 ssm_->SynchronizePowerStatus(state);
1053 #undef POWERMGR_DISPLAY_MANAGER_ENABLE
1054 #undef FOLD_ABILITY_ENABLE
1055 EXPECT_TRUE(g_errLog.find("notify brightness") != std::string::npos);
1056 }
1057
1058 /**
1059 * @tc.name: GetSuperFoldStatus
1060 * @tc.desc: GetSuperFoldStatus test SystemCalling false.
1061 * @tc.type: FUNC
1062 */
1063 HWTEST_F(ScreenSessionManagerTest, GetSuperFoldStatus01, TestSize.Level1)
1064 {
1065 g_errLog.clear();
1066 LOG_SetCallback(MyLogCallback);
1067 MockAccesstokenKit::MockIsSystemApp(false);
1068 MockAccesstokenKit::MockIsSACalling(false);
1069 SuperFoldStatus superFoldStatus = ssm_->GetSuperFoldStatus();
1070 EXPECT_TRUE(g_errLog.find("Permission Denied") != std::string::npos);
1071 EXPECT_EQ(superFoldStatus, SuperFoldStatus::UNKNOWN);
1072 }
1073
1074 /**
1075 * @tc.name: GetSuperFoldStatus
1076 * @tc.desc: GetSuperFoldStatus test SystemCalling true.
1077 * @tc.type: FUNC
1078 */
1079 HWTEST_F(ScreenSessionManagerTest, GetSuperFoldStatus02, TestSize.Level1)
1080 {
1081 MockAccesstokenKit::MockIsSystemApp(true);
1082 #define FOLD_ABILITY_ENABLE
1083 SuperFoldStatus superFoldStatus = ssm_->GetSuperFoldStatus();
1084 SuperFoldStatus status = SuperFoldStateManager::GetInstance().GetCurrentStatus();
1085 #undef FOLD_ABILITY_ENABLE
1086 if (!FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
1087 EXPECT_EQ(superFoldStatus, SuperFoldStatus::UNKNOWN);
1088 } else {
1089 EXPECT_EQ(superFoldStatus, status);
1090 }
1091 }
1092
1093 /**
1094 * @tc.name: NotifyScreenMaskAppear
1095 * @tc.desc: NotifyScreenMaskAppear test SystemCalling false.
1096 * @tc.type: FUNC
1097 */
1098 HWTEST_F(ScreenSessionManagerTest, NotifyScreenMaskAppear01, TestSize.Level1)
1099 {
1100 g_errLog.clear();
1101 LOG_SetCallback(MyLogCallback);
1102 MockAccesstokenKit::MockIsSystemApp(false);
1103 MockAccesstokenKit::MockIsSACalling(false);
1104 ssm_->NotifyScreenMaskAppear();
1105 EXPECT_TRUE(g_errLog.find("Permission Denied") != std::string::npos);
1106 }
1107
1108 /**
1109 * @tc.name: NotifyScreenMaskAppear
1110 * @tc.desc: NotifyScreenMaskAppear test SystemCalling true.
1111 * @tc.type: FUNC
1112 */
1113 HWTEST_F(ScreenSessionManagerTest, NotifyScreenMaskAppear02, TestSize.Level1)
1114 {
1115 g_errLog.clear();
1116 LOG_SetCallback(MyLogCallback);
1117 MockAccesstokenKit::MockIsSystemApp(true);
1118 ssm_->NotifyScreenMaskAppear();
1119 bool hasLog = g_errLog.find("not pc device") != std::string::npos ||
1120 g_errLog.find("screen mask appeared") != std::string::npos;
1121 EXPECT_TRUE(hasLog);
1122 }
1123
1124 /**
1125 * @tc.name: TryToCancelScreenOff01
1126 * @tc.desc: TryToCancelScreenOff test
1127 * @tc.type: FUNC
1128 */
1129 HWTEST_F(ScreenSessionManagerTest, TryToCancelScreenOff01, TestSize.Level1)
1130 {
1131 g_errLog.clear();
1132 MockAccesstokenKit::MockIsSACalling(false);
1133 MockAccesstokenKit::MockIsSystemApp(false);
1134 MockSessionPermission::MockIsStarByHdcd(false);
1135 ssm_->TryToCancelScreenOff();
1136 EXPECT_TRUE(g_errLog.find("Permission denied!") != std::string::npos);
1137 }
1138
1139 /**
1140 * @tc.name: WaitUpdateAvailableAreaForPc01
1141 * @tc.desc: WaitUpdateAvailableAreaForPc test
1142 * @tc.type: FUNC
1143 */
1144 HWTEST_F(ScreenSessionManagerTest, WaitUpdateAvailableAreaForPc01, TestSize.Level1)
1145 {
1146 g_errLog.clear();
1147 LOG_SetCallback(MyLogCallback);
1148 bool temp = ScreenSessionManager::GetInstance().GetPcStatus();
1149 ScreenSessionManager::GetInstance().SetPcStatus(true);
1150 ScreenSessionManager::GetInstance().WaitUpdateAvailableAreaForPc();
1151 EXPECT_TRUE(g_errLog.find("need wait update available area") == std::string::npos);
1152 g_errLog.clear();
1153 ScreenSessionManager::GetInstance().SetPcStatus(temp);
1154 }
1155
1156 /**
1157 * @tc.name: WaitUpdateAvailableAreaForPc02
1158 * @tc.desc: WaitUpdateAvailableAreaForPc test
1159 * @tc.type: FUNC
1160 */
1161 HWTEST_F(ScreenSessionManagerTest, WaitUpdateAvailableAreaForPc02, TestSize.Level1)
1162 {
1163 g_errLog.clear();
1164 LOG_SetCallback(MyLogCallback);
1165 bool temp = ScreenSessionManager::GetInstance().GetPcStatus();
1166 ScreenSessionManager::GetInstance().SetPcStatus(true);
1167 ScreenSessionManager::GetInstance().needWaitAvailableArea_ = true;
1168 ScreenSessionManager::GetInstance().WaitUpdateAvailableAreaForPc();
1169 EXPECT_TRUE(g_errLog.find("wait update available area timeout") != std::string::npos);
1170 g_errLog.clear();
1171 ScreenSessionManager::GetInstance().SetPcStatus(temp);
1172 }
1173
1174 /**
1175 * @tc.name: UpdateAvailableAreaWhenDisplayAdd01
1176 * @tc.desc: UpdateAvailableArea WhenDisplayAdd notify all
1177 * @tc.type: FUNC
1178 */
1179 HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea02, TestSize.Level1)
1180 {
1181 g_errLog.clear();
1182 LOG_SetCallback(MyLogCallback);
1183 bool temp = ssm_->GetPcStatus();
1184 ssm_->SetPcStatus(true);
1185 ssm_->needWaitAvailableArea_ = true;
1186
1187 ScreenId screenId = 1050;
1188 DMRect area{0, 0, 600, 900};
1189 DMRect area2{0, 0, 600, 800};
1190 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
1191 ssm_->screenSessionMap_[screenId] = screenSession;
1192 auto screenSession1 = ssm_->GetScreenSession(screenId);
1193 EXPECT_EQ(screenSession1, screenSession);
1194 EXPECT_TRUE(screenSession->UpdateAvailableArea(area));
1195 ssm_->UpdateAvailableArea(screenId, area2);
1196 EXPECT_FALSE(ssm_->needWaitAvailableArea_);
1197 g_errLog.clear();
1198 ssm_->SetPcStatus(temp);
1199 }
1200
1201 /**
1202 * @tc.name: UpdateAvailableAreaWhenDisplayAdd02
1203 * @tc.desc: UpdateAvailableArea WhenDisplayAdd not notify all
1204 * @tc.type: FUNC
1205 */
1206 HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea02, TestSize.Level1)
1207 {
1208 g_errLog.clear();
1209 LOG_SetCallback(MyLogCallback);
1210 bool temp = ssm_->GetPcStatus();
1211 ssm_->SetPcStatus(true);
1212 ssm_->needWaitAvailableArea_ = false;
1213
1214 ScreenId screenId = 1050;
1215 DMRect area{0, 0, 600, 800};
1216 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
1217 ssm_->screenSessionMap_[screenId] = screenSession;
1218 ssm_->UpdateAvailableArea(screenId, area);
1219 auto screenSession1 = ssm_->GetScreenSession(screenId);
1220 EXPECT_EQ(screenSession1->GetAvailabelArea(), area);
1221 EXPECT_FALSE(ssm_->needWaitAvailableArea_);
1222 g_errLog.clear();
1223 ssm_->SetPcStatus(temp);
1224 }
1225
1226 /**
1227 * @tc.name: ConfigureDpi01
1228 * @tc.desc: ConfigureDpi01
1229 * @tc.type: FUNC
1230 */
1231 HWTEST_F(ScreenSessionManagerTest, ConfigureDpi01, Function | SmallTest | Level3)
1232 {
1233 system::SetParameter("persist.sceneboard.ispcmode", "true");
1234 ScreenSceneConfig::intNumbersConfig_["pcModeDpi"].clear();
1235 ScreenSceneConfig::intNumbersConfig_["pcModeDpi"].emplace_back(EXCEPTION_DPI);
1236 ScreenSessionManager::GetInstance().ConfigureDpi();
1237 EXPECT_FALSE(ScreenSessionManager::GetInstance().densityDpi_ ==
1238 static_cast<float>(EXCEPTION_DPI) / BASELINE_DENSITY);
1239
1240 ScreenSceneConfig::intNumbersConfig_["pcModeDpi"].clear();
1241 ScreenSceneConfig::intNumbersConfig_["pcModeDpi"].emplace_back(PC_MODE_DPI);
1242 ScreenSessionManager::GetInstance().ConfigureDpi();
1243 EXPECT_TRUE(ScreenSessionManager::GetInstance().densityDpi_ ==
1244 static_cast<float>(PC_MODE_DPI) / BASELINE_DENSITY);
1245 system::SetParameter("persist.sceneboard.ispcmode", "false");
1246 }
1247
1248 /**
1249 * @tc.name: GetCancelSuspendStatus01
1250 * @tc.desc: GetCancelSuspendStatus01_BothFalse
1251 * @tc.type: FUNC
1252 */
1253 HWTEST_F(ScreenSessionManagerTest, GetCancelSuspendStatus01, TestSize.Level1)
1254 {
1255 ASSERT_NE(ssm_, nullptr);
1256 ssm_->sessionDisplayPowerController_->needCancelNotify_ = false;
1257 ssm_->sessionDisplayPowerController_->canceledSuspend_ = false;
1258 EXPECT_FALSE(ssm_->GetCancelSuspendStatus());
1259 }
1260
1261 /**
1262 * @tc.name: GetCancelSuspendStatus02
1263 * @tc.desc: GetCancelSuspendStatus02_NeedCancelNotifyTrue
1264 * @tc.type: FUNC
1265 */
1266 HWTEST_F(ScreenSessionManagerTest, GetCancelSuspendStatus02, TestSize.Level1)
1267 {
1268 ASSERT_NE(ssm_, nullptr);
1269 ssm_->sessionDisplayPowerController_->needCancelNotify_ = true;
1270 ssm_->sessionDisplayPowerController_->canceledSuspend_ = false;
1271 EXPECT_TRUE(ssm_->GetCancelSuspendStatus());
1272 }
1273
1274 /**
1275 * @tc.name: GetCancelSuspendStatus03
1276 * @tc.desc: GetCancelSuspendStatus03_CanceledSuspendTrue
1277 * @tc.type: FUNC
1278 */
1279 HWTEST_F(ScreenSessionManagerTest, GetCancelSuspendStatus03, TestSize.Level1)
1280 {
1281 ASSERT_NE(ssm_, nullptr);
1282 ssm_->sessionDisplayPowerController_->needCancelNotify_ = false;
1283 ssm_->sessionDisplayPowerController_->canceledSuspend_ = true;
1284 EXPECT_TRUE(ssm_->GetCancelSuspendStatus());
1285 }
1286
1287 /**
1288 * @tc.name: GetCancelSuspendStatus04
1289 * @tc.desc: GetCancelSuspendStatus04_BothTrue
1290 * @tc.type: FUNC
1291 */
1292 HWTEST_F(ScreenSessionManagerTest, GetCancelSuspendStatus04, TestSize.Level1)
1293 {
1294 ASSERT_NE(ssm_, nullptr);
1295 ssm_->sessionDisplayPowerController_->needCancelNotify_ = true;
1296 ssm_->sessionDisplayPowerController_->canceledSuspend_ = true;
1297 EXPECT_TRUE(ssm_->GetCancelSuspendStatus());
1298 }
1299
1300 /**
1301 * @tc.name: HasSameScreenCastInfo
1302 * @tc.desc: HasSameScreenCastInfo
1303 * @tc.type: FUNC
1304 */
1305 HWTEST_F(ScreenSessionManagerTest, HasSameScreenCastInfo01, TestSize.Level1) {
1306 ASSERT_NE(ssm_, nullptr);
1307 ScreenId screenId = 1660;
1308 ScreenId mainScreenId = 0;
1309 EXPECT_FALSE(ssm_->HasSameScreenCastInfo(screenId, mainScreenId, ScreenCombination::SCREEN_MIRROR));
1310 ssm_->SetScreenCastInfo(screenId, mainScreenId, ScreenCombination::SCREEN_MIRROR);
1311 EXPECT_TRUE(ssm_->HasSameScreenCastInfo(screenId, mainScreenId, ScreenCombination::SCREEN_MIRROR));
1312 ssm_->RemoveScreenCastInfo(screenId);
1313 EXPECT_FALSE(ssm_->HasSameScreenCastInfo(screenId, mainScreenId, ScreenCombination::SCREEN_MIRROR));
1314 }
1315
1316 /**
1317 * @tc.name: HasSameScreenCastInfo
1318 * @tc.desc: HasSameScreenCastInfo
1319 * @tc.type: FUNC
1320 */
1321 HWTEST_F(ScreenSessionManagerTest, HasSameScreenCastInfo02, TestSize.Level1) {
1322 ASSERT_NE(ssm_, nullptr);
1323 ScreenId screenId = 1660;
1324 ScreenId mainScreenId1 = 0;
1325 ScreenId mainScreenId2 = 1;
1326 ssm_->SetScreenCastInfo(screenId, mainScreenId1, ScreenCombination::SCREEN_MIRROR);
1327 EXPECT_FALSE(ssm_->HasSameScreenCastInfo(mainScreenId1, mainScreenId2, ScreenCombination::SCREEN_MIRROR));
1328 EXPECT_FALSE(ssm_->HasSameScreenCastInfo(screenId, mainScreenId2, ScreenCombination::SCREEN_MIRROR));
1329 EXPECT_FALSE(ssm_->HasSameScreenCastInfo(screenId, mainScreenId1, ScreenCombination::SCREEN_EXPAND));
1330 EXPECT_TRUE(ssm_->HasSameScreenCastInfo(screenId, mainScreenId1, ScreenCombination::SCREEN_MIRROR));
1331 ssm_->RemoveScreenCastInfo(screenId);
1332 }
1333
1334 /**
1335 * @tc.name: RemoveScreenCastInfo
1336 * @tc.desc: RemoveScreenCastInfo
1337 * @tc.type: FUNC
1338 */
1339 HWTEST_F(ScreenSessionManagerTest, RemoveScreenCastInfo, TestSize.Level1) {
1340 ASSERT_NE(ssm_, nullptr);
1341 ScreenId screenId = 1660;
1342 ScreenId mainScreenId = 0;
1343 ScreenId screenIdNotExist = 1080;
1344 ssm_->SetScreenCastInfo(screenId, mainScreenId, ScreenCombination::SCREEN_MIRROR);
1345 EXPECT_TRUE(ssm_->HasSameScreenCastInfo(screenId, mainScreenId, ScreenCombination::SCREEN_MIRROR));
1346 ssm_->RemoveScreenCastInfo(screenIdNotExist);
1347 EXPECT_TRUE(ssm_->HasSameScreenCastInfo(screenId, mainScreenId, ScreenCombination::SCREEN_MIRROR));
1348 ssm_->RemoveScreenCastInfo(screenId);
1349 EXPECT_FALSE(ssm_->HasSameScreenCastInfo(screenId, mainScreenId, ScreenCombination::SCREEN_MIRROR));
1350 }
1351
1352 /**
1353 * @tc.name: ChangeScreenGroup
1354 * @tc.desc: ChangeScreenGroup test screenCastInfo has same
1355 * @tc.type: FUNC
1356 */
1357 HWTEST_F(ScreenSessionManagerTest, ChangeScreenGroup, TestSize.Level1) {
1358 ASSERT_NE(ssm_, nullptr);
1359 g_errLog.clear();
1360 LOG_SetCallback(MyLogCallback);
1361 ScreenId groupId = 1;
1362 ScreenId screenId = 4080;
1363 ScreenId mainScreenId = 0;
1364 sptr<ScreenSessionGroup> group =
1365 sptr<ScreenSessionGroup>::MakeSptr(groupId, SCREEN_ID_INVALID, "test", ScreenCombination::SCREEN_MIRROR);
1366 group->mirrorScreenId_ = mainScreenId;
1367 sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr(screenId, ScreenProperty(), 0);
1368 ssm_->screenSessionMap_[screenId] = screenSession;
1369 std::vector<ScreenId> screens;
1370 screens.emplace_back(screenId);
1371 DMRect region = { 0, 0, 1, 1 };
1372 Point point;
1373 std::vector<Point> startPoints;
1374 startPoints.insert(startPoints.begin(), screens.size(), point);
1375 ssm_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_MIRROR, region);
1376 EXPECT_TRUE(g_errLog.find("has not same cast info") != std::string::npos);
1377 g_errLog.clear();
1378 ssm_->SetScreenCastInfo(screenId, mainScreenId, ScreenCombination::SCREEN_MIRROR);
1379 ssm_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_MIRROR, region);
1380 EXPECT_FALSE(g_errLog.find("has not same cast info") != std::string::npos);
1381 g_errLog.clear();
1382 ssm_->RemoveScreenCastInfo(screenId);
1383 }
1384
1385 /**
1386 * @tc.name: ChangeMirrorScreenConfig
1387 * @tc.desc: ChangeMirrorScreenConfig
1388 * @tc.type: FUNC
1389 */
1390 HWTEST_F(ScreenSessionManagerTest, ChangeMirrorScreenConfig, TestSize.Level1) {
1391 ASSERT_NE(ssm_, nullptr);
1392 g_errLog.clear();
1393 LOG_SetCallback(MyLogCallback);
1394 ScreenId groupId = 1;
1395 ScreenId screenId = 4080;
1396 ScreenId mainScreenId = 0;
1397 sptr<ScreenSessionGroup> group =
1398 sptr<ScreenSessionGroup>::MakeSptr(groupId, SCREEN_ID_INVALID, "test", ScreenCombination::SCREEN_MIRROR);
1399 sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr(screenId, ScreenProperty(), 0);
1400 ssm_->screenSessionMap_[screenId] = screenSession;
1401 group->mirrorScreenId_ = mainScreenId;
1402 DMRect region = { 0, 0, 1, 1 };
1403 ssm_->ChangeMirrorScreenConfig(group, region, screenSession);
1404 EXPECT_TRUE(g_errLog.find("convert to rs id failed") != std::string::npos);
1405 g_errLog.clear();
1406 ssm_->screenIdManager_.UpdateScreenId(screenId, screenId);
1407 ssm_->ChangeMirrorScreenConfig(group, region, screenSession);
1408 EXPECT_TRUE(g_errLog.find("with region") != std::string::npos);
1409 g_errLog.clear();
1410 group = nullptr;
1411 ssm_->ChangeMirrorScreenConfig(group, region, screenSession);
1412 EXPECT_FALSE(g_errLog.find("with region") != std::string::npos);
1413 g_errLog.clear();
1414 screenSession = nullptr;
1415 ssm_->ChangeMirrorScreenConfig(group, region, screenSession);
1416 EXPECT_FALSE(g_errLog.find("with region") != std::string::npos);
1417 g_errLog.clear();
1418 }
1419
1420 /*
1421 * @tc.name: RegisterSettingDuringCallStateObserver
1422 * @tc.desc: RegisterSettingDuringCallStateObserver
1423 * @tc.type: FUNC
1424 */
1425 HWTEST_F(ScreenSessionManagerTest, RegisterSettingDuringCallStateObserver, Function | SmallTest | Level3)
1426 {
1427 ASSERT_NE(ssm_, nullptr);
1428 if (FoldScreenStateInternel::IsDualDisplayFoldDevice() && ScreenSceneConfig::IsSupportDuringCall()) {
1429 ssm_->RegisterSettingDuringCallStateObserver();
1430 ASSERT_NE(ScreenSettingHelper::duringCallStateObserver_, nullptr);
1431 }
1432 }
1433
1434 /**
1435 * @tc.name: UpdateDuringCallState
1436 * @tc.desc: UpdateDuringCallState
1437 * @tc.type: FUNC
1438 */
1439 HWTEST_F(ScreenSessionManagerTest, UpdateDuringCallState, Function | SmallTest | Level3)
1440 {
1441 ASSERT_NE(ssm_, nullptr);
1442 if (FoldScreenStateInternel::IsDualDisplayFoldDevice() && ScreenSceneConfig::IsSupportDuringCall()) {
1443 ssm_->UpdateDuringCallState();
1444 ASSERT_EQ(ssm_->duringCallState_, 0);
1445 }
1446 }
1447 /**
1448 * @tc.name: DisconnectScreenIfScreenInfoNull
1449 * @tc.desc: DisconnectScreenIfScreenInfoNull
1450 * @tc.type: FUNC
1451 */
1452 HWTEST_F(ScreenSessionManagerTest, DisconnectScreenIfScreenInfoNull01, TestSize.Level1) {
1453 ASSERT_NE(ssm_, nullptr);
1454 #define FOLD_ABILITY_ENABLE
1455 if (FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
1456 sptr<ScreenSession> session = ssm_->GetOrCreateScreenSession(SCREENID);
1457 EXPECT_NE(session, nullptr);
1458 ssm_->SetClient(nullptr);
1459 ASSERT_EQ(ssm_->GetClientProxy(), nullptr);
1460 ssm_->DisConnectScreenIfScreenInfoNull(session);
1461 }
1462 #undef FOLD_ABILITY_ENABLE
1463 }
1464
1465 /**
1466 * @tc.name: SetDefaultScreenModeWhenCreateMirror
1467 * @tc.desc: SetDefaultScreenModeWhenCreateMirror
1468 * @tc.type: FUNC
1469 */
1470 HWTEST_F(ScreenSessionManagerTest, SetDefaultScreenModeWhenCreateMirror, TestSize.Level1) {
1471 ASSERT_NE(ssm_, nullptr);
1472 #define FOLD_ABILITY_ENABLE
1473 if (FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
1474 sptr<ScreenSession> session = nullptr;
1475 ssm_->SetDefaultScreenModeWhenCreateMirror(session);
1476 session = ssm_->GetOrCreateScreenSession(0);
1477 auto mode = session->GetScreenCombination();
1478 ssm_->SetDefaultScreenModeWhenCreateMirror(session);
1479 ASSERT_EQ(session->GetScreenCombination(), mode);
1480 }
1481 #undef FOLD_ABILITY_ENABLE
1482 }
1483
1484 /**
1485 * @tc.name: RecoverDefaultScreenModeInner
1486 * @tc.desc: RecoverDefaultScreenModeInner
1487 * @tc.type: FUNC
1488 */
1489 HWTEST_F(ScreenSessionManagerTest, RecoverDefaultScreenModeInner, TestSize.Level1) {
1490 ASSERT_NE(ssm_, nullptr);
1491 #define FOLD_ABILITY_ENABLE
1492 if (FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
1493 ScreenId innerRsId = 0;
1494 ScreenId externalRsId = 11;
1495 ssm_->SetIsFoldStatusLocked(true);
1496 EXPECT_EQ(ssm_->GetIsFoldStatusLocked(), true);
1497 ssm_->RecoverDefaultScreenModeInner(innerRsId, externalRsId);
1498 SuperFoldStateManager::GetInstance().SetCurrentStatus(SuperFoldStatus::EXPANDED);
1499 innerRsId = 1;
1500 externalRsId = 12;
1501 ssm_->RecoverDefaultScreenModeInner(innerRsId, externalRsId);
1502 }
1503 #undef FOLD_ABILITY_ENABLE
1504 }
1505 }
1506 }
1507 }