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 #include <memory>
18 #include <thread>
19 #include <chrono>
20 #include "mock/mock_session_stage.h"
21 #include "session/host/include/main_session.h"
22 #include "session/host/include/pc_fold_screen_controller.h"
23 #include "session/host/include/sub_session.h"
24 #include "wm_math.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace Rosen {
31
32 namespace {
33 // screen const
34 constexpr int32_t SCREEN_WIDTH = 2472;
35 constexpr int32_t SCREEN_HEIGHT = 3296;
36 constexpr int32_t SCREEN_HEIGHT_HALF = 1648;
37 constexpr int32_t CREASE_HEIGHT = 48;
38 constexpr int32_t TOP_AVOID_HEIGHT = 56;
39 constexpr int32_t BOT_AVOID_HEIGHT = 112;
40
41 // screen rects
42 const WSRect DISPLAY_RECT = { 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT };
43 const WSRect DEFAULT_DISPLAY_RECT = { 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT_HALF };
44 const WSRect VIRTUAL_DISPLAY_RECT = { 0, SCREEN_HEIGHT_HALF, SCREEN_WIDTH, SCREEN_HEIGHT_HALF };
45 const WSRect FOLD_CREASE_RECT = { 0, SCREEN_HEIGHT_HALF - CREASE_HEIGHT / 2, SCREEN_WIDTH, CREASE_HEIGHT };
46 const WSRect ZERO_RECT = { 0, 0, 0, 0 };
47 const WSRect DEFAULT_FULLSCREEN_RECT = { 0, TOP_AVOID_HEIGHT, SCREEN_WIDTH,
48 SCREEN_HEIGHT_HALF - CREASE_HEIGHT / 2 - TOP_AVOID_HEIGHT};
49 const WSRect VIRTUAL_FULLSCREEN_RECT = { 0, SCREEN_HEIGHT_HALF + CREASE_HEIGHT / 2, SCREEN_WIDTH,
50 SCREEN_HEIGHT_HALF - CREASE_HEIGHT / 2 - BOT_AVOID_HEIGHT };
51
52 // test rects
53 const WSRect B_RECT = { 100, 100, 400, 400 };
54 const WSRect B_ACROSS_RECT = { 400, SCREEN_HEIGHT_HALF - 300, 400, 400 };
55 const WSRect B_TOP_RECT = { 400, -100, 400, 400 };
56 const WSRect C_RECT = { 100, SCREEN_HEIGHT_HALF + 100, 400, 400 };
57 const WSRect C_ACROSS_RECT = { 400, SCREEN_HEIGHT_HALF - 100, 400, 400 };
58 const WSRect C_BOT_RECT = { 400, SCREEN_HEIGHT - 100, 400, 400 };
59
60 // arrange rule
61 constexpr int32_t RULE_TRANS_X = 48; // dp
62 constexpr int32_t MIN_DECOR_HEIGHT = 37; // dp
63 constexpr int32_t MAX_DECOR_HEIGHT = 112; // dp
64
65 // velocity test
66 constexpr int32_t MOVING_RECORDS_SIZE_LIMIT = 5;
67 constexpr int32_t MOVING_RECORDS_TIME_LIMIT_IN_NS = 100000;
68 const WSRectF B_VELOCITY = { 0.0f, 5.0f, 0.0f, 0.0f };
69 const WSRectF B_VELOCITY_SLOW = { 0.0f, 0.01f, 0.0f, 0.0f };
70 const WSRectF B_VELOCITY_SKEW = { 50.0f, 5.0f, 0.0f, 0.0f };
71 const WSRectF C_VELOCITY = { 0.0f, -5.0f, 0.0f, 0.0f };
72 const WSRectF C_VELOCITY_SLOW = { 0.0f, -0.01f, 0.0f, 0.0f };
73 const WSRectF C_VELOCITY_SKEW = { 50.0f, -5.0f, 0.0f, 0.0f };
74 } // namespace
75
76 class PcFoldScreenManagerTest : public testing::Test {
77 public:
78 static void SetUpTestCase();
79 static void TearDownTestCase();
80 void SetUp() override;
81 void TearDown() override;
82
83 static void SetHalfFolded();
84 static void SetExpanded();
85
86 static PcFoldScreenManager& manager_;
87 };
88
89 PcFoldScreenManager& PcFoldScreenManagerTest::manager_ = PcFoldScreenManager::GetInstance();
90
SetUpTestCase()91 void PcFoldScreenManagerTest::SetUpTestCase()
92 {
93 }
94
TearDownTestCase()95 void PcFoldScreenManagerTest::TearDownTestCase()
96 {
97 }
98
SetUp()99 void PcFoldScreenManagerTest::SetUp()
100 {
101 SetExpanded();
102 }
103
TearDown()104 void PcFoldScreenManagerTest::TearDown()
105 {
106 }
107
SetHalfFolded()108 void PcFoldScreenManagerTest::SetHalfFolded()
109 {
110 manager_.UpdateFoldScreenStatus(DEFAULT_SCREEN_ID, SuperFoldStatus::HALF_FOLDED,
111 DEFAULT_DISPLAY_RECT, VIRTUAL_DISPLAY_RECT, FOLD_CREASE_RECT);
112 }
113
SetExpanded()114 void PcFoldScreenManagerTest::SetExpanded()
115 {
116 manager_.UpdateFoldScreenStatus(DEFAULT_SCREEN_ID, SuperFoldStatus::EXPANDED,
117 DISPLAY_RECT, ZERO_RECT, ZERO_RECT);
118 }
119
120 class PcFoldScreenControllerTest : public testing::Test {
121 public:
122 static void SetUpTestCase();
123 static void TearDownTestCase();
124 void SetUp() override;
125 void TearDown() override;
126
127 static void SetHalfFolded();
128 static void SetExpanded();
129
130 static PcFoldScreenManager& manager_;
131 sptr<MainSession> mainSession_;
132 sptr<PcFoldScreenController> controller_;
133 };
134
135 PcFoldScreenManager& PcFoldScreenControllerTest::manager_ = PcFoldScreenManager::GetInstance();
136
SetUpTestCase()137 void PcFoldScreenControllerTest::SetUpTestCase()
138 {
139 }
140
TearDownTestCase()141 void PcFoldScreenControllerTest::TearDownTestCase()
142 {
143 }
144
SetUp()145 void PcFoldScreenControllerTest::SetUp()
146 {
147 // set up main session
148 SessionInfo info;
149 info.abilityName_ = "MainSession";
150 info.bundleName_ = "MainSession";
151 mainSession_ = sptr<MainSession>::MakeSptr(info, nullptr);
152
153 ASSERT_NE(mainSession_, nullptr);
154 ASSERT_NE(mainSession_->pcFoldScreenController_, nullptr);
155 controller_ = mainSession_->pcFoldScreenController_;
156
157 SetExpanded();
158 manager_.UpdateSystemKeyboardStatus(false);
159 }
160
TearDown()161 void PcFoldScreenControllerTest::TearDown()
162 {
163 controller_ = nullptr;
164 mainSession_ = nullptr;
165 }
166
SetHalfFolded()167 void PcFoldScreenControllerTest::SetHalfFolded()
168 {
169 manager_.UpdateFoldScreenStatus(DEFAULT_SCREEN_ID, SuperFoldStatus::HALF_FOLDED,
170 DEFAULT_DISPLAY_RECT, VIRTUAL_DISPLAY_RECT, FOLD_CREASE_RECT);
171 }
172
SetExpanded()173 void PcFoldScreenControllerTest::SetExpanded()
174 {
175 manager_.UpdateFoldScreenStatus(DEFAULT_SCREEN_ID, SuperFoldStatus::EXPANDED,
176 DISPLAY_RECT, ZERO_RECT, ZERO_RECT);
177 }
178
179 /**
180 * @tc.name: SetDisplayInfo
181 * @tc.desc: test function : SetDisplayInfo
182 * @tc.type: FUNC
183 */
184 HWTEST_F(PcFoldScreenManagerTest, SetDisplayInfo, Function | SmallTest | Level1)
185 {
186 SetExpanded();
187 int64_t otherDisplayId = 100;
188 manager_.SetDisplayInfo(DEFAULT_SCREEN_ID, SuperFoldStatus::EXPANDED);
189 // update display id
190 manager_.SetDisplayInfo(otherDisplayId, SuperFoldStatus::EXPANDED);
191 EXPECT_EQ(otherDisplayId, manager_.displayId_);
192 EXPECT_EQ(SuperFoldStatus::EXPANDED, manager_.screenFoldStatus_);
193 // update fold status
194 manager_.SetDisplayInfo(otherDisplayId, SuperFoldStatus::HALF_FOLDED);
195 EXPECT_EQ(SuperFoldStatus::HALF_FOLDED, manager_.screenFoldStatus_);
196 }
197
198 namespace {
199 /**
200 * @tc.name: IsHalfFolded
201 * @tc.desc: test function : IsHalfFolded
202 * @tc.type: FUNC
203 */
204 HWTEST_F(PcFoldScreenManagerTest, IsHalfFolded, Function | SmallTest | Level1)
205 {
206 SetHalfFolded();
207 EXPECT_TRUE(manager_.IsHalfFolded(DEFAULT_SCREEN_ID));
208 SetExpanded();
209 EXPECT_TRUE(!manager_.IsHalfFolded(DEFAULT_SCREEN_ID));
210 }
211
212 /**
213 * @tc.name: SetDisplayRects
214 * @tc.desc: test function : SetDisplayRects, GetDisplayRects
215 * @tc.type: FUNC
216 */
217 HWTEST_F(PcFoldScreenManagerTest, SetDisplayRects, Function | SmallTest | Level1)
218 {
219 manager_.SetDisplayRects(DISPLAY_RECT, ZERO_RECT, ZERO_RECT);
220 const auto& [rect1, rect2, rect3] = manager_.GetDisplayRects();
221 EXPECT_EQ(DISPLAY_RECT, rect1);
222 EXPECT_EQ(ZERO_RECT, rect2);
223 EXPECT_EQ(ZERO_RECT, rect3);
224 manager_.SetDisplayRects(DEFAULT_DISPLAY_RECT, VIRTUAL_DISPLAY_RECT, FOLD_CREASE_RECT);
225 const auto& [rect4, rect5, rect6] = manager_.GetDisplayRects();
226 EXPECT_EQ(DEFAULT_DISPLAY_RECT, rect4);
227 EXPECT_EQ(VIRTUAL_DISPLAY_RECT, rect5);
228 EXPECT_EQ(FOLD_CREASE_RECT, rect6);
229 }
230
231 /**
232 * @tc.name: UpdateSystemKeyboardStatus
233 * @tc.desc: test function : UpdateSystemKeyboardStatus, HasSystemKeyboard
234 * @tc.type: FUNC
235 */
236 HWTEST_F(PcFoldScreenManagerTest, UpdateSystemKeyboardStatus, Function | SmallTest | Level1)
237 {
238 manager_.UpdateSystemKeyboardStatus(true);
239 EXPECT_TRUE(manager_.HasSystemKeyboard());
240 manager_.UpdateSystemKeyboardStatus(false);
241 EXPECT_FALSE(manager_.HasSystemKeyboard());
242 }
243
244 /**
245 * @tc.name: CalculateScreenSide
246 * @tc.desc: test function : CalculateScreenSide
247 * @tc.type: FUNC
248 */
249 HWTEST_F(PcFoldScreenManagerTest, CalculateScreenSide, Function | SmallTest | Level1)
250 {
251 SetHalfFolded();
252 EXPECT_EQ(manager_.CalculateScreenSide(B_ACROSS_RECT), ScreenSide::FOLD_B);
253 EXPECT_EQ(manager_.CalculateScreenSide(C_ACROSS_RECT), ScreenSide::FOLD_C);
254 }
255
256 /**
257 * @tc.name: IsCrossFoldCrease
258 * @tc.desc: test function : IsCrossFoldCrease
259 * @tc.type: FUNC
260 */
261 HWTEST_F(PcFoldScreenManagerTest, IsCrossFoldCrease, Function | SmallTest | Level1)
262 {
263 SetHalfFolded();
264 EXPECT_FALSE(manager_.IsCrossFoldCrease(B_RECT));
265 EXPECT_TRUE(manager_.IsCrossFoldCrease(B_ACROSS_RECT));
266 }
267
268 /**
269 * @tc.name: ResetArrangeRule
270 * @tc.desc: test function : ResetArrangeRule, including overload functions
271 * @tc.type: FUNC
272 */
273 HWTEST_F(PcFoldScreenManagerTest, ResetArrangeRule, Function | SmallTest | Level2)
274 {
275 SetHalfFolded();
276 // param: rect
277 manager_.defaultArrangedRect_ = B_RECT;
278 manager_.virtualArrangedRect_ = C_RECT;
279 manager_.ResetArrangeRule(B_ACROSS_RECT);
280 EXPECT_EQ(ZERO_RECT, manager_.defaultArrangedRect_);
281 EXPECT_NE(ZERO_RECT, manager_.virtualArrangedRect_);
282 manager_.defaultArrangedRect_ = B_RECT;
283 manager_.virtualArrangedRect_ = C_RECT;
284 manager_.ResetArrangeRule(C_ACROSS_RECT);
285 EXPECT_NE(ZERO_RECT, manager_.defaultArrangedRect_);
286 EXPECT_EQ(ZERO_RECT, manager_.virtualArrangedRect_);
287
288 // param: void
289 manager_.defaultArrangedRect_ = B_RECT;
290 manager_.virtualArrangedRect_ = C_RECT;
291 manager_.ResetArrangeRule();
292 EXPECT_EQ(ZERO_RECT, manager_.defaultArrangedRect_);
293 EXPECT_EQ(ZERO_RECT, manager_.virtualArrangedRect_);
294
295 // param: side
296 manager_.defaultArrangedRect_ = B_RECT;
297 manager_.virtualArrangedRect_ = C_RECT;
298 manager_.ResetArrangeRule(ScreenSide::EXPAND);
299 EXPECT_NE(ZERO_RECT, manager_.defaultArrangedRect_);
300 EXPECT_NE(ZERO_RECT, manager_.virtualArrangedRect_);
301 manager_.defaultArrangedRect_ = B_RECT;
302 manager_.virtualArrangedRect_ = C_RECT;
303 manager_.ResetArrangeRule(ScreenSide::FOLD_B);
304 EXPECT_EQ(ZERO_RECT, manager_.defaultArrangedRect_);
305 EXPECT_NE(ZERO_RECT, manager_.virtualArrangedRect_);
306 manager_.defaultArrangedRect_ = B_RECT;
307 manager_.virtualArrangedRect_ = C_RECT;
308 manager_.ResetArrangeRule(ScreenSide::FOLD_C);
309 EXPECT_NE(ZERO_RECT, manager_.defaultArrangedRect_);
310 EXPECT_EQ(ZERO_RECT, manager_.virtualArrangedRect_);
311 }
312
313 /**
314 * @tc.name: ResizeToFullScreen
315 * @tc.desc: test function : ResizeToFullScreen
316 * @tc.type: FUNC
317 */
318 HWTEST_F(PcFoldScreenManagerTest, ResizeToFullScreen, Function | SmallTest | Level2)
319 {
320 SetHalfFolded();
321 WSRect rect = B_RECT;
322 manager_.ResizeToFullScreen(rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT);
323 EXPECT_EQ(rect, DEFAULT_FULLSCREEN_RECT);
324 rect = C_RECT;
325 manager_.ResizeToFullScreen(rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT);
326 EXPECT_EQ(rect, VIRTUAL_FULLSCREEN_RECT);
327 }
328
329 /**
330 * @tc.name: NeedDoThrowSlip
331 * @tc.desc: test function : NeedDoThrowSlip
332 * @tc.type: FUNC
333 */
334 HWTEST_F(PcFoldScreenManagerTest, NeedDoThrowSlip, Function | SmallTest | Level1)
335 {
336 SetHalfFolded();
337 // side B
338 ScreenSide throwSide = ScreenSide::FOLD_B;
339 EXPECT_TRUE(manager_.NeedDoThrowSlip(B_RECT, B_VELOCITY, throwSide));
340 EXPECT_FALSE(manager_.NeedDoThrowSlip(B_RECT, B_VELOCITY_SLOW, throwSide));
341 EXPECT_FALSE(manager_.NeedDoThrowSlip(B_RECT, B_VELOCITY_SKEW, throwSide));
342 // side C
343 throwSide = ScreenSide::FOLD_C;
344 EXPECT_TRUE(manager_.NeedDoThrowSlip(C_RECT, C_VELOCITY, throwSide));
345 EXPECT_FALSE(manager_.NeedDoThrowSlip(C_RECT, C_VELOCITY_SLOW, throwSide));
346 EXPECT_FALSE(manager_.NeedDoThrowSlip(C_RECT, C_VELOCITY_SKEW, throwSide));
347 }
348
349 /**
350 * @tc.name: NeedDoEasyThrowSlip
351 * @tc.desc: test function : NeedDoEasyThrowSlip
352 * @tc.type: FUNC
353 */
354 HWTEST_F(PcFoldScreenManagerTest, NeedDoEasyThrowSlip, Function | SmallTest | Level1)
355 {
356 SetHalfFolded();
357 // side B cross axis
358 WSRect startRectB = { 100, 100, 100, 20 };
359 WSRect rectB = { 100, SCREEN_HEIGHT_HALF + 90, 100, 20};
360 ScreenSide throwSide = ScreenSide::FOLD_C;
361 EXPECT_TRUE(manager_.NeedDoEasyThrowSlip(rectB, startRectB, B_VELOCITY, throwSide));
362 EXPECT_EQ(ScreenSide::FOLD_B, throwSide);
363 rectB = { 100, SCREEN_HEIGHT - 110, 100, 20};
364 throwSide = ScreenSide::FOLD_C;
365 EXPECT_FALSE(manager_.NeedDoEasyThrowSlip(rectB, startRectB, B_VELOCITY, throwSide));
366 EXPECT_EQ(ScreenSide::FOLD_C, throwSide);
367 // side C cross axis
368 WSRect startRectC = { 100, SCREEN_HEIGHT - 100, 100, 20 };
369 WSRect rectC = { 100, SCREEN_HEIGHT_HALF - 110, 100, 20};
370 throwSide = ScreenSide::FOLD_B;
371 EXPECT_TRUE(manager_.NeedDoEasyThrowSlip(rectC, startRectC, C_VELOCITY, throwSide));
372 EXPECT_EQ(ScreenSide::FOLD_C, throwSide);
373 rectC = { 100, 90, 100, 20};
374 throwSide = ScreenSide::FOLD_B;
375 EXPECT_FALSE(manager_.NeedDoEasyThrowSlip(rectC, startRectC, C_VELOCITY, throwSide));
376 EXPECT_EQ(ScreenSide::FOLD_B, throwSide);
377 }
378
379 /**
380 * @tc.name: CheckVelocityOrientation
381 * @tc.desc: test function : CheckVelocityOrientation
382 * @tc.type: FUNC
383 */
384 HWTEST_F(PcFoldScreenManagerTest, CheckVelocityOrientation, Function | SmallTest | Level1)
385 {
386 SetHalfFolded();
387 EXPECT_TRUE(manager_.CheckVelocityOrientation(B_RECT, B_VELOCITY));
388 EXPECT_FALSE(manager_.CheckVelocityOrientation(B_RECT, B_VELOCITY_SKEW));
389 WSRectF velocity1 = B_VELOCITY_SKEW;
390 velocity1.posX_ = -velocity1.posX_;
391 EXPECT_FALSE(manager_.CheckVelocityOrientation(B_RECT, velocity1));
392 EXPECT_TRUE(manager_.CheckVelocityOrientation(C_RECT, C_VELOCITY));
393 EXPECT_FALSE(manager_.CheckVelocityOrientation(C_RECT, C_VELOCITY_SKEW));
394 velocity1 = C_VELOCITY_SKEW;
395 velocity1.posX_ = -velocity1.posX_;
396 EXPECT_FALSE(manager_.CheckVelocityOrientation(C_RECT, velocity1));
397 }
398
399 /**
400 * @tc.name: CalculateThrowBacktracingRect
401 * @tc.desc: test function : CalculateThrowBacktracingRect
402 * @tc.type: FUNC
403 */
404 HWTEST_F(PcFoldScreenManagerTest, CalculateThrowBacktracingRect, Function | SmallTest | Level1)
405 {
406 SetHalfFolded();
407 // side B
408 WSRect rectB = { 100, SCREEN_HEIGHT_HALF + 90, 100, 20};
409 EXPECT_EQ(ScreenSide::FOLD_B,
410 manager_.CalculateScreenSide(manager_.CalculateThrowBacktracingRect(rectB, B_VELOCITY)));
411 rectB = { 100, SCREEN_HEIGHT - 110, 100, 20};
412 EXPECT_EQ(rectB, manager_.CalculateThrowBacktracingRect(rectB, B_VELOCITY));
413 // side C
414 WSRect rectC = { 100, SCREEN_HEIGHT_HALF - 110, 100, 20};
415 EXPECT_EQ(ScreenSide::FOLD_C,
416 manager_.CalculateScreenSide(manager_.CalculateThrowBacktracingRect(rectC, C_VELOCITY)));
417 rectC = { 100, 90, 100, 20};
418 EXPECT_EQ(rectC, manager_.CalculateThrowBacktracingRect(rectC, C_VELOCITY));
419 }
420
421 /**
422 * @tc.name: CalculateThrowEnd
423 * @tc.desc: test function : CalculateThrowEnd
424 * @tc.type: FUNC
425 */
426 HWTEST_F(PcFoldScreenManagerTest, CalculateThrowEnd, Function | SmallTest | Level1)
427 {
428 SetHalfFolded();
429 // side B
430 EXPECT_EQ(ScreenSide::FOLD_C, manager_.CalculateScreenSide(manager_.CalculateThrowEnd(B_RECT, B_VELOCITY)));
431 EXPECT_EQ(ScreenSide::FOLD_B, manager_.CalculateScreenSide(manager_.CalculateThrowEnd(B_RECT, B_VELOCITY_SLOW)));
432 // side C
433 EXPECT_EQ(ScreenSide::FOLD_B, manager_.CalculateScreenSide(manager_.CalculateThrowEnd(C_RECT, C_VELOCITY)));
434 EXPECT_EQ(ScreenSide::FOLD_C, manager_.CalculateScreenSide(manager_.CalculateThrowEnd(C_RECT, C_VELOCITY_SLOW)));
435 }
436
437 /**
438 * @tc.name: ThrowSlipToOppositeSide
439 * @tc.desc: test function : ThrowSlipToOppositeSide
440 * @tc.type: FUNC
441 */
442 HWTEST_F(PcFoldScreenManagerTest, ThrowSlipToOppositeSide, Function | SmallTest | Level1)
443 {
444 WSRect rect = B_RECT;
445 EXPECT_FALSE(manager_.ThrowSlipToOppositeSide(ScreenSide::EXPAND, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT, 0));
446 EXPECT_TRUE(manager_.ThrowSlipToOppositeSide(ScreenSide::FOLD_B, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT, 0));
447 rect = C_RECT;
448 EXPECT_TRUE(manager_.ThrowSlipToOppositeSide(ScreenSide::FOLD_C, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT, 0));
449 }
450
451 /**
452 * @tc.name: MappingRectInScreenSide
453 * @tc.desc: test function : MappingRectInScreenSide
454 * @tc.type: FUNC
455 */
456 HWTEST_F(PcFoldScreenManagerTest, MappingRectInScreenSide, Function | SmallTest | Level1)
457 {
458 // half folded
459 SetHalfFolded();
460 WSRect rect = B_ACROSS_RECT;
461 WSRect rectMapped = rect;
462 manager_.MappingRectInScreenSide(ScreenSide::FOLD_B, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT);
463 rectMapped.posY_ = FOLD_CREASE_RECT.posY_ - 400;
464 EXPECT_EQ(rect, rectMapped);
465
466 rect = B_TOP_RECT;
467 rectMapped = rect;
468 manager_.MappingRectInScreenSide(ScreenSide::FOLD_B, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT);
469 rectMapped.posY_ = TOP_AVOID_HEIGHT;
470 EXPECT_EQ(rect, rectMapped);
471
472 rect = C_ACROSS_RECT;
473 rectMapped = rect;
474 manager_.MappingRectInScreenSide(ScreenSide::FOLD_C, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT);
475 rectMapped.posY_ = FOLD_CREASE_RECT.posY_ + FOLD_CREASE_RECT.height_;
476 EXPECT_EQ(rect, rectMapped);
477
478 rect = C_BOT_RECT;
479 rectMapped = rect;
480 manager_.MappingRectInScreenSide(ScreenSide::FOLD_C, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT);
481 rectMapped.posY_ = SCREEN_HEIGHT - BOT_AVOID_HEIGHT - MIN_DECOR_HEIGHT * manager_.vpr_;
482 EXPECT_EQ(rect, rectMapped);
483
484 // flattened
485 SetExpanded();
486 rect = B_ACROSS_RECT;
487 rectMapped = rect;
488 manager_.MappingRectInScreenSide(ScreenSide::EXPAND, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT);
489 EXPECT_EQ(rect, rectMapped);
490 }
491
492 /**
493 * @tc.name: MappingRectInScreenSideWithArrangeRule1
494 * @tc.desc: test function : MappingRectInScreenSideWithArrangeRule + ApplyInitArrangeRule
495 * @tc.type: FUNC
496 */
497 HWTEST_F(PcFoldScreenManagerTest, MappingRectInScreenSideWithArrangeRule1, Function | SmallTest | Level1)
498 {
499 int32_t decorHeight = (MIN_DECOR_HEIGHT + MAX_DECOR_HEIGHT) / 2;
500
501 SetHalfFolded();
502 float vpr = manager_.vpr_;
503 WSRect rect = B_RECT;
504
505 // init arrange rule
506 manager_.defaultArrangedRect_ = ZERO_RECT;
507 rect = B_RECT;
508 manager_.MappingRectInScreenSideWithArrangeRule(ScreenSide::FOLD_B, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT,
509 decorHeight);
510 const int32_t centerBX = (DEFAULT_DISPLAY_RECT.width_ - B_RECT.width_) / 2;
511 const int32_t centerBY = TOP_AVOID_HEIGHT + (FOLD_CREASE_RECT.posY_ - TOP_AVOID_HEIGHT - B_RECT.height_) / 2;
512 EXPECT_EQ(rect, (WSRect { centerBX, centerBY, B_RECT.width_, B_RECT.height_ }));
513 EXPECT_EQ(manager_.defaultArrangedRect_,
514 (WSRect { centerBX, centerBY, RULE_TRANS_X * vpr, decorHeight * vpr }));
515
516 manager_.virtualArrangedRect_ = ZERO_RECT;
517 rect = C_RECT;
518 manager_.MappingRectInScreenSideWithArrangeRule(ScreenSide::FOLD_C, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT,
519 decorHeight);
520 const int32_t centerCX = (VIRTUAL_DISPLAY_RECT.width_ - C_RECT.width_) / 2;
521 const int32_t centerCY = FOLD_CREASE_RECT.posY_ + FOLD_CREASE_RECT.height_ +
522 (SCREEN_HEIGHT - FOLD_CREASE_RECT.posY_ - FOLD_CREASE_RECT.height_ - BOT_AVOID_HEIGHT - C_RECT.height_) / 2;
523 EXPECT_EQ(rect, (WSRect { centerCX, centerCY, C_RECT.width_, C_RECT.height_ }));
524 EXPECT_EQ(manager_.virtualArrangedRect_,
525 (WSRect { centerCX, centerCY, RULE_TRANS_X * vpr, decorHeight * vpr }));
526 }
527
528 /**
529 * @tc.name: MappingRectInScreenSideWithArrangeRule2
530 * @tc.desc: test function : MappingRectInScreenSideWithArrangeRule + ApplyArrangeRule, normal arrange rule
531 * @tc.type: FUNC
532 */
533 HWTEST_F(PcFoldScreenManagerTest, MappingRectInScreenSideWithArrangeRule2, Function | SmallTest | Level1)
534 {
535 int32_t decorHeight = (MIN_DECOR_HEIGHT + MAX_DECOR_HEIGHT) / 2;
536
537 SetHalfFolded();
538 float vpr = manager_.vpr_;
539 WSRect rect = B_RECT;
540
541 // normal arrange rule
542 manager_.defaultArrangedRect_ = WSRect { 100, 100, RULE_TRANS_X * vpr, 100 * vpr };
543 rect = B_RECT;
544 manager_.MappingRectInScreenSideWithArrangeRule(ScreenSide::FOLD_B, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT,
545 decorHeight);
546 EXPECT_EQ(rect, (WSRect { 100 + RULE_TRANS_X * vpr, 100 + 100 * vpr, B_RECT.width_, B_RECT.height_ }));
547 EXPECT_EQ(manager_.defaultArrangedRect_,
548 (WSRect { 100 + RULE_TRANS_X * vpr, 100 + 100 * vpr, RULE_TRANS_X * vpr, decorHeight * vpr }));
549
550 manager_.virtualArrangedRect_ = WSRect { 100, SCREEN_HEIGHT_HALF + 100, RULE_TRANS_X * vpr, 100 * vpr };
551 rect = C_RECT;
552 manager_.MappingRectInScreenSideWithArrangeRule(ScreenSide::FOLD_C, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT,
553 decorHeight);
554 EXPECT_EQ(rect,
555 (WSRect { 100 + RULE_TRANS_X * vpr, SCREEN_HEIGHT_HALF + 100 + 100 * vpr, C_RECT.width_, C_RECT.height_ }));
556 EXPECT_EQ(manager_.virtualArrangedRect_,
557 (WSRect { 100 + RULE_TRANS_X * vpr, SCREEN_HEIGHT_HALF + 100 + 100 * vpr,
558 RULE_TRANS_X * vpr, decorHeight * vpr }));
559 }
560
561 /**
562 * @tc.name: MappingRectInScreenSideWithArrangeRule3
563 * @tc.desc: test function : MappingRectInScreenSideWithArrangeRule + ApplyArrangeRule, special arrange rule
564 * @tc.type: FUNC
565 */
566 HWTEST_F(PcFoldScreenManagerTest, MappingRectInScreenSideWithArrangeRule3, Function | SmallTest | Level1)
567 {
568 int32_t decorHeight = (MIN_DECOR_HEIGHT + MAX_DECOR_HEIGHT) / 2;
569
570 SetHalfFolded();
571 float vpr = manager_.vpr_;
572 WSRect rect = B_RECT;
573 int32_t virtualPosY = FOLD_CREASE_RECT.posY_ + FOLD_CREASE_RECT.height_;
574
575 // new column rule
576 manager_.defaultArrangedRect_ = WSRect { 100, SCREEN_HEIGHT_HALF - 200, RULE_TRANS_X * vpr, 100 * vpr };
577 rect = B_RECT;
578 manager_.MappingRectInScreenSideWithArrangeRule(ScreenSide::FOLD_B, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT,
579 decorHeight);
580 EXPECT_EQ(rect, (WSRect { 100 + RULE_TRANS_X * vpr, TOP_AVOID_HEIGHT, B_RECT.width_, B_RECT.height_ }));
581 EXPECT_EQ(manager_.defaultArrangedRect_,
582 (WSRect { 100 + RULE_TRANS_X * vpr, TOP_AVOID_HEIGHT, RULE_TRANS_X * vpr, decorHeight * vpr }));
583
584 manager_.virtualArrangedRect_ = WSRect { 100, SCREEN_HEIGHT - 200, RULE_TRANS_X * vpr, 100 * vpr };
585 rect = C_RECT;
586 manager_.MappingRectInScreenSideWithArrangeRule(ScreenSide::FOLD_C, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT,
587 decorHeight);
588 EXPECT_EQ(rect,
589 (WSRect { 100 + RULE_TRANS_X * vpr, virtualPosY, C_RECT.width_, C_RECT.height_ }));
590 EXPECT_EQ(manager_.virtualArrangedRect_,
591 (WSRect { 100 + RULE_TRANS_X * vpr, virtualPosY, RULE_TRANS_X * vpr, decorHeight * vpr }));
592
593 // reset rule
594 manager_.defaultArrangedRect_ = WSRect { SCREEN_WIDTH - 200, 100, RULE_TRANS_X * vpr, 100 * vpr };
595 rect = B_RECT;
596 manager_.MappingRectInScreenSideWithArrangeRule(ScreenSide::FOLD_B, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT,
597 decorHeight);
598 EXPECT_EQ(rect, (WSRect { 0, TOP_AVOID_HEIGHT, B_RECT.width_, B_RECT.height_ }));
599 EXPECT_EQ(manager_.defaultArrangedRect_,
600 (WSRect { 0, TOP_AVOID_HEIGHT, RULE_TRANS_X * vpr, decorHeight * vpr }));
601
602 manager_.virtualArrangedRect_ = WSRect { SCREEN_WIDTH - 200, 100, RULE_TRANS_X * vpr, 100 * vpr };
603 rect = C_RECT;
604 manager_.MappingRectInScreenSideWithArrangeRule(ScreenSide::FOLD_C, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT,
605 decorHeight);
606 EXPECT_EQ(rect, (WSRect { 0, virtualPosY, C_RECT.width_, C_RECT.height_ }));
607 EXPECT_EQ(manager_.virtualArrangedRect_,
608 (WSRect { 0, virtualPosY, RULE_TRANS_X * vpr, decorHeight * vpr }));
609 }
610
611 /**
612 * @tc.name: RegisterFoldScreenStatusChangeCallback
613 * @tc.desc: test function : RegisterFoldScreenStatusChangeCallback, UnregisterFoldScreenStatusChangeCallback
614 * @tc.type: FUNC
615 */
616 HWTEST_F(PcFoldScreenManagerTest, RegisterFoldScreenStatusChangeCallback, Function | SmallTest | Level2)
617 {
618 auto& callbacks = manager_.foldScreenStatusChangeCallbacks_;
619 callbacks.clear();
620 EXPECT_EQ(callbacks.size(), 0);
621 int32_t persistentId = 100;
622 auto func = std::make_shared<FoldScreenStatusChangeCallback>(
__anonfe5706d20302(DisplayId displayId, SuperFoldStatus status, SuperFoldStatus prevStatus) 623 [](DisplayId displayId, SuperFoldStatus status, SuperFoldStatus prevStatus) {}
624 );
625 manager_.RegisterFoldScreenStatusChangeCallback(persistentId, std::weak_ptr<FoldScreenStatusChangeCallback>(func));
626 EXPECT_NE(callbacks.find(persistentId), callbacks.end());
627 manager_.UnregisterFoldScreenStatusChangeCallback(persistentId);
628 EXPECT_EQ(callbacks.find(persistentId), callbacks.end());
629 }
630
631 /**
632 * @tc.name: ExecuteFoldScreenStatusChangeCallbacks
633 * @tc.desc: test function : ExecuteFoldScreenStatusChangeCallbacks
634 * @tc.type: FUNC
635 */
636 HWTEST_F(PcFoldScreenManagerTest, ExecuteFoldScreenStatusChangeCallbacks, Function | SmallTest | Level2)
637 {
638 auto& callbacks = manager_.foldScreenStatusChangeCallbacks_;
639 callbacks.clear();
640 EXPECT_EQ(callbacks.size(), 0);
641 int32_t persistentId = 100;
642 DisplayId testDisplayId = 0;
643 SuperFoldStatus testStatus = SuperFoldStatus::UNKNOWN;
644 SuperFoldStatus testPrevStatus = SuperFoldStatus::UNKNOWN;
645 auto func = std::make_shared<FoldScreenStatusChangeCallback>(
646 [&testDisplayId, &testStatus, &testPrevStatus](DisplayId displayId,
__anonfe5706d20402(DisplayId displayId, SuperFoldStatus status, SuperFoldStatus prevStatus) 647 SuperFoldStatus status, SuperFoldStatus prevStatus) {
648 testDisplayId = displayId;
649 testStatus = status;
650 testPrevStatus = prevStatus;
651 }
652 );
653 manager_.RegisterFoldScreenStatusChangeCallback(persistentId, std::weak_ptr<FoldScreenStatusChangeCallback>(func));
654 EXPECT_NE(callbacks.find(persistentId), callbacks.end());
655 manager_.ExecuteFoldScreenStatusChangeCallbacks(100, SuperFoldStatus::EXPANDED, SuperFoldStatus::HALF_FOLDED);
656 EXPECT_EQ(testDisplayId, 100);
657 EXPECT_EQ(testStatus, SuperFoldStatus::EXPANDED);
658 EXPECT_EQ(testPrevStatus, SuperFoldStatus::HALF_FOLDED);
659 }
660
661 /**
662 * @tc.name: RegisterSystemKeyboardStatusChangeCallback
663 * @tc.desc: test function : RegisterSystemKeyboardStatusChangeCallback, UnregisterSystemKeyboardStatusChangeCallback
664 * @tc.type: FUNC
665 */
666 HWTEST_F(PcFoldScreenManagerTest, RegisterSystemKeyboardStatusChangeCallback, Function | SmallTest | Level2)
667 {
668 auto& callbacks = manager_.systemKeyboardStatusChangeCallbacks_;
669 callbacks.clear();
670 EXPECT_EQ(callbacks.size(), 0);
671 int32_t persistentId = 100;
672 auto func = std::make_shared<SystemKeyboardStatusChangeCallback>(
__anonfe5706d20502(DisplayId displayId, bool hasSystemKeyboard) 673 [](DisplayId displayId, bool hasSystemKeyboard) {}
674 );
675 manager_.RegisterSystemKeyboardStatusChangeCallback(persistentId,
676 std::weak_ptr<SystemKeyboardStatusChangeCallback>(func));
677 EXPECT_NE(callbacks.find(persistentId), callbacks.end());
678 manager_.UnregisterSystemKeyboardStatusChangeCallback(persistentId);
679 EXPECT_EQ(callbacks.find(persistentId), callbacks.end());
680 }
681
682 /**
683 * @tc.name: ExecuteSystemKeyboardStatusChangeCallbacks
684 * @tc.desc: test function : ExecuteSystemKeyboardStatusChangeCallbacks
685 * @tc.type: FUNC
686 */
687 HWTEST_F(PcFoldScreenManagerTest, ExecuteSystemKeyboardStatusChangeCallbacks, Function | SmallTest | Level2)
688 {
689 auto& callbacks = manager_.systemKeyboardStatusChangeCallbacks_;
690 callbacks.clear();
691 EXPECT_EQ(callbacks.size(), 0);
692 int32_t persistentId = 100;
693 DisplayId testDisplayId = 0;
694 bool testStatus = false;
695 auto func = std::make_shared<SystemKeyboardStatusChangeCallback>(
__anonfe5706d20602(DisplayId displayId, bool hasSystemKeyboard) 696 [&testDisplayId, &testStatus](DisplayId displayId, bool hasSystemKeyboard) {
697 testDisplayId = displayId;
698 testStatus = hasSystemKeyboard;
699 }
700 );
701 manager_.RegisterSystemKeyboardStatusChangeCallback(persistentId,
702 std::weak_ptr<SystemKeyboardStatusChangeCallback>(func));
703 EXPECT_NE(callbacks.find(persistentId), callbacks.end());
704 manager_.ExecuteSystemKeyboardStatusChangeCallbacks(100, true);
705 EXPECT_EQ(testDisplayId, 100);
706 EXPECT_EQ(testStatus, true);
707 }
708
709 /**
710 * @tc.name: GetVpr
711 * @tc.desc: test function : GetVpr
712 * @tc.type: FUNC
713 */
714 HWTEST_F(PcFoldScreenManagerTest, GetVpr, Function | SmallTest | Level2)
715 {
716 manager_.vpr_ = 1.0;
717 EXPECT_TRUE(MathHelper::NearZero(manager_.GetVpr() - 1.0));
718 }
719
720 /**
721 * @tc.name: IsAllowThrowSlip
722 * @tc.desc: test function : IsAllowThrowSlip, IsStartFullScreen
723 * @tc.type: FUNC
724 */
725 HWTEST_F(PcFoldScreenControllerTest, IsAllowThrowSlip, Function | SmallTest | Level1)
726 {
727 SetExpanded();
728 EXPECT_FALSE(controller_->IsAllowThrowSlip(DEFAULT_SCREEN_ID));
729 SetHalfFolded();
730 manager_.UpdateSystemKeyboardStatus(false);
731 EXPECT_TRUE(controller_->IsAllowThrowSlip(DEFAULT_SCREEN_ID));
732 manager_.UpdateSystemKeyboardStatus(true);
733 EXPECT_FALSE(controller_->IsAllowThrowSlip(DEFAULT_SCREEN_ID));
734
735 // sub session
736 SetHalfFolded();
737 manager_.UpdateSystemKeyboardStatus(false);
738 SessionInfo subInfo;
739 subInfo.abilityName_ = "SubSession";
740 subInfo.bundleName_ = "SubSession";
741 sptr<SubSession> subSession = sptr<SubSession>::MakeSptr(subInfo, nullptr);
742 ASSERT_NE(subSession, nullptr);
743 ASSERT_NE(subSession->pcFoldScreenController_, nullptr);
744 subSession->GetSessionProperty()->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
745 const auto& subController = subSession->pcFoldScreenController_;
746 subSession->property_->SetDecorEnable(true);
747 EXPECT_TRUE(subController->IsAllowThrowSlip(DEFAULT_SCREEN_ID));
748 subSession->property_->SetDecorEnable(false);
749 EXPECT_FALSE(subController->IsAllowThrowSlip(DEFAULT_SCREEN_ID));
750 }
751
752 /**
753 * @tc.name: OnConnect
754 * @tc.desc: test function : OnConnect
755 * @tc.type: FUNC
756 */
757 HWTEST_F(PcFoldScreenControllerTest, OnConnect, Function | SmallTest | Level2)
758 {
759 mainSession_->sessionInfo_.screenId_ = DEFAULT_DISPLAY_ID;
760 SetExpanded();
761 controller_->OnConnect();
762 EXPECT_FALSE(controller_->supportEnterWaterfallMode_);
763 controller_->onFoldScreenStatusChangeCallback_ = nullptr;
764 controller_->onSystemKeyboardStatusChangeCallback_ = nullptr;
765 SetExpanded();
766 controller_->OnConnect();
767 EXPECT_FALSE(controller_->supportEnterWaterfallMode_);
768 }
769
770 /**
771 * @tc.name: RecordStartMoveRect
772 * @tc.desc: test function : RecordStartMoveRect, IsStartFullScreen
773 * @tc.type: FUNC
774 */
775 HWTEST_F(PcFoldScreenControllerTest, RecordStartMoveRect, Function | SmallTest | Level2)
776 {
777 WSRect rect = { 100, 100, 200, 200 };
778 controller_->RecordStartMoveRect(rect, true);
779 EXPECT_EQ(controller_->startMoveRect_, rect);
780 EXPECT_TRUE(controller_->IsStartFullScreen());
781 EXPECT_FALSE(controller_->isStartDirectly_);
782 }
783
784 /**
785 * @tc.name: RecordStartMoveRectDirectly
786 * @tc.desc: test function : RecordStartMoveRectDirectly, IsStartFullScreen
787 * @tc.type: FUNC
788 */
789 HWTEST_F(PcFoldScreenControllerTest, RecordStartMoveRectDirectly, Function | SmallTest | Level1)
790 {
791 WSRect rect = { 100, 100, 200, 200 };
792 controller_->RecordStartMoveRectDirectly(rect, B_VELOCITY, true);
793 EXPECT_EQ(controller_->startMoveRect_, rect);
794 EXPECT_TRUE(controller_->IsStartFullScreen());
795 EXPECT_TRUE(controller_->isStartDirectly_);
796 EXPECT_TRUE(MathHelper::GreatNotEqual(controller_->startVelocity_.posY_, 0.0f));
797 }
798
799 /**
800 * @tc.name: RecordMoveRects
801 * @tc.desc: test function : RecordMoveRects
802 * @tc.type: FUNC
803 */
804 HWTEST_F(PcFoldScreenControllerTest, RecordMoveRects, Function | SmallTest | Level2)
805 {
806 WSRect rect = ZERO_RECT;
807 for (int i = 0; i < MOVING_RECORDS_SIZE_LIMIT; ++i) {
808 controller_->RecordMoveRects(rect);
809 EXPECT_EQ(i + 1, controller_->movingRectRecords_.size());
810 }
811 controller_->RecordMoveRects(rect);
812 EXPECT_EQ(MOVING_RECORDS_SIZE_LIMIT, controller_->movingRectRecords_.size());
813 usleep(2 * MOVING_RECORDS_TIME_LIMIT_IN_NS);
814 controller_->RecordMoveRects(rect);
815 EXPECT_EQ(1, controller_->movingRectRecords_.size());
816 }
817
818 /**
819 * @tc.name: ThrowSlip1
820 * @tc.desc: test function : ThrowSlip in B
821 * @tc.type: FUNC
822 */
823 HWTEST_F(PcFoldScreenControllerTest, ThrowSlip1, Function | SmallTest | Level1)
824 {
825 SetHalfFolded();
826 WSRect rect0 = B_RECT;
827 WSRect rect = ZERO_RECT;
828
829 // throw
830 controller_->RecordStartMoveRect(rect0, false);
831 controller_->RecordMoveRects(rect0);
832 usleep(10000);
833 rect = rect0;
834 rect.posY_ += 400;
835 controller_->RecordMoveRects(rect);
836 EXPECT_TRUE(controller_->ThrowSlip(DEFAULT_SCREEN_ID, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT));
837
838 // throw failed
839 controller_->movingRectRecords_.clear();
840 controller_->RecordStartMoveRect(rect0, false);
841 controller_->RecordMoveRects(rect0);
842 usleep(10000);
843 rect = rect0;
844 rect.posY_ += 1;
845 controller_->RecordMoveRects(rect);
846 EXPECT_FALSE(controller_->ThrowSlip(DEFAULT_SCREEN_ID, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT));
847 }
848
849 /**
850 * @tc.name: ThrowSlip2
851 * @tc.desc: test function : ThrowSlip in C
852 * @tc.type: FUNC
853 */
854 HWTEST_F(PcFoldScreenControllerTest, ThrowSlip2, Function | SmallTest | Level1)
855 {
856 SetHalfFolded();
857 WSRect rect0 = { 100, SCREEN_HEIGHT - 500, 400, 400 };
858 WSRect rect = ZERO_RECT;
859
860 // throw
861 controller_->RecordStartMoveRect(rect0, false);
862 controller_->RecordMoveRects(rect0);
863 usleep(10000);
864 rect = rect0;
865 rect.posY_ -= 400;
866 controller_->RecordMoveRects(rect);
867 EXPECT_TRUE(controller_->ThrowSlip(DEFAULT_SCREEN_ID, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT));
868
869 // throw failed
870 controller_->movingRectRecords_.clear();
871 controller_->RecordStartMoveRect(rect0, false);
872 controller_->RecordMoveRects(rect0);
873 usleep(10000);
874 rect = rect0;
875 rect.posY_ -= 1;
876 controller_->RecordMoveRects(rect);
877 EXPECT_FALSE(controller_->ThrowSlip(DEFAULT_SCREEN_ID, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT));
878 }
879
880 /**
881 * @tc.name: ThrowSlip3
882 * @tc.desc: test function : ThrowSlip when flattened
883 * @tc.type: FUNC
884 */
885 HWTEST_F(PcFoldScreenControllerTest, ThrowSlip3, Function | SmallTest | Level1)
886 {
887 SetExpanded();
888 WSRect rect0 = B_RECT;
889 WSRect rect = ZERO_RECT;
890
891 // throw failed
892 controller_->RecordStartMoveRect(rect0, false);
893 controller_->RecordMoveRects(rect0);
894 usleep(10000);
895 rect = rect0;
896 rect.posY_ += 400;
897 controller_->RecordMoveRects(rect);
898 EXPECT_FALSE(controller_->ThrowSlip(DEFAULT_SCREEN_ID, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT));
899 }
900
901 /**
902 * @tc.name: ThrowSlip4
903 * @tc.desc: test function : ThrowSlip waterfall mode directly
904 * @tc.type: FUNC
905 */
906 HWTEST_F(PcFoldScreenControllerTest, ThrowSlip4, Function | SmallTest | Level1)
907 {
908 SetHalfFolded();
909 WSRect rect = DISPLAY_RECT;
910 // throw to B side
911 controller_->isFullScreenWaterfallMode_ = true;
912 controller_->RecordStartMoveRectDirectly(rect, B_VELOCITY, true);
913 EXPECT_TRUE(controller_->ThrowSlip(DEFAULT_SCREEN_ID, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT));
914 EXPECT_EQ(ScreenSide::FOLD_C, manager_.CalculateScreenSide(rect));
915 // throw to C side
916 rect = DISPLAY_RECT;
917 controller_->isFullScreenWaterfallMode_ = true;
918 controller_->RecordStartMoveRectDirectly(rect, C_VELOCITY, true);
919 EXPECT_TRUE(controller_->ThrowSlip(DEFAULT_SCREEN_ID, rect, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT));
920 EXPECT_EQ(ScreenSide::FOLD_C, manager_.CalculateScreenSide(rect));
921 }
922
923 /**
924 * @tc.name: ThrowSlipFloatingRectDirectly
925 * @tc.desc: test function : ThrowSlipFloatingRectDirectly
926 * @tc.type: FUNC
927 */
928 HWTEST_F(PcFoldScreenControllerTest, ThrowSlipFloatingRectDirectly, Function | SmallTest | Level1)
929 {
930 SetHalfFolded();
931 WSRect rect = DEFAULT_FULLSCREEN_RECT;
932 controller_->ThrowSlipFloatingRectDirectly(rect, B_RECT, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT);
933 EXPECT_EQ(B_RECT, rect);
934 rect = VIRTUAL_FULLSCREEN_RECT;
935 controller_->ThrowSlipFloatingRectDirectly(rect, B_RECT, TOP_AVOID_HEIGHT, BOT_AVOID_HEIGHT);
936 EXPECT_EQ(ScreenSide::FOLD_C, manager_.CalculateScreenSide(rect));
937 }
938
939 /**
940 * @tc.name: IsThrowSlipDirectly
941 * @tc.desc: test function : IsThrowSlipDirectly
942 * @tc.type: FUNC
943 */
944 HWTEST_F(PcFoldScreenControllerTest, IsThrowSlipDirectly, Function | SmallTest | Level1)
945 {
946 controller_->isStartDirectly_ = true;
947 EXPECT_TRUE(controller_->IsThrowSlipDirectly());
948 }
949
950 /**
951 * @tc.name: UpdateFullScreenWaterfallMode
952 * @tc.desc: test function : UpdateFullScreenWaterfallMode, IsFullScreenWaterfallMode
953 * @tc.type: FUNC
954 */
955 HWTEST_F(PcFoldScreenControllerTest, UpdateFullScreenWaterfallMode, Function | SmallTest | Level2)
956 {
957 controller_->UpdateFullScreenWaterfallMode(true);
958 std::this_thread::sleep_for(std::chrono::milliseconds(100));
959 EXPECT_TRUE(controller_->IsFullScreenWaterfallMode());
960 controller_->UpdateFullScreenWaterfallMode(false);
961 std::this_thread::sleep_for(std::chrono::milliseconds(100));
962 EXPECT_FALSE(controller_->IsFullScreenWaterfallMode());
963 }
964
965 /**
966 * @tc.name: RegisterFullScreenWaterfallModeChangeCallback
967 * @tc.desc: test function : RegisterFullScreenWaterfallModeChangeCallback
968 * @tc.desc: test function : UnregisterFullScreenWaterfallModeChangeCallback
969 * @tc.desc: test function : ExecuteFullScreenWaterfallModeChangeCallback
970 * @tc.type: FUNC
971 */
972 HWTEST_F(PcFoldScreenControllerTest, RegisterFullScreenWaterfallModeChangeCallback, Function | SmallTest | Level2)
973 {
974 // register and unregister
__anonfe5706d20702(bool isWaterfallMode) 975 auto func1 = [](bool isWaterfallMode) {};
976 controller_->RegisterFullScreenWaterfallModeChangeCallback(std::move(func1));
977 ASSERT_NE(controller_->fullScreenWaterfallModeChangeCallback_, nullptr);
978 controller_->UnregisterFullScreenWaterfallModeChangeCallback();
979 ASSERT_EQ(controller_->fullScreenWaterfallModeChangeCallback_, nullptr);
980
981 // register and execute
982 controller_->isFullScreenWaterfallMode_ = true;
983 bool testWaterfallMode = false;
__anonfe5706d20802(bool isWaterfallMode) 984 auto func2 = [&testWaterfallMode](bool isWaterfallMode) {
985 testWaterfallMode = isWaterfallMode;
986 };
987 controller_->RegisterFullScreenWaterfallModeChangeCallback(std::move(func2));
988 ASSERT_NE(controller_->fullScreenWaterfallModeChangeCallback_, nullptr);
989 EXPECT_TRUE(testWaterfallMode);
990 controller_->isFullScreenWaterfallMode_ = false;
991 controller_->ExecuteFullScreenWaterfallModeChangeCallback();
992 EXPECT_FALSE(testWaterfallMode);
993 }
994
995 /**
996 * @tc.name: UpdateSupportEnterWaterfallMode
997 * @tc.desc: test function : UpdateSupportEnterWaterfallMode
998 * @tc.type: FUNC
999 */
1000 HWTEST_F(PcFoldScreenControllerTest, UpdateSupportEnterWaterfallMode, Function | SmallTest | Level3)
1001 {
1002 controller_->lastSupportEnterWaterfallMode_ = false;
1003 controller_->maskSupportEnterWaterfallMode_ = true;
1004 controller_->supportEnterWaterfallMode_ = true;
1005 controller_->UpdateSupportEnterWaterfallMode();
1006 EXPECT_NE(controller_->lastSupportEnterWaterfallMode_, controller_->supportEnterWaterfallMode_);
1007 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr();
1008 controller_->maskSupportEnterWaterfallMode_ = false;
1009 mainSession_->sessionStage_ = mockSessionStage;
1010 controller_->UpdateSupportEnterWaterfallMode();
1011 EXPECT_EQ(controller_->lastSupportEnterWaterfallMode_, controller_->supportEnterWaterfallMode_);
1012 }
1013
1014 /**
1015 * @tc.name: MaskSupportEnterWaterfallMode
1016 * @tc.desc: test function : MaskSupportEnterWaterfallMode
1017 * Test Procedure
1018 * step1: test maskSupportEnterWaterfallMode_ default is false
1019 * step2: test after invoking MaskSupportEnterWaterfallMode
1020 * expect maskSupportEnterWaterfallMode_ is true
1021 * @tc.type: FUNC
1022 */
1023 HWTEST_F(PcFoldScreenControllerTest, MaskSupportEnterWaterfallMode, Function | SmallTest | Level3)
1024 {
1025 controller_->maskSupportEnterWaterfallMode_ = false;
1026 EXPECT_FALSE(controller_->maskSupportEnterWaterfallMode_);
1027 controller_->MaskSupportEnterWaterfallMode();
1028 EXPECT_TRUE(controller_->maskSupportEnterWaterfallMode_);
1029 }
1030
1031 /**
1032 * @tc.name: GetPersistentId
1033 * @tc.desc: test function : GetPersistentId
1034 * @tc.type: FUNC
1035 */
1036 HWTEST_F(PcFoldScreenControllerTest, GetPersistentId, Function | SmallTest | Level3)
1037 {
1038 controller_->persistentId_ = 100;
1039 EXPECT_EQ(mainSession_->pcFoldScreenController_->GetPersistentId(), 100);
1040 }
1041
1042 /**
1043 * @tc.name: GetDisplayId
1044 * @tc.desc: test function : GetDisplayId
1045 * @tc.type: FUNC
1046 */
1047 HWTEST_F(PcFoldScreenControllerTest, GetDisplayId, Function | SmallTest | Level3)
1048 {
1049 mainSession_->sessionInfo_.screenId_ = 100;
1050 EXPECT_EQ(100, controller_->GetDisplayId());
1051 mainSession_ = nullptr;
1052 EXPECT_EQ(SCREEN_ID_INVALID, controller_->GetDisplayId());
1053 }
1054
1055 /**
1056 * @tc.name: GetTitleHeight
1057 * @tc.desc: test function : GetTitleHeight
1058 * @tc.type: FUNC
1059 */
1060 HWTEST_F(PcFoldScreenControllerTest, GetTitleHeight, Function | SmallTest | Level2)
1061 {
1062 // min
1063 mainSession_->customDecorHeight_ = MIN_DECOR_HEIGHT - 10;
1064 EXPECT_EQ(controller_->GetTitleHeight(), MIN_DECOR_HEIGHT);
1065 // normal
1066 const int32_t height = (MIN_DECOR_HEIGHT + MAX_DECOR_HEIGHT) / 2;
1067 mainSession_->customDecorHeight_ = height;
1068 EXPECT_EQ(controller_->GetTitleHeight(), height);
1069 // max
1070 mainSession_->customDecorHeight_ = MAX_DECOR_HEIGHT + 10;
1071 EXPECT_EQ(controller_->GetTitleHeight(), MAX_DECOR_HEIGHT);
1072 }
1073
1074 /**
1075 * @tc.name: CalculateMovingVelocity
1076 * @tc.desc: test function : CalculateMovingVelocity
1077 * @tc.type: FUNC
1078 */
1079 HWTEST_F(PcFoldScreenControllerTest, CalculateMovingVelocity, Function | SmallTest | Level1)
1080 {
1081 SetHalfFolded();
1082 WSRect rect0 = { 100, SCREEN_HEIGHT - 500, 400, 400 };
1083 WSRect rect = ZERO_RECT;
1084 int32_t dt = 50;
1085 float err = 0.05f;
1086
1087 // throw
1088 controller_->RecordStartMoveRect(rect0, false);
1089 controller_->RecordMoveRects(rect0);
1090 auto t0 = std::chrono::high_resolution_clock::now();
1091 usleep(dt * 1000);
1092 rect = rect0;
1093 rect.posX_ += dt;
1094 rect.posY_ += dt;
1095 rect.width_ += dt;
1096 rect.height_ += dt;
1097 controller_->RecordMoveRects(rect);
1098 auto t1 = std::chrono::high_resolution_clock::now();
1099 float ratio = float(TimeHelper::GetDuration(t0, t1)) / float(dt);
1100 WSRectF velocity = controller_->CalculateMovingVelocity();
1101 EXPECT_LE(std::abs(velocity.posX_ - ratio), err);
1102 EXPECT_LE(std::abs(velocity.posY_ - ratio), err);
1103 EXPECT_LE(std::abs(velocity.width_ - ratio), err);
1104 EXPECT_LE(std::abs(velocity.height_ - ratio), err);
1105
1106 // throw directly
1107 controller_->RecordStartMoveRectDirectly(rect0, B_VELOCITY, false);
1108 EXPECT_EQ(controller_->startVelocity_, controller_->CalculateMovingVelocity());
1109 }
1110
1111 /**
1112 * @tc.name: IsSupportEnterWaterfallMode
1113 * @tc.desc: test function : IsSupportEnterWaterfallMode
1114 * @tc.type: FUNC
1115 */
1116 HWTEST_F(PcFoldScreenControllerTest, IsSupportEnterWaterfallMode, Function | SmallTest | Level2)
1117 {
1118 EXPECT_TRUE(controller_->IsSupportEnterWaterfallMode(SuperFoldStatus::HALF_FOLDED, false));
1119 EXPECT_FALSE(controller_->IsSupportEnterWaterfallMode(SuperFoldStatus::HALF_FOLDED, true));
1120 EXPECT_FALSE(controller_->IsSupportEnterWaterfallMode(SuperFoldStatus::EXPANDED, false));
1121 }
1122 }
1123 }
1124 }