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