1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstdint>
17 #include <memory>
18 #include <utility>
19
20 #include "gtest/gtest.h"
21
22 #include "base/geometry/ng/size_t.h"
23 #include "base/geometry/offset.h"
24 #include "base/memory/ace_type.h"
25 #define private public
26 #define protected public
27 #include "test/mock/base/mock_task_executor.h"
28 #include "test/mock/core/common/mock_container.h"
29 #include "test/mock/core/common/mock_theme_manager.h"
30 #include "test/mock/core/pipeline/mock_pipeline_context.h"
31 #include "test/mock/core/rosen/mock_canvas.h"
32 #include "test/unittest/core/pattern/test_ng.h"
33
34 #include "core/animation/animator.h"
35 #include "core/components/common/layout/grid_system_manager.h"
36 #include "core/components/common/properties/color.h"
37 #include "core/components/scroll/scroll_bar_theme.h"
38 #include "core/components_ng/base/view_abstract.h"
39 #include "core/components_ng/base/view_abstract_model_ng.h"
40 #include "core/components_ng/base/view_stack_processor.h"
41 #include "core/components_ng/layout/layout_wrapper.h"
42 #include "core/components_ng/pattern/linear_layout/column_model_ng.h"
43 #include "core/components_ng/pattern/linear_layout/row_model_ng.h"
44 #include "core/components_ng/pattern/pattern.h"
45 #include "core/components_ng/pattern/scroll/effect/scroll_fade_effect.h"
46 #include "core/components_ng/pattern/scroll/scroll_model_ng.h"
47 #include "core/components_ng/pattern/scroll/scroll_pattern.h"
48 #include "core/components_ng/pattern/scroll/scroll_spring_effect.h"
49 #include "core/components_ng/pattern/scrollable/scrollable_paint_property.h"
50 #include "core/components_v2/inspector/inspector_constants.h"
51 #include "core/pipeline/base/constants.h"
52
53 using namespace testing;
54 using namespace testing::ext;
55
56 namespace OHOS::Ace::NG {
57 namespace {
58 constexpr float SCROLL_WIDTH = 480.f;
59 constexpr float SCROLL_HEIGHT = 800.f;
60 constexpr int32_t TOTAL_LINE_NUMBER = 10;
61 constexpr int32_t VIEW_LINE_NUMBER = 8;
62 constexpr float DEFAULT_ACTIVE_WIDTH = 8.0f;
63 constexpr float DEFAULT_INACTIVE_WIDTH = 4.0f;
64 constexpr float DEFAULT_NORMAL_WIDTH = 4.0f;
65 constexpr float DEFAULT_TOUCH_WIDTH = 32.0f;
66 constexpr float ITEM_WIDTH = SCROLL_WIDTH / VIEW_LINE_NUMBER;
67 constexpr float ITEM_HEIGHT = SCROLL_HEIGHT / VIEW_LINE_NUMBER;
68 constexpr float VERTICAL_SCROLLABLE_DISTANCE = (TOTAL_LINE_NUMBER - VIEW_LINE_NUMBER) * ITEM_HEIGHT;
69 constexpr float NORMAL_WIDTH = 4.f;
70 constexpr float SCROLL_PAGING_SPEED_THRESHOLD = 1200.0f;
71 } // namespace
72
73 class ScrollTestNg : public TestNG {
74 public:
75 static void SetUpTestSuite();
76 static void TearDownTestSuite();
77 void SetUp() override;
78 void TearDown() override;
79 void GetInstance();
80 void UpdateCurrentOffset(float offset);
81
82 void Create(const std::function<void(ScrollModelNG)>& callback = nullptr);
83 void CreateWithContent(const std::function<void(ScrollModelNG)>& callback = nullptr);
84 void CreateSnapScroll(ScrollSnapAlign scrollSnapAlign, const Dimension& intervalSize,
85 const std::vector<Dimension>& snapPaginations, const std::pair<bool, bool>& enableSnapToSide);
86
87 static void CreateContent(int32_t childNumber = TOTAL_LINE_NUMBER);
88 RefPtr<FrameNode> GetContentChild(int32_t index);
89 void Touch(TouchLocationInfo locationInfo, SourceType sourceType);
90 void Touch(TouchType touchType, Offset offset, SourceType sourceType);
91 void Mouse(MouseInfo mouseInfo);
92 void Mouse(Offset moveOffset);
93 void Hover(bool isHover);
94 bool OnScrollCallback(float offset, int32_t source);
95 void ScrollToEdge(ScrollEdgeType scrollEdgeType);
96 static Axis GetAxis();
97 float GetOffset(float childNumber);
98 AssertionResult UpdateAndVerifyPosition(float offset, float expectOffset, int32_t source = SCROLL_FROM_UPDATE);
99 AssertionResult ScrollToNode(int32_t childIndex, float expectChildNumber);
100 AssertionResult IsEqualCurrentPosition(float expectOffset);
101
102 RefPtr<FrameNode> frameNode_;
103 RefPtr<ScrollPattern> pattern_;
104 RefPtr<ScrollEventHub> eventHub_;
105 RefPtr<ScrollLayoutProperty> layoutProperty_;
106 RefPtr<ScrollablePaintProperty> paintProperty_;
107 RefPtr<ScrollAccessibilityProperty> accessibilityProperty_;
108 };
109
SetUpTestSuite()110 void ScrollTestNg::SetUpTestSuite()
111 {
112 TestNG::SetUpTestSuite();
113 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
114 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
115 auto scrollBarTheme = AceType::MakeRefPtr<ScrollBarTheme>();
116 scrollBarTheme->normalWidth_ = Dimension(NORMAL_WIDTH);
117 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(scrollBarTheme));
118 MockPipelineContext::GetCurrentContext()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
119 }
120
TearDownTestSuite()121 void ScrollTestNg::TearDownTestSuite()
122 {
123 TestNG::TearDownTestSuite();
124 }
125
SetUp()126 void ScrollTestNg::SetUp() {}
127
TearDown()128 void ScrollTestNg::TearDown()
129 {
130 frameNode_ = nullptr;
131 pattern_ = nullptr;
132 eventHub_ = nullptr;
133 layoutProperty_ = nullptr;
134 paintProperty_ = nullptr;
135 accessibilityProperty_ = nullptr;
136 }
137
GetInstance()138 void ScrollTestNg::GetInstance()
139 {
140 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
141 frameNode_ = AceType::DynamicCast<FrameNode>(element);
142 pattern_ = frameNode_->GetPattern<ScrollPattern>();
143 eventHub_ = frameNode_->GetEventHub<ScrollEventHub>();
144 layoutProperty_ = frameNode_->GetLayoutProperty<ScrollLayoutProperty>();
145 paintProperty_ = frameNode_->GetPaintProperty<ScrollablePaintProperty>();
146 accessibilityProperty_ = frameNode_->GetAccessibilityProperty<ScrollAccessibilityProperty>();
147 }
148
Create(const std::function<void (ScrollModelNG)> & callback)149 void ScrollTestNg::Create(const std::function<void(ScrollModelNG)>& callback)
150 {
151 ScrollModelNG model;
152 model.Create();
153 auto proxy = model.CreateScrollBarProxy();
154 model.SetScrollBarProxy(proxy);
155 ViewAbstract::SetWidth(CalcLength(SCROLL_WIDTH));
156 ViewAbstract::SetHeight(CalcLength(SCROLL_HEIGHT));
157 if (callback) {
158 callback(model);
159 }
160 GetInstance();
161 FlushLayoutTask(frameNode_);
162 }
163
CreateWithContent(const std::function<void (ScrollModelNG)> & callback)164 void ScrollTestNg::CreateWithContent(const std::function<void(ScrollModelNG)>& callback)
165 {
166 Create([callback](ScrollModelNG model) {
167 if (callback) {
168 callback(model);
169 }
170 CreateContent();
171 });
172 }
173
CreateSnapScroll(ScrollSnapAlign scrollSnapAlign,const Dimension & intervalSize,const std::vector<Dimension> & snapPaginations,const std::pair<bool,bool> & enableSnapToSide)174 void ScrollTestNg::CreateSnapScroll(ScrollSnapAlign scrollSnapAlign, const Dimension& intervalSize,
175 const std::vector<Dimension>& snapPaginations, const std::pair<bool, bool>& enableSnapToSide)
176 {
177 CreateWithContent([scrollSnapAlign, intervalSize, snapPaginations, enableSnapToSide](ScrollModelNG model) {
178 model.SetScrollSnap(scrollSnapAlign, intervalSize, snapPaginations, enableSnapToSide);
179 });
180 }
181
CreateContent(int32_t childNumber)182 void ScrollTestNg::CreateContent(int32_t childNumber)
183 {
184 if (GetAxis() == Axis::HORIZONTAL) {
185 RowModelNG rowModel;
186 rowModel.Create(Dimension(0), nullptr, "");
187 ViewAbstract::SetWidth(CalcLength(Dimension(childNumber * ITEM_WIDTH)));
188 ViewAbstract::SetHeight(CalcLength(FILL_LENGTH));
189 for (int32_t index = 0; index < childNumber; index++) {
190 RowModelNG rowModel;
191 rowModel.Create(Dimension(0), nullptr, "");
192 ViewAbstract::SetWidth(CalcLength(Dimension(ITEM_WIDTH)));
193 ViewAbstract::SetHeight(CalcLength(FILL_LENGTH));
194 ViewStackProcessor::GetInstance()->Pop();
195 }
196 } else {
197 ColumnModelNG colModel;
198 colModel.Create(Dimension(0), nullptr, "");
199 ViewAbstract::SetWidth(CalcLength(FILL_LENGTH));
200 ViewAbstract::SetHeight(CalcLength(Dimension(childNumber * ITEM_HEIGHT)));
201 for (int32_t index = 0; index < childNumber; index++) {
202 ColumnModelNG colModel;
203 colModel.Create(Dimension(0), nullptr, "");
204 ViewAbstract::SetWidth(CalcLength(FILL_LENGTH));
205 ViewAbstract::SetHeight(CalcLength(Dimension(ITEM_HEIGHT)));
206 ViewStackProcessor::GetInstance()->Pop();
207 }
208 }
209 ViewStackProcessor::GetInstance()->Pop();
210 }
211
UpdateCurrentOffset(float offset)212 void ScrollTestNg::UpdateCurrentOffset(float offset)
213 {
214 pattern_->UpdateCurrentOffset(offset, SCROLL_FROM_UPDATE);
215 FlushLayoutTask(frameNode_);
216 }
217
GetContentChild(int32_t index)218 RefPtr<FrameNode> ScrollTestNg::GetContentChild(int32_t index)
219 {
220 auto content = GetChildFrameNode(frameNode_, 0);
221 auto contentChild = GetChildFrameNode(content, index);
222 return contentChild;
223 }
224
Touch(TouchLocationInfo locationInfo,SourceType sourceType)225 void ScrollTestNg::Touch(TouchLocationInfo locationInfo, SourceType sourceType)
226 {
227 auto touchEventHub = frameNode_->GetOrCreateGestureEventHub();
228 RefPtr<TouchEventImpl> touchEventImpl = touchEventHub->touchEventActuator_->touchEvents_.back();
229 auto touchEvent = touchEventImpl->GetTouchEventCallback();
230 TouchEventInfo eventInfo("touch");
231 eventInfo.SetSourceDevice(sourceType);
232 eventInfo.AddTouchLocationInfo(std::move(locationInfo));
233 touchEvent(eventInfo);
234 }
235
Touch(TouchType touchType,Offset offset,SourceType sourceType)236 void ScrollTestNg::Touch(TouchType touchType, Offset offset, SourceType sourceType)
237 {
238 TouchLocationInfo locationInfo(1);
239 locationInfo.SetTouchType(touchType);
240 locationInfo.SetLocalLocation(offset);
241 Touch(locationInfo, sourceType);
242 }
243
Mouse(MouseInfo mouseInfo)244 void ScrollTestNg::Mouse(MouseInfo mouseInfo)
245 {
246 auto mouseEventHub = frameNode_->GetOrCreateInputEventHub();
247 RefPtr<InputEvent> inputEvent = mouseEventHub->mouseEventActuator_->inputEvents_.front();
248 auto mouseEvent = inputEvent->GetOnMouseEventFunc();
249 mouseEvent(mouseInfo);
250 }
251
Mouse(Offset moveOffset)252 void ScrollTestNg::Mouse(Offset moveOffset)
253 {
254 MouseInfo mouseInfo;
255 mouseInfo.SetAction(MouseAction::MOVE);
256 mouseInfo.SetLocalLocation(moveOffset);
257 Mouse(mouseInfo);
258 }
259
Hover(bool isHover)260 void ScrollTestNg::Hover(bool isHover)
261 {
262 auto hoverEventHub = frameNode_->GetOrCreateInputEventHub();
263 RefPtr<InputEvent> inputEvent = hoverEventHub->hoverEventActuator_->inputEvents_.front();
264 auto hoverEvent = inputEvent->GetOnHoverEventFunc();
265 hoverEvent(isHover);
266 }
267
OnScrollCallback(float offset,int32_t source)268 bool ScrollTestNg::OnScrollCallback(float offset, int32_t source)
269 {
270 bool result = pattern_->OnScrollCallback(offset, source);
271 FlushLayoutTask(frameNode_);
272 return result;
273 }
274
ScrollToEdge(ScrollEdgeType scrollEdgeType)275 void ScrollTestNg::ScrollToEdge(ScrollEdgeType scrollEdgeType)
276 {
277 pattern_->ScrollToEdge(scrollEdgeType, false);
278 FlushLayoutTask(frameNode_);
279 }
280
GetAxis()281 Axis ScrollTestNg::GetAxis()
282 {
283 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
284 auto layoutProperty = frameNode->GetLayoutProperty<ScrollLayoutProperty>();
285 auto axis = layoutProperty->GetAxis();
286 return axis.has_value() ? axis.value() : Axis::VERTICAL;
287 }
288
GetOffset(float childNumber)289 float ScrollTestNg::GetOffset(float childNumber)
290 {
291 bool isHorizontal = pattern_->GetAxis() == Axis::HORIZONTAL;
292 float offset = childNumber * (isHorizontal ? ITEM_WIDTH : ITEM_HEIGHT);
293 return offset;
294 }
295
UpdateAndVerifyPosition(float childNumber,float expectChildNumber,int32_t source)296 AssertionResult ScrollTestNg::UpdateAndVerifyPosition(float childNumber, float expectChildNumber, int32_t source)
297 {
298 pattern_->UpdateCurrentOffset(GetOffset(childNumber), source);
299 return IsEqualCurrentPosition(GetOffset(expectChildNumber));
300 }
301
ScrollToNode(int32_t childIndex,float expectChildNumber)302 AssertionResult ScrollTestNg::ScrollToNode(int32_t childIndex, float expectChildNumber)
303 {
304 pattern_->ScrollToNode(GetContentChild(childIndex));
305 return IsEqualCurrentPosition(GetOffset(expectChildNumber));
306 }
307
IsEqualCurrentPosition(float expectOffset)308 AssertionResult ScrollTestNg::IsEqualCurrentPosition(float expectOffset)
309 {
310 FlushLayoutTask(frameNode_);
311 float currentOffset = pattern_->GetCurrentPosition();
312 return IsEqual(currentOffset, expectOffset);
313 }
314
315 /**
316 * @tc.name: AttrScrollable001
317 * @tc.desc: Test attribute about scrollable,
318 * @tc.type: FUNC
319 */
320 HWTEST_F(ScrollTestNg, AttrScrollable001, TestSize.Level1)
321 {
322 /**
323 * @tc.steps: step1. Text default value: VERTICAL
324 */
325 CreateWithContent();
326 EXPECT_TRUE(UpdateAndVerifyPosition(-1, -1));
327
328 /**
329 * @tc.steps: step2. Text set value: HORIZONTAL
330 */
__anon4dcc91dc0402(ScrollModelNG model) 331 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::HORIZONTAL); });
332 EXPECT_TRUE(UpdateAndVerifyPosition(-1, -1));
333
334 /**
335 * @tc.steps: step3. Text set value: NONE
336 */
__anon4dcc91dc0502(ScrollModelNG model) 337 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::NONE); });
338 EXPECT_TRUE(UpdateAndVerifyPosition(-1, -1));
339 }
340
341 /**
342 * @tc.name: AttrScrollBar001
343 * @tc.desc: Test attribute about scrollBar,
344 * @tc.type: FUNC
345 */
346 HWTEST_F(ScrollTestNg, AttrScrollBar001, TestSize.Level1)
347 {
348 /**
349 * @tc.steps: step1. Text default value: AUTO
350 */
351 CreateWithContent();
352 EXPECT_EQ(paintProperty_->GetBarStateString(), "BarState.Auto");
353
354 /**
355 * @tc.steps: step2. Text set value: OFF
356 */
__anon4dcc91dc0602(ScrollModelNG model) 357 CreateWithContent([](ScrollModelNG model) { model.SetDisplayMode(static_cast<int>(DisplayMode::OFF)); });
358 EXPECT_EQ(paintProperty_->GetBarStateString(), "BarState.Off");
359
360 /**
361 * @tc.steps: step3. Text set value: ON
362 */
__anon4dcc91dc0702(ScrollModelNG model) 363 CreateWithContent([](ScrollModelNG model) { model.SetDisplayMode(static_cast<int>(DisplayMode::ON)); });
364 EXPECT_EQ(paintProperty_->GetBarStateString(), "BarState.On");
365 }
366
367 /**
368 * @tc.name: AttrScrollBarColorWidth001
369 * @tc.desc: Test attribute about scrollBarColor/scrollBarWidth,
370 * @tc.type: FUNC
371 */
372 HWTEST_F(ScrollTestNg, AttrScrollBarColorWidth001, TestSize.Level1)
373 {
374 /**
375 * @tc.steps: step1. Text default value: [color:foregroundColor_, width: 4]
376 */
377 CreateWithContent();
378 auto themeManager = MockPipelineContext::GetCurrent()->GetThemeManager();
379 auto scrollBarTheme = themeManager->GetTheme<ScrollBarTheme>();
380 EXPECT_EQ(paintProperty_->GetBarColor(), scrollBarTheme->GetForegroundColor());
381 EXPECT_EQ(paintProperty_->GetBarWidth(), scrollBarTheme->GetNormalWidth());
382
383 /**
384 * @tc.steps: step2. Text set value: Color::RED
385 */
__anon4dcc91dc0802(ScrollModelNG model) 386 CreateWithContent([](ScrollModelNG model) { model.SetScrollBarColor(Color::RED); });
387 EXPECT_EQ(paintProperty_->GetBarColor(), Color::RED);
388
389 /**
390 * @tc.steps: step3. Text set width value: Dimension(10)
391 */
__anon4dcc91dc0902(ScrollModelNG model) 392 CreateWithContent([](ScrollModelNG model) { model.SetScrollBarWidth(Dimension(10)); });
393 EXPECT_EQ(paintProperty_->GetBarWidth(), Dimension(10));
394 }
395
396 /**
397 * @tc.name: AttrEdgeEffect001
398 * @tc.desc: Test attribute about edgeEffect,
399 * @tc.type: FUNC
400 */
401 HWTEST_F(ScrollTestNg, AttrEdgeEffect001, TestSize.Level1)
402 {
403 /**
404 * @tc.steps: step1. Text default value: NONE
405 */
406 CreateWithContent();
407 EXPECT_EQ(pattern_->GetEdgeEffect(), EdgeEffect::NONE);
408
409 /**
410 * @tc.steps: step2. Text set value: SPRING
411 */
__anon4dcc91dc0a02(ScrollModelNG model) 412 CreateWithContent([](ScrollModelNG model) { model.SetEdgeEffect(EdgeEffect::SPRING, true); });
413 EXPECT_EQ(pattern_->GetEdgeEffect(), EdgeEffect::SPRING);
414
415 /**
416 * @tc.steps: step3. Text set width value: FADE
417 */
__anon4dcc91dc0b02(ScrollModelNG model) 418 CreateWithContent([](ScrollModelNG model) { model.SetEdgeEffect(EdgeEffect::FADE, true); });
419 EXPECT_EQ(pattern_->GetEdgeEffect(), EdgeEffect::FADE);
420 }
421
422 /**
423 * @tc.name: AttrEnableScrollInteraction001
424 * @tc.desc: Test attribute about enableScrollInteraction,
425 * @tc.type: FUNC
426 */
427 HWTEST_F(ScrollTestNg, AttrEnableScrollInteraction001, TestSize.Level1)
428 {
429 /**
430 * @tc.steps: step1. Test default value: true
431 */
432 CreateWithContent();
433 EXPECT_TRUE(pattern_->GetScrollableEvent()->GetEnable());
434
435 /**
436 * @tc.steps: step2. Test set value: false
437 */
__anon4dcc91dc0c02(ScrollModelNG model) 438 CreateWithContent([](ScrollModelNG model) { model.SetScrollEnabled(false); });
439 EXPECT_FALSE(pattern_->GetScrollableEvent()->GetEnable());
440 }
441
442 /**
443 * @tc.name: Event001
444 * @tc.desc: Test RegisterScrollEventTask
445 * @tc.type: FUNC
446 */
447 HWTEST_F(ScrollTestNg, Event001, TestSize.Level1)
448 {
__anon4dcc91dc0d02(Dimension, ScrollState) 449 auto event1 = [](Dimension, ScrollState) { return ScrollFrameResult(); };
__anon4dcc91dc0e02(Dimension, Dimension) 450 auto event2 = [](Dimension, Dimension) { return ScrollInfo(); };
__anon4dcc91dc0f02(ScrollModelNG model) 451 CreateWithContent([event1, event2](ScrollModelNG model) {
452 model.SetOnScrollFrameBegin(event1);
453 model.SetOnScrollBegin(event2);
454 });
455
456 /**
457 * @tc.steps: step1. When set event
458 * @tc.expected: scrollableEvent would has event that setted
459 */
460 ASSERT_NE(eventHub_->GetOnScrollFrameBegin(), nullptr);
461 ASSERT_NE(eventHub_->GetScrollBeginEvent(), nullptr);
462 }
463
464 /**
465 * @tc.name: Event002
466 * @tc.desc: Test attribute about onScroll,
467 * Event is triggered while scrolling
468 * @tc.type: FUNC
469 */
470 HWTEST_F(ScrollTestNg, Event002, TestSize.Level1)
471 {
472 /**
473 * @tc.steps: step1. Test event in VERTICAL
474 */
475 bool isTrigger = false;
__anon4dcc91dc1002(ScrollModelNG model) 476 CreateWithContent([&isTrigger](ScrollModelNG model) {
477 NG::ScrollEvent event = [&isTrigger](Dimension, Dimension) { isTrigger = true; };
478 model.SetOnScroll(std::move(event));
479 });
480
481 /**
482 * @tc.steps: step2. Trigger event by OnScrollCallback
483 * @tc.expected: isTrigger is true
484 */
485 pattern_->OnScrollCallback(-ITEM_HEIGHT * TOTAL_LINE_NUMBER, SCROLL_FROM_UPDATE);
486 EXPECT_TRUE(isTrigger);
487
488 /**
489 * @tc.steps: step3. Trigger event by ScrollToEdge
490 * @tc.expected: isTrigger is true
491 */
492 isTrigger = false;
493 pattern_->ScrollToEdge(ScrollEdgeType::SCROLL_TOP, false);
494 EXPECT_TRUE(isTrigger);
495
496 /**
497 * @tc.steps: step4. Test event in HORIZONTAL
498 */
499 isTrigger = false;
__anon4dcc91dc1202(ScrollModelNG model) 500 CreateWithContent([&isTrigger](ScrollModelNG model) {
501 NG::ScrollEvent event = [&isTrigger](Dimension, Dimension) { isTrigger = true; };
502 model.SetAxis(Axis::HORIZONTAL);
503 model.SetOnScroll(std::move(event));
504 });
505
506 /**
507 * @tc.steps: step5. Trigger event by OnScrollCallback
508 * @tc.expected: isTrigger is true
509 */
510 isTrigger = false;
511 pattern_->OnScrollCallback(-ITEM_WIDTH * TOTAL_LINE_NUMBER, SCROLL_FROM_UPDATE);
512 EXPECT_TRUE(isTrigger);
513
514 /**
515 * @tc.steps: step6. Trigger event by ScrollToEdge
516 * @tc.expected: isTrigger is true
517 */
518 isTrigger = false;
519 pattern_->ScrollToEdge(ScrollEdgeType::SCROLL_TOP, false);
520 EXPECT_TRUE(isTrigger);
521 }
522
523 /**
524 * @tc.name: Event003
525 * @tc.desc: Test attribute about onScrollEdge,
526 * Event is triggered while scroll to edge
527 * @tc.type: FUNC
528 */
529 HWTEST_F(ScrollTestNg, Event003, TestSize.Level1)
530 {
531 /**
532 * @tc.steps: step1. Test event in VERTICAL
533 */
534 bool isTrigger = false;
__anon4dcc91dc1402(ScrollModelNG model) 535 CreateWithContent([&isTrigger](ScrollModelNG model) {
536 NG::ScrollEdgeEvent event = [&isTrigger](ScrollEdge) { isTrigger = true; };
537 model.SetOnScrollEdge(std::move(event));
538 });
539
540 /**
541 * @tc.steps: step2. Trigger event by OnScrollCallback
542 * @tc.expected: isTrigger is true
543 */
544 pattern_->OnScrollCallback(-ITEM_HEIGHT * TOTAL_LINE_NUMBER, SCROLL_FROM_UPDATE);
545 EXPECT_TRUE(isTrigger);
546
547 /**
548 * @tc.steps: step3. Trigger event by ScrollToEdge
549 * @tc.expected: isTrigger is true
550 */
551 isTrigger = false;
552 pattern_->ScrollToEdge(ScrollEdgeType::SCROLL_TOP, false);
553 EXPECT_TRUE(isTrigger);
554
555 /**
556 * @tc.steps: step4. Test event in HORIZONTAL
557 */
558 isTrigger = false;
__anon4dcc91dc1602(ScrollModelNG model) 559 CreateWithContent([&isTrigger](ScrollModelNG model) {
560 NG::ScrollEdgeEvent event = [&isTrigger](ScrollEdge) { isTrigger = true; };
561 model.SetAxis(Axis::HORIZONTAL);
562 model.SetOnScrollEdge(std::move(event));
563 });
564
565 /**
566 * @tc.steps: step5. Trigger event by OnScrollCallback
567 * @tc.expected: isTrigger is true
568 */
569 pattern_->OnScrollCallback(-ITEM_WIDTH * TOTAL_LINE_NUMBER, SCROLL_FROM_UPDATE);
570 EXPECT_TRUE(isTrigger);
571
572 /**
573 * @tc.steps: step6. Trigger event by ScrollToEdge
574 * @tc.expected: isTrigger is true
575 */
576 isTrigger = false;
577 pattern_->ScrollToEdge(ScrollEdgeType::SCROLL_TOP, false);
578 EXPECT_TRUE(isTrigger);
579 }
580
581 /**
582 * @tc.name: Event004
583 * @tc.desc: Test attribute about onScrollStart and onScrollStop and onScrollEnd,
584 * Event is triggered while scrolling start
585 * @tc.type: FUNC
586 */
587 HWTEST_F(ScrollTestNg, Event004, TestSize.Level1)
588 {
589 /**
590 * @tc.steps: step1. Test onScrollStart event in VERTICAL
591 */
592 bool isTrigger = false;
__anon4dcc91dc1802(ScrollModelNG model) 593 CreateWithContent([&isTrigger](ScrollModelNG model) {
594 OnScrollStartEvent startEvent = [&isTrigger]() { isTrigger = true; };
595 model.SetOnScrollStart(std::move(startEvent));
596 OnScrollStopEvent stopEvent = [&isTrigger]() { isTrigger = true; };
597 model.SetOnScrollStop(std::move(stopEvent));
598 ScrollEndEvent endEvent = [&isTrigger]() { isTrigger = true; };
599 model.SetOnScrollEnd(std::move(endEvent));
600 });
601
602 /**
603 * @tc.steps: step2. Trigger onScrollStart event by OnScrollCallback
604 * @tc.expected: isTrigger is true
605 */
606 pattern_->OnScrollCallback(-ITEM_HEIGHT * TOTAL_LINE_NUMBER, SCROLL_FROM_START);
607 EXPECT_TRUE(isTrigger);
608
609 /**
610 * @tc.steps: step3. Trigger onScrollStart event by ScrollToEdge
611 * @tc.expected: isTrigger is true
612 */
613 isTrigger = false;
614 pattern_->ScrollToEdge(ScrollEdgeType::SCROLL_BOTTOM, true);
615 EXPECT_TRUE(isTrigger);
616
617 /**
618 * @tc.steps: step4. Trigger onScrollStop / onScrollEnd event
619 * @tc.expected: isTrigger is true
620 */
621 isTrigger = false;
622 pattern_->OnScrollEndCallback(); // Trigger onScrollEnd, set scrollStop_ = true;
623 EXPECT_TRUE(isTrigger);
624 isTrigger = false;
625 FlushLayoutTask(frameNode_); // Trigger onScrollStop
626 EXPECT_TRUE(isTrigger);
627
628 /**
629 * @tc.steps: step5. Set scrollAbort_ to true
630 * @tc.expected: onScrollStop would not be trigger
631 */
632 pattern_->animator_ = CREATE_ANIMATOR(PipelineBase::GetCurrentContext());
633 pattern_->animator_->Resume();
634 pattern_->AnimateTo(ITEM_HEIGHT * TOTAL_LINE_NUMBER, 1.f, Curves::LINEAR, false);
635 EXPECT_TRUE(pattern_->GetScrollAbort());
636
637 isTrigger = false;
638 pattern_->OnScrollEndCallback(); // Trigger onScrollEnd, set scrollStop_ = true;
639 EXPECT_TRUE(isTrigger);
640 isTrigger = false;
641 FlushLayoutTask(frameNode_); // Trigger onScrollStop
642 EXPECT_FALSE(isTrigger);
643 }
644
645 /**
646 * @tc.name: Event005
647 * @tc.desc: Test attribute about onReachStart/onReachEnd,
648 * Event is triggered while scroll to edge
649 * @tc.type: FUNC
650 */
651 HWTEST_F(ScrollTestNg, Event005, TestSize.Level1)
652 {
653 /**
654 * @tc.steps: step1. Test event in VERTICAL
655 * @tc.expected: reachStart is true on first layout
656 */
657 bool reachStart = false;
658 bool reachEnd = false;
__anon4dcc91dc1c02(ScrollModelNG model) 659 CreateWithContent([&reachStart, &reachEnd](ScrollModelNG model) {
660 auto reachStartEvent = [&reachStart]() { reachStart = true; };
661 model.SetOnReachStart(std::move(reachStartEvent));
662 auto reachEndEvent = [&reachEnd]() { reachEnd = true; };
663 model.SetOnReachEnd(std::move(reachEndEvent));
664 });
665 FlushLayoutTask(frameNode_);
666 EXPECT_TRUE(reachStart);
667 EXPECT_TRUE(pattern_->isInitialized_);
668
669 /**
670 * @tc.steps: step2. Trigger event by UpdateCurrentOffset
671 * @tc.expected: reachEnd is true
672 */
673 UpdateCurrentOffset(-(ITEM_HEIGHT * TOTAL_LINE_NUMBER - SCROLL_HEIGHT));
674 EXPECT_TRUE(reachEnd);
675
676 /**
677 * @tc.steps: step3. Trigger event by ScrollToEdge
678 * @tc.expected: reachStart is true
679 */
680 reachStart = false;
681 pattern_->ScrollToEdge(ScrollEdgeType::SCROLL_TOP, false);
682 FlushLayoutTask(frameNode_);
683 EXPECT_TRUE(reachStart);
684 }
685
686 /**
687 * @tc.name: Event006
688 * @tc.desc: Test animate scroll func about event
689 * @tc.type: FUNC
690 */
691 HWTEST_F(ScrollTestNg, Event006, TestSize.Level1)
692 {
693 bool isStartTrigger = false;
694 bool isStopTrigger = false;
__anon4dcc91dc1f02(ScrollModelNG model) 695 CreateWithContent([&isStartTrigger, &isStopTrigger](ScrollModelNG model) {
696 OnScrollStartEvent startEvent = [&isStartTrigger]() { isStartTrigger = true; };
697 OnScrollStopEvent stopEvent = [&isStopTrigger]() { isStopTrigger = true; };
698 model.SetOnScrollStart(std::move(startEvent));
699 model.SetOnScrollStop(std::move(stopEvent));
700 });
701
702 /**
703 * @tc.steps: step1. Scroll with animate by run ScrollToEdge
704 * @tc.expected: onScrollStart would not be trigger
705 */
706 pattern_->ScrollToEdge(ScrollEdgeType::SCROLL_BOTTOM, true);
707 EXPECT_TRUE(isStartTrigger);
708
709 /**
710 * @tc.steps: step1. When animte stop
711 * @tc.expected: onScrollStop would not be trigger
712 */
713 float endValue = pattern_->GetFinalPosition();
714 pattern_->UpdateCurrentOffset(pattern_->GetTotalOffset() - endValue, SCROLL_FROM_ANIMATION_CONTROLLER);
715 // when out of scrollable distance, will trigger animator stop
716 pattern_->UpdateCurrentOffset(-1, SCROLL_FROM_ANIMATION_CONTROLLER);
717 if (pattern_->IsAtBottom()) {
718 pattern_->StopAnimation(pattern_->springAnimation_);
719 }
720 FlushLayoutTask(frameNode_);
721 EXPECT_TRUE(isStopTrigger);
722 }
723
724 /**
725 * @tc.name: ScrollPositionController001
726 * @tc.desc: Test ScrollPositionController with Axis::VERTICAL
727 * @tc.type: FUNC
728 */
729 HWTEST_F(ScrollTestNg, ScrollPositionController001, TestSize.Level1)
730 {
731 CreateWithContent();
732 auto controller = pattern_->GetScrollPositionController();
733 controller->JumpTo(1, false, ScrollAlign::START, 0);
734
735 /**
736 * @tc.steps: step1. Test AnimateTo
737 */
738 bool animate = controller->AnimateTo(Dimension(ITEM_HEIGHT * TOTAL_LINE_NUMBER), -1.f, Curves::LINEAR, false);
739 EXPECT_TRUE(animate);
740 animate = controller->AnimateTo(Dimension(1.0, DimensionUnit::PERCENT), 1.f, Curves::LINEAR, false);
741 EXPECT_FALSE(animate);
742
743 /**
744 * @tc.steps: step2. jump to a position
745 * @tc.expected: CurrentOffset would be to the position
746 */
747 pattern_->DoJump(-ITEM_HEIGHT, SCROLL_FROM_UPDATE);
748 EXPECT_TRUE(IsEqualCurrentPosition(-ITEM_HEIGHT));
749
750 /**
751 * @tc.steps: step3. jump to the same position
752 * @tc.expected: CurrentOffset would not be change
753 */
754 pattern_->DoJump(-ITEM_HEIGHT, SCROLL_FROM_UPDATE);
755 EXPECT_TRUE(IsEqualCurrentPosition(-ITEM_HEIGHT));
756
757 /**
758 * @tc.steps: step4. ScrollBy 0
759 * @tc.expected: CurrentOffset would not change
760 */
761 CreateWithContent();
762 controller = pattern_->GetScrollPositionController();
763 controller->ScrollBy(0, 0, false);
764 EXPECT_TRUE(IsEqualCurrentPosition(0));
765
766 /**
767 * @tc.steps: step5. ScrollBy a distance
768 * @tc.expected: Scroll by the distance
769 */
770 controller->ScrollBy(ITEM_WIDTH, ITEM_HEIGHT, false);
771 EXPECT_TRUE(IsEqualCurrentPosition(-ITEM_HEIGHT));
772
773 /**
774 * @tc.steps: step6. ScrollTo same currentOffset_
775 * @tc.expected: JumpToPosition do not SendEventToAccessibility
776 */
777 pattern_->ScrollTo(-pattern_->currentOffset_);
778 EXPECT_TRUE(IsEqualCurrentPosition(-ITEM_HEIGHT));
779
780 /**
781 * @tc.steps: step7. Test GetCurrentPosition
782 */
783 EXPECT_EQ(controller->GetCurrentOffset().GetY(), ITEM_HEIGHT);
784
785 /**
786 * @tc.steps: step8. Test ScrollEdgeType::SCROLL_NONE
787 * @tc.expected: CurrentOffset would not be change
788 */
789 CreateWithContent();
790 controller = pattern_->GetScrollPositionController();
791 controller->ScrollToEdge(ScrollEdgeType::SCROLL_NONE, false);
792 EXPECT_TRUE(IsEqualCurrentPosition(0));
793
794 /**
795 * @tc.steps: step9. Test ScrollEdgeType::SCROLL_BOTTOM
796 * @tc.expected: CurrentOffset would to be bottom
797 */
798 controller->ScrollToEdge(ScrollEdgeType::SCROLL_BOTTOM, false);
799 EXPECT_TRUE(IsEqualCurrentPosition(SCROLL_HEIGHT - ITEM_HEIGHT * TOTAL_LINE_NUMBER));
800
801 /**
802 * @tc.steps: step10. Test ScrollEdgeType::SCROLL_TOP
803 * @tc.expected: CurrentOffset would to be top
804 */
805 controller->ScrollToEdge(ScrollEdgeType::SCROLL_TOP, false);
806 EXPECT_TRUE(IsEqualCurrentPosition(0));
807
808 /**
809 * @tc.steps: step11. Test ScrollPage
810 */
811 controller->ScrollPage(false, false);
812 EXPECT_TRUE(IsEqualCurrentPosition(SCROLL_HEIGHT - ITEM_HEIGHT * TOTAL_LINE_NUMBER));
813
814 /**
815 * @tc.steps: step12. Test ScrollPage
816 */
817 controller->ScrollPage(true, false);
818 EXPECT_TRUE(IsEqualCurrentPosition(0));
819
820 /**
821 * @tc.steps: step13. Test IsAtEnd
822 */
823 EXPECT_FALSE(controller->IsAtEnd());
824 UpdateCurrentOffset(-(ITEM_HEIGHT * TOTAL_LINE_NUMBER - SCROLL_HEIGHT));
825 EXPECT_TRUE(controller->IsAtEnd());
826 }
827
828 /**
829 * @tc.name: ScrollPositionController002
830 * @tc.desc: Test ScrollPositionController with Axis::VERTICAL
831 * @tc.type: FUNC
832 */
833 HWTEST_F(ScrollTestNg, ScrollPositionController002, TestSize.Level1)
834 {
__anon4dcc91dc2202(ScrollModelNG model) 835 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::HORIZONTAL); });
836 auto controller = pattern_->GetScrollPositionController();
837 controller->JumpTo(1, false, ScrollAlign::START, 0);
838
839 /**
840 * @tc.steps: step1. Test AnimateTo
841 */
842 bool animate = controller->AnimateTo(Dimension(ITEM_HEIGHT * TOTAL_LINE_NUMBER), -1.f, Curves::LINEAR, false);
843 EXPECT_TRUE(animate);
844 animate = controller->AnimateTo(Dimension(1.0, DimensionUnit::PERCENT), 1.f, Curves::LINEAR, false);
845 EXPECT_FALSE(animate);
846
847 /**
848 * @tc.steps: step2. jump to a position
849 * @tc.expected: CurrentOffset would be to the position
850 */
851 pattern_->DoJump(-ITEM_WIDTH, SCROLL_FROM_UPDATE);
852 EXPECT_TRUE(IsEqualCurrentPosition(-ITEM_WIDTH));
853
854 /**
855 * @tc.steps: step3. jump to the same position
856 * @tc.expected: CurrentOffset would not be change
857 */
858 pattern_->DoJump(-ITEM_WIDTH, SCROLL_FROM_UPDATE);
859 EXPECT_TRUE(IsEqualCurrentPosition(-ITEM_WIDTH));
860
861 /**
862 * @tc.steps: step4. ScrollBy 0
863 * @tc.expected: CurrentOffset would not change
864 */
__anon4dcc91dc2302(ScrollModelNG model) 865 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::HORIZONTAL); });
866 controller = pattern_->GetScrollPositionController();
867 controller->ScrollBy(0, 0, false);
868 EXPECT_TRUE(IsEqualCurrentPosition(0));
869
870 /**
871 * @tc.steps: step5. ScrollBy a distance
872 * @tc.expected: Scroll by the distance
873 */
874 controller->ScrollBy(ITEM_WIDTH, ITEM_HEIGHT, false);
875 EXPECT_TRUE(IsEqualCurrentPosition(-ITEM_WIDTH));
876
877 /**
878 * @tc.steps: step6. Test GetCurrentPosition
879 */
880 EXPECT_EQ(controller->GetCurrentOffset().GetX(), ITEM_WIDTH);
881
882 /**
883 * @tc.steps: step7. Test ScrollEdgeType::SCROLL_NONE
884 * @tc.expected: CurrentOffset would not be change
885 */
__anon4dcc91dc2402(ScrollModelNG model) 886 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::HORIZONTAL); });
887 controller = pattern_->GetScrollPositionController();
888 controller->ScrollToEdge(ScrollEdgeType::SCROLL_NONE, false);
889 EXPECT_TRUE(IsEqualCurrentPosition(0));
890
891 /**
892 * @tc.steps: step8. Test ScrollEdgeType::SCROLL_BOTTOM
893 * @tc.expected: CurrentOffset would to be bottom
894 */
895 controller->ScrollToEdge(ScrollEdgeType::SCROLL_BOTTOM, false);
896 EXPECT_TRUE(IsEqualCurrentPosition(SCROLL_WIDTH - ITEM_WIDTH * TOTAL_LINE_NUMBER));
897
898 /**
899 * @tc.steps: step9. Test ScrollEdgeType::SCROLL_TOP
900 * @tc.expected: CurrentOffset would to be top
901 */
902 controller->ScrollToEdge(ScrollEdgeType::SCROLL_TOP, false);
903 EXPECT_TRUE(IsEqualCurrentPosition(0));
904
905 /**
906 * @tc.steps: step10. Test ScrollPage
907 */
908 controller->ScrollPage(false, false);
909 EXPECT_TRUE(IsEqualCurrentPosition(SCROLL_WIDTH - ITEM_WIDTH * TOTAL_LINE_NUMBER));
910
911 /**
912 * @tc.steps: step11. Test ScrollPage
913 */
914 controller->ScrollPage(true, false);
915 EXPECT_TRUE(IsEqualCurrentPosition(0));
916
917 /**
918 * @tc.steps: step12. Test IsAtEnd
919 */
920 EXPECT_FALSE(controller->IsAtEnd());
921 UpdateCurrentOffset(-(ITEM_WIDTH * TOTAL_LINE_NUMBER - SCROLL_WIDTH));
922 EXPECT_TRUE(controller->IsAtEnd());
923 }
924
925 /**
926 * @tc.name: ScrollPositionControlle003
927 * @tc.desc: Test ScrollPositionController with Axis::NONE
928 * @tc.type: FUNC
929 */
930 HWTEST_F(ScrollTestNg, ScrollPositionControlle003, TestSize.Level1)
931 {
__anon4dcc91dc2502(ScrollModelNG model) 932 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::NONE); });
933 auto controller = pattern_->GetScrollPositionController();
934
935 /**
936 * @tc.steps: step1. Test AnimateTo
937 */
938 bool animate = controller->AnimateTo(Dimension(ITEM_HEIGHT * TOTAL_LINE_NUMBER), 1.f, Curves::LINEAR, false);
939 EXPECT_FALSE(animate);
940
941 /**
942 * @tc.steps: step2. ScrollToEdge AnimateTo
943 */
944 controller->ScrollToEdge(ScrollEdgeType::SCROLL_BOTTOM, false);
945 EXPECT_TRUE(IsEqualCurrentPosition(0));
946
947 /**
948 * @tc.steps: step3. Test ScrollPage
949 */
950 controller->ScrollPage(false, false);
951 EXPECT_TRUE(IsEqualCurrentPosition(0));
952 }
953
954 /**
955 * @tc.name: ScrollBarAnimation001
956 * @tc.desc: Test ScrollBar Hover Animation
957 * @tc.type: FUNC
958 */
959 HWTEST_F(ScrollTestNg, ScrollBarAnimation001, TestSize.Level1)
960 {
961 Testing::MockCanvas canvas;
962 EXPECT_CALL(canvas, AttachBrush(_)).WillRepeatedly(ReturnRef(canvas));
963 EXPECT_CALL(canvas, DetachBrush()).WillRepeatedly(ReturnRef(canvas));
964 EXPECT_CALL(canvas, DrawRoundRect(_)).Times(AtLeast(1));
965 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
966 PaintWrapper paintWrapper(nullptr, geometryNode, paintProperty_);
967
968 const Offset downInBar = Offset(SCROLL_WIDTH - 1.f, 0.f);
969 const Offset moveInBar = Offset(SCROLL_WIDTH - 1.f, 10.f);
970 const Offset upInBar = moveInBar;
971
972 /**
973 * @tc.steps: step1. Axis::NONE
974 * @tc.expected: scrollBar->NeedPaint() is false and scrollBarOverlayModifier is nullptr.
975 */
__anon4dcc91dc2602(ScrollModelNG model) 976 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::NONE); });
977 auto paint = pattern_->CreateNodePaintMethod();
978 auto scrollPaint = AceType::DynamicCast<ScrollPaintMethod>(paint);
979 auto scrollBar = scrollPaint->scrollBar_.Upgrade();
980 EXPECT_FALSE(scrollBar->NeedPaint());
981 auto modifier = scrollPaint->GetOverlayModifier(&paintWrapper);
982 auto scrollBarOverlayModifier = AceType::DynamicCast<ScrollBarOverlayModifier>(modifier);
983 EXPECT_EQ(scrollBarOverlayModifier, nullptr);
984
985 /**
986 * @tc.steps: step2. Axis::Vertical, test grow animation.
987 * @tc.expected: scrollBarOverlayModifier->hoverAnimatingType_ is HoverAnimationType::GROW and the width of.
988 * scrollBar is DEFAULT_ACTIVE_WIDTH
989 */
990 CreateWithContent();
991 paint = pattern_->CreateNodePaintMethod();
992 scrollPaint = AceType::DynamicCast<ScrollPaintMethod>(paint);
993 scrollBar = scrollPaint->scrollBar_.Upgrade();
994 scrollBar->SetTouchWidth(Dimension(DEFAULT_TOUCH_WIDTH, DimensionUnit::VP));
995 scrollBar->SetActiveWidth(Dimension(DEFAULT_ACTIVE_WIDTH, DimensionUnit::VP));
996 scrollBar->SetInactiveWidth(Dimension(DEFAULT_INACTIVE_WIDTH, DimensionUnit::VP));
997 scrollBar->SetNormalWidth(Dimension(DEFAULT_NORMAL_WIDTH, DimensionUnit::VP));
998 EXPECT_TRUE(scrollBar->NeedPaint());
999 modifier = scrollPaint->GetOverlayModifier(&paintWrapper);
1000 scrollBarOverlayModifier = AceType::DynamicCast<ScrollBarOverlayModifier>(modifier);
1001 ASSERT_NE(scrollBarOverlayModifier, nullptr);
1002 DrawingContext drawingContext = { canvas, SCROLL_WIDTH, SCROLL_HEIGHT };
1003 scrollBarOverlayModifier->onDraw(drawingContext);
1004 Touch(TouchType::DOWN, downInBar, SourceType::TOUCH);
1005 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::GROW);
1006 scrollPaint->UpdateOverlayModifier(&paintWrapper);
1007 EXPECT_EQ(scrollBarOverlayModifier->hoverAnimatingType_, HoverAnimationType::NONE);
1008 EXPECT_EQ(scrollBar->GetActiveRect().Width(), DEFAULT_ACTIVE_WIDTH);
1009 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
1010
1011 /**
1012 * @tc.steps: step3. Axis::Vertical, test shrink animation.
1013 * @tc.expected: scrollBarOverlayModifier->hoverAnimatingType_ is HoverAnimationType::SHRINK and the width of
1014 * scrollBar is DEFAULT_INACTIVE_WIDTH.
1015 */
1016 Touch(TouchType::UP, upInBar, SourceType::TOUCH);
1017 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::SHRINK);
1018 scrollPaint->UpdateOverlayModifier(&paintWrapper);
1019 EXPECT_EQ(scrollBarOverlayModifier->hoverAnimatingType_, HoverAnimationType::NONE);
1020 EXPECT_EQ(scrollBar->GetActiveRect().Width(), DEFAULT_INACTIVE_WIDTH);
1021 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
1022 }
1023
1024 /**
1025 * @tc.name: ScrollBarAnimation002
1026 * @tc.desc: Test ScrollBar Opacity Animation
1027 * @tc.type: FUNC
1028 */
1029 HWTEST_F(ScrollTestNg, ScrollBarAnimation002, TestSize.Level1)
1030 {
1031 Testing::MockCanvas canvas;
1032 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
1033 PaintWrapper paintWrapper(nullptr, geometryNode, paintProperty_);
1034
1035 /**
1036 * @tc.steps: step1. DisplayMode::ON
1037 * @tc.expected: the opacity of scrollBarOverlayModifier is UINT8_MAX and opacityAnimatingType_ is
1038 * OpacityAnimationType::NONE.
1039 */
1040 CreateWithContent();
1041 auto paint = pattern_->CreateNodePaintMethod();
1042 auto scrollPaint = AceType::DynamicCast<ScrollPaintMethod>(paint);
1043 auto scrollBar = scrollPaint->scrollBar_.Upgrade();
1044 auto modifier = scrollPaint->GetOverlayModifier(&paintWrapper);
1045 auto scrollBarOverlayModifier = AceType::DynamicCast<ScrollBarOverlayModifier>(modifier);
1046 pattern_->SetScrollBar(DisplayMode::ON);
1047 EXPECT_EQ(scrollBar->displayMode_, DisplayMode::ON);
1048 EXPECT_TRUE(scrollBar->NeedPaint());
1049 ASSERT_NE(scrollBarOverlayModifier, nullptr);
1050 EXPECT_EQ(scrollBarOverlayModifier->GetOpacity(), UINT8_MAX);
1051 EXPECT_EQ(scrollBarOverlayModifier->opacityAnimation_, nullptr);
1052 EXPECT_EQ(scrollBarOverlayModifier->opacityAnimatingType_, OpacityAnimationType::NONE);
1053
1054 /**
1055 * @tc.steps: step2. DisplayMode::AUTO
1056 * @tc.expected: opacityAnimatingType_ is OpacityAnimationType::NONE.
1057 */
1058 pattern_->SetScrollBar(DisplayMode::AUTO);
1059 EXPECT_EQ(scrollBar->displayMode_, DisplayMode::AUTO);
1060 EXPECT_TRUE(scrollBar->NeedPaint());
1061 ASSERT_NE(scrollBarOverlayModifier, nullptr);
1062 scrollPaint->UpdateOverlayModifier(&paintWrapper);
1063 EXPECT_EQ(scrollBarOverlayModifier->opacityAnimatingType_, OpacityAnimationType::NONE);
1064
1065 /**
1066 * @tc.steps: step3. play appear animation.
1067 * @tc.expected: opacityAnimatingType_ is OpacityAnimationType::NONE.
1068 */
1069 scrollBar->PlayScrollBarAppearAnimation();
1070 scrollPaint->UpdateOverlayModifier(&paintWrapper);
1071 EXPECT_EQ(scrollBarOverlayModifier->opacityAnimatingType_, OpacityAnimationType::NONE);
1072
1073 /**
1074 * @tc.steps: step4. DisplayMode::OFF
1075 * @tc.expected: scrollBar->NeedPaint() is false.
1076 */
1077 pattern_->SetScrollBar(DisplayMode::OFF);
1078 EXPECT_EQ(pattern_->scrollBar_, nullptr);
1079 }
1080
1081 /**
1082 * @tc.name: ScrollBarAnimation003
1083 * @tc.desc: Test ScrollBar Adapt Animation
1084 * @tc.type: FUNC
1085 */
1086 HWTEST_F(ScrollTestNg, ScrollBarAnimation003, TestSize.Level1)
1087 {
1088 Testing::MockCanvas canvas;
1089 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
1090 PaintWrapper paintWrapper(nullptr, geometryNode, paintProperty_);
1091
1092 CreateWithContent();
1093 auto paint = pattern_->CreateNodePaintMethod();
1094 auto scrollPaint = AceType::DynamicCast<ScrollPaintMethod>(paint);
1095 auto scrollBar = scrollPaint->scrollBar_.Upgrade();
1096 auto modifier = scrollPaint->GetOverlayModifier(&paintWrapper);
1097 auto scrollBarOverlayModifier = AceType::DynamicCast<ScrollBarOverlayModifier>(modifier);
1098 pattern_->SetScrollBar(DisplayMode::ON);
1099 EXPECT_TRUE(scrollBar->NeedPaint());
1100 EXPECT_FLOAT_EQ(scrollBar->GetActiveRect().Height(), SCROLL_HEIGHT * VIEW_LINE_NUMBER / TOTAL_LINE_NUMBER);
1101
1102 /**
1103 * @tc.steps: step1. change scrollBar height.
1104 * @tc.expected: scrollBar->needAdaptAnimation_ is true.
1105 */
1106 scrollBar->UpdateScrollBarRegion(Offset::Zero(), Size(480.0, 800.0), Offset::Zero(), 1080.0f);
1107 scrollPaint->UpdateOverlayModifier(&paintWrapper);
1108 EXPECT_TRUE(NearEqual(scrollBar->GetActiveRect().Height(), 592.592f));
1109 EXPECT_TRUE(scrollBar->needAdaptAnimation_);
1110 }
1111
1112 /**
1113 * @tc.name: SpringEffect001
1114 * @tc.desc: Test SpringEffect
1115 * @tc.type: FUNC
1116 */
1117 HWTEST_F(ScrollTestNg, SpringEffect001, TestSize.Level1)
1118 {
1119 auto springEffect = AceType::MakeRefPtr<ScrollSpringEffect>();
1120 springEffect->ProcessScrollOver(0.0);
1121
__anon4dcc91dc2702(ScrollModelNG model) 1122 CreateWithContent([](ScrollModelNG model) { model.SetEdgeEffect(EdgeEffect::SPRING, true); });
1123 springEffect = AceType::DynamicCast<ScrollSpringEffect>(pattern_->GetScrollEdgeEffect());
1124 auto scrollable = AceType::MakeRefPtr<Scrollable>();
1125 springEffect->SetScrollable(scrollable);
1126 springEffect->ProcessScrollOver(0.0);
1127
1128 scrollable->MarkAvailable(false);
1129 springEffect->ProcessScrollOver(0.0);
1130
1131 pattern_->SetDirection(FlexDirection::ROW_REVERSE);
1132 pattern_->SetEdgeEffect(EdgeEffect::SPRING);
1133 springEffect->ProcessScrollOver(0.0);
1134
1135 EXPECT_TRUE(true);
1136 }
1137
1138 /**
1139 * @tc.name: ScrollTest002
1140 * @tc.desc: When setting a fixed length and width, verify the related functions in the scroll pattern.
1141 * @tc.type: FUNC
1142 */
1143 HWTEST_F(ScrollTestNg, ScrollTest002, TestSize.Level1)
1144 {
__anon4dcc91dc2802(ScrollModelNG model) 1145 CreateWithContent([](ScrollModelNG model) {
1146 model.SetAxis(Axis::HORIZONTAL);
1147 model.SetDisplayMode(static_cast<int>(DisplayMode::OFF));
1148 auto scrollProxy = model.CreateScrollBarProxy();
1149 model.SetScrollBarProxy(scrollProxy);
1150 });
1151
1152 /**
1153 * @tc.steps: step1. When Axis is HORIZONTAL, Verify the callback function registered in scrollBarProxy.
1154 * @tc.expected: Check whether the return value is as expected.
1155 */
1156 auto scrollBarProxy = pattern_->GetScrollBarProxy();
1157 EXPECT_FALSE(scrollBarProxy->scrollableNodes_.empty());
1158 bool ret = scrollBarProxy->scrollableNodes_.back().onPositionChanged(0.0, SCROLL_FROM_BAR);
1159 EXPECT_TRUE(ret);
1160 ret = scrollBarProxy->scrollableNodes_.back().onPositionChanged(0.0, SCROLL_FROM_START);
1161 EXPECT_TRUE(ret);
1162 }
1163
1164 /**
1165 * @tc.name: ScrollTest003
1166 * @tc.desc: When setting a fixed length and width, verify the related callback functions in the scroll pattern.
1167 * @tc.type: FUNC
1168 */
1169 HWTEST_F(ScrollTestNg, ScrollTest003, TestSize.Level1)
1170 {
1171 /**
1172 * @tc.steps: step1. Set ScrollSpringEffect and call relevant callback functions.
1173 * @tc.expected: Check whether the return value is correct.
1174 */
__anon4dcc91dc2902(ScrollModelNG model) 1175 CreateWithContent([](ScrollModelNG model) { model.SetEdgeEffect(EdgeEffect::SPRING, true); });
1176 EXPECT_EQ(pattern_->scrollableDistance_, VERTICAL_SCROLLABLE_DISTANCE);
1177 RefPtr<ScrollEdgeEffect> scrollEdgeEffect = pattern_->GetScrollEdgeEffect();
1178 auto springEffect = AceType::DynamicCast<ScrollSpringEffect>(scrollEdgeEffect);
1179 pattern_->currentOffset_ = 100.f;
1180 EXPECT_TRUE(springEffect->outBoundaryCallback_());
1181 auto currentPosition = scrollEdgeEffect->currentPositionCallback_();
1182 EXPECT_EQ(currentPosition, 100.0);
1183
1184 /**
1185 * @tc.steps: step2. When direction is the default value, call the relevant callback function.
1186 * @tc.expected: Check whether the return value is correct.
1187 */
1188 auto leading = scrollEdgeEffect->leadingCallback_();
1189 auto trailing = scrollEdgeEffect->trailingCallback_();
1190 auto initLeading = scrollEdgeEffect->initLeadingCallback_();
1191 auto initTrailing = scrollEdgeEffect->initTrailingCallback_();
1192 EXPECT_EQ(leading, -VERTICAL_SCROLLABLE_DISTANCE);
1193 EXPECT_EQ(trailing, 0.0);
1194 EXPECT_EQ(initLeading, -VERTICAL_SCROLLABLE_DISTANCE);
1195 EXPECT_EQ(initTrailing, 0.0);
1196
1197 /**
1198 * @tc.steps: step3. When direction is ROW_REVERSE, call the relevant callback function.
1199 * @tc.expected: Check whether the return value is correct.
1200 */
1201 pattern_->direction_ = FlexDirection::ROW_REVERSE;
1202 leading = scrollEdgeEffect->leadingCallback_();
1203 trailing = scrollEdgeEffect->trailingCallback_();
1204 initLeading = scrollEdgeEffect->initLeadingCallback_();
1205 initTrailing = scrollEdgeEffect->initTrailingCallback_();
1206 EXPECT_EQ(leading, 0.0);
1207 EXPECT_EQ(trailing, VERTICAL_SCROLLABLE_DISTANCE);
1208 EXPECT_EQ(initLeading, 0.0);
1209 EXPECT_EQ(initTrailing, VERTICAL_SCROLLABLE_DISTANCE);
1210
1211 /**
1212 * @tc.steps: step4. When direction is COLUMN_REVERSE, call the relevant callback function.
1213 * @tc.expected: Check whether the return value is correct.
1214 */
1215 pattern_->direction_ = FlexDirection::COLUMN_REVERSE;
1216 leading = scrollEdgeEffect->leadingCallback_();
1217 trailing = scrollEdgeEffect->trailingCallback_();
1218 initLeading = scrollEdgeEffect->initLeadingCallback_();
1219 initTrailing = scrollEdgeEffect->initTrailingCallback_();
1220 EXPECT_EQ(leading, 0.0);
1221 EXPECT_EQ(trailing, VERTICAL_SCROLLABLE_DISTANCE);
1222 EXPECT_EQ(initLeading, 0.0);
1223 EXPECT_EQ(initTrailing, VERTICAL_SCROLLABLE_DISTANCE);
1224
1225 /**
1226 * @tc.steps: step5. When direction is the default value and scrollableDistance_ <= 0.
1227 * @tc.expected: return 0.0
1228 */
__anon4dcc91dc2a02(ScrollModelNG model) 1229 Create([](ScrollModelNG model) {
1230 model.SetEdgeEffect(EdgeEffect::SPRING, true);
1231 CreateContent(VIEW_LINE_NUMBER);
1232 });
1233 EXPECT_EQ(pattern_->scrollableDistance_, 0);
1234 scrollEdgeEffect = pattern_->GetScrollEdgeEffect();
1235 leading = scrollEdgeEffect->leadingCallback_();
1236 initLeading = scrollEdgeEffect->initLeadingCallback_();
1237 EXPECT_EQ(leading, 0.0);
1238 EXPECT_EQ(initLeading, 0.0);
1239 }
1240
1241 /**
1242 * @tc.name: ScrollTest004
1243 * @tc.desc: When setting a fixed length and width, verify the related functions in the scroll pattern.
1244 * @tc.type: FUNC
1245 */
1246 HWTEST_F(ScrollTestNg, ScrollTest004, TestSize.Level1)
1247 {
1248 /**
1249 * @tc.steps: step1. Set ScrollFadeEffect and call relevant callback functions.
1250 * @tc.expected: Check whether the return value is correct.
1251 */
1252 CreateWithContent();
1253 pattern_->SetEdgeEffect(EdgeEffect::FADE);
1254 RefPtr<ScrollEdgeEffect> scrollEdgeEffect = pattern_->GetScrollEdgeEffect();
1255 ASSERT_NE(scrollEdgeEffect, nullptr);
1256 pattern_->currentOffset_ = 100.f;
1257 pattern_->scrollableDistance_ = 100.f;
1258 auto scrollFade = AceType::DynamicCast<ScrollFadeEffect>(scrollEdgeEffect);
1259 ASSERT_NE(scrollFade, nullptr);
1260 scrollFade->handleOverScrollCallback_();
1261 ASSERT_NE(scrollFade->fadeController_, nullptr);
1262 pattern_->SetEdgeEffect(EdgeEffect::NONE);
1263 EXPECT_EQ(pattern_->scrollEffect_, nullptr);
1264 }
1265
1266 /**
1267 * @tc.name: UpdateCurrentOffset001
1268 * @tc.desc: Test UpdateCurrentOffset that return
1269 * @tc.type: FUNC
1270 */
1271 HWTEST_F(ScrollTestNg, UpdateCurrentOffset001, TestSize.Level1)
1272 {
1273 /**
1274 * @tc.steps: step1. When unscrollable
1275 * @tc.expected: currentOffset would not change
1276 */
1277 Create();
1278 EXPECT_TRUE(UpdateAndVerifyPosition(-1, 0, SCROLL_FROM_UPDATE));
1279
1280 /**
1281 * @tc.steps: step2. When !HandleEdgeEffect and !IsOutOfBoundary
1282 * @tc.expected: currentOffset would not change
1283 */
1284 CreateWithContent();
1285 EXPECT_TRUE(UpdateAndVerifyPosition(1, 0, SCROLL_FROM_UPDATE));
1286
1287 /**
1288 * @tc.steps: step3. When !HandleEdgeEffect and IsOutOfBoundary
1289 * @tc.expected: currentOffset would not change
1290 */
1291 CreateWithContent();
1292 pattern_->currentOffset_ = 10.f;
1293 EXPECT_TRUE(UpdateAndVerifyPosition(1, 0, SCROLL_FROM_UPDATE));
1294 }
1295
1296 /**
1297 * @tc.name: UpdateCurrentOffset002
1298 * @tc.desc: Test UpdateCurrentOffset
1299 * @tc.type: FUNC
1300 */
1301 HWTEST_F(ScrollTestNg, UpdateCurrentOffset002, TestSize.Level1)
1302 {
1303 /**
1304 * @tc.steps: step1. When Axis::VERTICAL
1305 */
1306 CreateWithContent();
1307 EXPECT_TRUE(UpdateAndVerifyPosition(-1, -1, SCROLL_FROM_JUMP));
1308 EXPECT_TRUE(UpdateAndVerifyPosition(1, 0, SCROLL_FROM_BAR));
1309 EXPECT_TRUE(UpdateAndVerifyPosition(-1, -1, SCROLL_FROM_ROTATE));
1310 EXPECT_TRUE(UpdateAndVerifyPosition(1, 0, SCROLL_FROM_ANIMATION));
1311 EXPECT_TRUE(UpdateAndVerifyPosition(-1, -1, SCROLL_FROM_ANIMATION_SPRING));
1312
1313 /**
1314 * @tc.steps: step2. When Axis::HORIZONTAL
1315 */
__anon4dcc91dc2b02(ScrollModelNG model) 1316 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::HORIZONTAL); });
1317 EXPECT_TRUE(UpdateAndVerifyPosition(-1, -1, SCROLL_FROM_JUMP));
1318 EXPECT_TRUE(UpdateAndVerifyPosition(1, 0, SCROLL_FROM_BAR));
1319 EXPECT_TRUE(UpdateAndVerifyPosition(-1, -1, SCROLL_FROM_ROTATE));
1320 EXPECT_TRUE(UpdateAndVerifyPosition(1, 0, SCROLL_FROM_ANIMATION));
1321 EXPECT_TRUE(UpdateAndVerifyPosition(-1, -1, SCROLL_FROM_ANIMATION_SPRING));
1322
1323 /**
1324 * @tc.steps: step3. When EdgeEffect::SPRING, Test ValidateOffset
1325 */
__anon4dcc91dc2c02(ScrollModelNG model) 1326 CreateWithContent([](ScrollModelNG model) { model.SetEdgeEffect(EdgeEffect::SPRING, true); });
1327 EXPECT_FALSE(pattern_->IsRestrictBoundary());
1328 EXPECT_TRUE(UpdateAndVerifyPosition(-1, -1, SCROLL_FROM_JUMP));
1329 EXPECT_TRUE(UpdateAndVerifyPosition(1, 0, SCROLL_FROM_BAR));
1330 EXPECT_TRUE(UpdateAndVerifyPosition(-1, -1, SCROLL_FROM_BAR_FLING));
1331 EXPECT_TRUE(UpdateAndVerifyPosition(1, 0, SCROLL_FROM_ROTATE));
1332
1333 pattern_->currentOffset_ = -10.f;
1334 pattern_->UpdateScrollBarOffset();
1335 FlushLayoutTask(frameNode_);
1336 EXPECT_EQ(pattern_->GetScrollBarOutBoundaryExtent(), 0);
1337
1338 pattern_->currentOffset_ = -1000.f;
1339 pattern_->UpdateScrollBarOffset();
1340 FlushLayoutTask(frameNode_);
1341 EXPECT_EQ(pattern_->GetScrollBarOutBoundaryExtent(),
1342 -pattern_->currentOffset_ - (ITEM_HEIGHT * TOTAL_LINE_NUMBER - SCROLL_HEIGHT));
1343
1344 pattern_->currentOffset_ = -100.f;
1345 pattern_->UpdateScrollBarOffset();
1346 FlushLayoutTask(frameNode_);
1347 EXPECT_EQ(pattern_->GetScrollBarOutBoundaryExtent(), 0.0f);
1348 }
1349
1350 /**
1351 * @tc.name: ScrollFadeEffect001
1352 * @tc.desc: Test the correlation function in ScrollFadeEffect under different conditions.
1353 * @tc.type: FUNC
1354 */
1355 HWTEST_F(ScrollTestNg, ScrollFadeEffect001, TestSize.Level1)
1356 {
__anon4dcc91dc2d02(ScrollModelNG model) 1357 CreateWithContent([](ScrollModelNG model) { model.SetEdgeEffect(EdgeEffect::FADE, true); });
1358 RefPtr<ScrollEdgeEffect> scrollEdgeEffect = pattern_->GetScrollEdgeEffect();
1359 auto scrollable = AceType::MakeRefPtr<Scrollable>();
1360 scrollEdgeEffect->SetScrollable(scrollable);
1361
1362 /**
1363 * @tc.steps: step1. call InitialEdgeEffect()
1364 */
1365 auto scrollFadeEffect = AceType::DynamicCast<ScrollFadeEffect>(scrollEdgeEffect);
1366 scrollEdgeEffect->InitialEdgeEffect();
1367 EXPECT_EQ(scrollFadeEffect->fadeColor_, Color::GRAY);
1368 scrollFadeEffect->fadeController_->DecelerateListener(1.0);
1369
1370 /**
1371 * @tc.steps: step2. call HandleOverScroll(), overScroll is 0
1372 * @tc.expected: do nothing
1373 */
1374 const SizeF viewPort(SCROLL_WIDTH, SCROLL_HEIGHT);
1375 scrollFadeEffect->HandleOverScroll(Axis::VERTICAL, 0.f, viewPort);
1376
1377 /**
1378 * @tc.steps: step3. call HandleOverScroll()
1379 */
1380 scrollFadeEffect->fadeController_ = nullptr;
1381 scrollFadeEffect->HandleOverScroll(Axis::VERTICAL, -1.f, viewPort);
1382 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::UP);
1383 ASSERT_NE(scrollFadeEffect->fadeController_, nullptr);
1384 scrollFadeEffect->fadeController_->DecelerateListener(1.0);
1385
1386 scrollFadeEffect->scrollable_->currentVelocity_ = 1000.0;
1387 scrollFadeEffect->HandleOverScroll(Axis::VERTICAL, 1.f, viewPort);
1388 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::DOWN);
1389
1390 scrollFadeEffect->scrollable_->currentVelocity_ = 0.0;
1391 scrollFadeEffect->HandleOverScroll(Axis::HORIZONTAL, -1.f, viewPort);
1392 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::LEFT);
1393
1394 scrollFadeEffect->scrollable_->currentVelocity_ = 1000.0;
1395 scrollFadeEffect->HandleOverScroll(Axis::HORIZONTAL, 1.f, viewPort);
1396 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::RIGHT);
1397
1398 /**
1399 * @tc.steps: step4. scrollable_ is null, call HandleOverScroll()
1400 */
1401 scrollFadeEffect->scrollable_ = nullptr;
1402 scrollFadeEffect->HandleOverScroll(Axis::HORIZONTAL, -1.f, viewPort);
1403
1404 /**
1405 * @tc.steps: step5. Call CalculateOverScroll()
1406 */
1407 // minExtent: 0
1408 // maxExtent: ITEM_HEIGHT * 2
1409 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(ITEM_HEIGHT, true), 0.0));
1410 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(0.0, true), 0.0));
1411 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(-ITEM_HEIGHT, true), 0.0));
1412
1413 UpdateCurrentOffset(-ITEM_HEIGHT);
1414 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(ITEM_HEIGHT * 2, true), 0.0));
1415 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(0.0, true), 0.0));
1416 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(-ITEM_HEIGHT * 2, true), 0.0));
1417
1418 UpdateCurrentOffset(-ITEM_HEIGHT);
1419 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(ITEM_HEIGHT, true), 0.0));
1420 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(0.0, true), 0.0));
1421 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(-ITEM_HEIGHT, true), 0.0));
1422
1423 pattern_->currentOffset_ = ITEM_HEIGHT;
1424 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(ITEM_HEIGHT, true), -ITEM_HEIGHT));
1425 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(0.0, true), -ITEM_HEIGHT));
1426 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(-ITEM_HEIGHT * 2, true), 0.0));
1427
1428 pattern_->currentOffset_ = -ITEM_HEIGHT;
1429 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(ITEM_HEIGHT * 2, true), 0.0));
1430 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(0.0, true), 0.0));
1431 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(-ITEM_HEIGHT, true), 0.0));
1432
1433 // over scroll
1434 pattern_->currentOffset_ = -ITEM_HEIGHT * 3;
1435 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(ITEM_HEIGHT * 2, true), ITEM_HEIGHT));
1436
1437 // crash the bottom
1438 pattern_->currentOffset_ = -ITEM_HEIGHT * 3;
1439 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(ITEM_HEIGHT, true), ITEM_HEIGHT));
1440 pattern_->currentOffset_ = -ITEM_HEIGHT * 3;
1441 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(ITEM_HEIGHT, false), 0.0));
1442 pattern_->currentOffset_ = -ITEM_HEIGHT * 3;
1443 EXPECT_TRUE(NearEqual(scrollFadeEffect->CalculateOverScroll(ITEM_HEIGHT * 3, false), 0.0));
1444 }
1445
1446 /**
1447 * @tc.name: ScrollFadeEffect002
1448 * @tc.desc: Test
1449 * @tc.type: FUNC
1450 */
1451 HWTEST_F(ScrollTestNg, ScrollFadeEffect002, TestSize.Level1)
1452 {
__anon4dcc91dc2e02(ScrollModelNG model) 1453 CreateWithContent([](ScrollModelNG model) { model.SetEdgeEffect(EdgeEffect::FADE, true); });
1454 RefPtr<ScrollEdgeEffect> scrollEdgeEffect = pattern_->GetScrollEdgeEffect();
1455 auto scrollFadeEffect = AceType::DynamicCast<ScrollFadeEffect>(scrollEdgeEffect);
1456 scrollFadeEffect->InitialEdgeEffect();
1457
1458 Testing::MockCanvas rsCanvas;
1459 EXPECT_CALL(rsCanvas, Restore()).Times(AtLeast(1));
1460 EXPECT_CALL(rsCanvas, Save()).Times(AtLeast(1));
1461 EXPECT_CALL(rsCanvas, Translate(_, _)).Times(AtLeast(1));
1462 EXPECT_CALL(rsCanvas, Scale(_, _)).Times(AtLeast(1));
1463 EXPECT_CALL(rsCanvas, Rotate(_)).Times(AtLeast(1));
1464 OffsetF offset = OffsetF(0, 0);
1465 scrollFadeEffect->fadePainter_->SetOpacity(0);
1466 scrollFadeEffect->fadePainter_->direction_ = OverScrollDirection::UP;
1467 scrollFadeEffect->Paint(rsCanvas, SizeF(1, 1), offset);
1468 scrollFadeEffect->fadePainter_->SetOpacity(1);
1469 scrollFadeEffect->fadePainter_->direction_ = OverScrollDirection::DOWN;
1470 scrollFadeEffect->Paint(rsCanvas, SizeF(0, 1), offset);
1471 scrollFadeEffect->fadePainter_->direction_ = OverScrollDirection::LEFT;
1472 scrollFadeEffect->Paint(rsCanvas, SizeF(1, 0), offset);
1473 scrollFadeEffect->fadePainter_->direction_ = OverScrollDirection::RIGHT;
1474 scrollFadeEffect->Paint(rsCanvas, SizeF(0, 0), offset);
1475 SUCCEED();
1476 }
1477
1478 /**
1479 * @tc.name: ScrollFadeEffect003
1480 * @tc.desc: Test SetPaintDirection in different situations.
1481 * @tc.type: FUNC
1482 */
1483 HWTEST_F(ScrollTestNg, ScrollFadeEffect003, TestSize.Level1)
1484 {
__anon4dcc91dc2f02(ScrollModelNG model) 1485 CreateWithContent([](ScrollModelNG model) { model.SetEdgeEffect(EdgeEffect::FADE, true); });
1486 RefPtr<ScrollEdgeEffect> scrollEdgeEffect = pattern_->GetScrollEdgeEffect();
1487 auto scrollable = AceType::MakeRefPtr<Scrollable>();
1488 scrollEdgeEffect->SetScrollable(scrollable);
1489
1490 /**
1491 * @tc.steps: step1. call InitialEdgeEffect()
1492 */
1493 auto scrollFadeEffect = AceType::DynamicCast<ScrollFadeEffect>(scrollEdgeEffect);
1494 scrollEdgeEffect->InitialEdgeEffect();
1495 EXPECT_EQ(scrollFadeEffect->fadeColor_, Color::GRAY);
1496 scrollFadeEffect->fadeController_->DecelerateListener(1.0);
1497
1498 /**
1499 * @tc.steps: step2. overScroll is 0.001, call SetPaintDirection()
1500 */
1501 scrollFadeEffect->SetPaintDirection(Axis::HORIZONTAL, 0.001f, true);
1502
1503 /**
1504 * @tc.steps: step3. call SetPaintDirection() and axis is vertical.
1505 */
1506 scrollFadeEffect->fadeController_ = nullptr;
1507 scrollFadeEffect->SetPaintDirection(Axis::VERTICAL, -1.f, true);
1508 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::UP);
1509
1510 scrollFadeEffect->scrollable_->currentVelocity_ = 1000.0;
1511 scrollFadeEffect->SetPaintDirection(Axis::VERTICAL, 1.f, true);
1512 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::DOWN);
1513
1514 /**
1515 * @tc.steps: step4. call SetPaintDirection() and axis is horizontal.
1516 */
1517 scrollFadeEffect->scrollable_->currentVelocity_ = 0.0;
1518 scrollFadeEffect->SetPaintDirection(Axis::HORIZONTAL, -1.f, true);
1519 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::LEFT);
1520
1521 scrollFadeEffect->scrollable_->currentVelocity_ = 1000.0;
1522 scrollFadeEffect->SetPaintDirection(Axis::HORIZONTAL, 1.f, true);
1523 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::RIGHT);
1524 }
1525
1526 /**
1527 * @tc.name: ScrollFadeEffect004
1528 * @tc.desc: Test SetPaintDirection in different situations.
1529 * @tc.type: FUNC
1530 */
1531 HWTEST_F(ScrollTestNg, ScrollFadeEffect004, TestSize.Level1)
1532 {
__anon4dcc91dc3002(ScrollModelNG model) 1533 CreateWithContent([](ScrollModelNG model) { model.SetEdgeEffect(EdgeEffect::FADE, true); });
1534 RefPtr<ScrollEdgeEffect> scrollEdgeEffect = pattern_->GetScrollEdgeEffect();
1535 auto scrollable = AceType::MakeRefPtr<Scrollable>();
1536 scrollEdgeEffect->SetScrollable(scrollable);
1537
1538 /**
1539 * @tc.steps: step1. call InitialEdgeEffect()
1540 */
1541 auto scrollFadeEffect = AceType::DynamicCast<ScrollFadeEffect>(scrollEdgeEffect);
1542 scrollEdgeEffect->InitialEdgeEffect();
1543 EXPECT_EQ(scrollFadeEffect->fadeColor_, Color::GRAY);
1544 scrollFadeEffect->fadeController_->DecelerateListener(1.0);
1545
1546 /**
1547 * @tc.steps: step2. call SetPaintDirection() and axis is vertical.
1548 */
1549 scrollFadeEffect->scrollable_->currentVelocity_ = 1000.0;
1550 scrollFadeEffect->SetPaintDirection(Axis::VERTICAL, 1.f, true);
1551 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::DOWN);
1552
1553 scrollFadeEffect->SetPaintDirection(Axis::VERTICAL, -1.f, true);
1554 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::UP);
1555
1556 /**
1557 * @tc.steps: step3. call SetPaintDirection() and axis is horizontal.
1558 */
1559 scrollFadeEffect->scrollable_->currentVelocity_ = 1000.0;
1560 scrollFadeEffect->SetPaintDirection(Axis::HORIZONTAL, 1.f, true);
1561 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::RIGHT);
1562
1563 scrollFadeEffect->scrollable_->currentVelocity_ = 0.0;
1564 scrollFadeEffect->SetPaintDirection(Axis::HORIZONTAL, -1.f, true);
1565 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::LEFT);
1566 }
1567
1568 /**
1569 * @tc.name: ScrollFadeEffect005
1570 * @tc.desc: Test HandleOverScroll in different situations.
1571 * @tc.type: FUNC
1572 */
1573 HWTEST_F(ScrollTestNg, ScrollFadeEffect005, TestSize.Level1)
1574 {
__anon4dcc91dc3102(ScrollModelNG model) 1575 CreateWithContent([](ScrollModelNG model) { model.SetEdgeEffect(EdgeEffect::FADE, true); });
1576 RefPtr<ScrollEdgeEffect> scrollEdgeEffect = pattern_->GetScrollEdgeEffect();
1577 auto scrollable = AceType::MakeRefPtr<Scrollable>();
1578 scrollEdgeEffect->SetScrollable(scrollable);
1579
1580 /**
1581 * @tc.steps: step1. call InitialEdgeEffect()
1582 */
1583 auto scrollFadeEffect = AceType::DynamicCast<ScrollFadeEffect>(scrollEdgeEffect);
1584 scrollEdgeEffect->InitialEdgeEffect();
1585 EXPECT_EQ(scrollFadeEffect->fadeColor_, Color::GRAY);
1586 scrollFadeEffect->fadeController_->DecelerateListener(1.0);
1587
1588 /**
1589 * @tc.steps: step2. call HandleOverScroll(), axis is vertical and isScrollFromUpdate is false.
1590 * @tc.expected: do nothing
1591 */
1592 const SizeF viewPort(SCROLL_WIDTH, SCROLL_HEIGHT);
1593 scrollFadeEffect->HandleOverScroll(Axis::VERTICAL, 0.f, viewPort);
1594
1595 /**
1596 * @tc.steps: step3. call HandleOverScroll(), axis is vertical and isScrollFromUpdate is true.
1597 */
1598 scrollFadeEffect->fadeController_ = nullptr;
1599 scrollFadeEffect->HandleOverScroll(Axis::VERTICAL, -1.f, viewPort, true, false);
1600 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::UP);
1601 ASSERT_NE(scrollFadeEffect->fadeController_, nullptr);
1602
1603 /**
1604 * @tc.steps: step4. call HandleOverScroll(), axis is horizontal and isScrollFromUpdate is true.
1605 */
1606 scrollFadeEffect->scrollable_->currentVelocity_ = 0.0;
1607 scrollFadeEffect->HandleOverScroll(Axis::HORIZONTAL, -1.f, viewPort, true, false);
1608 EXPECT_EQ(scrollFadeEffect->fadePainter_->direction_, OverScrollDirection::LEFT);
1609 }
1610
1611 /**
1612 * @tc.name: FadeController001
1613 * @tc.desc: Test scroll_fade_controller
1614 * @tc.type: FUNC
1615 */
1616 HWTEST_F(ScrollTestNg, FadeController001, TestSize.Level1)
1617 {
1618 /**
1619 * @tc.steps: step1. Create ScrollFadeController and set callback function.
1620 */
1621 auto fadeController = AceType::MakeRefPtr<ScrollFadeController>();
1622 ASSERT_NE(fadeController, nullptr);
1623 double param1 = 10.f;
1624 double param2 = -10.0;
__anon4dcc91dc3202(double parameter1, double parameter2) 1625 auto callback = [¶m1, ¶m2](double parameter1, double parameter2) {
1626 param1 = parameter1;
1627 param2 = parameter2;
1628 };
1629 fadeController->SetCallback(callback);
1630
1631 /**
1632 * @tc.steps: step2. Verify the ProcessAbsorb function and callback function in fadeController.
1633 * @tc.expected: step2. Check whether relevant parameters are correct.
1634 */
1635 fadeController->ProcessAbsorb(100.0);
1636 EXPECT_EQ(fadeController->opacityFloor_, 0.3);
1637 EXPECT_EQ(fadeController->opacityCeil_, 0.3);
1638 EXPECT_EQ(fadeController->scaleSizeFloor_, 0.0);
1639 EXPECT_EQ(fadeController->scaleSizeCeil_, 0.0325);
1640 EXPECT_EQ(fadeController->state_, OverScrollState::ABSORB);
1641 fadeController->decele_->NotifyListener(100.0);
1642 EXPECT_EQ(fadeController->opacity_, 0.3);
1643 EXPECT_EQ(fadeController->scaleSize_, 3.25);
1644 EXPECT_EQ(param1, fadeController->opacity_);
1645 EXPECT_EQ(param2, fadeController->scaleSize_);
1646
1647 /**
1648 * @tc.steps: step2. When OverScrollState is ABSORB, call the callback function in fadeController.
1649 * @tc.expected: step2. Check whether relevant parameters are correct.
1650 */
1651 fadeController->controller_->NotifyStopListener();
1652 EXPECT_EQ(fadeController->opacityCeil_, 0.0);
1653 EXPECT_EQ(fadeController->scaleSizeCeil_, 0.0);
1654 EXPECT_EQ(fadeController->state_, OverScrollState::RECEDE);
1655
1656 /**
1657 * @tc.steps: step3. When OverScrollState is RECEDE, call the ProcessRecede function and callback function in
1658 * fadeController.
1659 * @tc.expected: step3. Check whether relevant parameters are correct.
1660 */
1661 fadeController->ProcessRecede(1000);
1662 fadeController->controller_->NotifyStopListener();
1663 EXPECT_EQ(fadeController->state_, OverScrollState::IDLE);
1664 EXPECT_EQ(fadeController->pullDistance_, 0.0);
1665 fadeController->ProcessRecede(1000);
1666 EXPECT_EQ(fadeController->pullDistance_, 0.0);
1667
1668 /**
1669 * @tc.steps: step4. When OverScrollState is IDLE, call the ProcessPull function and callback function in
1670 * fadeController.
1671 * @tc.expected: step4. Check whether relevant parameters are correct.
1672 */
1673 fadeController->ProcessPull(1.0, 1.0, 1.0);
1674 EXPECT_EQ(fadeController->opacityFloor_, 0.3);
1675 EXPECT_EQ(fadeController->opacityCeil_, 0.0);
1676 EXPECT_EQ(fadeController->scaleSizeFloor_, 3.25);
1677 EXPECT_EQ(fadeController->scaleSizeCeil_, 0.0);
1678 EXPECT_EQ(fadeController->state_, OverScrollState::RECEDE);
1679
1680 /**
1681 * @tc.steps: step5. When OverScrollState is PULL, call the ProcessAbsorb function and callback function in
1682 * fadeController.
1683 * @tc.expected: step5. Check whether relevant parameters are correct.
1684 */
1685 fadeController->ProcessAbsorb(-10.0);
1686 fadeController->decele_->NotifyListener(100.0);
1687 EXPECT_EQ(fadeController->opacity_, -29.7);
1688 EXPECT_EQ(fadeController->scaleSize_, -321.75);
1689 fadeController->controller_->NotifyStopListener();
1690 EXPECT_EQ(fadeController->state_, OverScrollState::IDLE);
1691 fadeController->ProcessAbsorb(100.0);
1692 fadeController->ProcessPull(1.0, 1.0, 1.0);
1693 fadeController->decele_->NotifyListener(100.0);
1694 EXPECT_EQ(param1, 2940.3);
1695 EXPECT_EQ(param2, 31853.25);
1696 }
1697
1698 /**
1699 * @tc.name: FadeController002
1700 * @tc.desc: Test scroll_fade_controller
1701 * @tc.type: FUNC
1702 */
1703 HWTEST_F(ScrollTestNg, FadeController002, TestSize.Level1)
1704 {
1705 /**
1706 * @tc.steps: step1. Create ScrollFadeController and set callback function.
1707 */
1708 auto fadeController = AceType::MakeRefPtr<ScrollFadeController>();
1709 ASSERT_NE(fadeController, nullptr);
1710 double param1 = 10.f;
1711 double param2 = -10.0;
__anon4dcc91dc3302(double parameter1, double parameter2) 1712 auto callback = [¶m1, ¶m2](double parameter1, double parameter2) {
1713 param1 = parameter1;
1714 param2 = parameter2;
1715 };
1716 fadeController->SetCallback(callback);
1717
1718 /**
1719 * @tc.steps: step2. When OverScrollState is IDLE, call the ProcessAbsorb function and callback function in
1720 * fadeController.
1721 * @tc.expected: step2. Check whether relevant parameters are correct.
1722 */
1723 fadeController->state_ = OverScrollState::IDLE;
1724 fadeController->ProcessAbsorb(1.0);
1725 fadeController->decele_->NotifyListener(100.0);
1726 EXPECT_EQ(fadeController->opacity_, 0.3);
1727 EXPECT_EQ(fadeController->scaleSize_, 3.25);
1728
1729 /**
1730 * @tc.steps: step3. When OverScrollState is PULL, call the ProcessPull function and callback function in
1731 * fadeController.
1732 * @tc.expected: step3. Check whether relevant parameters are correct.
1733 */
1734 fadeController->controller_->NotifyStopListener();
1735 fadeController->state_ = OverScrollState::PULL;
1736 fadeController->ProcessPull(1.0, 1.0, 1.0);
1737 EXPECT_EQ(fadeController->state_, OverScrollState::RECEDE);
1738
1739 /**
1740 * @tc.steps: step4. When OverScrollState is PULL, call the ProcessRecede function and callback function in
1741 * fadeController.
1742 * @tc.expected: step4. Check whether relevant parameters are correct.
1743 */
1744 fadeController->controller_ = nullptr;
1745 fadeController->ProcessRecede(10);
1746 EXPECT_EQ(fadeController->state_, OverScrollState::RECEDE);
1747
1748 /**
1749 * @tc.steps: step5. When OverScrollState is 0, call the Initialize function and callback function in
1750 * fadeController.
1751 * @tc.expected: step5. Check whether relevant parameters are correct.
1752 */
1753 int value = 4;
1754 OverScrollState data = static_cast<OverScrollState>(value);
1755 fadeController->state_ = data;
1756 fadeController->ProcessAbsorb(1.0);
1757 }
1758
1759 /**
1760 * @tc.name: FadeController003
1761 * @tc.desc: Test scroll_fade_controller
1762 * @tc.type: FUNC
1763 */
1764 HWTEST_F(ScrollTestNg, FadeController003, TestSize.Level1)
1765 {
1766 /**
1767 * @tc.steps: step1. Create ScrollFadeController and set callback function.
1768 */
1769 auto fadeController = AceType::MakeRefPtr<ScrollFadeController>();
1770 ASSERT_NE(fadeController, nullptr);
1771 double param1 = 10.f;
1772 double param2 = -10.0;
__anon4dcc91dc3402(double parameter1, double parameter2) 1773 auto callback = [¶m1, ¶m2](double parameter1, double parameter2) {
1774 param1 = parameter1;
1775 param2 = parameter2;
1776 };
1777 fadeController->SetCallback(callback);
1778
1779 /**
1780 * @tc.steps: step2. When OverScrollState is PULL, call the ProcessAbsorb function and callback function in
1781 * fadeController.
1782 * @tc.expected: step2. Check whether relevant parameters are correct.
1783 */
1784 fadeController->controller_ = nullptr;
1785 fadeController->state_ = OverScrollState::PULL;
1786 fadeController->ProcessAbsorb(10);
1787 fadeController->ProcessRecede(10);
1788 EXPECT_EQ(fadeController->state_, OverScrollState::PULL);
1789 fadeController->ProcessPull(1.0, 0.0, 1.0);
1790
1791 /**
1792 * @tc.steps: step3. When OverScrollState is IDLE, call the DecelerateListener function and callback function in
1793 * fadeController.
1794 * @tc.expected: step3. Check whether relevant parameters are correct.
1795 */
1796 fadeController->state_ = OverScrollState::IDLE;
1797 fadeController->ProcessAbsorb(-10);
1798 fadeController->callback_ = nullptr;
1799 fadeController->DecelerateListener(0.0);
1800 EXPECT_EQ(fadeController->state_, OverScrollState::IDLE);
1801 }
1802
1803 /**
1804 * @tc.name: ScrollBar001
1805 * @tc.desc: Test UpdateScrollBarRegion function in ScrollBar under different conditions.
1806 * @tc.type: FUNC
1807 */
1808 HWTEST_F(ScrollTestNg, ScrollBar001, TestSize.Level1)
1809 {
1810 /**
1811 * @tc.steps: step1. When the ShapeMode is RECT and DisplayMode is LEFT, verify the UpdateScrollBarRegion function.
1812 * @tc.expected: step1. Check whether relevant parameters are correct.
1813 */
1814 auto scrollBar = AceType::MakeRefPtr<ScrollBar>(DisplayMode::AUTO);
1815 ASSERT_NE(scrollBar, nullptr);
1816 scrollBar->shapeMode_ = ShapeMode::RECT;
1817 scrollBar->positionMode_ = PositionMode::LEFT;
1818 scrollBar->UpdateScrollBarRegion(Offset::Zero(), Size(100.0, 100.0), Offset(1.f, 1.f), 1.0);
1819 auto barRect = Rect(0.0, 0.0, NORMAL_WIDTH, 100.0) + Offset::Zero();
1820 EXPECT_TRUE(IsEqual(scrollBar->barRect_, barRect));
1821 EXPECT_TRUE(IsEqual(scrollBar->activeRect_, Rect(0.0, -9900.0, NORMAL_WIDTH, 10000.0)));
1822 EXPECT_TRUE(IsEqual(scrollBar->touchRegion_, Rect(0.0, -9900.0, NORMAL_WIDTH, 10000.0)));
1823
1824 /**
1825 * @tc.steps: step2. When the ShapeMode is RECT and DisplayMode is BOTTOM, verify the UpdateScrollBarRegion
1826 * function.
1827 * @tc.expected: step2. Check whether relevant parameters are correct.
1828 */
1829 scrollBar->positionModeUpdate_ = true;
1830 scrollBar->positionMode_ = PositionMode::BOTTOM;
1831 scrollBar->SetOutBoundary(1.0);
1832 scrollBar->UpdateScrollBarRegion(Offset::Zero(), Size(100.0, 100.0), Offset(1.f, 1.f), 1.0);
1833 barRect = Rect(0.0, 100.0 - NORMAL_WIDTH, 100.0, NORMAL_WIDTH) + Offset::Zero();
1834 EXPECT_TRUE(IsEqual(scrollBar->barRect_, barRect));
1835 EXPECT_TRUE(IsEqual(scrollBar->activeRect_, Rect(-9899.0, 100.0 - NORMAL_WIDTH, 9999.0, NORMAL_WIDTH)));
1836 EXPECT_TRUE(IsEqual(scrollBar->touchRegion_, Rect(-9899.0, 100.0, 9999.0, 0.0)));
1837
1838 /**
1839 * @tc.steps: step3. When the ShapeMode is RECT and DisplayMode is RIGHT, verify the UpdateScrollBarRegion function.
1840 * @tc.expected: step3. Check whether relevant parameters are correct.
1841 */
1842 scrollBar->positionModeUpdate_ = true;
1843 scrollBar->positionMode_ = PositionMode::RIGHT;
1844 scrollBar->UpdateScrollBarRegion(Offset::Zero(), Size(100.0, 100.0), Offset(1.f, 1.f), 1.0);
1845 barRect = Rect(100.0 - NORMAL_WIDTH, 0.0, NORMAL_WIDTH, 100.0) + Offset::Zero();
1846 EXPECT_TRUE(IsEqual(scrollBar->barRect_, barRect));
1847 EXPECT_TRUE(IsEqual(scrollBar->activeRect_, Rect(100.0 - NORMAL_WIDTH, -9899.0, NORMAL_WIDTH, 9999.0)));
1848 EXPECT_TRUE(IsEqual(scrollBar->touchRegion_, Rect(100.0, -9899.0, 0.0, 9999.0)));
1849
1850 /**
1851 * @tc.steps: step4. When the ShapeMode is ROUND and DisplayMode is LEFT, verify the UpdateScrollBarRegion function.
1852 * @tc.expected: step4. Check whether relevant parameters are correct.
1853 */
1854 scrollBar->positionModeUpdate_ = true;
1855 scrollBar->shapeMode_ = ShapeMode::ROUND;
1856 scrollBar->positionMode_ = PositionMode::LEFT;
1857 scrollBar->UpdateScrollBarRegion(Offset::Zero(), Size(100.0, 100.0), Offset(1.f, 1.f), 1.0);
1858 EXPECT_EQ(scrollBar->trickStartAngle_, 150);
1859 EXPECT_EQ(scrollBar->trickSweepAngle_, -6000);
1860
1861 /**
1862 * @tc.steps: step5. When the ShapeMode is ROUND and DisplayMode is RIGHT, verify the UpdateScrollBarRegion
1863 * function.
1864 * @tc.expected: step5. Check whether relevant parameters are correct.
1865 */
1866 scrollBar->positionModeUpdate_ = true;
1867 scrollBar->positionMode_ = PositionMode::RIGHT;
1868 scrollBar->UpdateScrollBarRegion(Offset::Zero(), Size(100.0, 100.0), Offset(1.f, 1.f), 1.0);
1869 EXPECT_EQ(scrollBar->trickStartAngle_, 30);
1870 EXPECT_EQ(scrollBar->trickSweepAngle_, 6000);
1871
1872 /**
1873 * @tc.steps: step6. When the ShapeMode is ROUND and DisplayMode is LEFT, verify the UpdateScrollBarRegion function.
1874 * @tc.expected: step6. Check whether relevant parameters are correct.
1875 */
1876 scrollBar->positionModeUpdate_ = true;
1877 scrollBar->positionMode_ = PositionMode::LEFT;
1878 scrollBar->bottomAngle_ = 50.f;
1879 scrollBar->topAngle_ = 100.0;
1880 scrollBar->SetOutBoundary(1.0);
1881 scrollBar->UpdateScrollBarRegion(Offset::Zero(), Size(100.0, 100.0), Offset(1.f, 1.f), 200.0);
1882 EXPECT_EQ(scrollBar->trickStartAngle_, -155);
1883 EXPECT_EQ(scrollBar->trickSweepAngle_, -10);
1884 }
1885
1886 /**
1887 * @tc.name: ScrollBar002
1888 * @tc.desc: Test SetGestureEvent() / SetMouseEvent() / SetHoverEvent()
1889 * @tc.type: FUNC
1890 */
1891 HWTEST_F(ScrollTestNg, ScrollBar002, TestSize.Level1)
1892 {
1893 /**
1894 * @tc.steps: step1. Touch in bar
1895 * @tc.expected: touchAnimator_ is take effect
1896 */
1897 // pattern_->GetScrollBar()->touchRegion_ == Rect (710.00, 0.00) - [10.00 x 946.67]
1898 const float barWidth = 10.f;
__anon4dcc91dc3502(ScrollModelNG model) 1899 CreateWithContent([barWidth](ScrollModelNG model) { model.SetScrollBarWidth(Dimension(barWidth)); });
1900 auto scrollBar = pattern_->GetScrollBar();
1901 const Offset downInBar = Offset(SCROLL_WIDTH - 1.f, 0.f);
1902 const Offset moveInBar = Offset(SCROLL_WIDTH - 1.f, 10.f);
1903 const Offset upInBar = moveInBar;
1904 const Offset upOutBar = Offset(SCROLL_WIDTH - barWidth - 1.f, 10.f);
1905
1906 Touch(TouchType::DOWN, downInBar, SourceType::TOUCH);
1907
1908 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::GROW);
1909 EXPECT_TRUE(scrollBar->IsPressed());
1910 Touch(TouchType::MOVE, moveInBar, SourceType::TOUCH);
1911 EXPECT_TRUE(scrollBar->IsPressed());
1912 Touch(TouchType::UP, upInBar, SourceType::TOUCH);
1913 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::SHRINK);
1914 EXPECT_FALSE(scrollBar->IsPressed());
1915
1916 /**
1917 * @tc.steps: step2. Touch in bar and up out of bar
1918 * @tc.expected: touchAnimator_ is take effect
1919 */
1920 Touch(TouchType::DOWN, downInBar, SourceType::TOUCH);
1921 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::GROW);
1922 EXPECT_TRUE(scrollBar->IsPressed());
1923 Touch(TouchType::MOVE, moveInBar, SourceType::TOUCH);
1924 EXPECT_TRUE(scrollBar->IsPressed());
1925 Touch(TouchType::UP, upOutBar, SourceType::TOUCH);
1926 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::SHRINK);
1927 EXPECT_FALSE(scrollBar->IsPressed());
1928
1929 /**
1930 * @tc.steps: step3. Touch in bar with SourceType::MOUSE
1931 * @tc.expected: touchAnimator_ is take effect
1932 */
1933 Touch(TouchType::DOWN, downInBar, SourceType::MOUSE);
1934 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::GROW);
1935 EXPECT_TRUE(scrollBar->IsPressed());
1936 Touch(TouchType::MOVE, moveInBar, SourceType::MOUSE);
1937 EXPECT_TRUE(scrollBar->IsPressed());
1938 Touch(TouchType::UP, upInBar, SourceType::MOUSE);
1939 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::SHRINK);
1940 EXPECT_FALSE(scrollBar->IsPressed());
1941
1942 /**
1943 * @tc.steps: step4. Touch in bar with SourceType::TOUCH_PAD
1944 * @tc.expected: touchAnimator_ is not take effect
1945 */
1946 scrollBar->SetHoverAnimationType(HoverAnimationType::NONE);
1947 Touch(TouchType::DOWN, downInBar, SourceType::TOUCH_PAD);
1948 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
1949 EXPECT_FALSE(scrollBar->IsPressed());
1950 Touch(TouchType::MOVE, moveInBar, SourceType::TOUCH_PAD);
1951 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
1952 EXPECT_FALSE(scrollBar->IsPressed());
1953 Touch(TouchType::UP, upInBar, SourceType::TOUCH_PAD);
1954 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
1955 EXPECT_FALSE(scrollBar->IsPressed());
1956
1957 /**
1958 * @tc.steps: step5. Touch out of bar
1959 * @tc.expected: touchAnimator_ is not take effect
1960 */
1961 scrollBar->SetHoverAnimationType(HoverAnimationType::NONE);
1962 Touch(TouchType::DOWN, Offset::Zero(), SourceType::TOUCH);
1963 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
1964 EXPECT_FALSE(scrollBar->IsPressed());
1965 Touch(TouchType::MOVE, moveInBar, SourceType::TOUCH);
1966 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
1967 EXPECT_FALSE(scrollBar->IsPressed());
1968 Touch(TouchType::UP, upInBar, SourceType::TOUCH);
1969 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
1970 EXPECT_FALSE(scrollBar->IsPressed());
1971
1972 /**
1973 * @tc.steps: step6. Touch in bar and scrollBar->IsHover() is true
1974 * @tc.expected: touchAnimator_ is not take effect
1975 */
1976 scrollBar->SetHoverAnimationType(HoverAnimationType::NONE);
1977 scrollBar->SetHover(true);
1978 Touch(TouchType::DOWN, downInBar, SourceType::TOUCH);
1979 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
1980 EXPECT_TRUE(scrollBar->IsPressed());
1981 Touch(TouchType::MOVE, moveInBar, SourceType::TOUCH);
1982 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
1983 EXPECT_TRUE(scrollBar->IsPressed());
1984 Touch(TouchType::UP, upInBar, SourceType::TOUCH);
1985 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
1986 EXPECT_FALSE(scrollBar->IsPressed());
1987
1988 /**
1989 * @tc.steps: step7. Mouse in bar and move out of bar (out->in->in->out)
1990 * @tc.expected: touchAnimator_ is take effect
1991 */
__anon4dcc91dc3602(ScrollModelNG model) 1992 CreateWithContent([barWidth](ScrollModelNG model) { model.SetScrollBarWidth(Dimension(barWidth)); });
1993 scrollBar = pattern_->GetScrollBar();
1994 const Offset moveOutBar = Offset(SCROLL_WIDTH - barWidth - 1.f, 0.f);
1995 scrollBar->SetHoverAnimationType(HoverAnimationType::NONE);
1996 Mouse(moveOutBar);
1997 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
1998 EXPECT_FALSE(scrollBar->IsHover());
1999 Mouse(moveInBar);
2000 EXPECT_TRUE(scrollBar->IsHover());
2001 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::GROW);
2002 Mouse(moveInBar);
2003 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::GROW);
2004 EXPECT_TRUE(scrollBar->IsHover());
2005 Mouse(moveOutBar);
2006 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::SHRINK);
2007 EXPECT_FALSE(scrollBar->IsHover());
2008
2009 /**
2010 * @tc.steps: step8. (out->in->in->out) and scrollBar->IsPressed() is true
2011 * @tc.expected: touchAnimator_ is not take effect
2012 */
2013 scrollBar->SetHoverAnimationType(HoverAnimationType::NONE);
2014 scrollBar->SetPressed(true);
2015 Mouse(moveOutBar);
2016 scrollBar->SetHoverAnimationType(HoverAnimationType::NONE);
2017 EXPECT_FALSE(scrollBar->IsHover());
2018 Mouse(moveInBar);
2019 scrollBar->SetHoverAnimationType(HoverAnimationType::NONE);
2020 EXPECT_TRUE(scrollBar->IsHover());
2021 Mouse(moveInBar);
2022 scrollBar->SetHoverAnimationType(HoverAnimationType::NONE);
2023 EXPECT_TRUE(scrollBar->IsHover());
2024 Mouse(moveOutBar);
2025 scrollBar->SetHoverAnimationType(HoverAnimationType::NONE);
2026 EXPECT_FALSE(scrollBar->IsHover());
2027
2028 /**
2029 * @tc.steps: step9. Mouse in bar and move out of component containing bar
2030 * @tc.expected: HoverAnimation is take effect
2031 */
2032 scrollBar->SetHoverAnimationType(HoverAnimationType::NONE);
2033 Hover(true);
2034 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
2035 scrollBar->SetHover(false);
2036 Hover(false);
2037 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
2038 scrollBar->SetHover(true);
2039 scrollBar->SetPressed(true);
2040 Hover(false);
2041 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
2042 scrollBar->SetHover(true);
2043 scrollBar->SetPressed(false);
2044 Hover(false);
2045 EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::SHRINK);
2046 EXPECT_FALSE(scrollBar->IsHover());
2047 }
2048
2049 /**
2050 * @tc.name: ScrollBar003
2051 * @tc.desc: Test bar rect
2052 * @tc.type: FUNC
2053 */
2054 HWTEST_F(ScrollTestNg, ScrollBar003, TestSize.Level1)
2055 {
2056 /**
2057 * @tc.steps: step1. Test Bar in VERTICAL
2058 * @tc.expected: Verify bar rect
2059 */
2060 const float barWidth = 10.f;
2061 const float ratio = static_cast<float>(VIEW_LINE_NUMBER) / TOTAL_LINE_NUMBER;
__anon4dcc91dc3702(ScrollModelNG model) 2062 CreateWithContent([barWidth](ScrollModelNG model) { model.SetScrollBarWidth(Dimension(barWidth)); });
2063 auto scrollBar = pattern_->GetScrollBar();
2064
2065 Rect rect = scrollBar->touchRegion_;
2066 Rect expectRect = Rect(SCROLL_WIDTH - barWidth, 0.f, barWidth, SCROLL_HEIGHT * ratio);
2067 EXPECT_TRUE(IsEqual(rect, expectRect));
2068
2069 UpdateCurrentOffset(-ITEM_HEIGHT);
2070 rect = scrollBar->touchRegion_;
2071 expectRect = Rect(SCROLL_WIDTH - barWidth, ITEM_HEIGHT * ratio, barWidth, SCROLL_HEIGHT * ratio);
2072 EXPECT_TRUE(IsEqual(rect, expectRect));
2073
2074 /**
2075 * @tc.steps: step2. Test Bar in HORIZONTAL
2076 * @tc.expected: Verify bar rect
2077 */
__anon4dcc91dc3802(ScrollModelNG model) 2078 CreateWithContent([barWidth](ScrollModelNG model) {
2079 model.SetAxis(Axis::HORIZONTAL);
2080 model.SetScrollBarWidth(Dimension(barWidth));
2081 });
2082 scrollBar = pattern_->GetScrollBar();
2083
2084 rect = scrollBar->touchRegion_;
2085 expectRect = Rect(0.f, SCROLL_HEIGHT - barWidth, SCROLL_WIDTH * ratio, barWidth);
2086 EXPECT_TRUE(IsEqual(rect, expectRect));
2087
2088 UpdateCurrentOffset(-ITEM_WIDTH);
2089 rect = scrollBar->touchRegion_;
2090 expectRect = Rect(ITEM_WIDTH * ratio, SCROLL_HEIGHT - barWidth, SCROLL_WIDTH * ratio, barWidth);
2091 EXPECT_TRUE(IsEqual(rect, expectRect));
2092 }
2093
2094 /**
2095 * @tc.name: ScrollBar004
2096 * @tc.desc: Test ScrollBar
2097 * @tc.type: FUNC
2098 */
2099 HWTEST_F(ScrollTestNg, ScrollBar004, TestSize.Level1)
2100 {
2101 const float barWidth = 10.f;
__anon4dcc91dc3902(ScrollModelNG model) 2102 CreateWithContent([barWidth](ScrollModelNG model) { model.SetScrollBarWidth(Dimension(barWidth)); });
2103 auto scrollBar = pattern_->GetScrollBar();
2104 scrollBar->SetShapeMode(ShapeMode::ROUND);
2105 EXPECT_FALSE(scrollBar->InBarTouchRegion(Point(0, 0)));
2106 EXPECT_FALSE(scrollBar->InBarHoverRegion(Point(0, 0)));
2107 scrollBar->FlushBarWidth();
2108
2109 scrollBar->SetDisplayMode(DisplayMode::OFF);
2110 EXPECT_FALSE(scrollBar->InBarTouchRegion(Point(0, 0)));
2111 EXPECT_FALSE(scrollBar->InBarHoverRegion(Point(0, 0)));
2112
2113 scrollBar->SetPositionMode(PositionMode::LEFT);
2114 scrollBar->UpdateActiveRectSize(20.f);
2115 EXPECT_EQ(scrollBar->touchRegion_.Height(), 20.f);
2116 scrollBar->UpdateActiveRectOffset(30.f);
2117 EXPECT_EQ(scrollBar->touchRegion_.Top(), 30.f);
2118 scrollBar->SetPositionMode(PositionMode::BOTTOM);
2119 scrollBar->UpdateActiveRectSize(20.f);
2120 EXPECT_EQ(scrollBar->touchRegion_.Width(), 20.f);
2121 scrollBar->UpdateActiveRectOffset(30.f);
2122 EXPECT_EQ(scrollBar->touchRegion_.Left(), 30.f);
2123 }
2124
2125 /**
2126 * @tc.name: ScrollBar005
2127 * @tc.desc: Test CalcReservedHeight()
2128 * @tc.type: FUNC
2129 */
2130 HWTEST_F(ScrollTestNg, ScrollBar005, TestSize.Level1)
2131 {
2132 CreateWithContent();
2133 auto pipelineContext = PipelineContext::GetCurrentContext();
2134 pipelineContext->SetMinPlatformVersion(static_cast<int32_t>(PlatformVersion::VERSION_ELEVEN));
2135 auto scrollBar = pattern_->GetScrollBar();
2136
2137 scrollBar->SetPositionMode(PositionMode::LEFT);
2138 scrollBar->SetNormalWidth(Dimension(1)); // call CalcReservedHeight;
2139 EXPECT_EQ(scrollBar->endReservedHeight_.Value(), 0);
2140
2141 BorderRadiusProperty borderRadiusProperty;
2142 float radius = 13.f;
2143 borderRadiusProperty.radiusTopRight = std::make_optional<Dimension>(radius);
2144 borderRadiusProperty.radiusBottomRight = std::make_optional<Dimension>(radius);
2145 scrollBar->SetHostBorderRadius(borderRadiusProperty);
2146 scrollBar->SetPadding(Edge(1, 1, 1, 1));
2147 scrollBar->SetPositionMode(PositionMode::RIGHT);
2148 scrollBar->SetNormalWidth(Dimension(2)); // call CalcReservedHeight;
2149 EXPECT_EQ(scrollBar->startReservedHeight_, Dimension(14.5))
2150 << "startReservedHeight_: " << scrollBar->startReservedHeight_.ConvertToPx();
2151 EXPECT_EQ(scrollBar->endReservedHeight_, Dimension(14.5))
2152 << "endReservedHeight_: " << scrollBar->endReservedHeight_.ConvertToPx();
2153
2154 borderRadiusProperty.radiusBottomLeft = std::make_optional<Dimension>(radius);
2155 borderRadiusProperty.radiusBottomRight = std::make_optional<Dimension>(radius);
2156 scrollBar->SetHostBorderRadius(borderRadiusProperty);
2157 scrollBar->SetPadding(Edge(1, 1, 1, 1));
2158 scrollBar->SetPositionMode(PositionMode::BOTTOM);
2159 scrollBar->SetNormalWidth(Dimension(6)); // call CalcReservedHeight;
2160 EXPECT_EQ(scrollBar->startReservedHeight_, Dimension(11.25))
2161 << "startReservedHeight_: " << scrollBar->startReservedHeight_.ConvertToPx();
2162 EXPECT_EQ(scrollBar->endReservedHeight_, Dimension(11.25))
2163 << "endReservedHeight_: " << scrollBar->endReservedHeight_.ConvertToPx();
2164 }
2165
2166 /**
2167 * @tc.name: ScrollBar006
2168 * @tc.desc: Test scrollbar width
2169 * @tc.type: FUNC
2170 */
2171 HWTEST_F(ScrollTestNg, ScrollBar006, TestSize.Level1)
2172 {
2173 /**
2174 * @tc.steps: step1. Not set bar width
2175 * @tc.expected: It will be default
2176 */
__anon4dcc91dc3a02(ScrollModelNG model) 2177 CreateWithContent([](ScrollModelNG model) { model.SetDisplayMode(static_cast<int>(DisplayMode::ON)); });
2178 EXPECT_EQ(pattern_->scrollBar_->activeRect_.Width(), NORMAL_WIDTH);
2179
2180 /**
2181 * @tc.steps: step2. Set bar width less than bar height
2182 * @tc.expected: It will be the value that was set
2183 */
__anon4dcc91dc3b02(ScrollModelNG model) 2184 CreateWithContent([](ScrollModelNG model) {
2185 model.SetDisplayMode(static_cast<int>(DisplayMode::ON));
2186 model.SetScrollBarWidth(Dimension(10));
2187 });
2188 EXPECT_EQ(pattern_->scrollBar_->activeRect_.Width(), 10);
2189
2190 /**
2191 * @tc.steps: step3. Set bar width greater than SCROLL_HEIGHT
2192 * @tc.expected: It will be default
2193 */
__anon4dcc91dc3c02(ScrollModelNG model) 2194 CreateWithContent([](ScrollModelNG model) {
2195 model.SetDisplayMode(static_cast<int>(DisplayMode::ON));
2196 model.SetScrollBarWidth(Dimension(SCROLL_HEIGHT + 1));
2197 });
2198 EXPECT_EQ(pattern_->scrollBar_->activeRect_.Width(), NORMAL_WIDTH);
2199
2200 /**
2201 * @tc.steps: step4. Set bar width greater than SCROLL_HEIGHT
2202 * @tc.expected: The bar width will be the value that was set, and bar height will be equal to bar width
2203 */
__anon4dcc91dc3d02(ScrollModelNG model) 2204 CreateWithContent([](ScrollModelNG model) {
2205 model.SetDisplayMode(static_cast<int>(DisplayMode::ON));
2206 model.SetScrollBarWidth(Dimension(SCROLL_HEIGHT - 1));
2207 });
2208 EXPECT_EQ(pattern_->scrollBar_->activeRect_.Width(), SCROLL_HEIGHT - 1);
2209 EXPECT_EQ(pattern_->scrollBar_->activeRect_.Height(), SCROLL_HEIGHT - 1);
2210 }
2211
2212 /**
2213 * @tc.name: ScrollBar007
2214 * @tc.desc: when IsPressed is true, can not trigger scrollstart event
2215 * @tc.type: FUNC
2216 */
2217 HWTEST_F(ScrollTestNg, ScrollBar007, TestSize.Level1)
2218 {
2219 bool isTrigger = false;
__anon4dcc91dc3e02(ScrollModelNG model) 2220 CreateWithContent([&isTrigger](ScrollModelNG model) {
2221 Dimension intervalSize = Dimension(10.f);
2222 std::vector<Dimension> snapPaginations = {
2223 Dimension(10.f),
2224 Dimension(20.f),
2225 Dimension(30.f),
2226 };
2227 std::pair<bool, bool> enableSnapToSide = { true, true };
2228 model.SetScrollSnap(ScrollSnapAlign::START, intervalSize, snapPaginations, enableSnapToSide);
2229 OnScrollStartEvent event = [&isTrigger]() { isTrigger = true; };
2230 model.SetOnScrollStart(std::move(event));
2231 });
2232
2233 /**
2234 * @tc.steps: step1. when scrollbar IsPressed() is false
2235 * @tc.expected: can trigger snap scrollstart event
2236 */
2237 auto scrollBar = pattern_->GetScrollBar();
2238 pattern_->ScrollTo(5.f);
2239 pattern_->scrollableEvent_ = nullptr; // make ScrollableIdle() true
2240 scrollBar->SetPressed(false);
2241 FlushLayoutTask(frameNode_);
2242 EXPECT_TRUE(isTrigger);
2243 }
2244
2245 /**
2246 * @tc.name: ScrollBar008
2247 * @tc.desc: when IsPressed is false, can trigger scrollstart event
2248 * @tc.type: FUNC
2249 */
2250 HWTEST_F(ScrollTestNg, ScrollBar008, TestSize.Level1)
2251 {
2252 bool isTrigger = false;
__anon4dcc91dc4002(ScrollModelNG model) 2253 CreateWithContent([&isTrigger](ScrollModelNG model) {
2254 Dimension intervalSize = Dimension(10.f);
2255 std::vector<Dimension> snapPaginations = {
2256 Dimension(10.f),
2257 Dimension(20.f),
2258 Dimension(30.f),
2259 };
2260 std::pair<bool, bool> enableSnapToSide = { true, true };
2261 model.SetScrollSnap(ScrollSnapAlign::START, intervalSize, snapPaginations, enableSnapToSide);
2262 OnScrollStartEvent event = [&isTrigger]() { isTrigger = true; };
2263 model.SetOnScrollStart(std::move(event));
2264 });
2265
2266 /**
2267 * @tc.steps: step1. when scrollbar IsPressed() is true
2268 * @tc.expected: can not trigger snap scrollstart event
2269 */
2270 auto scrollBar = pattern_->GetScrollBar();
2271 pattern_->ScrollTo(5.f);
2272 pattern_->scrollableEvent_ = nullptr; // make ScrollableIdle() true
2273 scrollBar->SetPressed(true);
2274 FlushLayoutTask(frameNode_);
2275 EXPECT_FALSE(isTrigger);
2276 }
2277
2278 /**
2279 * @tc.name: ScrollBar009
2280 * @tc.desc: Test scrollbar width.
2281 * @tc.type: FUNC
2282 */
2283 HWTEST_F(ScrollTestNg, ScrollBar009, TestSize.Level1)
2284 {
2285 /**
2286 * @tc.steps: step1. Create scroll model and set the width, height
2287 * @tc.expected: Check the scrollBar property value.
2288 */
__anon4dcc91dc4202(ScrollModelNG model) 2289 CreateWithContent([](ScrollModelNG model) { model.SetDisplayMode(static_cast<int32_t>(DisplayMode::ON)); });
2290
2291 RefPtr<ScrollBar> scrollBar = pattern_->GetScrollBar();
2292 pattern_->CreateScrollBarOverlayModifier();
2293 auto barRect = scrollBar->GetBarRect();
2294 auto activeRect = scrollBar->GetActiveRect();
2295 EXPECT_FLOAT_EQ(barRect.x_ + barRect.width_, SCROLL_WIDTH);
2296 EXPECT_FLOAT_EQ(activeRect.x_ + activeRect.width_, SCROLL_WIDTH);
2297 EXPECT_FLOAT_EQ(barRect.height_, SCROLL_HEIGHT);
2298
2299 /**
2300 * @tc.steps: step1.set the width
2301 * @tc.expected: Check the scrollBar property value.
2302 */
2303 ViewAbstract::SetWidth(AceType::RawPtr(frameNode_), CalcLength(300.f));
2304 ViewAbstract::SetHeight(AceType::RawPtr(frameNode_), CalcLength(500.f));
2305 FlushLayoutTask(frameNode_);
2306
2307 RefPtr<LayoutWrapperNode> layoutWrapper = frameNode_->CreateLayoutWrapper(false, false);
2308 layoutWrapper->layoutAlgorithm_->SetNeedMeasure();
2309 layoutWrapper->layoutAlgorithm_->SetNeedLayout();
2310 auto layoutAlgorithm = AceType::MakeRefPtr<ScrollLayoutAlgorithm>(pattern_->currentOffset_);
2311 layoutWrapper->layoutAlgorithm_->SetLayoutAlgorithm(layoutAlgorithm);
2312 auto childLayoutConstraint = layoutProperty_->CreateChildConstraint();
2313 childLayoutConstraint.selfIdealSize = { 300.f, 625.0f };
2314 auto colNode = AceType::DynamicCast<FrameNode>(frameNode_->GetChildAtIndex(0));
2315 ASSERT_NE(colNode, nullptr);
2316 RefPtr<LayoutWrapperNode> colLayoutWrapper =
2317 AceType::MakeRefPtr<LayoutWrapperNode>(colNode, colNode->GetGeometryNode(), colNode->GetLayoutProperty());
2318 colLayoutWrapper->GetLayoutProperty()->UpdateLayoutConstraint(childLayoutConstraint);
2319 colLayoutWrapper->GetLayoutProperty()->UpdateUserDefinedIdealSize(CalcSize(CalcLength(300.f), CalcLength(62.5f)));
2320 layoutWrapper->AppendChild(colLayoutWrapper);
2321
2322 DirtySwapConfig config;
2323 pattern_->OnDirtyLayoutWrapperSwap(layoutWrapper, config);
2324 auto paint = AceType::MakeRefPtr<ScrollPaintMethod>();
2325 paint->SetScrollBar(scrollBar);
2326 paint->SetScrollBarOverlayModifier(pattern_->GetScrollBarOverlayModifier());
2327 WeakPtr<RenderContext> renderContext;
2328 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
2329 auto paintWrapper = AceType::MakeRefPtr<PaintWrapper>(renderContext, geometryNode, paintProperty_);
2330 paint->UpdateOverlayModifier(Referenced::RawPtr(paintWrapper));
2331
2332 barRect = scrollBar->GetBarRect();
2333 activeRect = scrollBar->GetActiveRect();
2334 EXPECT_FLOAT_EQ(barRect.x_ + barRect.width_, 300.f);
2335 EXPECT_FLOAT_EQ(activeRect.x_ + activeRect.width_, 300.f);
2336 EXPECT_FLOAT_EQ(barRect.height_, 500.f);
2337 EXPECT_FLOAT_EQ(pattern_->scrollBarOverlayModifier_->barX_->Get(), 296.f);
2338 }
2339
2340 /**
2341 * @tc.name: Measure001
2342 * @tc.desc: Test Measure
2343 * @tc.type: FUNC
2344 */
2345 HWTEST_F(ScrollTestNg, Measure001, TestSize.Level1)
2346 {
2347 ScrollModelNG model;
2348 model.Create();
2349 model.SetAxis(Axis::NONE);
2350 CreateContent();
2351 GetInstance();
2352
2353 /**
2354 * @tc.steps: step1. Do not set idealSize
2355 * @tc.expected: The idealSize would be child size
2356 */
2357 RefPtr<LayoutWrapperNode> layoutWrapper = frameNode_->CreateLayoutWrapper(false, false);
2358 layoutWrapper->SetActive();
2359 layoutWrapper->SetRootMeasureNode();
2360 LayoutConstraintF LayoutConstraint;
2361 LayoutConstraint.parentIdealSize = { SCROLL_WIDTH, SCROLL_HEIGHT };
2362 LayoutConstraint.percentReference = { SCROLL_WIDTH, SCROLL_HEIGHT };
2363 layoutWrapper->Measure(LayoutConstraint);
2364 layoutWrapper->Layout();
2365 layoutWrapper->MountToHostOnMainThread();
2366 auto scrollSize = frameNode_->GetGeometryNode()->GetFrameSize();
2367 auto expectSize = SizeF(SCROLL_WIDTH, ITEM_HEIGHT * TOTAL_LINE_NUMBER);
2368 EXPECT_EQ(scrollSize, expectSize) << "scrollSize: " << scrollSize.ToString()
2369 << " expectSize: " << expectSize.ToString();
2370 }
2371
2372 /**
2373 * @tc.name: Layout001
2374 * @tc.desc: Test Layout
2375 * @tc.type: FUNC
2376 */
2377 HWTEST_F(ScrollTestNg, Layout001, TestSize.Level1)
2378 {
__anon4dcc91dc4302(ScrollModelNG model) 2379 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::NONE); });
2380 layoutProperty_->UpdateAlignment(Alignment::CENTER);
2381 FlushLayoutTask(frameNode_);
2382 auto col = frameNode_->GetChildAtIndex(0);
2383 auto colNode = AceType::DynamicCast<FrameNode>(col);
2384 auto colOffset = colNode->GetGeometryNode()->GetMarginFrameOffset();
2385 auto expectOffset = OffsetF(0, 0);
2386 EXPECT_EQ(colOffset, expectOffset) << "colOffset: " << colOffset.ToString()
2387 << " expectOffset: " << expectOffset.ToString();
2388 }
2389
2390 /**
2391 * @tc.name: OnScrollCallback001
2392 * @tc.desc: Test OnScrollCallback that has no effect
2393 * @tc.type: FUNC
2394 */
2395 HWTEST_F(ScrollTestNg, OnScrollCallback001, TestSize.Level1)
2396 {
2397 /**
2398 * @tc.steps: step1. Axis::NONE and SCROLL_FROM_UPDATE
2399 * @tc.expected: Do nothing
2400 */
__anon4dcc91dc4402(ScrollModelNG model) 2401 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::NONE); });
2402 EXPECT_FALSE(OnScrollCallback(-ITEM_HEIGHT, SCROLL_FROM_UPDATE));
2403
2404 /**
2405 * @tc.steps: step2. animator_ is running and SCROLL_FROM_UPDATE
2406 * @tc.expected: Do nothing
2407 */
2408 CreateWithContent();
2409 pattern_->animator_ = CREATE_ANIMATOR(PipelineBase::GetCurrentContext());
2410 pattern_->animator_->Resume();
2411 EXPECT_FALSE(OnScrollCallback(-ITEM_HEIGHT, SCROLL_FROM_UPDATE));
2412 }
2413
2414 /**
2415 * @tc.name: OnScrollCallback002
2416 * @tc.desc: Test OnScrollCallback about trigger FireOnScrollStart
2417 * @tc.type: FUNC
2418 */
2419 HWTEST_F(ScrollTestNg, OnScrollCallback002, TestSize.Level1)
2420 {
2421 /**
2422 * @tc.steps: step1. no animator and SCROLL_FROM_START
2423 * @tc.expected: Trigger FireOnScrollStart()
2424 */
2425 bool isTrigger = false;
__anon4dcc91dc4502(ScrollModelNG model) 2426 CreateWithContent([&isTrigger](ScrollModelNG model) {
2427 OnScrollStartEvent event = [&isTrigger]() { isTrigger = true; };
2428 model.SetOnScrollStart(std::move(event));
2429 });
2430 OnScrollCallback(-ITEM_HEIGHT, SCROLL_FROM_START);
2431 EXPECT_TRUE(isTrigger);
2432
2433 /**
2434 * @tc.steps: step2. animator is Stopped and SCROLL_FROM_START
2435 * @tc.expected: Trigger FireOnScrollStart()
2436 */
2437 isTrigger = false;
2438 pattern_->animator_ = CREATE_ANIMATOR(PipelineBase::GetCurrentContext());
2439 pattern_->animator_->Stop();
2440 OnScrollCallback(-ITEM_HEIGHT, SCROLL_FROM_START);
2441 EXPECT_TRUE(isTrigger);
2442
2443 /**
2444 * @tc.steps: step3. animator is running and SCROLL_FROM_START
2445 * @tc.expected: because of scrollAbort_ is true, would not trigger event, and animator stop()
2446 */
2447 isTrigger = false;
2448 pattern_->animator_->Resume();
2449 auto scrollable = pattern_->scrollableEvent_->GetScrollable();
2450 auto onScrollCallback = scrollable->callback_;
2451 onScrollCallback(-ITEM_HEIGHT, SCROLL_FROM_START);
2452 EXPECT_TRUE(pattern_->animator_->IsStopped());
2453 EXPECT_FALSE(isTrigger);
2454 }
2455
2456 /**
2457 * @tc.name: OnScrollCallback003
2458 * @tc.desc: Test OnScrollCallback about AdjustOffset/UpdateCurrentOffset when scrollableDistance_ bigger than 0
2459 * @tc.type: FUNC
2460 */
2461 HWTEST_F(ScrollTestNg, OnScrollCallback003, TestSize.Level1)
2462 {
2463 /**
2464 * @tc.steps: step1. Create the content that total size is bigger than Scroll Component
2465 * @tc.expected: The scrollableDistance_ is two of ITEM_HEIGHT
2466 */
__anon4dcc91dc4702(ScrollModelNG model) 2467 CreateWithContent([](ScrollModelNG model) { model.SetEdgeEffect(EdgeEffect::SPRING, true); });
2468 float scrollableDistance = ITEM_HEIGHT * 2;
2469 EXPECT_EQ(pattern_->scrollableDistance_, scrollableDistance);
2470
2471 /**
2472 * @tc.steps: step2. scroll to above of content
2473 * @tc.expected: friction is not effected
2474 */
2475 pattern_->OnScrollCallback(1, SCROLL_FROM_UPDATE);
2476 EXPECT_EQ(pattern_->GetCurrentPosition(), 1);
2477
2478 /**
2479 * @tc.steps: step3. Continue scroll up
2480 * @tc.expected: friction is effected, but is 1
2481 */
2482 pattern_->OnScrollCallback(1, SCROLL_FROM_UPDATE);
2483 EXPECT_EQ(pattern_->GetCurrentPosition(), 2);
2484
2485 /**
2486 * @tc.steps: step4. Continue scroll up
2487 * @tc.expected: friction is effected
2488 */
2489 pattern_->OnScrollCallback(1, SCROLL_FROM_UPDATE);
2490 EXPECT_LT(pattern_->GetCurrentPosition(), 3);
2491
2492 /**
2493 * @tc.steps: step5. Scroll down
2494 * @tc.expected: friction is not effected
2495 */
2496 pattern_->OnScrollCallback(-1, SCROLL_FROM_UPDATE);
2497 EXPECT_LT(pattern_->GetCurrentPosition(), 2);
2498
2499 /**
2500 * @tc.steps: step6. Scroll to bottom for test other condition
2501 */
2502 ScrollToEdge(ScrollEdgeType::SCROLL_BOTTOM);
2503 EXPECT_EQ(pattern_->GetCurrentPosition(), -scrollableDistance);
2504
2505 /**
2506 * @tc.steps: step7. scroll to below of content
2507 * @tc.expected: friction is not effected
2508 */
2509 pattern_->OnScrollCallback(-1, SCROLL_FROM_UPDATE);
2510 EXPECT_EQ(pattern_->GetCurrentPosition(), -(scrollableDistance + 1));
2511
2512 /**
2513 * @tc.steps: step8. Continue scroll down
2514 * @tc.expected: friction is effected, but is 1
2515 */
2516 pattern_->OnScrollCallback(-1, SCROLL_FROM_UPDATE);
2517 EXPECT_EQ(pattern_->GetCurrentPosition(), -(scrollableDistance + 2));
2518
2519 /**
2520 * @tc.steps: step9. Continue scroll down
2521 * @tc.expected: friction is effected
2522 */
2523 pattern_->OnScrollCallback(-1, SCROLL_FROM_UPDATE);
2524 EXPECT_GT(pattern_->GetCurrentPosition(), -(scrollableDistance + 3));
2525
2526 /**
2527 * @tc.steps: step10. Scroll up
2528 * @tc.expected: friction is not effected
2529 */
2530 pattern_->OnScrollCallback(1, SCROLL_FROM_UPDATE);
2531 EXPECT_GT(pattern_->GetCurrentPosition(), -(scrollableDistance + 2));
2532
2533 /**
2534 * @tc.steps: step11. scroll to middle of content
2535 * @tc.expected: friction is not effected
2536 */
2537 ScrollToEdge(ScrollEdgeType::SCROLL_TOP);
2538 EXPECT_EQ(pattern_->GetCurrentPosition(), 0);
2539 pattern_->OnScrollCallback(-1, SCROLL_FROM_UPDATE);
2540 EXPECT_EQ(pattern_->GetCurrentPosition(), -1);
2541 }
2542
2543 /**
2544 * @tc.name: OnScrollCallback004
2545 * @tc.desc: Test OnScrollCallback about AdjustOffset/UpdateCurrentOffset when scrollableDistance_ is 0
2546 * @tc.type: FUNC
2547 */
2548 HWTEST_F(ScrollTestNg, OnScrollCallback004, TestSize.Level1)
2549 {
2550 /**
2551 * @tc.steps: step1. Create the content that total size is not bigger than Scroll Component
2552 * @tc.expected: The scrollableDistance_ is 0
2553 */
__anon4dcc91dc4802(ScrollModelNG model) 2554 Create([](ScrollModelNG model) {
2555 model.SetEdgeEffect(EdgeEffect::SPRING, true);
2556 CreateContent(VIEW_LINE_NUMBER);
2557 });
2558 EXPECT_EQ(pattern_->scrollableDistance_, 0);
2559
2560 /**
2561 * @tc.steps: step2. scroll to above of content
2562 * @tc.expected: friction is not effected
2563 */
2564 pattern_->OnScrollCallback(1, SCROLL_FROM_UPDATE);
2565 EXPECT_EQ(pattern_->GetCurrentPosition(), 1);
2566
2567 /**
2568 * @tc.steps: step3. Continue scroll up
2569 * @tc.expected: friction is effected, but is 1
2570 */
2571 pattern_->OnScrollCallback(1, SCROLL_FROM_UPDATE);
2572 EXPECT_EQ(pattern_->GetCurrentPosition(), 2);
2573
2574 /**
2575 * @tc.steps: step4. Continue scroll up
2576 * @tc.expected: friction is effected
2577 */
2578 pattern_->OnScrollCallback(1, SCROLL_FROM_UPDATE);
2579 EXPECT_LT(pattern_->GetCurrentPosition(), 3);
2580
2581 /**
2582 * @tc.steps: step5. Scroll down
2583 * @tc.expected: friction is not effected
2584 */
2585 pattern_->OnScrollCallback(-1, SCROLL_FROM_UPDATE);
2586 EXPECT_LT(pattern_->GetCurrentPosition(), 2);
2587
2588 /**
2589 * @tc.steps: step6. Scroll to bottom for test other condition
2590 */
2591 ScrollToEdge(ScrollEdgeType::SCROLL_BOTTOM);
2592 EXPECT_EQ(pattern_->GetCurrentPosition(), 0);
2593
2594 /**
2595 * @tc.steps: step7. scroll to below of content
2596 * @tc.expected: friction is not effected
2597 */
2598 pattern_->OnScrollCallback(-1, SCROLL_FROM_UPDATE);
2599 EXPECT_EQ(pattern_->GetCurrentPosition(), -1);
2600
2601 /**
2602 * @tc.steps: step8. Continue scroll down
2603 * @tc.expected: friction is effected, but is 1
2604 */
2605 pattern_->OnScrollCallback(-1, SCROLL_FROM_UPDATE);
2606 EXPECT_EQ(pattern_->GetCurrentPosition(), -2);
2607
2608 /**
2609 * @tc.steps: step9. Continue scroll down
2610 * @tc.expected: friction is effected
2611 */
2612 pattern_->OnScrollCallback(-1, SCROLL_FROM_UPDATE);
2613 EXPECT_GT(pattern_->GetCurrentPosition(), -3);
2614
2615 /**
2616 * @tc.steps: step10. Scroll up
2617 * @tc.expected: friction is not effected
2618 */
2619 pattern_->OnScrollCallback(1, SCROLL_FROM_UPDATE);
2620 EXPECT_GT(pattern_->GetCurrentPosition(), -2);
2621 }
2622
2623 /**
2624 * @tc.name: OnScrollCallback005
2625 * @tc.desc: Test AdjustOffset that return
2626 * @tc.type: FUNC
2627 */
2628 HWTEST_F(ScrollTestNg, OnScrollCallback005, TestSize.Level1)
2629 {
__anon4dcc91dc4902(ScrollModelNG model) 2630 CreateWithContent([](ScrollModelNG model) { model.SetEdgeEffect(EdgeEffect::SPRING, true); });
2631
2632 /**
2633 * @tc.steps: step1. The delta is 0
2634 * @tc.expected: AdjustOffset return
2635 */
2636 OnScrollCallback(0, SCROLL_FROM_UPDATE);
2637 EXPECT_TRUE(IsEqualCurrentPosition(0));
2638
2639 /**
2640 * @tc.steps: step2. The source is SCROLL_FROM_ANIMATION
2641 * @tc.expected: AdjustOffset return
2642 */
2643 OnScrollCallback(-ITEM_HEIGHT, SCROLL_FROM_ANIMATION);
2644 EXPECT_TRUE(IsEqualCurrentPosition(-ITEM_HEIGHT));
2645
2646 /**
2647 * @tc.steps: step3. The source is SCROLL_FROM_ANIMATION_SPRING
2648 * @tc.expected: AdjustOffset return
2649 */
2650 OnScrollCallback(-ITEM_HEIGHT, SCROLL_FROM_ANIMATION_SPRING);
2651 EXPECT_TRUE(IsEqualCurrentPosition(-ITEM_HEIGHT * 2));
2652
2653 /**
2654 * @tc.steps: step4. The viewPortLength_ is 0
2655 * @tc.expected: AdjustOffset return
2656 */
2657 ScrollModelNG model;
2658 model.Create();
2659 model.SetEdgeEffect(EdgeEffect::SPRING, true);
2660 GetInstance();
2661 FlushLayoutTask(frameNode_);
2662 OnScrollCallback(-ITEM_HEIGHT, SCROLL_FROM_ANIMATION_SPRING);
2663 EXPECT_TRUE(IsEqualCurrentPosition(-ITEM_HEIGHT));
2664 }
2665
2666 /**
2667 * @tc.name: ScrollToNode001
2668 * @tc.desc: Test ScrollToNode
2669 * @tc.type: FUNC
2670 */
2671 HWTEST_F(ScrollTestNg, ScrollToNode001, TestSize.Level1)
2672 {
2673 /**
2674 * @tc.steps: step1. ScrollToNode in VERTICAL
2675 * @tc.expected: currentOffset_ is correct
2676 */
2677 CreateWithContent();
2678 EXPECT_TRUE(ScrollToNode(5, 0));
2679 EXPECT_TRUE(ScrollToNode(8, -1));
2680 EXPECT_TRUE(ScrollToNode(9, -2));
2681 EXPECT_TRUE(ScrollToNode(5, -2));
2682 EXPECT_TRUE(ScrollToNode(0, 0));
2683
2684 /**
2685 * @tc.steps: step2. ScrollToNode in HORIZONTAL
2686 * @tc.expected: currentOffset_ is correct
2687 */
__anon4dcc91dc4a02(ScrollModelNG model) 2688 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::HORIZONTAL); });
2689 EXPECT_TRUE(ScrollToNode(5, 0));
2690 EXPECT_TRUE(ScrollToNode(8, -1));
2691 EXPECT_TRUE(ScrollToNode(9, -2));
2692 EXPECT_TRUE(ScrollToNode(5, -2));
2693 EXPECT_TRUE(ScrollToNode(0, 0));
2694
2695 /**
2696 * @tc.steps: step1. ScrollToNode itSelf
2697 * @tc.expected: currentOffset_ is zero
2698 */
2699 CreateWithContent();
2700 pattern_->ScrollToNode(frameNode_);
2701 EXPECT_TRUE(IsEqualCurrentPosition(0));
2702 pattern_->ScrollToNode(GetChildFrameNode(frameNode_, 0));
2703 EXPECT_TRUE(IsEqualCurrentPosition(0));
2704 }
2705
2706 /**
2707 * @tc.name: Pattern003
2708 * @tc.desc: Test HandleScrollBarOutBoundary
2709 * @tc.type: FUNC
2710 */
2711 HWTEST_F(ScrollTestNg, Pattern003, TestSize.Level1)
2712 {
2713 CreateWithContent();
2714
2715 /**
2716 * @tc.steps: step1. When scrollBar is not OFF
2717 * @tc.expected: outBoundary_ would be set
2718 */
2719 pattern_->HandleScrollBarOutBoundary(100.f);
2720 auto scrollBar = pattern_->GetScrollBar();
2721 EXPECT_EQ(scrollBar->outBoundary_, 100.f);
2722
2723 /**
2724 * @tc.steps: step1. When scrollBar is OFF
2725 * @tc.expected: outBoundary_ would not be set
2726 */
2727 scrollBar->displayMode_ = DisplayMode::OFF;
2728 pattern_->HandleScrollBarOutBoundary(200.f);
2729 EXPECT_EQ(scrollBar->outBoundary_, 100.f);
2730 }
2731
2732 /**
2733 * @tc.name: Test001
2734 * @tc.desc: Test GetOverScrollOffset
2735 * @tc.type: FUNC
2736 */
2737 HWTEST_F(ScrollTestNg, Test001, TestSize.Level1)
2738 {
2739 CreateWithContent();
2740
2741 OverScrollOffset offset = pattern_->GetOverScrollOffset(ITEM_HEIGHT);
2742 OverScrollOffset expectOffset = { ITEM_HEIGHT, 0 };
2743 EXPECT_TRUE(IsEqual(offset, expectOffset));
2744 offset = pattern_->GetOverScrollOffset(0.f);
2745 expectOffset = { 0, 0 };
2746 EXPECT_TRUE(IsEqual(offset, expectOffset));
2747 offset = pattern_->GetOverScrollOffset(-ITEM_HEIGHT);
2748 expectOffset = { 0, 0 };
2749 EXPECT_TRUE(IsEqual(offset, expectOffset));
2750
2751 pattern_->currentOffset_ = -ITEM_HEIGHT;
2752 offset = pattern_->GetOverScrollOffset(ITEM_HEIGHT * 2);
2753 expectOffset = { ITEM_HEIGHT, 0 };
2754 EXPECT_TRUE(IsEqual(offset, expectOffset));
2755 offset = pattern_->GetOverScrollOffset(0.f);
2756 expectOffset = { 0, 0 };
2757 EXPECT_TRUE(IsEqual(offset, expectOffset));
2758 offset = pattern_->GetOverScrollOffset(-ITEM_HEIGHT * 2);
2759 expectOffset = { 0, -ITEM_HEIGHT };
2760 EXPECT_TRUE(IsEqual(offset, expectOffset));
2761
2762 pattern_->currentOffset_ = -ITEM_HEIGHT * 2;
2763 offset = pattern_->GetOverScrollOffset(ITEM_HEIGHT);
2764 expectOffset = { 0, 0 };
2765 EXPECT_TRUE(IsEqual(offset, expectOffset));
2766 offset = pattern_->GetOverScrollOffset(0.f);
2767 expectOffset = { 0, 0 };
2768 EXPECT_TRUE(IsEqual(offset, expectOffset));
2769 offset = pattern_->GetOverScrollOffset(-ITEM_HEIGHT);
2770 expectOffset = { 0, -ITEM_HEIGHT };
2771 EXPECT_TRUE(IsEqual(offset, expectOffset));
2772
2773 pattern_->currentOffset_ = ITEM_HEIGHT;
2774 offset = pattern_->GetOverScrollOffset(ITEM_HEIGHT);
2775 expectOffset = { ITEM_HEIGHT, 0 };
2776 EXPECT_TRUE(IsEqual(offset, expectOffset));
2777 offset = pattern_->GetOverScrollOffset(0.f);
2778 expectOffset = { 0, 0 };
2779 EXPECT_TRUE(IsEqual(offset, expectOffset));
2780 offset = pattern_->GetOverScrollOffset(-ITEM_HEIGHT * 2);
2781 expectOffset = { -ITEM_HEIGHT, 0 };
2782 EXPECT_TRUE(IsEqual(offset, expectOffset));
2783
2784 pattern_->currentOffset_ = -ITEM_HEIGHT * 3;
2785 offset = pattern_->GetOverScrollOffset(ITEM_HEIGHT * 2);
2786 expectOffset = { 0, ITEM_HEIGHT };
2787 EXPECT_TRUE(IsEqual(offset, expectOffset));
2788 offset = pattern_->GetOverScrollOffset(0.f);
2789 expectOffset = { 0, 0 };
2790 EXPECT_TRUE(IsEqual(offset, expectOffset));
2791 offset = pattern_->GetOverScrollOffset(-ITEM_HEIGHT);
2792 expectOffset = { 0, -ITEM_HEIGHT };
2793 EXPECT_TRUE(IsEqual(offset, expectOffset));
2794 }
2795
2796 /**
2797 * @tc.name: AccessibilityProperty001
2798 * @tc.desc: Test AccessibilityProperty
2799 * @tc.type: FUNC
2800 */
2801 HWTEST_F(ScrollTestNg, AccessibilityProperty001, TestSize.Level1)
2802 {
2803 /**
2804 * @tc.steps: step1. Create unscrollable scroll, test SetSpecificSupportAction
2805 * @tc.expected: action is correct
2806 */
2807 Create();
2808 accessibilityProperty_->ResetSupportAction();
2809 EXPECT_EQ(GetActions(accessibilityProperty_), 0);
2810
2811 /**
2812 * @tc.steps: step2. scroll is at top
2813 * @tc.expected: action is correct
2814 */
2815 CreateWithContent();
2816 accessibilityProperty_->ResetSupportAction();
2817 uint64_t expectActions = 0;
2818 expectActions |= 1UL << static_cast<uint32_t>(AceAction::ACTION_SCROLL_FORWARD);
2819 EXPECT_EQ(GetActions(accessibilityProperty_), expectActions);
2820
2821 /**
2822 * @tc.steps: step3. scroll to middle
2823 * @tc.expected: action is correct
2824 */
2825 UpdateCurrentOffset(-ITEM_HEIGHT);
2826 accessibilityProperty_->ResetSupportAction();
2827 expectActions = 0;
2828 expectActions |= 1UL << static_cast<uint32_t>(AceAction::ACTION_SCROLL_FORWARD);
2829 expectActions |= 1UL << static_cast<uint32_t>(AceAction::ACTION_SCROLL_BACKWARD);
2830 EXPECT_EQ(GetActions(accessibilityProperty_), expectActions);
2831
2832 /**
2833 * @tc.steps: step4. scroll to bottom
2834 * @tc.expected: action is correct
2835 */
2836 UpdateCurrentOffset(-ITEM_HEIGHT);
2837 accessibilityProperty_->ResetSupportAction();
2838 expectActions = 0;
2839 expectActions |= 1UL << static_cast<uint32_t>(AceAction::ACTION_SCROLL_BACKWARD);
2840 EXPECT_EQ(GetActions(accessibilityProperty_), expectActions);
2841
2842 /**
2843 * @tc.steps: step6. test IsScrollable()
2844 * @tc.expected: return value is correct
2845 */
2846 CreateWithContent();
2847 EXPECT_TRUE(accessibilityProperty_->IsScrollable());
__anon4dcc91dc4b02(ScrollModelNG model) 2848 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::NONE); });
2849 EXPECT_FALSE(accessibilityProperty_->IsScrollable());
2850 }
2851
2852 /**
2853 * @tc.name: OnModifyDone001
2854 * @tc.desc: Test OnModifyDone
2855 * @tc.type: FUNC
2856 */
2857 HWTEST_F(ScrollTestNg, OnModifyDone001, TestSize.Level1)
2858 {
2859 /**
2860 * @tc.steps: step1. Create to trigger OnModifyDone
2861 * @tc.expected: Has ScrollableEvent, has AccessibilityAction, set Axis::VERTICAL
2862 */
2863 CreateWithContent();
2864 ASSERT_NE(pattern_->GetScrollableEvent(), nullptr);
2865 ASSERT_NE(accessibilityProperty_->actionScrollForwardImpl_, nullptr);
2866 ASSERT_NE(accessibilityProperty_->actionScrollBackwardImpl_, nullptr);
2867 EXPECT_EQ(pattern_->GetAxis(), Axis::VERTICAL);
2868
2869 /**
2870 * @tc.steps: step2. Change axis and trigger OnModifyDone
2871 * @tc.expected: Axis would be changed
2872 */
2873 layoutProperty_->UpdateAxis(Axis::HORIZONTAL);
2874 pattern_->OnModifyDone();
2875 EXPECT_EQ(pattern_->GetAxis(), Axis::HORIZONTAL);
2876
2877 /**
2878 * @tc.steps: step3. Change scrollSnapUpdate_ to true
2879 * @tc.expected: Will MarkDirtyNode
2880 */
2881 pattern_->scrollSnapUpdate_ = true;
2882 pattern_->OnModifyDone();
2883 }
2884
2885 /**
2886 * @tc.name: Pattern002
2887 * @tc.desc: Test SetAccessibilityAction
2888 * @tc.type: FUNC
2889 */
2890 HWTEST_F(ScrollTestNg, Pattern002, TestSize.Level1)
2891 {
2892 /**
2893 * @tc.steps: step1. Test SetAccessibilityAction with scrollable scroll
2894 * @tc.expected: Can trigger AnimateTo()
2895 */
2896 CreateWithContent();
2897 accessibilityProperty_->actionScrollForwardImpl_();
2898 ASSERT_NE(pattern_->springAnimation_, nullptr);
2899 pattern_->springAnimation_ = nullptr;
2900 accessibilityProperty_->actionScrollBackwardImpl_();
2901 ASSERT_NE(pattern_->springAnimation_, nullptr);
2902
2903 /**
2904 * @tc.steps: step2. Test SetAccessibilityAction with unScrollable scroll, scrollableDistance_ <= 0
2905 * @tc.expected: Cannot trigger AnimateTo()
2906 */
2907 Create();
2908 accessibilityProperty_->actionScrollForwardImpl_();
2909 EXPECT_EQ(pattern_->animator_, nullptr);
2910 accessibilityProperty_->actionScrollBackwardImpl_();
2911 EXPECT_EQ(pattern_->animator_, nullptr);
2912
2913 /**
2914 * @tc.steps: step3. Test SetAccessibilityAction with unScrollable scroll, Axis::NONE
2915 * @tc.expected: Cannot trigger AnimateTo()
2916 */
__anon4dcc91dc4c02(ScrollModelNG model) 2917 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::NONE); });
2918 accessibilityProperty_->actionScrollForwardImpl_();
2919 EXPECT_EQ(pattern_->animator_, nullptr);
2920 accessibilityProperty_->actionScrollBackwardImpl_();
2921 EXPECT_EQ(pattern_->animator_, nullptr);
2922 }
2923
2924 /**
2925 * @tc.name: ScrollTest005
2926 * @tc.desc: Scroll Accessibility PerformAction test ScrollForward and ScrollBackward..
2927 * @tc.type: FUNC
2928 */
2929 HWTEST_F(ScrollTestNg, ScrollTest005, TestSize.Level1)
2930 {
2931 /**
2932 * @tc.steps: step1. Create scroll and initialize related properties.
2933 */
__anon4dcc91dc4d02(ScrollModelNG model) 2934 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::NONE); });
2935
2936 /**
2937 * @tc.steps: step2. Get scroll frameNode and pattern, set callback function.
2938 * @tc.expected: Related function is called.
2939 */
2940 pattern_->scrollableDistance_ = 0.0;
2941 pattern_->SetAccessibilityAction();
2942
2943 /**
2944 * @tc.steps: step4. When scroll is not scrollable and scrollable distance is 0, call the callback function in
2945 * accessibilityProperty_.
2946 * @tc.expected: Related function is called.
2947 */
2948 EXPECT_TRUE(accessibilityProperty_->ActActionScrollForward());
2949 EXPECT_TRUE(accessibilityProperty_->ActActionScrollBackward());
2950
2951 /**
2952 * @tc.steps: step5. When scroll is not scrollable and scrollable distance is not 0, call the callback function in
2953 * accessibilityProperty_.
2954 * @tc.expected: Related function is called.
2955 */
2956 pattern_->scrollableDistance_ = 100.f;
2957 EXPECT_TRUE(accessibilityProperty_->ActActionScrollForward());
2958 EXPECT_TRUE(accessibilityProperty_->ActActionScrollBackward());
2959
2960 /**
2961 * @tc.steps: step6. When scroll is scrollable and scrollable distance is not 0, call the callback function in
2962 * accessibilityProperty_.
2963 * @tc.expected: Related function is called.
2964 */
2965 pattern_->SetAxis(Axis::VERTICAL);
2966 EXPECT_TRUE(accessibilityProperty_->ActActionScrollForward());
2967 EXPECT_TRUE(accessibilityProperty_->ActActionScrollBackward());
2968
2969 /**
2970 * @tc.steps: step7. When scroll is scrollable and scrollable distance is 0, call the callback function in
2971 * accessibilityProperty_.
2972 * @tc.expected: Related function is called.
2973 */
2974 pattern_->scrollableDistance_ = 0.0;
2975 EXPECT_TRUE(accessibilityProperty_->ActActionScrollForward());
2976 EXPECT_TRUE(accessibilityProperty_->ActActionScrollBackward());
2977 }
2978
2979 /**
2980 * @tc.name: ScrollSetFrictionTest001
2981 * @tc.desc: Test SetFriction
2982 * @tc.type: FUNC
2983 */
2984 HWTEST_F(ScrollTestNg, ScrollSetFrictionTest001, TestSize.Level1)
2985 {
2986 /**
2987 * @tc.steps: step1. set friction less than 0
2988 * @tc.expected: should be more than 0.0,if out of range,should be default value.
2989 */
2990 double friction = -1;
2991 ScrollModelNG scrollModelNG_1;
2992 scrollModelNG_1.Create();
2993 scrollModelNG_1.SetFriction(friction);
2994 GetInstance();
2995 FlushLayoutTask(frameNode_);
2996 EXPECT_DOUBLE_EQ(pattern_->GetFriction(), NEW_DEFAULT_FRICTION);
2997
2998 /**
2999 * @tc.steps: step1. set friction more than 0
3000 * @tc.expected: friction should be more than 0.0,if out of range,should be default value.
3001 */
3002 friction = 10;
3003 ScrollModelNG scrollModelNG_2;
3004 scrollModelNG_2.Create();
3005 scrollModelNG_2.SetFriction(friction);
3006 GetInstance();
3007 FlushLayoutTask(frameNode_);
3008 EXPECT_DOUBLE_EQ(pattern_->GetFriction(), friction);
3009 }
3010
3011 /**
3012 * @tc.name: Snap001
3013 * @tc.desc: Test snap
3014 * @tc.type: FUNC
3015 */
3016 HWTEST_F(ScrollTestNg, Snap001, TestSize.Level1)
3017 {
3018 Dimension intervalSize = Dimension(10.f);
3019 std::vector<Dimension> snapPaginations = {
3020 Dimension(10.f),
3021 Dimension(20.f),
3022 Dimension(30.f),
3023 };
3024
3025 // snapOffsets_: {0, -10, -20, -30, -160}
3026 std::pair<bool, bool> enableSnapToSide = { false, false };
3027 CreateSnapScroll(ScrollSnapAlign::START, intervalSize, snapPaginations, enableSnapToSide);
3028 EXPECT_FALSE(pattern_->CalePredictSnapOffset(0.f).has_value());
3029 EXPECT_FALSE(pattern_->CalePredictSnapOffset(-20.f).has_value());
3030 pattern_->currentOffset_ = -20.f;
3031 EXPECT_TRUE(pattern_->CalePredictSnapOffset(0.f).has_value());
3032
3033 pattern_->currentOffset_ = -10.f;
3034 EXPECT_TRUE(pattern_->NeedScrollSnapToSide(-10.f));
3035 EXPECT_FALSE(pattern_->NeedScrollSnapToSide(10.f));
3036 pattern_->currentOffset_ = -20.f;
3037 EXPECT_FALSE(pattern_->NeedScrollSnapToSide(0.f));
3038
3039 enableSnapToSide = { true, false };
3040 CreateSnapScroll(ScrollSnapAlign::START, intervalSize, snapPaginations, enableSnapToSide);
3041 EXPECT_FALSE(pattern_->CalePredictSnapOffset(-40.f).has_value());
3042 pattern_->currentOffset_ = 20.f;
3043 EXPECT_TRUE(pattern_->CalePredictSnapOffset(-40.f).has_value());
3044 EXPECT_FALSE(pattern_->CalePredictSnapOffset(0.f).has_value());
3045
3046 pattern_->currentOffset_ = -30.f;
3047 EXPECT_TRUE(pattern_->NeedScrollSnapToSide(10.f));
3048 EXPECT_FALSE(pattern_->NeedScrollSnapToSide(-10.f));
3049 pattern_->currentOffset_ = -20.f;
3050 EXPECT_FALSE(pattern_->NeedScrollSnapToSide(0.f));
3051
3052 // snapOffsets_: {-5, -15, -145, -155}
3053 snapPaginations = {};
3054 CreateSnapScroll(ScrollSnapAlign::START, intervalSize, snapPaginations, enableSnapToSide);
3055 EXPECT_FALSE(pattern_->CalePredictSnapOffset(10.f).has_value());
3056 EXPECT_FALSE(pattern_->CalePredictSnapOffset(-(VERTICAL_SCROLLABLE_DISTANCE + 10.f)).has_value());
3057 EXPECT_TRUE(pattern_->CalePredictSnapOffset(-2.f).has_value());
3058 EXPECT_TRUE(pattern_->CalePredictSnapOffset(-158.f).has_value());
3059 EXPECT_TRUE(pattern_->CalePredictSnapOffset(-10.f).has_value());
3060 }
3061
3062 /**
3063 * @tc.name: Snap002
3064 * @tc.desc: Test snap
3065 * @tc.type: FUNC
3066 */
3067 HWTEST_F(ScrollTestNg, Snap002, TestSize.Level1)
3068 {
3069 Dimension intervalSize = Dimension(10.f / SCROLL_HEIGHT, DimensionUnit::PERCENT);
3070 std::vector<Dimension> snapPaginations = {
3071 Dimension(0.f, DimensionUnit::PERCENT),
3072 Dimension(10.f / SCROLL_HEIGHT, DimensionUnit::PERCENT),
3073 Dimension(20.f / SCROLL_HEIGHT, DimensionUnit::PERCENT),
3074 Dimension(30.f / SCROLL_HEIGHT, DimensionUnit::PERCENT),
3075 Dimension((VERTICAL_SCROLLABLE_DISTANCE + 10.f) / SCROLL_HEIGHT, DimensionUnit::PERCENT),
3076 };
3077
3078 // snapOffsets_: {0, -10, -20, -30, -160}
3079 std::pair<bool, bool> enableSnapToSide = { false, false };
3080 CreateSnapScroll(ScrollSnapAlign::CENTER, intervalSize, snapPaginations, enableSnapToSide);
3081 EXPECT_FALSE(pattern_->CalePredictSnapOffset(0.f).has_value());
3082 EXPECT_FALSE(pattern_->CalePredictSnapOffset(-20.f).has_value());
3083 pattern_->currentOffset_ = -20.f;
3084 EXPECT_TRUE(pattern_->CalePredictSnapOffset(0.f).has_value());
3085
3086 enableSnapToSide = { true, false };
3087 CreateSnapScroll(ScrollSnapAlign::CENTER, intervalSize, snapPaginations, enableSnapToSide);
3088 EXPECT_FALSE(pattern_->CalePredictSnapOffset(-40.f).has_value());
3089 pattern_->currentOffset_ = 20.f;
3090 EXPECT_TRUE(pattern_->CalePredictSnapOffset(-40.f).has_value());
3091 EXPECT_FALSE(pattern_->CalePredictSnapOffset(0.f).has_value());
3092
3093 // snapOffsets_: {-5, -15, -145, -155}
3094 snapPaginations = {};
3095 CreateSnapScroll(ScrollSnapAlign::CENTER, intervalSize, snapPaginations, enableSnapToSide);
3096 EXPECT_FALSE(pattern_->CalePredictSnapOffset(10.f).has_value());
3097 EXPECT_FALSE(pattern_->CalePredictSnapOffset(-(VERTICAL_SCROLLABLE_DISTANCE + 10.f)).has_value());
3098 EXPECT_TRUE(pattern_->CalePredictSnapOffset(-2.f).has_value());
3099 EXPECT_TRUE(pattern_->CalePredictSnapOffset(-158.f).has_value());
3100 EXPECT_TRUE(pattern_->CalePredictSnapOffset(-10.f).has_value());
3101 }
3102
3103 /**
3104 * @tc.name: Snap003
3105 * @tc.desc: Test snap
3106 * @tc.type: FUNC
3107 */
3108 HWTEST_F(ScrollTestNg, Snap003, TestSize.Level1)
3109 {
3110 Dimension intervalSize = Dimension(10.f);
3111 std::vector<Dimension> snapPaginations = {
3112 Dimension(10.f),
3113 Dimension(20.f),
3114 Dimension(30.f),
3115 };
3116
3117 // snapOffsets_: {0, -10, -20, -30, -160}
3118 std::pair<bool, bool> enableSnapToSide = { false, false };
3119 CreateSnapScroll(ScrollSnapAlign::END, intervalSize, snapPaginations, enableSnapToSide);
3120 EXPECT_FALSE(pattern_->CalePredictSnapOffset(0.f).has_value());
3121 EXPECT_FALSE(pattern_->CalePredictSnapOffset(-20.f).has_value());
3122 pattern_->currentOffset_ = -20.f;
3123 EXPECT_TRUE(pattern_->CalePredictSnapOffset(0.f).has_value());
3124
3125 enableSnapToSide = { true, false };
3126 CreateSnapScroll(ScrollSnapAlign::END, intervalSize, snapPaginations, enableSnapToSide);
3127 EXPECT_FALSE(pattern_->CalePredictSnapOffset(-40.f).has_value());
3128 pattern_->currentOffset_ = 20.f;
3129 EXPECT_TRUE(pattern_->CalePredictSnapOffset(-40.f).has_value());
3130 EXPECT_FALSE(pattern_->CalePredictSnapOffset(0.f).has_value());
3131
3132 // snapOffsets_: {-5, -15, -145, -155}
3133 snapPaginations = {};
3134 CreateSnapScroll(ScrollSnapAlign::END, intervalSize, snapPaginations, enableSnapToSide);
3135 EXPECT_FALSE(pattern_->CalePredictSnapOffset(10.f).has_value());
3136 EXPECT_FALSE(pattern_->CalePredictSnapOffset(-(VERTICAL_SCROLLABLE_DISTANCE + 10.f)).has_value());
3137 EXPECT_TRUE(pattern_->CalePredictSnapOffset(-2.f).has_value());
3138 EXPECT_TRUE(pattern_->CalePredictSnapOffset(-158.f).has_value());
3139 EXPECT_TRUE(pattern_->CalePredictSnapOffset(-10.f).has_value());
3140 }
3141
3142 /**
3143 * @tc.name: Drag001
3144 * @tc.desc: Test snap
3145 * @tc.type: FUNC
3146 */
3147 HWTEST_F(ScrollTestNg, Drag001, TestSize.Level1)
3148 {
3149 CreateWithContent();
3150 auto scrollBar = pattern_->GetScrollBar();
3151 GestureEvent info;
3152 scrollBar->HandleDragStart(info);
3153 EXPECT_TRUE(scrollBar->isDriving_);
3154 scrollBar->HandleDragUpdate(info);
3155 info.SetMainVelocity(0.0);
3156 scrollBar->HandleDragEnd(info);
3157 EXPECT_FALSE(scrollBar->isDriving_);
3158 info.SetMainVelocity(1000.0);
3159 scrollBar->HandleDragEnd(info);
3160 }
3161
3162 /**
3163 * @tc.name: Distributed001
3164 * @tc.desc: Test the distributed capability of Scroll.
3165 * @tc.type: FUNC
3166 */
3167 HWTEST_F(ScrollTestNg, Distributed001, TestSize.Level1)
3168 {
3169 /**
3170 * @tc.steps: step1. Initialize Scroll node
3171 */
3172 CreateWithContent();
3173
3174 // need dpi to be 1
3175 /**
3176 * @tc.steps: step2. get pattern .
3177 * @tc.expected: function ProvideRestoreInfo is called.
3178 */
3179 pattern_->currentOffset_ = 1.0f;
3180 std::string ret = pattern_->ProvideRestoreInfo();
3181
3182 /**
3183 * @tc.steps: step3. function OnRestoreInfo is called.
3184 * @tc.expected: Passing JSON format.
3185 */
3186 pattern_->OnRestoreInfo(ret);
3187 EXPECT_DOUBLE_EQ(pattern_->currentOffset_, 1.0f);
3188 }
3189
3190 /**
3191 * @tc.name: ScrollGetItemRect001
3192 * @tc.desc: Test Scroll GetItemRect function.
3193 * @tc.type: FUNC
3194 */
3195 HWTEST_F(ScrollTestNg, ScrollGetItemRect001, TestSize.Level1)
3196 {
3197 /**
3198 * @tc.steps: step1. Initialize Scroll.
3199 */
__anon4dcc91dc4e02(ScrollModelNG model) 3200 CreateWithContent([](ScrollModelNG model) { model.SetAxis(Axis::HORIZONTAL); });
3201
3202 /**
3203 * @tc.steps: step2. Get invalid ScrollItem Rect.
3204 * @tc.expected: Return 0 when input invalid index.
3205 */
3206 EXPECT_TRUE(IsEqual(pattern_->GetItemRect(-1), Rect()));
3207 EXPECT_TRUE(IsEqual(pattern_->GetItemRect(1), Rect()));
3208
3209 /**
3210 * @tc.steps: step3. Get valid ScrollItem Rect.
3211 * @tc.expected: Return actual Rect when input valid index.
3212 */
3213 EXPECT_TRUE(IsEqual(
3214 pattern_->GetItemRect(0), Rect(0, 0, TOTAL_LINE_NUMBER * ITEM_WIDTH, FILL_LENGTH.Value() * SCROLL_HEIGHT)));
3215 }
3216
3217 /**
3218 * @tc.name: EdgeEffectOption001
3219 * @tc.desc: Test EdgeEffectOption
3220 * @tc.type: FUNC
3221 */
3222 HWTEST_F(ScrollTestNg, EdgeEffectOption001, TestSize.Level1)
3223 {
__anon4dcc91dc4f02(ScrollModelNG model) 3224 Create([](ScrollModelNG model) {
3225 model.SetEdgeEffect(EdgeEffect::SPRING, false);
3226 CreateContent(VIEW_LINE_NUMBER);
3227 });
3228 EXPECT_FALSE(pattern_->GetAlwaysEnabled());
3229 EXPECT_FALSE(pattern_->GetScrollableEvent()->GetEnable());
3230 }
3231
3232 /**
3233 * @tc.name: EdgeEffectOption002
3234 * @tc.desc: Test EdgeEffectOption
3235 * @tc.type: FUNC
3236 */
3237 HWTEST_F(ScrollTestNg, EdgeEffectOption002, TestSize.Level1)
3238 {
__anon4dcc91dc5002(ScrollModelNG model) 3239 Create([](ScrollModelNG model) {
3240 model.SetEdgeEffect(EdgeEffect::SPRING, true);
3241 CreateContent(VIEW_LINE_NUMBER);
3242 });
3243 EXPECT_TRUE(pattern_->GetAlwaysEnabled());
3244 EXPECT_TRUE(pattern_->GetScrollableEvent()->GetEnable());
3245 }
3246
3247 /**
3248 * @tc.name: EdgeEffectOption003
3249 * @tc.desc: Test EdgeEffectOption
3250 * @tc.type: FUNC
3251 */
3252 HWTEST_F(ScrollTestNg, EdgeEffectOption003, TestSize.Level1)
3253 {
__anon4dcc91dc5102(ScrollModelNG model) 3254 Create([](ScrollModelNG model) {
3255 model.SetEdgeEffect(EdgeEffect::SPRING, false);
3256 // 20 is childNumber.
3257 CreateContent(20);
3258 });
3259 EXPECT_FALSE(pattern_->GetAlwaysEnabled());
3260 EXPECT_TRUE(pattern_->GetScrollableEvent()->GetEnable());
3261 }
3262
3263 /**
3264 * @tc.name: EdgeEffectOption004
3265 * @tc.desc: Test EdgeEffectOption
3266 * @tc.type: FUNC
3267 */
3268 HWTEST_F(ScrollTestNg, EdgeEffectOption004, TestSize.Level1)
3269 {
__anon4dcc91dc5202(ScrollModelNG model) 3270 Create([](ScrollModelNG model) {
3271 model.SetEdgeEffect(EdgeEffect::SPRING, true);
3272 // 20 is childNumber.
3273 CreateContent(20);
3274 });
3275 EXPECT_TRUE(pattern_->GetAlwaysEnabled());
3276 EXPECT_TRUE(pattern_->GetScrollableEvent()->GetEnable());
3277 }
3278
3279 /**
3280 * @tc.name: ScrollWidth001
3281 * @tc.desc: Test the usability of scroll width property and its get and set function.
3282 * @tc.type: FUNC
3283 */
3284 HWTEST_F(ScrollTestNg, ScrollWidth001, TestSize.Level1)
3285 {
3286 /**
3287 * @tc.steps: step1. Create scroll by calling CreateWithContent() and verify the scroll width property
3288 * of scroll layout property.
3289 * @tc.expected: Default value is ought to be false.
3290 */
3291 CreateWithContent();
3292 float scrollWidth = 150.0f;
3293 EXPECT_FALSE(layoutProperty_->GetScrollWidth().has_value());
3294 layoutProperty_->UpdateScrollWidth(scrollWidth);
3295 EXPECT_EQ(layoutProperty_->GetScrollWidth().value(), scrollWidth);
3296 }
3297
3298 /**
3299 * @tc.name: SelectScroll001
3300 * @tc.desc: Test the flags of select scroll that determines whether it belong to or be modified by a select
3301 * and their get and set functions.
3302 * @tc.type: FUNC
3303 */
3304 HWTEST_F(ScrollTestNg, SelectScroll001, TestSize.Level1)
3305 {
3306 /**
3307 * @tc.steps: step1. Create scroll by calling CreateWithContent() and verify the default value of the flags
3308 * which inform whether the scroll belongs to or is modified by a select.
3309 * @tc.expected: Default value is ought to be false.
3310 */
3311 CreateWithContent();
3312 EXPECT_FALSE(pattern_->IsWidthModifiedBySelect());
3313 EXPECT_FALSE(pattern_->IsSelectScroll());
3314 /**
3315 * @tc.steps: step2. Set both flags to be true and verify the usability of their get and set functions in
3316 * select pattern.
3317 * @tc.expected: After setting the value should be true.
3318 */
3319 pattern_->SetIsWidthModifiedBySelect(true);
3320 pattern_->SetIsSelectScroll(true);
3321 EXPECT_TRUE(pattern_->IsWidthModifiedBySelect());
3322 EXPECT_TRUE(pattern_->IsSelectScroll());
3323 }
3324
3325 /**
3326 * @tc.name: Measure002
3327 * @tc.desc: Test ScrollLayoutAlgorithm Measure when the scroll belongs to a select.
3328 * @tc.type: FUNC
3329 */
3330 HWTEST_F(ScrollTestNg, Measure002, TestSize.Level1)
3331 {
3332 /**
3333 * @tc.steps: step1. Create scroll model and set the width, height, axis of the scroll, create the content of
3334 * the scroll and get its instance.
3335 * @tc.expected: Objects are created successfully.
3336 */
3337 CreateWithContent();
3338 ScrollModelNG model;
3339 model.Create();
3340 ViewAbstract::SetWidth(CalcLength(SCROLL_WIDTH));
3341 ViewAbstract::SetHeight(CalcLength(SCROLL_HEIGHT));
3342 model.SetAxis(Axis::NONE);
3343 CreateContent();
3344 GetInstance();
3345
3346 RefPtr<LayoutWrapperNode> layoutWrapper = frameNode_->CreateLayoutWrapper(false, false);
3347 pattern_->SetIsSelectScroll(true);
3348 FlushLayoutTask(frameNode_);
3349 layoutWrapper->MountToHostOnMainThread();
3350
3351 RefPtr<GridColumnInfo> columnInfo = GridSystemManager::GetInstance().GetInfoByType(GridColumnType::MENU);
3352 columnInfo->GetParent()->BuildColumnWidth();
3353 auto defaultWidth = static_cast<float>(columnInfo->GetWidth(2));
3354 auto scrollSize = frameNode_->GetGeometryNode()->GetFrameSize();
3355 auto expectSize = SizeF(defaultWidth, ITEM_HEIGHT * TOTAL_LINE_NUMBER);
3356 EXPECT_NE(scrollSize, expectSize) << "scrollSize: " << scrollSize.ToString()
3357 << " expectSize: " << expectSize.ToString();
3358 }
3359
3360 /**
3361 * @tc.name: Measure003
3362 * @tc.desc: Test ScrollLayoutAlgorithm Measure.
3363 * @tc.type: FUNC
3364 */
3365 HWTEST_F(ScrollTestNg, Measure003, TestSize.Level1)
3366 {
3367 /**
3368 * @tc.steps: step1. Create scroll without children
3369 */
3370 Create();
3371 auto scrollSize = frameNode_->GetGeometryNode()->GetFrameSize();
3372 auto expectSize = SizeF(SCROLL_WIDTH, SCROLL_HEIGHT);
3373 EXPECT_TRUE(IsEqual(scrollSize, expectSize));
3374
3375 /**
3376 * @tc.steps: step1. set idealSize
3377 * @tc.expected: The frameSize would be idealSize
3378 */
3379 ViewAbstract::SetWidth(AceType::RawPtr(frameNode_), CalcLength(300.f));
3380 ViewAbstract::SetHeight(AceType::RawPtr(frameNode_), CalcLength(500.f));
3381 FlushLayoutTask(frameNode_);
3382
3383 scrollSize = frameNode_->GetGeometryNode()->GetFrameSize();
3384 expectSize = SizeF(300.f, 500.f);
3385 EXPECT_TRUE(IsEqual(scrollSize, expectSize));
3386 }
3387
3388 /**
3389 * @tc.name: SelectScroll002
3390 * @tc.desc: Test select scroll default width.
3391 * @tc.type: FUNC
3392 */
3393 HWTEST_F(ScrollTestNg, SelectScroll002, TestSize.Level1)
3394 {
3395 /**
3396 * @tc.steps: step1. Get the width of select scroll without setting it, this case is meant to test the correctness
3397 * of its default value.
3398 * @tc.expected: Default width of select scroll should be 0.0.
3399 */
3400 CreateWithContent();
3401 ASSERT_NE(pattern_, nullptr);
3402 auto ScrollWidth = pattern_->GetSelectScrollWidth();
3403 ASSERT_NE(ScrollWidth, 0.0);
3404 }
3405
3406 /**
3407 * @tc.name: ScrollTo001
3408 * @tc.desc: Test ScrollTo
3409 * @tc.type: FUNC
3410 */
3411 HWTEST_F(ScrollTestNg, ScrollTo001, TestSize.Level1)
3412 {
__anon4dcc91dc5302(ScrollModelNG model) 3413 CreateWithContent([](ScrollModelNG model) {});
3414
3415 /**
3416 * @tc.steps: step1. ScrollTo normal position
3417 */
3418 pattern_->ScrollTo(ITEM_HEIGHT);
3419 FlushLayoutTask(frameNode_);
3420 EXPECT_EQ(pattern_->GetTotalOffset(), ITEM_HEIGHT);
3421
3422 /**
3423 * @tc.steps: step2. ScrollTo same position
3424 */
3425 pattern_->ScrollTo(ITEM_HEIGHT);
3426 FlushLayoutTask(frameNode_);
3427 EXPECT_EQ(pattern_->GetTotalOffset(), ITEM_HEIGHT);
3428
3429 /**
3430 * @tc.steps: step3. ScrollTo invalid position
3431 * @tc.expected: ScrollTo zero position
3432 */
3433 pattern_->ScrollTo(-1);
3434 FlushLayoutTask(frameNode_);
3435 EXPECT_EQ(pattern_->GetTotalOffset(), 0);
3436 }
3437
3438 /**
3439 * @tc.name: AnimateTo001
3440 * @tc.desc: Test AnimateTo
3441 * @tc.type: FUNC
3442 */
3443 HWTEST_F(ScrollTestNg, AnimateTo001, TestSize.Level1)
3444 {
__anon4dcc91dc5402(ScrollModelNG model) 3445 CreateWithContent([](ScrollModelNG model) {});
3446 auto smooth = false;
3447 pattern_->isAnimationStop_ = false;
3448 pattern_->AnimateTo(ITEM_HEIGHT * TOTAL_LINE_NUMBER, 1.f, Curves::LINEAR, smooth);
3449 EXPECT_FALSE(pattern_->isAnimationStop_);
3450 }
3451
3452 /**
3453 * @tc.name: AnimateTo002
3454 * @tc.desc: Test the canOverScroll of AnimateTo
3455 * @tc.type: FUNC
3456 */
3457 HWTEST_F(ScrollTestNg, AnimateTo002, TestSize.Level1)
3458 {
__anon4dcc91dc5502(ScrollModelNG model) 3459 CreateWithContent([](ScrollModelNG model) {});
3460 auto smooth = false;
3461 auto canOverScroll = false;
3462 pattern_->isAnimationStop_ = false;
3463
3464 pattern_->AnimateTo(-100, 1.f, Curves::LINEAR, smooth, canOverScroll);
3465 EXPECT_EQ(pattern_->animateCanOverScroll_, false);
3466 EXPECT_FALSE(pattern_->isAnimationStop_);
3467
3468 pattern_->StopAnimate();
3469 canOverScroll = true;
3470 auto scrollable = pattern_->scrollableEvent_->GetScrollable();
3471 pattern_->AnimateTo(-100, 1.f, Curves::LINEAR, smooth, canOverScroll);
3472 EXPECT_EQ(pattern_->animateCanOverScroll_, false);
3473 EXPECT_NE(pattern_->curveAnimation_, nullptr);
3474 }
3475
3476 /**
3477 * @tc.name: PlaySpringAnimation001
3478 * @tc.desc: Test PlaySpringAnimation
3479 * @tc.type: FUNC
3480 */
3481 HWTEST_F(ScrollTestNg, PlaySpringAnimation001, TestSize.Level1)
3482 {
__anon4dcc91dc5602(ScrollModelNG model) 3483 CreateWithContent([](ScrollModelNG model) {});
3484 auto smooth = false;
3485 pattern_->isAnimationStop_ = false;
3486 pattern_->AnimateTo(ITEM_HEIGHT * TOTAL_LINE_NUMBER, 1.f, Curves::LINEAR, smooth);
3487 EXPECT_FALSE(pattern_->isAnimationStop_);
3488 }
3489
3490 /**
3491 * @tc.name: StopAnimation001
3492 * @tc.desc: Test StopAnimation
3493 * @tc.type: FUNC
3494 */
3495 HWTEST_F(ScrollTestNg, StopAnimation001, TestSize.Level1)
3496 {
__anon4dcc91dc5702(ScrollModelNG model) 3497 CreateWithContent([](ScrollModelNG model) {});
3498 std::shared_ptr<AnimationUtils::Animation> animation;
3499 pattern_->StopAnimation(animation);
3500 EXPECT_TRUE(pattern_->isAnimationStop_);
3501 }
3502
3503 /**
3504 * @tc.name: EnablePaging001
3505 * @tc.desc: Test enablePaging
3506 * @tc.type: FUNC
3507 */
3508 HWTEST_F(ScrollTestNg, EnablePaging001, TestSize.Level1)
3509 {
3510 /**
3511 * @tc.steps: step1. Create scroll and initialize related properties.
3512 */
__anon4dcc91dc5802(ScrollModelNG model) 3513 CreateWithContent([](ScrollModelNG model) { model.SetEnablePaging(true); });
3514 auto viewPortLength = pattern_->GetMainContentSize();
3515 pattern_->scrollableDistance_ = viewPortLength * 10;
3516 pattern_->currentOffset_ = -viewPortLength * 5 - 10.0f;
3517 SizeF viewPortExtent(SCROLL_WIDTH, viewPortLength * 11);
3518 pattern_->viewPortExtent_ = viewPortExtent;
3519 pattern_->SetIntervalSize(Dimension(static_cast<double>(viewPortLength)));
3520 pattern_->CaleSnapOffsets();
3521
3522 /**
3523 * @tc.steps: step2. dragDistance and dragSpeed less than threshold
3524 * @tc.expected: predictSnapOffset.value() less than 0
3525 */
3526 auto dragDistance = viewPortLength * 0.5 - 1;
3527 auto dragSpeed = SCROLL_PAGING_SPEED_THRESHOLD - 1;
3528 auto predictSnapOffset = pattern_->CalePredictSnapOffset(0.f, dragDistance, dragSpeed);
3529 EXPECT_TRUE(predictSnapOffset.has_value());
3530 EXPECT_LT(predictSnapOffset.value(), 0);
3531
3532 /**
3533 * @tc.steps: step3. dragDistance and dragSpeed larger than threshold
3534 * @tc.expected: the absolute value of predictSnapOffset.value() less than viewPortLength
3535 */
3536 dragDistance = viewPortLength * 0.5 * 5;
3537 dragSpeed = SCROLL_PAGING_SPEED_THRESHOLD * 5;
3538 predictSnapOffset = pattern_->CalePredictSnapOffset(0.f, dragDistance, dragSpeed);
3539 EXPECT_TRUE(predictSnapOffset.has_value());
3540 EXPECT_LT(abs(predictSnapOffset.value()), viewPortLength);
3541 EXPECT_GT(predictSnapOffset.value(), 0);
3542
3543 /**
3544 * @tc.steps: step4. dragDistance equals threshold and dragSpeed less than threshold
3545 * @tc.expected: the absolute value of predictSnapOffset.value() less than viewPortLength
3546 */
3547 dragDistance = viewPortLength * 0.5;
3548 dragSpeed = SCROLL_PAGING_SPEED_THRESHOLD - 1;
3549 predictSnapOffset = pattern_->CalePredictSnapOffset(0.f, dragDistance, dragSpeed);
3550 EXPECT_TRUE(predictSnapOffset.has_value());
3551 EXPECT_LT(abs(predictSnapOffset.value()), viewPortLength);
3552 EXPECT_GT(predictSnapOffset.value(), 0);
3553
3554 /**
3555 * @tc.steps: step5. dragDistance less than threshold and dragSpeed equals threshold
3556 * @tc.expected: the absolute value of predictSnapOffset.value() less than viewPortLength
3557 */
3558 dragDistance = viewPortLength * 0.5 - 1;
3559 dragSpeed = SCROLL_PAGING_SPEED_THRESHOLD;
3560 predictSnapOffset = pattern_->CalePredictSnapOffset(0.f, dragDistance, dragSpeed);
3561 EXPECT_TRUE(predictSnapOffset.has_value());
3562 EXPECT_LT(abs(predictSnapOffset.value()), viewPortLength);
3563 EXPECT_GT(predictSnapOffset.value(), 0);
3564 }
3565
3566 /**
3567 * @tc.name: EnablePaging002
3568 * @tc.desc: Test enablePaging
3569 * @tc.type: FUNC
3570 */
3571 HWTEST_F(ScrollTestNg, EnablePaging002, TestSize.Level1)
3572 {
3573 /**
3574 * @tc.steps: step1. Create scroll and set enablePaging.
3575 * @tc.expected: the value of GetEnablePaging() if VALID
3576 */
__anon4dcc91dc5902(ScrollModelNG model) 3577 CreateWithContent([](ScrollModelNG model) { model.SetEnablePaging(true); });
3578 EXPECT_EQ(pattern_->GetEnablePaging(), ScrollPagingStatus::VALID);
3579
3580 /**
3581 * @tc.steps: step2. Create scroll, first set enablePaging and than set snap.
3582 * @tc.expected: the value of GetEnablePaging() if INVALID
3583 */
3584 Dimension intervalSize = Dimension(10.f);
3585 std::vector<Dimension> snapPaginations = {
3586 Dimension(10.f),
3587 Dimension(20.f),
3588 Dimension(30.f),
3589 };
3590 std::pair<bool, bool> enableSnapToSide = { false, false };
3591 auto scrollSnapAlign = ScrollSnapAlign::START;
__anon4dcc91dc5a02(ScrollModelNG model) 3592 CreateWithContent([scrollSnapAlign, intervalSize, snapPaginations, enableSnapToSide](ScrollModelNG model) {
3593 model.SetEnablePaging(true);
3594 model.SetScrollSnap(scrollSnapAlign, intervalSize, snapPaginations, enableSnapToSide);
3595 });
3596 EXPECT_EQ(pattern_->GetEnablePaging(), ScrollPagingStatus::INVALID);
3597
3598 /**
3599 * @tc.steps: step3. Create scroll, first set snap and than set enablePaging.
3600 * @tc.expected: the value of GetEnablePaging() if INVALID
3601 */
__anon4dcc91dc5b02(ScrollModelNG model) 3602 CreateWithContent([scrollSnapAlign, intervalSize, snapPaginations, enableSnapToSide](ScrollModelNG model) {
3603 model.SetScrollSnap(scrollSnapAlign, intervalSize, snapPaginations, enableSnapToSide);
3604 model.SetEnablePaging(true);
3605 });
3606 EXPECT_EQ(pattern_->GetEnablePaging(), ScrollPagingStatus::INVALID);
3607
3608 /**
3609 * @tc.steps: step4. Create scroll, set enablePaging true and than set enablePaging false.
3610 * @tc.expected: the value of GetEnablePaging() if NONE
3611 */
__anon4dcc91dc5c02(ScrollModelNG model) 3612 CreateWithContent([](ScrollModelNG model) {
3613 model.SetEnablePaging(true);
3614 model.SetEnablePaging(false);
3615 });
3616 EXPECT_EQ(pattern_->GetEnablePaging(), ScrollPagingStatus::NONE);
3617
3618 /**
3619 * @tc.steps: step5. Create scroll, set enablePaging false and than set enablePaging true.
3620 * @tc.expected: the value of GetEnablePaging() if VALID
3621 */
__anon4dcc91dc5d02(ScrollModelNG model) 3622 CreateWithContent([](ScrollModelNG model) {
3623 model.SetEnablePaging(false);
3624 model.SetEnablePaging(true);
3625 });
3626 EXPECT_EQ(pattern_->GetEnablePaging(), ScrollPagingStatus::VALID);
3627 }
3628
3629 /**
3630 * @tc.name: SetMainModeSize001
3631 * @tc.desc: Test SetMainModeSize
3632 * @tc.type: FUNC
3633 */
3634 HWTEST_F(ScrollTestNg, SetMainModeSize001, TestSize.Level1)
3635 {
3636 /**
3637 * @tc.steps: step1. Create scrollBarOverlayModifier, set positionMode_ is BOTTOM
3638 * @tc.expected: modifer's barWidth_ is equal to the width of size
3639 */
3640 ScrollBarOverlayModifier modifer;
3641 modifer.SetPositionMode(PositionMode::BOTTOM);
3642 auto width = 1.0;
3643 auto hight = 1.0;
3644 modifer.SetMainModeSize(Size(width, hight));
3645 EXPECT_EQ(modifer.barWidth_, width);
3646 }
3647
3648 /**
3649 * @tc.name: SetCrossModeSize001
3650 * @tc.desc: Test SetCrossModeSize
3651 * @tc.type: FUNC
3652 */
3653 HWTEST_F(ScrollTestNg, SetCrossModeSize001, TestSize.Level1)
3654 {
3655 /**
3656 * @tc.steps: step1. Create scrollBarOverlayModifier, set positionMode_ is BOTTOM
3657 * @tc.expected: modifer's barHeight_ is equal to the hight of size
3658 */
3659 ScrollBarOverlayModifier modifer;
3660 modifer.SetPositionMode(PositionMode::BOTTOM);
3661 auto width = 1.0;
3662 auto hight = 1.0;
3663 modifer.SetCrossModeSize(Size(width, hight));
3664 EXPECT_EQ(modifer.barHeight_, hight);
3665 }
3666
3667 /**
3668 * @tc.name: SetCrossModeSize002
3669 * @tc.desc: Test SetCrossModeSize
3670 * @tc.type: FUNC
3671 */
3672 HWTEST_F(ScrollTestNg, SetCrossModeSize002, TestSize.Level1)
3673 {
3674 /**
3675 * @tc.steps: step1. Create scrollBarOverlayModifier, set positionMode_ is not BOTTOM
3676 * @tc.expected: modifer's barWidth_ is equal to the width of size
3677 */
3678 auto width = 1.0;
3679 auto hight = 1.0;
3680 ScrollBarOverlayModifier modifer;
3681 modifer.SetPositionMode(PositionMode::LEFT);
3682 modifer.SetCrossModeSize(Size(width, hight));
3683 EXPECT_EQ(modifer.barWidth_, width);
3684 }
3685
3686 /**
3687 * @tc.name: SetMainModeOffset001
3688 * @tc.desc: Test SetMainModeOffset
3689 * @tc.type: FUNC
3690 */
3691 HWTEST_F(ScrollTestNg, SetMainModeOffset001, TestSize.Level1)
3692 {
3693 /**
3694 * @tc.steps: step1. Create scrollBarOverlayModifier, set positionMode_ is BOTTOM
3695 * @tc.expected: modifer's barX_ is equal to the width of x
3696 */
3697 auto x = 1.f;
3698 auto y = 2.f;
3699 ScrollBarOverlayModifier modifer;
3700 modifer.SetPositionMode(PositionMode::BOTTOM);
3701 modifer.SetMainModeOffset(Offset(x, y));
3702 EXPECT_EQ(modifer.barX_, x);
3703 }
3704
3705 /**
3706 * @tc.name: SetCrossModeOffset001
3707 * @tc.desc: Test SetCrossModeOffset
3708 * @tc.type: FUNC
3709 */
3710 HWTEST_F(ScrollTestNg, SetCrossModeOffset001, TestSize.Level1)
3711 {
3712 /**
3713 * @tc.steps: step1. Create scrollBarOverlayModifier, set positionMode_ is BOTTOM
3714 * @tc.expected: modifer's barY_ is equal to the y of Offset
3715 */
3716 auto x = 1.f;
3717 auto y = 1.f;
3718 ScrollBarOverlayModifier modifer;
3719 modifer.SetPositionMode(PositionMode::BOTTOM);
3720 modifer.SetCrossModeOffset(Offset(x, y));
3721 EXPECT_EQ(modifer.barY_, y);
3722 }
3723
3724 /**
3725 * @tc.name: StopAdaptAnimation001
3726 * @tc.desc: Test StopAdaptAnimation
3727 * @tc.type: FUNC
3728 */
3729 HWTEST_F(ScrollTestNg, StopAdaptAnimation001, TestSize.Level1)
3730 {
3731 /**
3732 * @tc.steps: step1. Create scrollBarOverlayModifier, start adapt animation
3733 * @tc.expected: Change modifer's MainModeSize to the initial value
3734 */
3735 double x = 1.00;
3736 double y = 1.25;
3737 double width = 1.00;
3738 double height = 2.00;
3739 Rect rect(x, y, width, height);
3740 bool needAdaptAnimation = true;
3741 ScrollBarOverlayModifier modifer;
3742 AnimationOption option;
3743 auto motion = AceType::MakeRefPtr<ResponsiveSpringMotion>(0.314f, 0.95f);
3744 option.SetCurve(motion);
__anon4dcc91dc5e02() 3745 std::shared_ptr<AnimationUtils::Animation> adaptAnimation_ = AnimationUtils::StartAnimation(option, [&]() {});
3746 modifer.StartAdaptAnimation(rect, needAdaptAnimation);
3747 modifer.StopAdaptAnimation();
3748 EXPECT_NE(adaptAnimation_, nullptr);
3749 }
3750
3751 /**
3752 * @tc.name: StartHoverAnimation001
3753 * @tc.desc: Test StartHoverAnimation
3754 * @tc.type: FUNC
3755 */
3756 HWTEST_F(ScrollTestNg, StartHoverAnimation001, TestSize.Level1)
3757 {
3758 /**
3759 * @tc.steps: step1. Create scrollBarOverlayModifier, set hoverAnimationType is GROW
3760 * @tc.expected: modifer's hoverAnimatingType_ is equal to the hoverType
3761 */
3762 ScrollBarOverlayModifier modifer;
3763 auto hoverType = HoverAnimationType::GROW;
3764 double x = 1.00;
3765 double y = 1.25;
3766 double width = 1.00;
3767 double height = 2.00;
3768 Rect rect(x, y, width, height);
3769 modifer.StartHoverAnimation(rect, HoverAnimationType::GROW);
3770 EXPECT_EQ(modifer.hoverAnimatingType_, hoverType);
3771 }
3772
3773 /**
3774 * @tc.name: StartHoverAnimation002
3775 * @tc.desc: Test StartHoverAnimation
3776 * @tc.type: FUNC
3777 */
3778 HWTEST_F(ScrollTestNg, StartHoverAnimation002, TestSize.Level1)
3779 {
3780 /**
3781 * @tc.steps: step1. Create scrollBarOverlayModifier, set hoverAnimationType is GROW
3782 * @tc.expected: modifer's hoverAnimatingType_ is equal to the hoverType
3783 */
3784 ScrollBarOverlayModifier modifer;
3785 auto hoverType = HoverAnimationType::SHRINK;
3786 double x = 1.00;
3787 double y = 1.25;
3788 double width = 1.00;
3789 double height = 2.00;
3790 Rect rect(x, y, width, height);
3791 modifer.StartHoverAnimation(rect, HoverAnimationType::SHRINK);
3792 EXPECT_EQ(modifer.hoverAnimatingType_, hoverType);
3793 }
3794
3795 /**
3796 * @tc.name: StopHoverAnimation001
3797 * @tc.desc: Test StopHoverAnimation
3798 * @tc.type: FUNC
3799 */
3800 HWTEST_F(ScrollTestNg, StopHoverAnimation001, TestSize.Level1)
3801 {
3802 /**
3803 * @tc.steps: step1. Create scrollBarOverlayModifier, start hover animation
3804 * @tc.expected: modifer's hoverAnimation_ is initialized and stopped
3805 */
3806 ScrollBarOverlayModifier modifer;
3807 AnimationOption option;
3808 auto motion = AceType::MakeRefPtr<ResponsiveSpringMotion>(0.314f, 0.95f);
3809 option.SetCurve(motion);
__anon4dcc91dc5f02() 3810 std::shared_ptr<AnimationUtils::Animation> hoverAnimation_ = AnimationUtils::StartAnimation(option, [&]() {});
3811 double x = 1.00;
3812 double y = 1.25;
3813 double width = 1.00;
3814 double height = 2.00;
3815 Rect rect(x, y, width, height);
3816 modifer.StartHoverAnimation(rect, HoverAnimationType::SHRINK);
3817 modifer.StopHoverAnimation();
3818 EXPECT_NE(modifer.hoverAnimation_, nullptr);
3819 }
3820
3821 /**
3822 * @tc.name: GetHoverOffset001
3823 * @tc.desc: Test GetHoverOffset
3824 * @tc.type: FUNC
3825 */
3826 HWTEST_F(ScrollTestNg, GetHoverOffset001, TestSize.Level1)
3827 {
3828 /**
3829 * @tc.steps: step1. Create scrollBarOverlayModifier, set positionMode_ is RIGHT
3830 * @tc.expected: modifer's Offset is assigned a correlation value
3831 */
3832 auto width = 1.0;
3833 auto hight = 1.0;
3834 ScrollBarOverlayModifier modifer;
3835 modifer.SetPositionMode(PositionMode::RIGHT);
3836 auto result = modifer.GetHoverOffset(Size(width, hight));
3837 auto offsetResult = width - modifer.barWidth_->Get();
3838 EXPECT_EQ(result, Offset(offsetResult, 0.f));
3839 }
3840
3841 /**
3842 * @tc.name: GetHoverOffset002
3843 * @tc.desc: Test GetHoverOffset
3844 * @tc.type: FUNC
3845 */
3846 HWTEST_F(ScrollTestNg, GetHoverOffset002, TestSize.Level1)
3847 {
3848 /**
3849 * @tc.steps: step1. Create scrollBarOverlayModifier, set positionMode_ is BOTTOM
3850 * @tc.expected: modifer's Offset is assigned a correlation value
3851 */
3852 auto width = 1.0;
3853 auto hight = 1.0;
3854 ScrollBarOverlayModifier modifer;
3855 modifer.SetPositionMode(PositionMode::BOTTOM);
3856 modifer.GetHoverOffset(Size(width, hight));
3857 auto result = modifer.GetHoverOffset(Size(width, hight));
3858 auto offsetResult = hight - modifer.barHeight_->Get();
3859 EXPECT_EQ(result, Offset(0.f, offsetResult));
3860 }
3861
3862 /**
3863 * @tc.name: SetGestureEvent001
3864 * @tc.desc: Test GestureEvent
3865 * @tc.type: FUNC
3866 */
3867 HWTEST_F(ScrollTestNg, SetGestureEvent001, TestSize.Level1)
3868 {
3869 /**
3870 * @tc.steps: step1. Create scrollBar, touchEvent_
3871 * @tc.expected: touchEvent_ is initialized correctly
3872 */
3873 CreateWithContent();
3874 auto paint = pattern_->CreateNodePaintMethod();
3875 auto scrollPaint = AceType::DynamicCast<ScrollPaintMethod>(paint);
3876 auto scrollBar = scrollPaint->scrollBar_.Upgrade();
__anon4dcc91dc6002(const TouchEventInfo& info) 3877 auto touchCallback = [](const TouchEventInfo& info) {};
3878 RefPtr<TouchEventImpl> touchEvent_ = AccessibilityManager::MakeRefPtr<TouchEventImpl>(std::move(touchCallback));
3879 scrollBar->SetGestureEvent();
3880 EXPECT_NE(touchEvent_, nullptr);
3881 }
3882
3883 /**
3884 * @tc.name: SetSetMouseEvent001
3885 * @tc.desc: Test SetMouseEvent
3886 * @tc.type: FUNC
3887 */
3888 HWTEST_F(ScrollTestNg, SetMouseEvent001, TestSize.Level1)
3889 {
3890 /**
3891 * @tc.steps: step1. Create scrollBar, mouseEvent_
3892 * @tc.expected: mouseEvent_ is initialized correctly
3893 */
3894 CreateWithContent();
3895 auto paint = pattern_->CreateNodePaintMethod();
3896 auto scrollPaint = AceType::DynamicCast<ScrollPaintMethod>(paint);
3897 auto scrollBar = scrollPaint->scrollBar_.Upgrade();
__anon4dcc91dc6102(MouseInfo& info) 3898 auto mouseTask = [](MouseInfo& info) {};
3899 RefPtr<InputEvent> mouseEvent_ = AccessibilityManager::MakeRefPtr<InputEvent>(std::move(mouseTask));
3900 scrollBar->SetMouseEvent();
3901 EXPECT_NE(mouseEvent_, nullptr);
3902 }
3903 } // namespace OHOS::Ace::NG
3904