1 /*
2 * Copyright (c) 2024 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 <system_ability_definition.h>
19
20 #include "fold_screen_controller/super_fold_state_manager.h"
21 #include "fold_screen_state_internel.h"
22 #include "screen_session_manager/include/screen_session_manager.h"
23 #include "display_manager_agent_default.h"
24 #include "screen_scene_config.h"
25 #define private public
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32
33 namespace {
34 #define ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE if (!FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {return;}
35 }
36
37 namespace {
38 std::string g_errLog;
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)39 void MyLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char* tag,
40 const char* msg)
41 {
42 g_errLog += msg;
43 }
44 }
45
46 class SuperFoldStateManagerTest : public testing::Test {
47 public:
48 static void SetUpTestCase();
49 static void TearDownTestCase();
50 void SetUp() override;
51 void TearDown() override;
52 static ScreenSessionManager& ssm_;
53 };
54
55 ScreenSessionManager& SuperFoldStateManagerTest::ssm_ = ScreenSessionManager::GetInstance();
56
SetUpTestCase()57 void SuperFoldStateManagerTest::SetUpTestCase()
58 {
59 }
60
TearDownTestCase()61 void SuperFoldStateManagerTest::TearDownTestCase()
62 {
63 }
64
SetUp()65 void SuperFoldStateManagerTest::SetUp()
66 {
67 }
68
TearDown()69 void SuperFoldStateManagerTest::TearDown()
70 {
71 }
72
73 namespace {
74
75 /**
76 * @tc.name: HandleSuperFoldStatusChange
77 * @tc.desc: test function : ANGLE_CHANGE_EXPANDED
78 * @tc.type: FUNC
79 */
80 HWTEST_F(SuperFoldStateManagerTest, HandleSuperFoldStatusChange01, TestSize.Level1)
81 {
82 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
83 SuperFoldStatusChangeEvents events = SuperFoldStatusChangeEvents::ANGLE_CHANGE_EXPANDED;
84 SuperFoldStateManager::GetInstance().SetCurrentStatus(SuperFoldStatus::HALF_FOLDED);
85 std::function<void()> func = [&]()
__anon029a28ab0402() 86 {
87 SuperFoldStateManager::GetInstance().HandleSuperFoldStatusChange(events);
88 };
89
90 func();
91 SuperFoldStatus curState = SuperFoldStateManager::GetInstance().GetCurrentStatus();
92 SuperFoldStatus expState = SuperFoldStatus::EXPANDED;
93
94 EXPECT_EQ(curState, expState);
95 }
96
97 /**
98 * @tc.name: HandleSuperFoldStatusChange
99 * @tc.desc: test function : ANGLE_CHANGE_HALF_FOLDED
100 * @tc.type: FUNC
101 */
102 HWTEST_F(SuperFoldStateManagerTest, HandleSuperFoldStatusChange02, TestSize.Level1)
103 {
104 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
105 SuperFoldStatusChangeEvents events = SuperFoldStatusChangeEvents::ANGLE_CHANGE_HALF_FOLDED;
106 SuperFoldStateManager::GetInstance().SetCurrentStatus(SuperFoldStatus::FOLDED);
107 std::function<void()> func = [&]()
__anon029a28ab0502() 108 {
109 SuperFoldStateManager::GetInstance().HandleSuperFoldStatusChange(events);
110 };
111
112 func();
113 SuperFoldStatus curState = SuperFoldStateManager::GetInstance().GetCurrentStatus();
114 SuperFoldStatus expState = SuperFoldStatus::HALF_FOLDED;
115
116 EXPECT_EQ(curState, expState);
117 }
118
119 /**
120 * @tc.name: HandleSuperFoldStatusChange
121 * @tc.desc: test function : ANGLE_CHANGE_HALF_FOLDED
122 * @tc.type: FUNC
123 */
124 HWTEST_F(SuperFoldStateManagerTest, HandleSuperFoldStatusChange03, TestSize.Level1)
125 {
126 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
127 SuperFoldStatusChangeEvents events = SuperFoldStatusChangeEvents::ANGLE_CHANGE_HALF_FOLDED;
128 SuperFoldStateManager::GetInstance().SetCurrentStatus(SuperFoldStatus::EXPANDED);
129 std::function<void()> func = [&]()
__anon029a28ab0602() 130 {
131 SuperFoldStateManager::GetInstance().HandleSuperFoldStatusChange(events);
132 };
133
134 func();
135 SuperFoldStatus curState = SuperFoldStateManager::GetInstance().GetCurrentStatus();
136 SuperFoldStatus expState = SuperFoldStatus::HALF_FOLDED;
137
138 EXPECT_EQ(curState, expState);
139 }
140
141 /**
142 * @tc.name: HandleSuperFoldStatusChange
143 * @tc.desc: test function : ANGLE_CHANGE_FOLDED
144 * @tc.type: FUNC
145 */
146 HWTEST_F(SuperFoldStateManagerTest, HandleSuperFoldStatusChange04, TestSize.Level1)
147 {
148 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
149 SuperFoldStatusChangeEvents events = SuperFoldStatusChangeEvents::ANGLE_CHANGE_FOLDED;
150 SuperFoldStateManager::GetInstance().SetCurrentStatus(SuperFoldStatus::HALF_FOLDED);
151 std::function<void()> func = [&]()
__anon029a28ab0702() 152 {
153 SuperFoldStateManager::GetInstance().HandleSuperFoldStatusChange(events);
154 };
155
156 func();
157 SuperFoldStatus curState = SuperFoldStateManager::GetInstance().GetCurrentStatus();
158 SuperFoldStatus expState = SuperFoldStatus::FOLDED;
159
160 EXPECT_EQ(curState, expState);
161 }
162
163 /**
164 * @tc.name: HandleSuperFoldStatusChange
165 * @tc.desc: test function : KEYBOARD_ON
166 * @tc.type: FUNC
167 */
168 HWTEST_F(SuperFoldStateManagerTest, HandleSuperFoldStatusChange05, TestSize.Level1)
169 {
170 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
171 SuperFoldStatusChangeEvents events = SuperFoldStatusChangeEvents::KEYBOARD_ON;
172 SuperFoldStateManager::GetInstance().SetCurrentStatus(SuperFoldStatus::HALF_FOLDED);
173 std::function<void()> func = [&]()
__anon029a28ab0802() 174 {
175 SuperFoldStateManager::GetInstance().HandleSuperFoldStatusChange(events);
176 };
177
178 func();
179 SuperFoldStatus curState = SuperFoldStateManager::GetInstance().GetCurrentStatus();
180 SuperFoldStatus expState = SuperFoldStatus::KEYBOARD;
181
182 EXPECT_EQ(curState, expState);
183 }
184
185 /**
186 * @tc.name: HandleSuperFoldStatusChange
187 * @tc.desc: test function : KEYBOARD_ON
188 * @tc.type: FUNC
189 */
190 HWTEST_F(SuperFoldStateManagerTest, HandleSuperFoldStatusChange06, TestSize.Level1)
191 {
192 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
193 SuperFoldStatusChangeEvents events = SuperFoldStatusChangeEvents::KEYBOARD_ON;
194 SuperFoldStateManager::GetInstance().SetCurrentStatus(SuperFoldStatus::EXPANDED);
195 std::function<void()> func = [&]()
__anon029a28ab0902() 196 {
197 SuperFoldStateManager::GetInstance().
198 HandleSuperFoldStatusChange(SuperFoldStatusChangeEvents::ANGLE_CHANGE_HALF_FOLDED);
199 SuperFoldStateManager::GetInstance().HandleSuperFoldStatusChange(events);
200 };
201
202 func();
203 SuperFoldStatus curState = SuperFoldStateManager::GetInstance().GetCurrentStatus();
204 SuperFoldStatus expState = SuperFoldStatus::KEYBOARD;
205
206 EXPECT_EQ(curState, expState);
207 }
208
209 /**
210 * @tc.name: HandleSuperFoldStatusChange
211 * @tc.desc: test function : KEYBOARD_OFF
212 * @tc.type: FUNC
213 */
214 HWTEST_F(SuperFoldStateManagerTest, HandleSuperFoldStatusChange07, TestSize.Level1)
215 {
216 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
217 SuperFoldStatusChangeEvents events = SuperFoldStatusChangeEvents::KEYBOARD_OFF;
218 SuperFoldStateManager::GetInstance().SetCurrentStatus(SuperFoldStatus::KEYBOARD);
219 std::function<void()> func = [&]()
__anon029a28ab0a02() 220 {
221 SuperFoldStateManager::GetInstance().HandleSuperFoldStatusChange(events);
222 };
223
224 func();
225 SuperFoldStatus curState = SuperFoldStateManager::GetInstance().GetCurrentStatus();
226 SuperFoldStatus expState = SuperFoldStatus::HALF_FOLDED;
227
228 EXPECT_EQ(curState, expState);
229 }
230
231 /**
232 * @tc.name: HandleSuperFoldStatusChange
233 * @tc.desc: test function : SYSTEM_KEYBOARD_ON
234 * @tc.type: FUNC
235 */
236 HWTEST_F(SuperFoldStateManagerTest, HandleSuperFoldStatusChange08, Function | SmallTest | Level1)
237 {
238 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
239 SuperFoldStatusChangeEvents events = SuperFoldStatusChangeEvents::SYSTEM_KEYBOARD_ON;
240 SuperFoldStateManager::GetInstance().SetCurrentStatus(SuperFoldStatus::HALF_FOLDED);
241 std::function<void()> func = [&]()
__anon029a28ab0b02() 242 {
243 SuperFoldStateManager::GetInstance().HandleSuperFoldStatusChange(events);
244 };
245
246 func();
247 SuperFoldStatus curState = SuperFoldStateManager::GetInstance().GetCurrentStatus();
248 SuperFoldStatus expState = SuperFoldStatus::HALF_FOLDED;
249
250 EXPECT_EQ(curState, expState);
251 }
252
253 /**
254 * @tc.name: HandleSuperFoldStatusChange
255 * @tc.desc: test function : SYSTEM_KEYBOARD_OFF
256 * @tc.type: FUNC
257 */
258 HWTEST_F(SuperFoldStateManagerTest, HandleSuperFoldStatusChange09, Function | SmallTest | Level1)
259 {
260 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
261 SuperFoldStatusChangeEvents events = SuperFoldStatusChangeEvents::SYSTEM_KEYBOARD_OFF;
262 SuperFoldStateManager::GetInstance().SetCurrentStatus(SuperFoldStatus::HALF_FOLDED);
263 std::function<void()> func = [&]()
__anon029a28ab0c02() 264 {
265 SuperFoldStateManager::GetInstance().HandleSuperFoldStatusChange(events);
266 };
267
268 func();
269 SuperFoldStatus curState = SuperFoldStateManager::GetInstance().GetCurrentStatus();
270 SuperFoldStatus expState = SuperFoldStatus::HALF_FOLDED;
271
272 EXPECT_EQ(curState, expState);
273 }
274
275 /**
276 * @tc.name: MatchSuperFoldStatusToFoldStatus
277 * @tc.desc: test function : EXPANDED
278 * @tc.type: FUNC
279 */
280 HWTEST_F(SuperFoldStateManagerTest, MatchSuperFoldStatusToFoldStatus01, TestSize.Level1)
281 {
282 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
283 SuperFoldStatus superFoldStatus = SuperFoldStatus::EXPANDED;
284 FoldStatus foldStatus;
285 std::function<void()> func = [&]()
__anon029a28ab0d02() 286 {
287 foldStatus = SuperFoldStateManager::GetInstance().MatchSuperFoldStatusToFoldStatus(superFoldStatus);
288 };
289
290 func();
291 FoldStatus foldStatusExp = FoldStatus::EXPAND;
292 EXPECT_EQ(foldStatus, foldStatusExp);
293 }
294
295 /**
296 * @tc.name: MatchSuperFoldStatusToFoldStatus
297 * @tc.desc: test function : HALF_FOLDED
298 * @tc.type: FUNC
299 */
300 HWTEST_F(SuperFoldStateManagerTest, MatchSuperFoldStatusToFoldStatus02, TestSize.Level1)
301 {
302 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
303 SuperFoldStatus superFoldStatus = SuperFoldStatus::HALF_FOLDED;
304 FoldStatus foldStatus;
305 std::function<void()> func = [&]()
__anon029a28ab0e02() 306 {
307 foldStatus = SuperFoldStateManager::GetInstance().MatchSuperFoldStatusToFoldStatus(superFoldStatus);
308 };
309
310 func();
311 FoldStatus foldStatusExp = FoldStatus::HALF_FOLD;
312 EXPECT_EQ(foldStatus, foldStatusExp);
313 }
314
315 /**
316 * @tc.name: MatchSuperFoldStatusToFoldStatus
317 * @tc.desc: test function : FOLDED
318 * @tc.type: FUNC
319 */
320 HWTEST_F(SuperFoldStateManagerTest, MatchSuperFoldStatusToFoldStatus03, TestSize.Level1)
321 {
322 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
323 SuperFoldStatus superFoldStatus = SuperFoldStatus::FOLDED;
324 FoldStatus foldStatus;
325 std::function<void()> func = [&]()
__anon029a28ab0f02() 326 {
327 foldStatus = SuperFoldStateManager::GetInstance().MatchSuperFoldStatusToFoldStatus(superFoldStatus);
328 };
329
330 func();
331 FoldStatus foldStatusExp = FoldStatus::FOLDED;
332 EXPECT_EQ(foldStatus, foldStatusExp);
333 }
334
335 /**
336 * @tc.name: MatchSuperFoldStatusToFoldStatus
337 * @tc.desc: test function : KEYBOARD
338 * @tc.type: FUNC
339 */
340 HWTEST_F(SuperFoldStateManagerTest, MatchSuperFoldStatusToFoldStatus04, TestSize.Level1)
341 {
342 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
343 SuperFoldStatus superFoldStatus = SuperFoldStatus::KEYBOARD;
344 FoldStatus foldStatus;
345 std::function<void()> func = [&]()
__anon029a28ab1002() 346 {
347 foldStatus = SuperFoldStateManager::GetInstance().MatchSuperFoldStatusToFoldStatus(superFoldStatus);
348 };
349
350 func();
351 FoldStatus foldStatusExp = FoldStatus::HALF_FOLD;
352 EXPECT_EQ(foldStatus, foldStatusExp);
353 }
354
355 /**
356 * @tc.name: MatchSuperFoldStatusToFoldStatus
357 * @tc.desc: test function : UNKNOWN
358 * @tc.type: FUNC
359 */
360 HWTEST_F(SuperFoldStateManagerTest, MatchSuperFoldStatusToFoldStatus05, TestSize.Level1)
361 {
362 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
363 SuperFoldStatus superFoldStatus = SuperFoldStatus::UNKNOWN;
364 FoldStatus foldStatus;
365 std::function<void()> func = [&]()
__anon029a28ab1102() 366 {
367 foldStatus = SuperFoldStateManager::GetInstance().MatchSuperFoldStatusToFoldStatus(superFoldStatus);
368 };
369
370 func();
371 FoldStatus foldStatusExp = FoldStatus::UNKNOWN;
372 EXPECT_EQ(foldStatus, foldStatusExp);
373 }
374
375 /**
376 * @tc.name: SetSystemKeyboardStatus
377 * @tc.desc: SetSystemKeyboardStatus with true as parameter
378 * @tc.type: FUNC
379 */
380 HWTEST_F(SuperFoldStateManagerTest, SetSystemKeyboardStatus01, Function | SmallTest | Level1)
381 {
382 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
383 SuperFoldStateManager::GetInstance().SetCurrentStatus(SuperFoldStatus::HALF_FOLDED);
384 std::function<void()> func = [&]()
__anon029a28ab1202() 385 {
386 SuperFoldStateManager::GetInstance().SetSystemKeyboardStatus(true);
387 };
388
389 func();
390 SuperFoldStatus curState = SuperFoldStateManager::GetInstance().GetCurrentStatus();
391 SuperFoldStatus expState = SuperFoldStatus::HALF_FOLDED;
392
393 EXPECT_EQ(curState, expState);
394 }
395
396 /**
397 * @tc.name: SetSystemKeyboardStatus
398 * @tc.desc: SetSystemKeyboardStatus with false as parameter
399 * @tc.type: FUNC
400 */
401 HWTEST_F(SuperFoldStateManagerTest, SetSystemKeyboardStatus02, Function | SmallTest | Level1)
402 {
403 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
404 SuperFoldStateManager::GetInstance().SetCurrentStatus(SuperFoldStatus::HALF_FOLDED);
405 std::function<void()> func = [&]()
__anon029a28ab1302() 406 {
407 SuperFoldStateManager::GetInstance().SetSystemKeyboardStatus(false);
408 };
409
410 func();
411 SuperFoldStatus curState = SuperFoldStateManager::GetInstance().GetCurrentStatus();
412 SuperFoldStatus expState = SuperFoldStatus::HALF_FOLDED;
413
414 EXPECT_EQ(curState, expState);
415 }
416
417 /**
418 * @tc.name: GetCurrentStatus_ShouldReturnKeyboard_WhenHalfScreenIsFalse
419 * @tc.desc: Test GetCurrentStatus function when isHalfScreen_ is false.
420 * @tc.type: FUNC
421 */
422 HWTEST_F(SuperFoldStateManagerTest, GetCurrentStatus_ShouldReturnKeyboard_WhenHalfScreenIsFalse, TestSize.Level1)
423 {
424 SuperFoldStateManager superFoldStateManager = SuperFoldStateManager();
425 superFoldStateManager.SetCurrentStatus(SuperFoldStatus::UNKNOWN);
426 superFoldStateManager.ChangeScreenState(false);
427
428 SuperFoldStatus curState = superFoldStateManager.GetCurrentStatus();
429
430 EXPECT_EQ(curState, SuperFoldStatus::UNKNOWN);
431 }
432
433 /**
434 * @tc.name : GetFoldCreaseHeight
435 * @tc.desc : GetFoldCreaseHeight
436 * @tc.type: FUNC
437 */
438 HWTEST_F(SuperFoldStateManagerTest, GetFoldCreaseHeight, TestSize.Level1)
439 {
440 SuperFoldStateManager superFoldStateManager = SuperFoldStateManager();
441 const uint32_t DEFAULT_FOLD_REGION_HEIGHT = 82;
442 superFoldStateManager.currentSuperFoldCreaseRegion_ = nullptr;
443 uint32_t result = superFoldStateManager.GetFoldCreaseHeight();
444 EXPECT_EQ(result, DEFAULT_FOLD_REGION_HEIGHT);
445 std::vector<DMRect> rect = {};
446 superFoldStateManager.currentSuperFoldCreaseRegion_ = sptr<FoldCreaseRegion>::MakeSptr(0, rect);
447 result = superFoldStateManager.GetFoldCreaseHeight();
448 EXPECT_EQ(result, DEFAULT_FOLD_REGION_HEIGHT);
449 rect.push_back({0, 0,
450 DEFAULT_FOLD_REGION_HEIGHT * 2, DEFAULT_FOLD_REGION_HEIGHT * 2
451 });
452 superFoldStateManager.currentSuperFoldCreaseRegion_ = sptr<FoldCreaseRegion>::MakeSptr(0, rect);
453 result = superFoldStateManager.GetFoldCreaseHeight();
454 EXPECT_EQ(result, DEFAULT_FOLD_REGION_HEIGHT * 2);
455 }
456
457 /**
458 * @tc.name : RefreshMirrorRegionInner_NullptrScreenSession
459 * @tc.desc : Test When null, return expect
460 * @tc.type: FUNC
461 */
462 HWTEST_F(SuperFoldStateManagerTest, RefreshMirrorRegionInner_NullptrScreenSession, TestSize.Level1)
463 {
464 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
465 sptr<ScreenSession> mainScreenSession = nullptr;
466 sptr<ScreenSession> secondarySession = nullptr;
467 SuperFoldStateManager superFoldStateManager;
468 ASSERT_EQ(superFoldStateManager.RefreshMirrorRegionInner(mainScreenSession, secondarySession),
469 DMError::DM_ERROR_NULLPTR);
470 mainScreenSession = sptr<ScreenSession>::MakeSptr();
471 ASSERT_EQ(superFoldStateManager.RefreshMirrorRegionInner(mainScreenSession, secondarySession),
472 DMError::DM_ERROR_NULLPTR);
473 }
474
475 /**
476 * @tc.name : RefreshMirrorRegionInner_NormalCase
477 * @tc.desc : Test When NormalCase, return DMError::OK
478 * @tc.type: FUNC
479 */
480 HWTEST_F(SuperFoldStateManagerTest, RefreshMirrorRegionInner_NormalCase, TestSize.Level1)
481 {
482 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
483 SuperFoldStateManager superFoldStateManager;
484 superFoldStateManager.SetCurrentStatus(SuperFoldStatus::UNKNOWN);
485 sptr<ScreenSession> mainScreenSession = ssm_.GetOrCreateScreenSession(0);
486 ScreenProperty mainScreenProperty;
487 mainScreenProperty.bounds_.rect_ = { 0, 0, 100, 100 };
488 mainScreenSession->SetScreenProperty(mainScreenProperty);
489
490 sptr<ScreenSession> secondarySession = ssm_.GetOrCreateScreenSession(1);
491 superFoldStateManager.SetCurrentStatus(SuperFoldStatus::EXPANDED);
492 ScreenProperty secondaryScreenProperty;
493 secondaryScreenProperty.bounds_.rect_ = { 0, 0, 100, 100 };
494 secondarySession->SetScreenProperty(secondaryScreenProperty);
495 EXPECT_EQ(superFoldStateManager.RefreshMirrorRegionInner(mainScreenSession, secondarySession), DMError::DM_OK);
496 }
497
498 /**
499 * @tc.name : RefreshExternalRegion_ShouldReturnOk_WhenNoExtendScreenConnected
500 * @tc.desc : When the extended screen is not connected, the function should return DM_OK and ignore the refresh.
501 * @tc.type: FUNC
502 */
503 HWTEST_F(SuperFoldStateManagerTest, RefreshExternalRegion_ShouldReturnOk_WhenNoExtendScreenConnected, TestSize.Level1)
504 {
505 ONLY_FOR_SUPERFOLD_DISPLAY_DEVICE
506 ssm_.SetIsExtendScreenConnected(false);
507 SuperFoldStateManager superFoldStateManager;
508 DMError result = superFoldStateManager.RefreshExternalRegion();
509 ssm_.SetIsExtendScreenConnected(true);
510
511 sptr<ScreenSession> mainScreenSession = ssm_.GetOrCreateScreenSession(0);
512 mainScreenSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
513 ScreenProperty mainScreenProperty;
514 mainScreenProperty.bounds_.rect_ = { 0, 0, 100, 100 };
515 mainScreenSession->SetScreenProperty(mainScreenProperty);
516 result = superFoldStateManager.RefreshExternalRegion();
517
518 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
519 VirtualScreenOption virtualOption;
520 virtualOption.name_ = "createVirtualOption";
521 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
522 virtualOption, displayManagerAgent->AsObject());
523 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
524
525 secondarySession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
526 ScreenProperty secondaryScreenProperty;
527 secondaryScreenProperty.bounds_.rect_ = { 0, 0, 100, 100 };
528 secondarySession->SetScreenProperty(secondaryScreenProperty);
529 result = superFoldStateManager.RefreshExternalRegion();
530 EXPECT_EQ(result, DMError::DM_OK);
531
532 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
533 VirtualScreenOption virtualOption1;
534 virtualOption1.name_ = "createVirtualOption";
535 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
536 virtualOption1, displayManagerAgent1->AsObject());
537 auto thirdSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
538 thirdSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
539 ScreenProperty thirdScreenProperty;
540 thirdScreenProperty.bounds_.rect_ = { 0, 0, 100, 100 };
541 thirdSession->SetScreenProperty(thirdScreenProperty);
542 result = superFoldStateManager.RefreshExternalRegion();
543 EXPECT_EQ(result, DMError::DM_OK);
544
545 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
546 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
547 }
548
549 /**
550 * @tc.name : ForceChangeMirrorMode_ShouldReturnNullptrError_WhenMainScreenSessionIsNull
551 * @tc.number: ForceChangeMirrorModeTest_001
552 * @tc.desc : When `mainScreenSession` is `nullptr`, the function should return `DM_ERROR_NULLPTR`
553 */
554 HWTEST_F(SuperFoldStateManagerTest, ForceChangeMirrorMode_ShouldReturnNullptrError_WhenMainScreenSessionIsNull,
555 TestSize.Level0)
556 {
557 SuperFoldStateManager manager;
558 sptr<ScreenSession> mainScreenSession = nullptr;
559 sptr<ScreenSession> secondarySession = sptr<ScreenSession>::MakeSptr();
560 DMError result = manager.ForceChangeMirrorMode(mainScreenSession, secondarySession);
561 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, result);
562 }
563
564 /**
565 * @tc.name : ForceChangeMirrorMode_ShouldReturnNullptrError_WhenSecondarySessionIsNull
566 * @tc.number: ForceChangeMirrorModeTest_002
567 * @tc.desc : When `secondarySession` is `nullptr`, the function should return `DM_ERROR_NULLPTR`.
568 */
569 HWTEST_F(SuperFoldStateManagerTest, ForceChangeMirrorMode_ShouldReturnNullptrError_WhenSecondarySessionIsNull,
570 TestSize.Level0)
571 {
572 SuperFoldStateManager manager;
573 sptr<ScreenSession> mainScreenSession = sptr<ScreenSession>::MakeSptr();
574 sptr<ScreenSession> secondarySession = nullptr;
575 DMError result = manager.ForceChangeMirrorMode(mainScreenSession, secondarySession);
576 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, result);
577 }
578
579 /**
580 * @tc.name : ForceChangeMirrorMode_ShouldNotSetMultiScreenMode_WhenConditionsNotMet
581 * @tc.number: ForceChangeMirrorModeTest_003
582 * @tc.desc : When the conditions are not met, the function should not call SetMultiScreenMode and return DM_OK.
583 */
584 HWTEST_F(
585 SuperFoldStateManagerTest, ForceChangeMirrorMode_ShouldNotSetMultiScreenMode_WhenConditionsNotMet, TestSize.Level0)
586 {
587 sptr<ScreenSession> mainScreenSession = sptr<ScreenSession>::MakeSptr();
588 sptr<ScreenSession> secondarySession = sptr<ScreenSession>::MakeSptr();
589
590 SuperFoldStateManager manager;
591 manager.SetCurrentStatus(SuperFoldStatus::FOLDED);
592 DMError result = manager.ForceChangeMirrorMode(mainScreenSession, secondarySession);
593 ASSERT_EQ(DMError::DM_OK, result);
594
595 manager.SetCurrentStatus(SuperFoldStatus::EXPANDED);
596 result = manager.ForceChangeMirrorMode(mainScreenSession, secondarySession);
597 ASSERT_EQ(DMError::DM_OK, result);
598 }
599
600 /**
601 * @tc.name: GetFoldCreaseRect01
602 * @tc.desc: test function : GetFoldCreaseRect01
603 * @tc.type: FUNC
604 */
605 HWTEST_F(SuperFoldStateManagerTest, GetFoldCreaseRect01, TestSize.Level1)
606 {
607 g_errLog.clear();
608 LOG_SetCallback(MyLogCallback);
609 std::vector<DMRect> foldCreaseRect;
610 std::vector<int32_t> foldRect = {
611 100, // posX
612 200, // posY
613 300, // width
614 400 // height
615 };
616 std::function<void()> func = [&]()
__anon029a28ab1402() 617 {
618 SuperFoldStateManager::GetInstance().GetFoldCreaseRegion(true, false);
619 SuperFoldStateManager::GetInstance().GetFoldCreaseRect(true, false, foldRect, foldCreaseRect);
620 };
621
622 func();
623 EXPECT_TRUE(g_errLog.find("the current FoldCreaseRect is vertical") != std::string::npos);
624 LOG_SetCallback(nullptr);
625 }
626
627 /**
628 * @tc.name: GetFoldCreaseRect02
629 * @tc.desc: test function : GetFoldCreaseRect02
630 * @tc.type: FUNC
631 */
632 HWTEST_F(SuperFoldStateManagerTest, GetFoldCreaseRect02, TestSize.Level1)
633 {
634 g_errLog.clear();
635 LOG_SetCallback(MyLogCallback);
636 std::vector<DMRect> foldCreaseRect;
637 std::vector<int32_t> foldRect = {
638 100, // posX
639 200, // posY
640 300, // width
641 400 // height
642 };
643 std::function<void()> func = [&]()
__anon029a28ab1502() 644 {
645 SuperFoldStateManager::GetInstance().GetFoldCreaseRegion(false, false);
646 SuperFoldStateManager::GetInstance().GetFoldCreaseRect(false, false, foldRect, foldCreaseRect);
647 };
648
649 func();
650 EXPECT_TRUE(g_errLog.find("the current FoldCreaseRect is horizontal") != std::string::npos);
651 LOG_SetCallback(nullptr);
652 }
653 }
654 }
655 }