1 /*
2 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "swiper_test_ng.h"
17
18 #include "test/mock/base/mock_task_executor.h"
19 #include "test/mock/core/common/mock_theme_manager.h"
20 #include "test/mock/core/pipeline/mock_pipeline_context.h"
21 #include "test/mock/core/rosen/mock_canvas.h"
22
23 #include "core/components/button/button_theme.h"
24 #include "core/components/swiper/swiper_indicator_theme.h"
25 #include "core/components_ng/pattern/button/button_model_ng.h"
26 #include "core/components_ng/pattern/swiper_indicator/indicator_common/swiper_arrow_pattern.h"
27
28 namespace OHOS::Ace::NG {
SetUpTestSuite()29 void SwiperTestNg::SetUpTestSuite()
30 {
31 TestNG::SetUpTestSuite();
32 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
33 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
34 auto buttonTheme = AceType::MakeRefPtr<ButtonTheme>();
35 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(buttonTheme));
36 auto themeConstants = CreateThemeConstants(THEME_PATTERN_SWIPER);
37 auto swiperIndicatorTheme = SwiperIndicatorTheme::Builder().Build(themeConstants);
38 EXPECT_CALL(*themeManager, GetTheme(SwiperIndicatorTheme::TypeId())).WillRepeatedly(Return(swiperIndicatorTheme));
39 swiperIndicatorTheme->color_ = Color::FromString("#182431");
40 swiperIndicatorTheme->selectedColor_ = Color::FromString("#007DFF");
41 swiperIndicatorTheme->hoverArrowBackgroundColor_ = HOVER_ARROW_COLOR;
42 swiperIndicatorTheme->clickArrowBackgroundColor_ = CLICK_ARROW_COLOR;
43 swiperIndicatorTheme->arrowDisabledAlpha_ = ARROW_DISABLED_ALPHA;
44 swiperIndicatorTheme->size_ = Dimension(6.f);
45 TextStyle textStyle;
46 textStyle.SetTextColor(INDICATOR_TEXT_FONT_COLOR);
47 textStyle.SetFontSize(INDICATOR_TEXT_FONT_SIZE);
48 textStyle.SetFontWeight(INDICATOR_TEXT_FONT_WEIGHT);
49 swiperIndicatorTheme->digitalIndicatorTextStyle_ = textStyle;
50 MockPipelineContext::GetCurrentContext()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
51 EXPECT_CALL(*MockPipelineContext::pipeline_, FlushUITasks).Times(AnyNumber());
52 }
53
TearDownTestSuite()54 void SwiperTestNg::TearDownTestSuite()
55 {
56 TestNG::TearDownTestSuite();
57 }
58
SetUp()59 void SwiperTestNg::SetUp() {}
60
TearDown()61 void SwiperTestNg::TearDown()
62 {
63 frameNode_ = nullptr;
64 pattern_ = nullptr;
65 eventHub_ = nullptr;
66 layoutProperty_ = nullptr;
67 paintProperty_ = nullptr;
68 accessibilityProperty_ = nullptr;
69 controller_ = nullptr;
70 indicatorNode_ = nullptr;
71 leftArrowNode_ = nullptr;
72 rightArrowNode_ = nullptr;
73 }
74
GetInstance()75 void SwiperTestNg::GetInstance()
76 {
77 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
78 frameNode_ = AceType::DynamicCast<FrameNode>(element);
79 pattern_ = frameNode_->GetPattern<SwiperPattern>();
80 eventHub_ = frameNode_->GetEventHub<SwiperEventHub>();
81 layoutProperty_ = frameNode_->GetLayoutProperty<SwiperLayoutProperty>();
82 paintProperty_ = frameNode_->GetPaintProperty<SwiperPaintProperty>();
83 accessibilityProperty_ = frameNode_->GetAccessibilityProperty<SwiperAccessibilityProperty>();
84 controller_ = pattern_->GetSwiperController();
85
86 int index = pattern_->RealTotalCount();
87 if (pattern_->IsShowIndicator() && pattern_->HasIndicatorNode()) {
88 indicatorNode_ = GetChildFrameNode(frameNode_, index);
89 index += 1;
90 }
91 if (pattern_->HasLeftButtonNode()) {
92 leftArrowNode_ = GetChildFrameNode(frameNode_, index);
93 index += 1;
94 }
95 if (pattern_->HasRightButtonNode()) {
96 rightArrowNode_ = GetChildFrameNode(frameNode_, index);
97 }
98 }
99
Create(const std::function<void (SwiperModelNG)> & callback)100 void SwiperTestNg::Create(const std::function<void(SwiperModelNG)>& callback)
101 {
102 SwiperModelNG model;
103 model.Create();
104 model.SetIndicatorType(SwiperIndicatorType::DOT);
105 ViewAbstract::SetWidth(CalcLength(SWIPER_WIDTH));
106 ViewAbstract::SetHeight(CalcLength(SWIPER_HEIGHT));
107 if (callback) {
108 callback(model);
109 }
110 GetInstance();
111 FlushLayoutTask(frameNode_);
112 }
113
CreateWithItem(const std::function<void (SwiperModelNG)> & callback,int32_t itemNumber)114 void SwiperTestNg::CreateWithItem(const std::function<void(SwiperModelNG)>& callback, int32_t itemNumber)
115 {
116 Create([callback, itemNumber](SwiperModelNG model) {
117 if (callback) {
118 callback(model);
119 }
120 CreateItem(itemNumber);
121 });
122 }
123
CreateItem(int32_t itemNumber)124 void SwiperTestNg::CreateItem(int32_t itemNumber)
125 {
126 for (int32_t index = 0; index < itemNumber; index++) {
127 ButtonModelNG buttonModelNG;
128 buttonModelNG.CreateWithLabel("label");
129 ViewStackProcessor::GetInstance()->GetMainElementNode()->onMainTree_ = true;
130 ViewStackProcessor::GetInstance()->Pop();
131 }
132 }
133
CreateItemWithSize(float width,float height)134 void SwiperTestNg::CreateItemWithSize(float width, float height)
135 {
136 ButtonModelNG buttonModelNG;
137 buttonModelNG.CreateWithLabel("label");
138 ViewAbstract::SetWidth(CalcLength(width));
139 ViewAbstract::SetHeight(CalcLength(height));
140 ViewStackProcessor::GetInstance()->Pop();
141 }
142
ShowNext()143 void SwiperTestNg::ShowNext()
144 {
145 controller_->ShowNext();
146 FlushLayoutTask(frameNode_);
147 }
148
ShowPrevious()149 void SwiperTestNg::ShowPrevious()
150 {
151 controller_->ShowPrevious();
152 FlushLayoutTask(frameNode_);
153 }
154
ChangeIndex(int32_t index)155 void SwiperTestNg::ChangeIndex(int32_t index)
156 {
157 controller_->ChangeIndex(index, false);
158 FlushLayoutTask(frameNode_);
159 }
160
161 /**
162 * @tc.name: SwiperPatternOnDirtyLayoutWrapperSwap001
163 * @tc.desc: OnDirtyLayoutWrapperSwap
164 * @tc.type: FUNC
165 */
166 HWTEST_F(SwiperTestNg, SwiperPatternOnDirtyLayoutWrapperSwap001, TestSize.Level1)
167 {
__anonf92747110202(SwiperModelNG model) 168 CreateWithItem([](SwiperModelNG model) {
169 model.SetDisplayArrow(true); // show arrow
170 model.SetHoverShow(false);
171 model.SetArrowStyle(ARROW_PARAMETERS);
172 });
173 auto firstChild = AccessibilityManager::DynamicCast<FrameNode>(indicatorNode_);
174 RefPtr<GeometryNode> firstGeometryNode = AceType::MakeRefPtr<GeometryNode>();
175 firstGeometryNode->Reset();
176 firstGeometryNode->SetFrameSize(SizeF(20.0, 20.0));
177 auto dirty = AceType::MakeRefPtr<LayoutWrapperNode>(firstChild, firstGeometryNode, firstChild->GetLayoutProperty());
178 struct DirtySwapConfig config;
179 pattern_->isInit_ = true;
180 config.skipMeasure = true;
181 config.skipLayout = true;
182
183 /**
184 * @tc.steps: step2. call OnDirtyLayoutWrapperSwap.
185 * @tc.expected: Related function runs ok.
186 */
187 for (int i = 0; i <= 1; i++) {
188 for (int j = 0; j <= 1; j++) {
189 pattern_->OnDirtyLayoutWrapperSwap(dirty, config);
190 pattern_->isInit_ = false;
191 if (i == 1) {
192 config.skipLayout = false;
193 continue;
194 }
195 config.skipLayout = true;
196 }
197 config.skipMeasure = false;
198 }
199 struct SwiperItemInfo swiperItemInfo1;
200 struct SwiperItemInfo swiperItemInfo2;
201 struct SwiperItemInfo swiperItemInfo3;
202 struct SwiperItemInfo swiperItemInfo4;
203 swiperItemInfo1.startPos = -1.0f;
204 swiperItemInfo1.endPos = -1.0f;
205 swiperItemInfo2.startPos = 1.0f;
206 swiperItemInfo2.endPos = -1.0f;
207 swiperItemInfo3.startPos = -1.0f;
208 swiperItemInfo3.endPos = 0.0f;
209 swiperItemInfo4.startPos = 1.0f;
210 swiperItemInfo4.endPos = 1.0f;
211
212 auto swiperLayoutAlgorithm = AceType::DynamicCast<SwiperLayoutAlgorithm>(pattern_->CreateLayoutAlgorithm());
213 dirty->layoutAlgorithm_ = AceType::MakeRefPtr<LayoutAlgorithmWrapper>(swiperLayoutAlgorithm);
214 dirty->layoutAlgorithm_->layoutAlgorithm_ = AceType::MakeRefPtr<SwiperLayoutAlgorithm>();
215 ASSERT_NE(dirty->GetLayoutAlgorithm(), nullptr);
216 ASSERT_NE(AceType::DynamicCast<SwiperLayoutAlgorithm>(dirty->GetLayoutAlgorithm()->GetLayoutAlgorithm()), nullptr);
217 AceType::DynamicCast<SwiperLayoutAlgorithm>(dirty->GetLayoutAlgorithm()->GetLayoutAlgorithm())
218 ->itemPosition_.emplace(std::make_pair(1, swiperItemInfo1));
219 AceType::DynamicCast<SwiperLayoutAlgorithm>(dirty->GetLayoutAlgorithm()->GetLayoutAlgorithm())
220 ->itemPosition_.emplace(std::make_pair(2, swiperItemInfo2));
221 AceType::DynamicCast<SwiperLayoutAlgorithm>(dirty->GetLayoutAlgorithm()->GetLayoutAlgorithm())
222 ->itemPosition_.emplace(std::make_pair(3, swiperItemInfo3));
223 AceType::DynamicCast<SwiperLayoutAlgorithm>(dirty->GetLayoutAlgorithm()->GetLayoutAlgorithm())
224 ->itemPosition_.emplace(std::make_pair(4, swiperItemInfo4));
225 pattern_->OnDirtyLayoutWrapperSwap(dirty, config);
226 pattern_->indicatorDoingAnimation_ = false;
227 pattern_->jumpIndex_ = 1;
228
229 for (int i = 0; i <= 1; i++) {
230 pattern_->OnDirtyLayoutWrapperSwap(dirty, config);
231 pattern_->indicatorDoingAnimation_ = true;
232 pattern_->targetIndex_ = 1;
233 AceType::DynamicCast<SwiperLayoutAlgorithm>(dirty->GetLayoutAlgorithm()->GetLayoutAlgorithm())
234 ->itemPosition_.emplace(std::make_pair(1, swiperItemInfo1));
235 }
236
237 AceType::DynamicCast<SwiperPaintProperty>(frameNode_->paintProperty_)->UpdateEdgeEffect(EdgeEffect::SPRING);
238 for (int i = 0; i <= 1; i++) {
239 for (int j = 0; j <= 1; j++) {
240 pattern_->OnDirtyLayoutWrapperSwap(dirty, config);
241 if (i == 1) {
242 AceType::DynamicCast<SwiperPaintProperty>(frameNode_->paintProperty_)
243 ->UpdateEdgeEffect(EdgeEffect::FADE);
244 continue;
245 }
246 AceType::DynamicCast<SwiperPaintProperty>(frameNode_->paintProperty_)->UpdateEdgeEffect(EdgeEffect::SPRING);
247 }
248 AceType::DynamicCast<SwiperLayoutProperty>(frameNode_->layoutProperty_)->padding_ =
249 std::make_unique<PaddingProperty>();
250 }
251 }
252
253 /**
254 * @tc.name: SwiperPatternGetRemainingOffset001
255 * @tc.desc: GetRemainingOffset
256 * @tc.type: FUNC
257 */
258 HWTEST_F(SwiperTestNg, SwiperPatternGetRemainingOffset001, TestSize.Level1)
259 {
__anonf92747110302(SwiperModelNG model) 260 CreateWithItem([](SwiperModelNG model) {});
261 layoutProperty_->UpdateLoop(true);
262 struct SwiperItemInfo swiperItemInfo1;
263 swiperItemInfo1.startPos = -1.0f;
264 swiperItemInfo1.endPos = -1.0f;
265 pattern_->itemPosition_.emplace(std::make_pair(1, swiperItemInfo1));
266
267 /**
268 * @tc.steps: step2. call GetRemainingOffset.
269 * @tc.expected: Related function runs ok.
270 */
271 for (int i = 0; i <= 1; i++) {
272 for (int j = 0; j <= 1; j++) {
273 pattern_->GetDistanceToEdge();
274 if (i == 1) {
275 pattern_->itemPosition_.emplace(std::make_pair(0, swiperItemInfo1));
276 continue;
277 }
278 pattern_->itemPosition_.clear();
279 }
280 layoutProperty_->UpdateLoop(false);
281 }
282 pattern_->itemPosition_.emplace(std::make_pair(1, swiperItemInfo1));
283 pattern_->GetDistanceToEdge();
284 }
285
286 /**
287 * @tc.name: SwiperPatternCalculateDisplayCount001
288 * @tc.desc: CalculateDisplayCount
289 * @tc.type: FUNC
290 */
291 HWTEST_F(SwiperTestNg, SwiperPatternCalculateDisplayCount001, TestSize.Level1)
292 {
__anonf92747110402(SwiperModelNG model) 293 CreateWithItem([](SwiperModelNG model) {});
294 auto dimension = Dimension(1);
295 layoutProperty_->UpdateMinSize(dimension);
296
297 /**
298 * @tc.steps: step2. call CalculateDisplayCount.
299 * @tc.expected: Related function runs ok.
300 */
301 pattern_->CalculateDisplayCount();
302 }
303
304 /**
305 * @tc.name: SwiperPatternOnTouchTestHit001
306 * @tc.desc: OnTouchTestHit
307 * @tc.type: FUNC
308 */
309 HWTEST_F(SwiperTestNg, SwiperPatternOnTouchTestHit001, TestSize.Level1)
310 {
__anonf92747110502(SwiperModelNG model) 311 CreateWithItem([](SwiperModelNG model) {});
312
313 /**
314 * @tc.steps: step2. call OnTouchTestHit.
315 * @tc.expected: Related function runs ok.
316 */
__anonf92747110602null317 CommonFunc callback = [] {};
318 pattern_->isTouchDown_ = false;
319 pattern_->swiperController_->SetRemoveTabBarEventCallback(callback);
320 pattern_->OnTouchTestHit(SourceType::TOUCH);
321 EXPECT_NE(pattern_->swiperController_->GetRemoveTabBarEventCallback(), nullptr);
322 }
323
324 /**
325 * @tc.name: SwiperPatternOnDirtyLayoutWrapperSwap002
326 * @tc.desc: OnDirtyLayoutWrapperSwap
327 * @tc.type: FUNC
328 */
329 HWTEST_F(SwiperTestNg, SwiperPatternOnDirtyLayoutWrapperSwap002, TestSize.Level1)
330 {
__anonf92747110702(SwiperModelNG model) 331 CreateWithItem([](SwiperModelNG model) {
332 model.SetDisplayArrow(true); // show arrow
333 model.SetHoverShow(false);
334 model.SetArrowStyle(ARROW_PARAMETERS);
335 });
336 auto firstChild = AccessibilityManager::DynamicCast<FrameNode>(indicatorNode_);
337 RefPtr<GeometryNode> firstGeometryNode = AceType::MakeRefPtr<GeometryNode>();
338 firstGeometryNode->Reset();
339 firstGeometryNode->SetFrameSize(SizeF(20.0, 20.0));
340 auto firstLayoutWrapper =
341 AceType::MakeRefPtr<LayoutWrapperNode>(firstChild, firstGeometryNode, firstChild->GetLayoutProperty());
342 auto dirty = AceType::MakeRefPtr<LayoutWrapperNode>(firstChild, firstGeometryNode, firstChild->GetLayoutProperty());
343 dirty->AppendChild(firstLayoutWrapper);
344 struct DirtySwapConfig config;
345 pattern_->isInit_ = true;
346 config.skipMeasure = false;
347 config.skipLayout = false;
348
349 /**
350 * @tc.steps: step2. call OnDirtyLayoutWrapperSwap.
351 * @tc.expected: Related function runs ok.
352 */
__anonf92747110802(const int32_t i, float f) 353 TurnPageRateFunc callback = [](const int32_t i, float f) {};
354 pattern_->swiperController_->SetTurnPageRateCallback(callback);
355 struct SwiperItemInfo swiperItemInfo1;
356 swiperItemInfo1.startPos = -1.0f;
357 swiperItemInfo1.endPos = -1.0f;
358
359 auto swiperLayoutAlgorithm = AceType::DynamicCast<SwiperLayoutAlgorithm>(pattern_->CreateLayoutAlgorithm());
360 dirty->layoutAlgorithm_ = AceType::MakeRefPtr<LayoutAlgorithmWrapper>(swiperLayoutAlgorithm);
361 dirty->layoutAlgorithm_->layoutAlgorithm_ = AceType::MakeRefPtr<SwiperLayoutAlgorithm>();
362 ASSERT_NE(dirty->GetLayoutAlgorithm(), nullptr);
363 ASSERT_NE(AceType::DynamicCast<SwiperLayoutAlgorithm>(dirty->GetLayoutAlgorithm()->GetLayoutAlgorithm()), nullptr);
364 AceType::DynamicCast<SwiperLayoutAlgorithm>(dirty->GetLayoutAlgorithm()->GetLayoutAlgorithm())
365 ->itemPosition_.emplace(std::make_pair(1, swiperItemInfo1));
366 pattern_->isDragging_ = true;
367 pattern_->OnDirtyLayoutWrapperSwap(dirty, config);
368 EXPECT_NE(pattern_->swiperController_->GetTurnPageRateCallback(), nullptr);
369 }
370
371 /**
372 * @tc.name: SwiperPatternGetDisplayCount002
373 * @tc.desc: GetDisplayCount
374 * @tc.type: FUNC
375 */
376 HWTEST_F(SwiperTestNg, SwiperPatternGetDisplayCount002, TestSize.Level1)
377 {
__anonf92747110902(SwiperModelNG model) 378 CreateWithItem([](SwiperModelNG model) {});
379 layoutProperty_->UpdateShowIndicator(false);
380 pattern_->leftButtonId_.reset();
381
382 LayoutConstraintF layoutConstraint;
383 layoutConstraint.maxSize = SizeF(720.f, 1136.f);
384 layoutConstraint.percentReference = SizeF(720.f, 1136.f);
385 layoutConstraint.parentIdealSize.SetSize(SizeF(720.f, 1136.f));
386 layoutConstraint.selfIdealSize = OptionalSize(SizeF(720.f, 1200.f));
387 layoutProperty_->UpdateLayoutConstraint(layoutConstraint);
388 layoutProperty_->UpdateContentConstraint();
389
390 /**
391 * @tc.steps: step2. Set the FrameSize of the model.
392 */
393 frameNode_->GetGeometryNode()->SetFrameSize(SizeF(720.f, 1136.f));
394 Dimension SWIPER_MINSIZE = 50.0_vp;
395
396 for (int i = 0; i < 4; i++) {
397 /**
398 * @tc.steps: step3. Update the MinSize of one swiper item.
399 * @tc.expected: Related function runs ok.
400 */
401 layoutProperty_->UpdateMinSize(SWIPER_MINSIZE);
402 EXPECT_EQ(layoutProperty_->GetMinSize().value_or(Dimension(0.0, DimensionUnit::VP)), SWIPER_MINSIZE);
403
404 /**
405 * @tc.steps: step4. Call GetDisplayCount.
406 * @tc.expected: The return value is correct.
407 */
408 float displaycount = static_cast<int32_t>(
409 floor((SizeF(720.f, 1136.f).Width() - 2 * 16.f + 16.f) / (SWIPER_MINSIZE.ConvertToPx() + 16.f)));
410 displaycount = displaycount > 0 ? displaycount : 1;
411 displaycount = displaycount > pattern_->TotalCount() ? pattern_->TotalCount() : displaycount;
412 EXPECT_EQ(pattern_->GetDisplayCount(), displaycount);
413
414 constexpr Dimension delta = 200.0_vp;
415 SWIPER_MINSIZE += delta;
416 }
417 }
418
419 /**
420 * @tc.name: SwiperPatternGetFirstItemInfoInVisibleArea001
421 * @tc.desc: GetFirstItemInfoInVisibleArea
422 * @tc.type: FUNC
423 */
424 HWTEST_F(SwiperTestNg, SwiperPatternGetFirstItemInfoInVisibleArea001, TestSize.Level1)
425 {
__anonf92747110a02(SwiperModelNG model) 426 CreateWithItem([](SwiperModelNG model) {});
427 struct SwiperItemInfo swiperItemInfo1 {
428 0.1f, 0.2f
429 }, swiperItemInfo2 { -0.1f, -0.2f }, swiperItemInfo3 { -0.1f, 0.2f }, swiperItemInfo4 { 0.1f, -0.2f };
430 pattern_->itemPosition_.clear();
431 auto dimension = Dimension(1);
432
433 /**
434 * @tc.steps: step2. call GetFirstItemInfoInVisibleArea.
435 * @tc.expected: Related function runs ok.
436 */
437 for (int i = 0; i <= 1; i++) {
438 for (int j = 0; j <= 1; j++) {
439 pattern_->GetFirstItemInfoInVisibleArea();
440 if (i == 1) {
441 break;
442 }
443 pattern_->itemPosition_.emplace(std::make_pair(1, swiperItemInfo1));
444 pattern_->itemPosition_.emplace(std::make_pair(2, swiperItemInfo2));
445 pattern_->itemPosition_.emplace(std::make_pair(3, swiperItemInfo3));
446 pattern_->itemPosition_.emplace(std::make_pair(4, swiperItemInfo4));
447 layoutProperty_->UpdatePrevMargin(dimension);
448 layoutProperty_->layoutConstraint_->scaleProperty = ScaleProperty { 1.0f, 1.0f, 1.0f };
449 }
450 layoutProperty_->ResetPrevMargin();
451 layoutProperty_->layoutConstraint_->scaleProperty = ScaleProperty { 0.0f, 0.0f, 0.0f };
452 }
453 }
454
455 /**
456 * @tc.name: SwiperPatternGetSecondItemInfoInVisibleArea001
457 * @tc.desc: GetSecondItemInfoInVisibleArea
458 * @tc.type: FUNC
459 */
460 HWTEST_F(SwiperTestNg, SwiperPatternGetSecondItemInfoInVisibleArea001, TestSize.Level1)
461 {
__anonf92747110b02(SwiperModelNG model) 462 CreateWithItem([](SwiperModelNG model) {});
463 struct SwiperItemInfo swiperItemInfo1 {
464 0.1f, 0.2f
465 }, swiperItemInfo2 { -0.1f, -0.2f }, swiperItemInfo3 { -0.1f, 0.2f }, swiperItemInfo4 { 0.1f, -0.2f };
466 pattern_->itemPosition_.clear();
467 auto dimension = Dimension(1);
468
469 /**
470 * @tc.steps: step2. call GetSecondItemInfoInVisibleArea.
471 * @tc.expected: Related function runs ok.
472 */
473 for (int i = 0; i <= 1; i++) {
474 for (int j = 0; j <= 1; j++) {
475 pattern_->GetSecondItemInfoInVisibleArea();
476 if (i == 1) {
477 break;
478 }
479 pattern_->itemPosition_.emplace(std::make_pair(1, swiperItemInfo1));
480 pattern_->itemPosition_.emplace(std::make_pair(2, swiperItemInfo2));
481 pattern_->itemPosition_.emplace(std::make_pair(3, swiperItemInfo3));
482 pattern_->itemPosition_.emplace(std::make_pair(4, swiperItemInfo4));
483 layoutProperty_->UpdatePrevMargin(dimension);
484 layoutProperty_->layoutConstraint_->scaleProperty = ScaleProperty { 1.0f, 1.0f, 1.0f };
485 }
486 layoutProperty_->ResetPrevMargin();
487 layoutProperty_->layoutConstraint_->scaleProperty = ScaleProperty { 0.0f, 0.0f, 0.0f };
488 }
489 pattern_->itemPosition_.erase(2);
490 pattern_->GetSecondItemInfoInVisibleArea();
491 }
492
493 /**
494 * @tc.name: PostTranslateTask001
495 * @tc.desc: PostTranslateTask
496 * @tc.type: FUNC
497 */
498 HWTEST_F(SwiperTestNg, PostTranslateTask001, TestSize.Level1)
499 {
500 /**
501 * @tc.steps: step1. Call PostTranslateTask
502 * @tc.expected: Swipe to next
503 */
__anonf92747110c02(SwiperModelNG model) 504 CreateWithItem([](SwiperModelNG model) {});
505 pattern_->PostTranslateTask(DEFAULT_INTERVAL);
506 EXPECT_EQ(pattern_->targetIndex_, 1);
507 }
508
509 /**
510 * @tc.name: PostTranslateTask002
511 * @tc.desc: PostTranslateTask
512 * @tc.type: FUNC
513 */
514 HWTEST_F(SwiperTestNg, PostTranslateTask002, TestSize.Level1)
515 {
516 /**
517 * @tc.steps: step1. loop is false, index is last item index
518 * @tc.expected: Can not swipe to next
519 */
__anonf92747110d02(SwiperModelNG model) 520 CreateWithItem([](SwiperModelNG model) {
521 model.SetLoop(false);
522 model.SetIndex(2);
523 });
524
525 /**
526 * @tc.steps: step2. Call PostTranslateTask
527 * @tc.expected: Can swipe to next
528 */
529 pattern_->PostTranslateTask(DEFAULT_INTERVAL);
530 EXPECT_EQ(pattern_->targetIndex_, 3);
531
532 /**
533 * @tc.steps: step3. Swipe to last item and call PostTranslateTask
534 * @tc.expected: Can not swipe to next
535 */
536 ChangeIndex(3);
537 pattern_->PostTranslateTask(DEFAULT_INTERVAL);
538 EXPECT_FALSE(pattern_->targetIndex_.has_value());
539 }
540
541 /**
542 * @tc.name: PostTranslateTask003
543 * @tc.desc: PostTranslateTask
544 * @tc.type: FUNC
545 */
546 HWTEST_F(SwiperTestNg, PostTranslateTask003, TestSize.Level1)
547 {
__anonf92747110e02(SwiperModelNG model) 548 Create([](SwiperModelNG model) {});
549 pattern_->itemPosition_.clear();
550 pattern_->PostTranslateTask(DEFAULT_INTERVAL);
551 EXPECT_FALSE(pattern_->targetIndex_.has_value());
552
553 layoutProperty_->UpdateDisplayCount(0);
554 pattern_->PostTranslateTask(DEFAULT_INTERVAL);
555 EXPECT_FALSE(pattern_->targetIndex_.has_value());
556 }
557
558 /**
559 * @tc.name: SwiperPatternRegisterVisibleAreaChange001
560 * @tc.desc: RegisterVisibleAreaChange
561 * @tc.type: FUNC
562 */
563 HWTEST_F(SwiperTestNg, SwiperPatternRegisterVisibleAreaChange001, TestSize.Level1)
564 {
__anonf92747110f02(SwiperModelNG model) 565 CreateWithItem([](SwiperModelNG model) {});
566
567 /**
568 * @tc.steps: step2. call RegisterVisibleAreaChange.
569 * @tc.expected: Related function runs ok.
570 */
571 for (int i = 0; i <= 1; i++) {
572 for (int j = 0; j <= 1; j++) {
573 pattern_->RegisterVisibleAreaChange();
574 if (i == 1) {
575 pattern_->hasVisibleChangeRegistered_ = false;
576 }
577 pattern_->hasVisibleChangeRegistered_ = true;
578 }
579 frameNode_->GetPaintProperty<SwiperPaintProperty>()->UpdateAutoPlay(true);
580 }
581
582 pattern_->isWindowShow_ = false;
583 for (int i = 0; i <= 1; i++) {
584 pattern_->RegisterVisibleAreaChange();
585 pattern_->isWindowShow_ = true;
586 pattern_->isVisibleArea_ = true;
587 pattern_->isVisible_ = true;
588 }
589 }
590
591 /**
592 * @tc.name: SwiperPatternOnTranslateFinish001
593 * @tc.desc: OnTranslateFinish
594 * @tc.type: FUNC
595 */
596 HWTEST_F(SwiperTestNg, SwiperPatternOnTranslateFinish001, TestSize.Level1)
597 {
__anonf92747111002(SwiperModelNG model) 598 CreateWithItem([](SwiperModelNG model) {
599 model.SetDisplayArrow(true); // show arrow
600 model.SetHoverShow(false);
601 model.SetArrowStyle(ARROW_PARAMETERS);
602 });
603 int32_t nextIndex = 1;
604 bool restartAutoPlay = true;
605 bool forceStop = true;
606
607 /**
608 * @tc.steps: step2. call OnTranslateFinish.
609 * @tc.expected: Related function runs ok.
610 */
611 for (int i = 0; i <= 1; i++) {
612 for (int j = 0; j <= 1; j++) {
613 pattern_->OnTranslateFinish(nextIndex, restartAutoPlay, pattern_->isFinishAnimation_, forceStop);
614 if (i == 1) {
615 pattern_->isFinishAnimation_ = false;
616 continue;
617 }
618 pattern_->isFinishAnimation_ = true;
619 frameNode_->AddChild(indicatorNode_);
620 pattern_->isVisible_ = false;
621 }
622 frameNode_->AddChild(leftArrowNode_);
623 frameNode_->AddChild(indicatorNode_);
624 forceStop = false;
625 pattern_->isVisible_ = true;
626 frameNode_->GetPaintProperty<SwiperPaintProperty>()->UpdateAutoPlay(true);
627 layoutProperty_->UpdateLoop(true);
628 }
629 }
630
631 /**
632 * @tc.name: SwiperPatternGetCustomPropertyOffset001
633 * @tc.desc: GetCustomPropertyOffset
634 * @tc.type: FUNC
635 */
636 HWTEST_F(SwiperTestNg, SwiperPatternGetCustomPropertyOffset001, TestSize.Level1)
637 {
__anonf92747111102(SwiperModelNG model) 638 CreateWithItem([](SwiperModelNG model) {});
639 layoutProperty_->UpdateDirection(Axis::HORIZONTAL);
640 layoutProperty_->ResetPrevMargin();
641
642 /**
643 * @tc.steps: step2. call GetCustomPropertyOffset.
644 * @tc.expected: Related function runs ok.
645 */
646 for (int i = 0; i <= 1; i++) {
647 for (int j = 0; j <= 1; j++) {
648 pattern_->GetCustomPropertyOffset();
649 if (i == 1) {
650 break;
651 }
652 layoutProperty_->UpdateDirection(Axis::VERTICAL);
653 layoutProperty_->UpdatePrevMargin(Dimension(0));
654 }
655 layoutProperty_->UpdatePrevMargin(Dimension(1));
656 }
657 }
658
659 /**
660 * @tc.name: SwiperPatternComputeNextIndexByVelocity001
661 * @tc.desc: ComputeNextIndexByVelocity
662 * @tc.type: FUNC
663 */
664 HWTEST_F(SwiperTestNg, SwiperPatternComputeNextIndexByVelocity001, TestSize.Level1)
665 {
__anonf92747111202(SwiperModelNG model) 666 CreateWithItem([](SwiperModelNG model) { model.SetItemSpace(100.0_px); });
667 EXPECT_EQ(pattern_->currentIndex_, 0);
668 PipelineBase::GetCurrentContext()->SetMinPlatformVersion((int32_t)PlatformVersion::VERSION_TEN);
669 float velocity = -1201.0f;
670 EXPECT_EQ(pattern_->ComputeNextIndexByVelocity(velocity, false), 1);
671 PipelineBase::GetCurrentContext()->SetMinPlatformVersion((int32_t)PlatformVersion::VERSION_ELEVEN);
672 velocity = -781.0f;
673 EXPECT_EQ(pattern_->ComputeNextIndexByVelocity(velocity, false), 1);
674 velocity = -780.0f;
675 EXPECT_EQ(pattern_->ComputeNextIndexByVelocity(velocity, false), 0);
676 pattern_->UpdateCurrentOffset(239.0f);
677 FlushLayoutTask(frameNode_);
678 EXPECT_EQ(pattern_->ComputeNextIndexByVelocity(velocity, true), 0);
679 velocity = -781.0f;
680 EXPECT_EQ(pattern_->ComputeNextIndexByVelocity(velocity, false), 1);
681 pattern_->SwipeToWithoutAnimation(0);
682 FlushLayoutTask(frameNode_);
683 pattern_->UpdateCurrentOffset(-241.0f);
684 FlushLayoutTask(frameNode_);
685 EXPECT_EQ(pattern_->ComputeNextIndexByVelocity(velocity, true), 1);
686 velocity = -780.0f;
687 EXPECT_EQ(pattern_->ComputeNextIndexByVelocity(velocity, false), 1);
688 }
689
690 /**
691 * @tc.name: UpdateCurrentOffset001
692 * @tc.desc: UpdateCurrentOffset
693 * @tc.type: FUNC
694 */
695 HWTEST_F(SwiperTestNg, UpdateCurrentOffset001, TestSize.Level1)
696 {
__anonf92747111302(SwiperModelNG model) 697 CreateWithItem([](SwiperModelNG model) {});
698 pattern_->UpdateCurrentOffset(10.f);
699 FlushLayoutTask(frameNode_);
700 EXPECT_EQ(GetChildX(frameNode_, 0), 10.f);
701 }
702
703 /**
704 * @tc.name: UpdateCurrentOffset002
705 * @tc.desc: UpdateCurrentOffset
706 * @tc.type: FUNC
707 */
708 HWTEST_F(SwiperTestNg, UpdateCurrentOffset002, TestSize.Level1)
709 {
__anonf92747111402(SwiperModelNG model) 710 CreateWithItem([](SwiperModelNG model) {
711 model.SetLoop(false);
712 });
713 EXPECT_EQ(pattern_->GetEdgeEffect(), EdgeEffect::SPRING);
714 pattern_->isTouchPad_ = true;
715 pattern_->childScrolling_ = true;
716 pattern_->UpdateCurrentOffset(10.f);
717 FlushLayoutTask(frameNode_);
718 EXPECT_GT(GetChildX(frameNode_, 0), 0.f);
719 EXPECT_LT(GetChildX(frameNode_, 0), 10.f);
720
721 float preOffset = GetChildX(frameNode_, 0);
722 pattern_->UpdateCurrentOffset(-20.f);
723 FlushLayoutTask(frameNode_);
724 EXPECT_LT(GetChildX(frameNode_, 0), preOffset);
725 EXPECT_GT(GetChildX(frameNode_, 0), -20.f);
726 }
727
728 /**
729 * @tc.name: UpdateCurrentOffset003
730 * @tc.desc: UpdateCurrentOffset
731 * @tc.type: FUNC
732 */
733 HWTEST_F(SwiperTestNg, UpdateCurrentOffset003, TestSize.Level1)
734 {
__anonf92747111502(SwiperModelNG model) 735 CreateWithItem([](SwiperModelNG model) {
736 model.SetLoop(false);
737 model.SetEdgeEffect(EdgeEffect::FADE);
738 });
739 EXPECT_EQ(pattern_->GetEdgeEffect(), EdgeEffect::FADE);
740 pattern_->childScrolling_ = true;
741 pattern_->UpdateCurrentOffset(10.f);
742 FlushLayoutTask(frameNode_);
743 EXPECT_EQ(GetChildX(frameNode_, 0), 0.f);
744
745 pattern_->UpdateCurrentOffset(-20.f);
746 FlushLayoutTask(frameNode_);
747 EXPECT_EQ(GetChildX(frameNode_, 0), -20.f);
748 }
749
750 /**
751 * @tc.name: UpdateCurrentOffset004
752 * @tc.desc: UpdateCurrentOffset
753 * @tc.type: FUNC
754 */
755 HWTEST_F(SwiperTestNg, UpdateCurrentOffset004, TestSize.Level1)
756 {
__anonf92747111602(SwiperModelNG model) 757 CreateWithItem([](SwiperModelNG model) {
758 model.SetLoop(false);
759 model.SetEdgeEffect(EdgeEffect::NONE);
760 });
761 EXPECT_EQ(pattern_->GetEdgeEffect(), EdgeEffect::NONE);
762 pattern_->childScrolling_ = true;
763 pattern_->UpdateCurrentOffset(10.f);
764 FlushLayoutTask(frameNode_);
765 EXPECT_EQ(GetChildX(frameNode_, 0), 0.f);
766
767 pattern_->UpdateCurrentOffset(-20.f);
768 FlushLayoutTask(frameNode_);
769 EXPECT_EQ(GetChildX(frameNode_, 0), -20.f);
770 }
771
772 /**
773 * @tc.name: UpdateCurrentOffset005
774 * @tc.desc: UpdateCurrentOffset
775 * @tc.type: FUNC
776 */
777 HWTEST_F(SwiperTestNg, UpdateCurrentOffset005, TestSize.Level1)
778 {
__anonf92747111702(SwiperModelNG model) 779 Create([](SwiperModelNG model) {});
780 pattern_->UpdateCurrentOffset(10.f);
781 FlushLayoutTask(frameNode_);
782 EXPECT_EQ(pattern_->currentOffset_, 0.f);
783 }
784
785 /**
786 * @tc.name: SwiperPatternBeforeCreateLayoutWrapper001
787 * @tc.desc: BeforeCreateLayoutWrapper
788 * @tc.type: FUNC
789 */
790 HWTEST_F(SwiperTestNg, SwiperPatternBeforeCreateLayoutWrapper001, TestSize.Level1)
791 {
__anonf92747111802(SwiperModelNG model) 792 CreateWithItem([](SwiperModelNG model) {
793 model.SetDisplayArrow(true); // show arrow
794 model.SetHoverShow(false);
795 model.SetArrowStyle(ARROW_PARAMETERS);
796 });
797 pattern_->leftButtonId_.reset();
798 pattern_->rightButtonId_ = 1;
799 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateShowIndicator(true);
800 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateIndex(-1);
801
802 /**
803 * @tc.steps: step2. call BeforeCreateLayoutWrapper.
804 * @tc.expected: Related function runs ok.
805 */
806 for (int i = 0; i <= 1; i++) {
807 for (int j = 0; j <= 1; j++) {
808 pattern_->BeforeCreateLayoutWrapper();
809 if (i == 1) {
810 frameNode_->AddChild(leftArrowNode_);
811 continue;
812 }
813 pattern_->rightButtonId_.reset();
814 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateShowIndicator(false);
815 }
816 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateIndex(0);
817 }
818
819 frameNode_->AddChild(rightArrowNode_);
820 pattern_->currentIndex_ = 0;
821 pattern_->oldIndex_ = 0;
822 for (int i = 0; i <= 1; i++) {
823 pattern_->BeforeCreateLayoutWrapper();
824 pattern_->currentIndex_ = 1;
825 }
826 pattern_->jumpIndex_.reset();
827 pattern_->leftButtonId_.reset();
828 pattern_->rightButtonId_ = 1;
829 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateShowIndicator(true);
830 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateLoop(true);
831 for (int i = 0; i <= 1; i++) {
832 for (int j = 0; j <= 1; j++) {
833 for (int k = 0; k <= 1; k++) {
834 pattern_->BeforeCreateLayoutWrapper();
835 if (i == 1 && j == 0) {
836 pattern_->jumpIndex_ = 0;
837 continue;
838 }
839 if (i == 1 && j == 1) {
840 pattern_->jumpIndex_ = 10;
841 continue;
842 }
843 pattern_->jumpIndex_ = -1;
844 pattern_->usePropertyAnimation_ = true;
845 }
846 pattern_->jumpIndex_ = 10;
847 pattern_->rightButtonId_.reset();
848 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateShowIndicator(false);
849 frameNode_->AddChild(leftArrowNode_);
850 frameNode_->AddChild(rightArrowNode_);
851 }
852 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateLoop(false);
853 pattern_->jumpIndex_ = -1;
854 }
855 }
856
857 /**
858 * @tc.name: SwiperPatternIsVisibleChildrenSizeLessThanSwiper001
859 * @tc.desc: IsVisibleChildrenSizeLessThanSwiper
860 * @tc.type: FUNC
861 */
862 HWTEST_F(SwiperTestNg, SwiperPatternIsVisibleChildrenSizeLessThanSwiper001, TestSize.Level1)
863 {
__anonf92747111902(SwiperModelNG model) 864 CreateWithItem([](SwiperModelNG model) {
865 model.SetDisplayArrow(true); // show arrow
866 model.SetHoverShow(false);
867 model.SetArrowStyle(ARROW_PARAMETERS);
868 });
869 layoutProperty_->UpdateDisplayCount(5);
870 pattern_->IsVisibleChildrenSizeLessThanSwiper();
871 pattern_->leftButtonId_.reset();
872 pattern_->rightButtonId_.reset();
873 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateShowIndicator(false);
874 pattern_->itemPosition_.clear();
875 auto dimension = Dimension(1);
876 layoutProperty_->UpdateMinSize(dimension);
877 EXPECT_EQ(static_cast<int32_t>(pattern_->itemPosition_.size()), 0);
878
879 /**
880 * @tc.steps: step2. call IsVisibleChildrenSizeLessThanSwiper.
881 * @tc.expected: Related function runs ok.
882 */
883 for (int i = 0; i <= 1; i++) {
884 for (int j = 0; j <= 1; j++) {
885 pattern_->IsVisibleChildrenSizeLessThanSwiper();
886 if (i == 1) {
887 pattern_->itemPosition_.emplace(std::make_pair(2, SwiperItemInfo { 1, 2 }));
888 continue;
889 }
890 pattern_->itemPosition_.emplace(std::make_pair(1, SwiperItemInfo { 1, 2 }));
891 pattern_->itemPosition_.emplace(std::make_pair(0, SwiperItemInfo { 1, 2 }));
892 }
893 pattern_->itemPosition_.clear();
894 pattern_->itemPosition_.emplace(std::make_pair(0, SwiperItemInfo { 1, 2 }));
895 pattern_->itemPosition_.emplace(std::make_pair(1, SwiperItemInfo { 1, 1 }));
896 }
897
898 for (int i = 0; i <= 1; i++) {
899 for (int j = 0; j <= 1; j++) {
900 pattern_->IsVisibleChildrenSizeLessThanSwiper();
901 pattern_->itemPosition_.clear();
902 pattern_->itemPosition_.emplace(std::make_pair(0, SwiperItemInfo { 1, 2 }));
903 pattern_->itemPosition_.emplace(std::make_pair(2, SwiperItemInfo { 1, 2 }));
904 }
905 }
906 }
907
908 /**
909 * @tc.name: SwiperPatternGetLastItemInfoInVisibleArea001
910 * @tc.desc: GetLastItemInfoInVisibleArea
911 * @tc.type: FUNC
912 */
913 HWTEST_F(SwiperTestNg, SwiperPatternGetLastItemInfoInVisibleArea001, TestSize.Level1)
914 {
__anonf92747111a02(SwiperModelNG model) 915 CreateWithItem([](SwiperModelNG model) {});
916 pattern_->itemPosition_.clear();
917
918 /**
919 * @tc.steps: step2. call GetLastItemInfoInVisibleArea.
920 * @tc.expected: Related function runs ok.
921 */
922 pattern_->GetLastItemInfoInVisibleArea();
923 }
924
925 /**
926 * @tc.name: SwiperPatternBeforeCreateLayoutWrapper002
927 * @tc.desc: BeforeCreateLayoutWrapper
928 * @tc.type: FUNC
929 */
930 HWTEST_F(SwiperTestNg, SwiperPatternBeforeCreateLayoutWrapper002, TestSize.Level1)
931 {
__anonf92747111b02(SwiperModelNG model) 932 CreateWithItem([](SwiperModelNG model) {});
933
934 /**
935 * @tc.steps: step2. call BeforeCreateLayoutWrapper.
936 * @tc.expected: Related function runs ok.
937 */
938 for (int i = 0; i <= 1; i++) {
939 for (int j = 0; j <= 1; j++) {
940 pattern_->BeforeCreateLayoutWrapper();
941 if (i == 1) {
942 pattern_->mainSizeIsMeasured_ = false;
943 continue;
944 }
945 pattern_->mainSizeIsMeasured_ = true;
946 }
947 }
948 }
949
950 /**
951 * @tc.name: SwiperPatternBeforeCreateLayoutWrapper003
952 * @tc.desc: BeforeCreateLayoutWrapper
953 * @tc.type: FUNC
954 */
955 HWTEST_F(SwiperTestNg, SwiperPatternBeforeCreateLayoutWrapper003, TestSize.Level1)
956 {
__anonf92747111c02(SwiperModelNG model) 957 CreateWithItem([](SwiperModelNG model) {});
958 pattern_->itemPosition_.clear();
959 pattern_->isVoluntarilyClear_ = false;
960
961 /**
962 * @tc.steps: step2. call BeforeCreateLayoutWrapper.
963 * @tc.expected: Related function runs ok.
964 */
965 for (int i = 0; i <= 1; i++) {
966 pattern_->BeforeCreateLayoutWrapper();
967 pattern_->GetPaintProperty<SwiperPaintProperty>()->UpdateAutoPlay(true);
968 }
969 }
970
971 /**
972 * @tc.name: SwiperPatternIsVisibleChildrenSizeLessThanSwiper002
973 * @tc.desc: IsVisibleChildrenSizeLessThanSwiper
974 * @tc.type: FUNC
975 */
976 HWTEST_F(SwiperTestNg, SwiperPatternIsVisibleChildrenSizeLessThanSwiper002, TestSize.Level1)
977 {
__anonf92747111d02(SwiperModelNG model) 978 CreateWithItem([](SwiperModelNG model) {
979 model.SetDisplayArrow(true); // show arrow
980 model.SetHoverShow(false);
981 model.SetArrowStyle(ARROW_PARAMETERS);
982 });
983 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateShowIndicator(false);
984 pattern_->itemPosition_.clear();
985 pattern_->leftButtonId_.reset();
986 pattern_->rightButtonId_.reset();
987 auto dimension = Dimension(1);
988 layoutProperty_->UpdateMinSize(dimension);
989 pattern_->itemPosition_.emplace(std::make_pair(0, SwiperItemInfo { 1, 2 }));
990 pattern_->itemPosition_.emplace(std::make_pair(1, SwiperItemInfo { 1, 3 }));
991
992 /**
993 * @tc.steps: step2. call IsVisibleChildrenSizeLessThanSwiper.
994 * @tc.expected: Related function runs ok.
995 */
996 pattern_->IsVisibleChildrenSizeLessThanSwiper();
997 }
998
999 /**
1000 * @tc.name: SwiperPatternOnTouchTestHit002
1001 * @tc.desc: OnTouchTestHit
1002 * @tc.type: FUNC
1003 */
1004 HWTEST_F(SwiperTestNg, SwiperPatternOnTouchTestHit002, TestSize.Level1)
1005 {
__anonf92747111e02(SwiperModelNG model) 1006 CreateWithItem([](SwiperModelNG model) {});
1007 auto hitTestType = SourceType::MOUSE;
1008
1009 /**
1010 * @tc.steps: step2. call OnTouchTestHit.
1011 * @tc.expected: Related function runs ok.
1012 */
1013 for (int i = 0; i <= 1; i++) {
1014 pattern_->OnTouchTestHit(hitTestType);
1015 pattern_->isTouchDown_ = true;
1016 }
1017 }
1018
1019 /**
1020 * @tc.name: SwiperModelNGSetDisplayCount001
1021 * @tc.desc: Test SetDisplayCount
1022 * @tc.type: FUNC
1023 */
1024 HWTEST_F(SwiperTestNg, SwiperModelNGSetDisplayCount001, TestSize.Level1)
1025 {
1026 SwiperModelNG mode;
1027 auto controller = mode.Create();
1028 ViewAbstract::SetWidth(CalcLength(SWIPER_WIDTH));
1029 ViewAbstract::SetHeight(CalcLength(SWIPER_HEIGHT));
1030 ASSERT_NE(controller, nullptr);
1031 int32_t displayCount = 0;
1032
1033 /**
1034 * @tc.steps: step3. call SetDisplayCount.
1035 * @tc.expected: the related function runs ok.
1036 */
1037 mode.SetDisplayCount(displayCount);
1038 }
1039
1040 /**
1041 * @tc.name: SwiperOnLoopChange001
1042 * @tc.desc: Swiper OnLoopChange.
1043 * @tc.type: FUNC
1044 */
1045 HWTEST_F(SwiperTestNg, SwiperOnLoopChange001, TestSize.Level1)
1046 {
__anonf92747111f02(SwiperModelNG model) 1047 CreateWithItem([](SwiperModelNG model) {});
1048 pattern_->preLoop_ = true;
1049 layoutProperty_->UpdateLoop(false);
1050 layoutProperty_->ResetPrevMargin();
1051 layoutProperty_->ResetNextMargin();
1052
1053 /**
1054 * @tc.steps: step2. call OnLoopChange.
1055 * @tc.expected: Related function runs ok.
1056 */
1057 for (int i = 0; i <= 1; i++) {
1058 for (int j = 0; j <= 1; j++) {
1059 pattern_->OnLoopChange();
1060 if (i == 1) {
1061 layoutProperty_->ResetPrevMargin();
1062 continue;
1063 }
1064 layoutProperty_->UpdatePrevMargin(Dimension(1));
1065 }
1066 layoutProperty_->UpdateNextMargin(Dimension(1));
1067 }
1068 }
1069
1070 /**
1071 * @tc.name: SwiperPatternOnTranslateFinish002
1072 * @tc.desc: OnTranslateFinish
1073 * @tc.type: FUNC
1074 */
1075 HWTEST_F(SwiperTestNg, SwiperPatternOnTranslateFinish002, TestSize.Level1)
1076 {
__anonf92747112002(SwiperModelNG model) 1077 CreateWithItem([](SwiperModelNG model) {
1078 model.SetDisplayArrow(true); // show arrow
1079 model.SetHoverShow(false);
1080 model.SetArrowStyle(ARROW_PARAMETERS);
1081 });
1082 int32_t nextIndex = 1;
1083 bool restartAutoPlay = true;
1084 bool forceStop = true;
1085 layoutProperty_->UpdateLoop(true);
1086 layoutProperty_->ResetDisplayCount();
1087 layoutProperty_->ResetMinSize();
1088 layoutProperty_->UpdateDisplayMode(SwiperDisplayMode::AUTO_LINEAR);
1089 pattern_->currentIndex_ = 1;
1090 pattern_->leftButtonId_.reset();
1091 pattern_->rightButtonId_.reset();
1092 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateShowIndicator(false);
1093 pattern_->isVisible_ = true;
1094 pattern_->GetPaintProperty<SwiperPaintProperty>()->UpdateAutoPlay(true);
1095 pattern_->isIndicatorLongPress_ = false;
1096 EXPECT_EQ(frameNode_->GetChildren().size(), 7);
1097
1098 /**
1099 * @tc.steps: step2. call OnTranslateFinish.
1100 * @tc.expected: Related function runs ok.
1101 */
1102 for (int i = 0; i <= 1; i++) {
1103 for (int j = 0; j <= 1; j++) {
1104 pattern_->OnTranslateFinish(nextIndex, restartAutoPlay, pattern_->isFinishAnimation_, forceStop);
1105 if (i == 1) {
1106 pattern_->isUserFinish_ = true;
1107 continue;
1108 }
1109 pattern_->isUserFinish_ = false;
1110 }
1111 pattern_->isVisible_ = false;
1112 }
1113 }
1114
1115 /**
1116 * @tc.name: SwiperPatternOnModifyDone002
1117 * @tc.desc: Test OnModifyDone
1118 * @tc.type: FUNC
1119 */
1120 HWTEST_F(SwiperTestNg, SwiperPatternOnModifyDone002, TestSize.Level1)
1121 {
__anonf92747112102(SwiperModelNG model) 1122 CreateWithItem([](SwiperModelNG model) {
1123 model.SetDirection(Axis::VERTICAL);
1124 });
1125 RefPtr<SwiperPattern> indicatorPattern = frameNode_->GetPattern<SwiperPattern>();
1126 indicatorPattern->OnModifyDone();
1127 indicatorPattern->swiperController_->removeSwiperEventCallback_();
1128 indicatorPattern->swiperController_->addSwiperEventCallback_();
1129 pattern_->OnAfterModifyDone();
1130 EXPECT_NE(indicatorPattern, nullptr);
1131 }
1132
1133 /**
1134 * @tc.name: SwiperPatternRegisterVisibleAreaChange002
1135 * @tc.desc: RegisterVisibleAreaChange
1136 * @tc.type: FUNC
1137 */
1138 HWTEST_F(SwiperTestNg, SwiperPatternRegisterVisibleAreaChange002, TestSize.Level1)
1139 {
__anonf92747112202(SwiperModelNG model) 1140 CreateWithItem([](SwiperModelNG model) {});
1141 auto pipeline = frameNode_->GetContextRefPtr();
1142 auto paintProperty_ = pattern_->GetPaintProperty<SwiperPaintProperty>();
1143
1144 /**
1145 * @tc.steps: step2. call RegisterVisibleAreaChange.
1146 * @tc.expected: Related function runs ok.
1147 */
1148 pattern_->hasVisibleChangeRegistered_ = false;
1149 paintProperty_->UpdateAutoPlay(true);
1150 pattern_->RegisterVisibleAreaChange();
1151 EXPECT_TRUE(pattern_->hasVisibleChangeRegistered_);
1152 pattern_->isWindowShow_ = false;
1153 pattern_->hasVisibleChangeRegistered_ = false;
1154 paintProperty_->UpdateAutoPlay(true);
1155 pattern_->RegisterVisibleAreaChange();
1156 EXPECT_TRUE(pattern_->hasVisibleChangeRegistered_);
1157 }
1158
1159 /**
1160 * @tc.name: SwiperPatternInitSurfaceChangedCallback001
1161 * @tc.desc: InitSurfaceChangedCallback
1162 * @tc.type: FUNC
1163 */
1164 HWTEST_F(SwiperTestNg, SwiperPatternInitSurfaceChangedCallback001, TestSize.Level1)
1165 {
__anonf92747112302(SwiperModelNG model) 1166 CreateWithItem([](SwiperModelNG model) {});
1167 pattern_->leftButtonId_.reset();
1168 pattern_->rightButtonId_ = 1;
1169 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateShowIndicator(true);
1170 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateIndex(-1);
1171 auto leftArrowNode_ = FrameNode::GetOrCreateFrameNode(V2::SWIPER_LEFT_ARROW_ETS_TAG, pattern_->GetLeftButtonId(),
__anonf92747112402() 1172 []() { return AceType::MakeRefPtr<SwiperArrowPattern>(); });
1173 auto rightArrowNode_ = FrameNode::GetOrCreateFrameNode(V2::SWIPER_RIGHT_ARROW_ETS_TAG, pattern_->GetRightButtonId(),
__anonf92747112502() 1174 []() { return AceType::MakeRefPtr<SwiperArrowPattern>(); });
1175
1176 /**
1177 * @tc.steps: step2. call InitSurfaceChangedCallback and then callback.
1178 * @tc.expected: Related function is called.
1179 */
1180 auto pipeline = frameNode_->GetContext();
1181 pattern_->surfaceChangedCallbackId_.emplace(1);
1182 pattern_->InitSurfaceChangedCallback();
1183 pipeline->callbackId_ = 0;
1184 pattern_->surfaceChangedCallbackId_.reset();
1185 EXPECT_FALSE(pattern_->HasSurfaceChangedCallback());
1186 pipeline->surfaceChangedCallbackMap_.clear();
1187 pattern_->InitSurfaceChangedCallback();
1188 auto callbackmapnumber = pipeline->callbackId_;
1189 EXPECT_EQ(callbackmapnumber, 1);
1190 auto testFunction = pipeline->surfaceChangedCallbackMap_[1];
1191 testFunction(1, 1, 1, 1, WindowSizeChangeReason::CUSTOM_ANIMATION);
1192 auto callbacknumber = pattern_->surfaceChangedCallbackId_;
1193 EXPECT_EQ(callbacknumber, 1);
1194
1195 /**
1196 * @tc.steps: step3. call InitSurfaceChangedCallback and then callback in different conditions.
1197 * @tc.expected: Related function is called.
1198 */
1199 pipeline->callbackId_ = 0;
1200 pattern_->surfaceChangedCallbackId_.reset();
1201 EXPECT_FALSE(pattern_->HasSurfaceChangedCallback());
1202 pipeline->surfaceChangedCallbackMap_.clear();
1203 pattern_->InitSurfaceChangedCallback();
1204 auto callbackmapnumber2 = pipeline->callbackId_;
1205 EXPECT_EQ(callbackmapnumber2, 1);
1206 auto testFunction2 = pipeline->surfaceChangedCallbackMap_[1];
1207 testFunction2(1, 1, 1, 1, WindowSizeChangeReason::UNDEFINED);
1208 EXPECT_EQ(pattern_->surfaceChangedCallbackId_, 1);
1209 testFunction2(1, 1, 1, 1, WindowSizeChangeReason::ROTATION);
1210 EXPECT_EQ(pattern_->windowSizeChangeReason_, WindowSizeChangeReason::ROTATION);
1211
1212 auto childswiperNode1 = FrameNode::CreateFrameNode("childswiper", 1, AceType::MakeRefPtr<SwiperPattern>(), false);
1213 childswiperNode1->MountToParent(frameNode_);
1214 auto childswiperNode2 =
1215 FrameNode::CreateFrameNode(V2::JS_LAZY_FOR_EACH_ETS_TAG, 2, AceType::MakeRefPtr<SwiperPattern>(), false);
1216 childswiperNode2->MountToParent(frameNode_);
1217 pipeline->callbackId_ = 0;
1218 pattern_->surfaceChangedCallbackId_.reset();
1219 EXPECT_FALSE(pattern_->HasSurfaceChangedCallback());
1220 pipeline->surfaceChangedCallbackMap_.clear();
1221 pattern_->InitSurfaceChangedCallback();
1222 auto callbackmapnumber3 = pipeline->callbackId_;
1223 EXPECT_EQ(callbackmapnumber3, 1);
1224 auto testFunction3 = pipeline->surfaceChangedCallbackMap_[1];
1225 testFunction3(1, 1, 1, 1, WindowSizeChangeReason::CUSTOM_ANIMATION);
1226 auto callbacknumber3 = pattern_->surfaceChangedCallbackId_;
1227 EXPECT_EQ(callbacknumber3, 1);
1228 }
1229
1230 /**
1231 * @tc.name: SwiperPatternMarkDirtyNodeSelf001
1232 * @tc.desc: MarkDirtyNodeSelf
1233 * @tc.type: FUNC
1234 */
1235 HWTEST_F(SwiperTestNg, SwiperPatternMarkDirtyNodeSelf001, TestSize.Level1)
1236 {
__anonf92747112602(SwiperModelNG model) 1237 CreateWithItem([](SwiperModelNG model) {});
1238 pattern_->leftButtonId_.reset();
1239 pattern_->rightButtonId_ = 1;
1240 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateShowIndicator(true);
1241 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateIndex(-1);
1242
1243 /**
1244 * @tc.steps: step2. call MarkDirtyNodeSelf.
1245 * @tc.expected: Related function is called.
1246 */
1247 pattern_->crossMatchChild_ = true;
1248 pattern_->MarkDirtyNodeSelf();
1249 EXPECT_TRUE(pattern_->crossMatchChild_);
1250 pattern_->crossMatchChild_ = false;
1251 pattern_->MarkDirtyNodeSelf();
1252 EXPECT_FALSE(pattern_->crossMatchChild_);
1253 }
1254
1255 /**
1256 * @tc.name: SwiperPatternOnWindowHide001
1257 * @tc.desc: MarkDirtyNodeSelf
1258 * @tc.type: FUNC
1259 */
1260 HWTEST_F(SwiperTestNg, SwiperPatternOnWindowHide001, TestSize.Level1)
1261 {
__anonf92747112702(SwiperModelNG model) 1262 CreateWithItem([](SwiperModelNG model) {});
1263 pattern_->leftButtonId_.reset();
1264 pattern_->rightButtonId_ = 1;
1265 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateShowIndicator(true);
1266 pattern_->GetLayoutProperty<SwiperLayoutProperty>()->UpdateIndex(-1);
1267
1268 /**
1269 * @tc.steps: step2. call MarkDirtyNodeSelf.
1270 * @tc.expected: Related function is called.
1271 */
1272 pattern_->isDragging_ = true;
1273 pattern_->OnWindowHide();
1274 EXPECT_FALSE(pattern_->isDragging_);
1275 pattern_->isDragging_ = false;
1276 pattern_->OnWindowHide();
1277 EXPECT_FALSE(pattern_->isDragging_);
1278 }
1279
1280 /**
1281 * @tc.name: SwiperPatternOnDirtyLayoutWrapperSwap003
1282 * @tc.desc: OnDirtyLayoutWrapperSwap
1283 * @tc.type: FUNC
1284 */
1285 HWTEST_F(SwiperTestNg, SwiperPatternOnDirtyLayoutWrapperSwap003, TestSize.Level1)
1286 {
__anonf92747112802(SwiperModelNG model) 1287 CreateWithItem([](SwiperModelNG model) {
1288 model.SetDisplayArrow(true); // show arrow
1289 model.SetHoverShow(false);
1290 model.SetArrowStyle(ARROW_PARAMETERS);
1291 });
1292 auto firstChild = AccessibilityManager::DynamicCast<FrameNode>(indicatorNode_);
1293 RefPtr<GeometryNode> firstGeometryNode = AceType::MakeRefPtr<GeometryNode>();
1294 firstGeometryNode->Reset();
1295 firstGeometryNode->SetFrameSize(SizeF(20.0, 20.0));
1296 auto firstLayoutWrapper =
1297 AceType::MakeRefPtr<LayoutWrapperNode>(firstChild, firstGeometryNode, firstChild->GetLayoutProperty());
1298 auto dirty = AceType::MakeRefPtr<LayoutWrapperNode>(firstChild, firstGeometryNode, firstChild->GetLayoutProperty());
1299 dirty->AppendChild(firstLayoutWrapper);
1300 struct DirtySwapConfig config;
1301 pattern_->isInit_ = true;
1302 config.skipMeasure = true;
1303 config.skipLayout = false;
1304 auto paintProperty_ = pattern_->GetPaintProperty<SwiperPaintProperty>();
1305
1306 /**
1307 * @tc.steps: step2. call OnDirtyLayoutWrapperSwap.
1308 * @tc.expected: Related function runs ok.
1309 */
1310 paintProperty_->GetAutoPlay().emplace(false);
1311 pattern_->OnDirtyLayoutWrapperSwap(dirty, config);
1312 config.skipMeasure = false;
1313 paintProperty_->GetAutoPlay().emplace(false);
1314 pattern_->OnDirtyLayoutWrapperSwap(dirty, config);
1315 paintProperty_->GetAutoPlay().emplace(true);
1316 pattern_->OnDirtyLayoutWrapperSwap(dirty, config);
1317 paintProperty_->GetAutoPlay().emplace(true);
1318 config.skipMeasure = false;
1319 config.skipLayout = false;
1320 pattern_->OnDirtyLayoutWrapperSwap(dirty, config);
1321 }
1322
1323 /**
1324 * @tc.name: CalculateGestureState001
1325 * @tc.desc: test Swiper indicator gesture state
1326 * @tc.type: FUNC
1327 */
1328 HWTEST_F(SwiperTestNg, CalculateGestureState001, TestSize.Level1)
1329 {
__anonf92747112902(SwiperModelNG model) 1330 CreateWithItem([](SwiperModelNG model) {});
1331 EXPECT_EQ(pattern_->TotalCount(), 4);
1332 pattern_->gestureState_ = GestureState::GESTURE_STATE_NONE;
1333 pattern_->CalculateGestureState(1.0f, 0.0f, 1);
1334 EXPECT_EQ(pattern_->gestureState_, GestureState::GESTURE_STATE_RELEASE_LEFT);
1335
1336 pattern_->gestureState_ = GestureState::GESTURE_STATE_NONE;
1337 pattern_->CalculateGestureState(-1.0f, 0.0f, 1);
1338 EXPECT_EQ(pattern_->gestureState_, GestureState::GESTURE_STATE_RELEASE_RIGHT);
1339
1340 pattern_->currentFirstIndex_ = 0;
1341 pattern_->currentIndex_ = 0;
1342 pattern_->turnPageRate_ = -1.0f;
1343 pattern_->gestureState_ = GestureState::GESTURE_STATE_NONE;
1344 pattern_->CalculateGestureState(0.0f, -1.1f, 1);
1345 EXPECT_EQ(pattern_->gestureState_, GestureState::GESTURE_STATE_FOLLOW_RIGHT);
1346
1347 pattern_->currentFirstIndex_ = 0;
1348 pattern_->currentIndex_ = 1;
1349 pattern_->turnPageRate_ = -1.0f;
1350 pattern_->gestureState_ = GestureState::GESTURE_STATE_NONE;
1351 pattern_->CalculateGestureState(0.0f, -1.1f, 1);
1352 EXPECT_EQ(pattern_->gestureState_, GestureState::GESTURE_STATE_FOLLOW_LEFT);
1353
1354 pattern_->currentFirstIndex_ = 0;
1355 pattern_->currentIndex_ = 0;
1356 pattern_->turnPageRate_ = -1.0f;
1357 pattern_->gestureState_ = GestureState::GESTURE_STATE_NONE;
1358 pattern_->CalculateGestureState(0.0f, -0.9f, 1);
1359 EXPECT_EQ(pattern_->gestureState_, GestureState::GESTURE_STATE_FOLLOW_RIGHT);
1360 }
1361
1362 /**
1363 * @tc.name: ResetDisplayCount001
1364 * @tc.desc: Swiper Model NG.
1365 * @tc.type: FUNC
1366 */
1367 HWTEST_F(SwiperTestNg, ResetDisplayCount001, TestSize.Level1)
1368 {
1369 /**
1370 * @tc.steps: step1. Default value
1371 */
1372 SwiperModelNG model;
1373 model.Create();
1374 ViewAbstract::SetWidth(CalcLength(SWIPER_WIDTH));
1375 ViewAbstract::SetHeight(CalcLength(SWIPER_HEIGHT));
1376 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1377 EXPECT_NE(frameNode, nullptr);
1378 auto pattern = frameNode->GetPattern<SwiperPattern>();
1379 EXPECT_NE(pattern, nullptr);
1380 auto layoutProperty = frameNode->GetLayoutProperty<SwiperLayoutProperty>();
1381 EXPECT_NE(layoutProperty, nullptr);
1382 auto paintProperty = frameNode->GetPaintProperty<SwiperPaintProperty>();
1383 EXPECT_NE(paintProperty, nullptr);
1384
1385 /**
1386 * @tc.steps: step3.1. Test SetIndex function.
1387 * @tc.expected: layoutProperty->GetIndex() is equal to 1.
1388 */
1389 model.SetIndex(1);
1390 EXPECT_EQ(layoutProperty->GetIndex(), 1);
1391
1392 /**
1393 * @tc.steps: step3.1. Test SetIndex function.
1394 * @tc.expected: layoutProperty->GetIndex() is equal to 1.
1395 */
1396 model.SetDisplayCount(10);
1397 model.ResetDisplayCount();
1398 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1399 auto uiNode = AceType::DynamicCast<FrameNode>(element);
1400 pattern = uiNode->GetPattern<SwiperPattern>();
1401 EXPECT_NE(pattern->GetDisplayCount(), 10);
1402 }
1403
1404 /**
1405 * @tc.name: SwiperPatternOnDirtyLayoutWrapperSwap002
1406 * @tc.desc: OnDirtyLayoutWrapperSwap
1407 * @tc.type: FUNC
1408 */
1409 HWTEST_F(SwiperTestNg, SwiperPatternOnDirtyLayoutWrapperSwap005, TestSize.Level1)
1410 {
1411 /**
1412 * @tc.steps: step1. Default value
1413 */
__anonf92747112a02(SwiperModelNG model) 1414 CreateWithItem([](SwiperModelNG model) {
1415 model.SetDisplayArrow(true); // show arrow
1416 model.SetHoverShow(false);
1417 model.SetArrowStyle(ARROW_PARAMETERS);
1418 });
1419 auto firstChild = AccessibilityManager::DynamicCast<FrameNode>(indicatorNode_);
1420 RefPtr<GeometryNode> firstGeometryNode = AceType::MakeRefPtr<GeometryNode>();
1421 firstGeometryNode->Reset();
1422 firstGeometryNode->SetFrameSize(SizeF(20.0, 20.0));
1423 auto firstLayoutWrapper =
1424 AceType::MakeRefPtr<LayoutWrapperNode>(firstChild, firstGeometryNode, firstChild->GetLayoutProperty());
1425 auto dirty = AceType::MakeRefPtr<LayoutWrapperNode>(firstChild, firstGeometryNode, firstChild->GetLayoutProperty());
1426 dirty->AppendChild(firstLayoutWrapper);
1427 struct DirtySwapConfig config;
1428 pattern_->isInit_ = true;
1429 config.skipMeasure = false;
1430 config.skipLayout = false;
1431
__anonf92747112b02(const int32_t i, float f) 1432 TurnPageRateFunc callback = [](const int32_t i, float f) {};
1433 pattern_->swiperController_->SetTurnPageRateCallback(callback);
1434 struct SwiperItemInfo swiperItemInfo1;
1435 swiperItemInfo1.startPos = -1.0f;
1436 swiperItemInfo1.endPos = -1.0f;
1437
1438 auto swiperLayoutAlgorithm = AceType::DynamicCast<SwiperLayoutAlgorithm>(pattern_->CreateLayoutAlgorithm());
1439 dirty->layoutAlgorithm_ = AceType::MakeRefPtr<LayoutAlgorithmWrapper>(swiperLayoutAlgorithm);
1440 dirty->layoutAlgorithm_->layoutAlgorithm_ = AceType::MakeRefPtr<SwiperLayoutAlgorithm>();
1441 ASSERT_NE(dirty->GetLayoutAlgorithm(), nullptr);
1442 ASSERT_NE(AceType::DynamicCast<SwiperLayoutAlgorithm>(dirty->GetLayoutAlgorithm()->GetLayoutAlgorithm()), nullptr);
1443 AceType::DynamicCast<SwiperLayoutAlgorithm>(dirty->GetLayoutAlgorithm()->GetLayoutAlgorithm())
1444 ->itemPosition_.emplace(std::make_pair(1, swiperItemInfo1));
1445 pattern_->isDragging_ = true;
1446 pattern_->windowSizeChangeReason_ = WindowSizeChangeReason::ROTATION;
1447 /**
1448 * @tc.steps: step2. Calling the OnDirtyLayoutWrapperSwap interface
1449 * @tc.expected: Pattern_ -> WindowSizeChangeReason_ Not equal to WindowSizeChangeReason::ROTATION
1450 */
1451 pattern_->OnDirtyLayoutWrapperSwap(dirty, config);
1452 EXPECT_NE(pattern_->windowSizeChangeReason_, WindowSizeChangeReason::ROTATION);
1453 }
1454
1455 /**
1456 * @tc.name: SwiperProcessDelta001
1457 * @tc.desc: Test for SwiperPattern::ProcessDelta.
1458 * @tc.type: FUNC
1459 */
1460 HWTEST_F(SwiperTestNg, SwiperProcessDelta001, TestSize.Level1)
1461 {
1462 float mainSize = 50.0f;
1463 float delta = 5.0f;
1464 float deltaSum = 46.0f;
1465 SwiperPattern::ProcessDelta(delta, mainSize, deltaSum);
1466 EXPECT_EQ(delta, 4.0f);
1467
1468 delta = -10.0f;
1469 deltaSum = 50.0f;
1470 SwiperPattern::ProcessDelta(delta, mainSize, deltaSum);
1471 EXPECT_EQ(delta, -10.0f);
1472
1473 delta = -10.0f;
1474 deltaSum = -40.0f;
1475 SwiperPattern::ProcessDelta(delta, mainSize, deltaSum);
1476 EXPECT_EQ(delta, -10.0f);
1477
1478 delta = -10.0f;
1479 deltaSum = -50.0f;
1480 SwiperPattern::ProcessDelta(delta, mainSize, deltaSum);
1481 EXPECT_EQ(delta, 0.0f);
1482
1483 delta = -50.0f;
1484 deltaSum = -50.0f;
1485 SwiperPattern::ProcessDelta(delta, mainSize, deltaSum);
1486 EXPECT_EQ(delta, 0.0f);
1487
1488 delta = 1.0f;
1489 deltaSum = -50.0f;
1490 SwiperPattern::ProcessDelta(delta, mainSize, deltaSum);
1491 EXPECT_EQ(delta, 1.0f);
1492 }
1493
1494 /**
1495 * @tc.name: AdjustCurrentIndexOnSwipePage001
1496 * @tc.desc: Test SwiperPattern AdjustCurrentIndexOnSwipePage
1497 * @tc.type: FUNC
1498 */
1499 HWTEST_F(SwiperTestNg, SwiperPatternAdjustCurrentIndexOnSwipePage001, TestSize.Level1)
1500 {
__anonf92747112c02(SwiperModelNG model) 1501 CreateWithItem([](SwiperModelNG model) {});
1502 auto totalCount = pattern_->TotalCount();
1503 EXPECT_EQ(totalCount, 4);
1504
1505 layoutProperty_->UpdateSwipeByGroup(true);
1506 layoutProperty_->UpdateDisplayCount(3);
1507 pattern_->needAdjustIndex_ = true;
1508 layoutProperty_->UpdateIndex(1);
1509 pattern_->BeforeCreateLayoutWrapper();
1510 EXPECT_EQ(layoutProperty_->GetIndex().value(), 0);
1511 EXPECT_FALSE(pattern_->needAdjustIndex_);
1512
1513 layoutProperty_->UpdateIndex(5);
1514 pattern_->BeforeCreateLayoutWrapper();
1515 EXPECT_EQ(layoutProperty_->GetIndex().value(), 0);
1516
1517 layoutProperty_->UpdateIndex(6);
1518 pattern_->needAdjustIndex_ = true;
1519 pattern_->BeforeCreateLayoutWrapper();
1520 EXPECT_EQ(layoutProperty_->GetIndex().value(), 0);
1521
1522 layoutProperty_->UpdateIndex(3);
1523 pattern_->needAdjustIndex_ = true;
1524 pattern_->BeforeCreateLayoutWrapper();
1525 EXPECT_EQ(layoutProperty_->GetIndex().value(), 3);
1526
1527 layoutProperty_->UpdateDisplayCount(6);
1528 layoutProperty_->UpdateIndex(3);
1529 pattern_->needAdjustIndex_ = true;
1530 pattern_->BeforeCreateLayoutWrapper();
1531 EXPECT_EQ(layoutProperty_->GetIndex().value(), 0);
1532 }
1533
1534 /**
1535 * @tc.name: ComputeSwipePageNextIndex001
1536 * @tc.desc: Test SwiperPattern ComputeSwipePageNextIndex
1537 * @tc.type: FUNC
1538 */
1539 HWTEST_F(SwiperTestNg, SwiperPatternComputeSwipePageNextIndex001, TestSize.Level1)
1540 {
__anonf92747112d02(SwiperModelNG model) 1541 CreateWithItem([](SwiperModelNG model) {});
1542 auto totalCount = pattern_->TotalCount();
1543 EXPECT_EQ(totalCount, 4);
1544
1545 layoutProperty_->UpdateSwipeByGroup(true);
1546 layoutProperty_->UpdateDisplayCount(3);
1547 layoutProperty_->UpdateLoop(true);
1548 pattern_->currentIndex_ = 3;
1549 float dragVelocity = 500.0f;
1550 pattern_->contentMainSize_ = 0.0f;
1551 EXPECT_EQ(pattern_->ComputeSwipePageNextIndex(dragVelocity), 3);
1552
1553 pattern_->contentMainSize_ = 500.0f;
1554 EXPECT_EQ(pattern_->ComputeSwipePageNextIndex(dragVelocity), 3);
1555
1556 struct SwiperItemInfo swiperItemInfo1;
1557 swiperItemInfo1.startPos = -200.0f;
1558 swiperItemInfo1.endPos = 0.0f;
1559 pattern_->itemPosition_.emplace(std::make_pair(3, swiperItemInfo1));
1560 struct SwiperItemInfo swiperItemInfo2;
1561 swiperItemInfo2.startPos = 0.0f;
1562 swiperItemInfo2.endPos = 200.0f;
1563 pattern_->itemPosition_.emplace(std::make_pair(4, swiperItemInfo2));
1564 struct SwiperItemInfo swiperItemInfo3;
1565 swiperItemInfo3.startPos = 200.0f;
1566 swiperItemInfo3.endPos = 400.0f;
1567 pattern_->itemPosition_.emplace(std::make_pair(5, swiperItemInfo3));
1568 pattern_->contentMainSize_ = 600.0f;
1569 dragVelocity = -500.0f;
1570 EXPECT_EQ(pattern_->ComputeSwipePageNextIndex(dragVelocity), 3);
1571
1572 dragVelocity = -781.0f;
1573 EXPECT_EQ(pattern_->ComputeSwipePageNextIndex(dragVelocity), 3);
1574
1575 pattern_->itemPosition_.clear();
1576 swiperItemInfo1.startPos = -301.0f;
1577 swiperItemInfo1.endPos = -101.0f;
1578 pattern_->itemPosition_.emplace(std::make_pair(3, swiperItemInfo1));
1579 swiperItemInfo2.startPos = -101.0f;
1580 swiperItemInfo2.endPos = 99.0f;
1581 pattern_->itemPosition_.emplace(std::make_pair(4, swiperItemInfo2));
1582 swiperItemInfo3.startPos = 99.0f;
1583 swiperItemInfo3.endPos = 299.0f;
1584 pattern_->itemPosition_.emplace(std::make_pair(5, swiperItemInfo3));
1585 dragVelocity = -500.0f;
1586 EXPECT_EQ(pattern_->ComputeSwipePageNextIndex(dragVelocity), 6);
1587
1588 dragVelocity = -781.0f;
1589 EXPECT_EQ(pattern_->ComputeSwipePageNextIndex(dragVelocity), 6);
1590
1591 pattern_->itemPosition_.clear();
1592 swiperItemInfo1.startPos = -200.0f;
1593 swiperItemInfo1.endPos = 0.0f;
1594 pattern_->itemPosition_.emplace(std::make_pair(3, swiperItemInfo1));
1595 swiperItemInfo2.startPos = 0.0f;
1596 swiperItemInfo2.endPos = 200.0f;
1597 pattern_->itemPosition_.emplace(std::make_pair(4, swiperItemInfo2));
1598 swiperItemInfo3.startPos = 200.0f;
1599 swiperItemInfo3.endPos = 400.0f;
1600 pattern_->itemPosition_.emplace(std::make_pair(5, swiperItemInfo3));
1601 dragVelocity = -781.0f;
1602 EXPECT_EQ(pattern_->ComputeSwipePageNextIndex(dragVelocity), 6);
1603
1604 layoutProperty_->UpdateLoop(false);
1605 pattern_->currentIndex_ = 0;
1606 dragVelocity = 500.0f;
1607 EXPECT_EQ(pattern_->ComputeSwipePageNextIndex(dragVelocity), 0);
1608
1609 pattern_->currentIndex_ = 3;
1610 dragVelocity = -500.0f;
1611 EXPECT_EQ(pattern_->ComputeSwipePageNextIndex(dragVelocity), 3);
1612 }
1613
InitCaptureTest()1614 void SwiperTestNg::InitCaptureTest()
1615 {
1616 CreateWithItem([](SwiperModelNG model) {});
1617 layoutProperty_->UpdateDisplayMode(SwiperDisplayMode::STRETCH);
1618 layoutProperty_->UpdateLoop(true);
1619 layoutProperty_->UpdateDisplayCount(3);
1620 layoutProperty_->UpdatePrevMargin(Dimension(CAPTURE_MARGIN_SIZE));
1621 layoutProperty_->UpdateNextMargin(Dimension(CAPTURE_MARGIN_SIZE));
1622 pattern_->OnModifyDone();
1623 EXPECT_TRUE(pattern_->hasCachedCapture_);
1624 }
1625
1626 /**
1627 * @tc.name: SwipeInitCapture001
1628 * @tc.desc: Test SwiperPattern InitCapture
1629 * @tc.type: FUNC
1630 */
1631 HWTEST_F(SwiperTestNg, SwipeInitCapture001, TestSize.Level1)
1632 {
1633 /**
1634 * @tc.steps: step1. Create swiper witch need the capture
1635 */
1636 InitCaptureTest();
1637 EXPECT_TRUE(pattern_->leftCaptureId_.has_value());
1638 EXPECT_TRUE(pattern_->rightCaptureId_.has_value());
1639
1640 layoutProperty_->UpdatePrevMargin(Dimension(0));
1641 layoutProperty_->UpdateNextMargin(Dimension(CAPTURE_MARGIN_SIZE));
1642 EXPECT_TRUE(pattern_->hasCachedCapture_);
1643
1644 layoutProperty_->UpdatePrevMargin(Dimension(CAPTURE_MARGIN_SIZE));
1645 layoutProperty_->UpdateNextMargin(Dimension(0));
1646 EXPECT_TRUE(pattern_->hasCachedCapture_);
1647 /**
1648 * @tc.steps: step2. Create swiper witch does not need the capture
1649 */
1650 layoutProperty_->UpdateDisplayMode(SwiperDisplayMode::AUTO_LINEAR);
1651 layoutProperty_->ResetDisplayCount();
1652 pattern_->OnModifyDone();
1653 EXPECT_FALSE(pattern_->hasCachedCapture_);
1654 EXPECT_FALSE(pattern_->leftCaptureId_.has_value());
1655 EXPECT_FALSE(pattern_->rightCaptureId_.has_value());
1656
1657 layoutProperty_->UpdateDisplayMode(SwiperDisplayMode::STRETCH);
1658 layoutProperty_->UpdateDisplayCount(3);
1659 layoutProperty_->UpdateLoop(false);
1660 pattern_->OnModifyDone();
1661 EXPECT_FALSE(pattern_->hasCachedCapture_);
1662
1663 layoutProperty_->UpdateLoop(true);
1664 layoutProperty_->UpdateDisplayCount(4);
1665 pattern_->OnModifyDone();
1666 EXPECT_FALSE(pattern_->hasCachedCapture_);
1667
1668 layoutProperty_->UpdateDisplayCount(3);
1669 layoutProperty_->UpdatePrevMargin(Dimension(0));
1670 layoutProperty_->UpdateNextMargin(Dimension(0));
1671 pattern_->OnModifyDone();
1672 EXPECT_FALSE(pattern_->hasCachedCapture_);
1673 }
1674
1675 /**
1676 * @tc.name: SwipeCaptureLayoutInfo001
1677 * @tc.desc: Test check measure and layout info
1678 * @tc.type: FUNC
1679 */
1680 HWTEST_F(SwiperTestNg, SwipeCaptureLayoutInfo001, TestSize.Level1)
1681 {
1682 /**
1683 * @tc.steps: step1. create swiper witch need the capture
1684 */
1685 InitCaptureTest();
1686 /**
1687 * @tc.steps: step2. check layout info with Axis::VERTICAL
1688 */
1689 layoutProperty_->UpdateDirection(Axis::VERTICAL);
1690 pattern_->OnModifyDone();
1691 frameNode_->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
1692 FlushLayoutTask(frameNode_);
1693 EXPECT_EQ(pattern_->leftCaptureIndex_, 3);
1694 auto leftCaptureNode = AceType::DynamicCast<FrameNode>(
1695 frameNode_->GetChildAtIndex(frameNode_->GetChildIndexById(pattern_->GetLeftCaptureId())));
1696 EXPECT_NE(leftCaptureNode, nullptr);
1697 if (leftCaptureNode) {
1698 auto size = leftCaptureNode->GetGeometryNode()->GetFrameRect();
1699 EXPECT_EQ(size.Width(), SWIPER_WIDTH);
1700 EXPECT_EQ(size.Height(), (SWIPER_HEIGHT - CAPTURE_MARGIN_SIZE * 2) / 3);
1701 auto offset = leftCaptureNode->GetGeometryNode()->GetFrameOffset();
1702 EXPECT_EQ(offset.GetX(), 0.0f);
1703 EXPECT_EQ(offset.GetY(), CAPTURE_MARGIN_SIZE - size.Height());
1704 }
1705 /**
1706 * @tc.steps: step3. check layout info with Axis::HORIZONTAL
1707 * 3'|3' 0 1 2 3|3
1708 */
1709 layoutProperty_->UpdateDirection(Axis::HORIZONTAL);
1710 pattern_->OnModifyDone();
1711 frameNode_->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
1712 FlushLayoutTask(frameNode_);
1713 EXPECT_EQ(pattern_->leftCaptureIndex_, 3);
1714 leftCaptureNode = AceType::DynamicCast<FrameNode>(
1715 frameNode_->GetChildAtIndex(frameNode_->GetChildIndexById(pattern_->GetLeftCaptureId())));
1716 EXPECT_NE(leftCaptureNode, nullptr);
1717 float itemWidth = 0.0f;
1718 if (leftCaptureNode) {
1719 auto size = leftCaptureNode->GetGeometryNode()->GetFrameRect();
1720 EXPECT_EQ(size.Width(), (SWIPER_WIDTH - CAPTURE_MARGIN_SIZE * 2) / 3);
1721 EXPECT_EQ(size.Height(), SWIPER_HEIGHT);
1722 itemWidth = size.Width();
1723 auto offset = leftCaptureNode->GetGeometryNode()->GetFrameOffset();
1724 EXPECT_EQ(offset.GetX(), CAPTURE_MARGIN_SIZE - size.Width());
1725 EXPECT_EQ(offset.GetY(), 0.0f);
1726 }
1727
1728 /**
1729 * @tc.steps: step4. capture in left, delta swipe to right
1730 * 3'|3' 0 1 2 3|3 to 2'|2' 3 0 1 2|2
1731 */
1732 pattern_->currentDelta_ = -itemWidth;
1733 frameNode_->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
1734 FlushLayoutTask(frameNode_);
1735 EXPECT_EQ(pattern_->leftCaptureIndex_, 2);
1736 leftCaptureNode = AceType::DynamicCast<FrameNode>(
1737 frameNode_->GetChildAtIndex(frameNode_->GetChildIndexById(pattern_->GetLeftCaptureId())));
1738 EXPECT_NE(leftCaptureNode, nullptr);
1739 if (leftCaptureNode) {
1740 auto size = leftCaptureNode->GetGeometryNode()->GetFrameRect();
1741 auto offset = leftCaptureNode->GetGeometryNode()->GetFrameOffset();
1742 EXPECT_EQ(offset.GetX(), CAPTURE_MARGIN_SIZE - size.Width());
1743 }
1744
1745 /**
1746 * @tc.steps: step5. capture in left, delta swipe to left
1747 * 2'|2' 3 0 1 2|2 to 3|3 0 1 2 3'|3'
1748 */
1749 pattern_->currentDelta_ = itemWidth;
1750 frameNode_->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
1751 FlushLayoutTask(frameNode_);
1752 EXPECT_EQ(pattern_->rightCaptureIndex_, 3);
1753 auto rightCaptureNode = AceType::DynamicCast<FrameNode>(
1754 frameNode_->GetChildAtIndex(frameNode_->GetChildIndexById(pattern_->GetRightCaptureId())));
1755 EXPECT_NE(rightCaptureNode, nullptr);
1756 if (rightCaptureNode) {
1757 auto size = rightCaptureNode->GetGeometryNode()->GetFrameRect();
1758 EXPECT_EQ(size.Width(), (SWIPER_WIDTH - CAPTURE_MARGIN_SIZE * 2) / 3);
1759 EXPECT_EQ(size.Height(), SWIPER_HEIGHT);
1760 auto offset = rightCaptureNode->GetGeometryNode()->GetFrameOffset();
1761 EXPECT_EQ(offset.GetX(), SWIPER_WIDTH - CAPTURE_MARGIN_SIZE);
1762 EXPECT_EQ(offset.GetY(), 0.0f);
1763 }
1764
1765 /**
1766 * @tc.steps: step6. capture in right, delta swipe to left
1767 * 3|3 0 1 2 3'|3' to 0|0 1 2 3 0'|0'
1768 */
1769 pattern_->currentDelta_ = itemWidth;
1770 frameNode_->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
1771 FlushLayoutTask(frameNode_);
1772 EXPECT_EQ(pattern_->rightCaptureIndex_, 0);
1773 rightCaptureNode = AceType::DynamicCast<FrameNode>(
1774 frameNode_->GetChildAtIndex(frameNode_->GetChildIndexById(pattern_->GetRightCaptureId())));
1775 EXPECT_NE(rightCaptureNode, nullptr);
1776 if (rightCaptureNode) {
1777 auto offset = rightCaptureNode->GetGeometryNode()->GetFrameOffset();
1778 EXPECT_EQ(offset.GetX(), SWIPER_WIDTH - CAPTURE_MARGIN_SIZE);
1779 }
1780
1781 /**
1782 * @tc.steps: step7. capture in right, delta swipe to right
1783 * 0|0 1 2 3 0'|0' to 3'|3' 0 1 2 3|3
1784 */
1785 pattern_->currentDelta_ = -itemWidth;
1786 frameNode_->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
1787 FlushLayoutTask(frameNode_);
1788 EXPECT_EQ(pattern_->leftCaptureIndex_, 3);
1789 leftCaptureNode = AceType::DynamicCast<FrameNode>(
1790 frameNode_->GetChildAtIndex(frameNode_->GetChildIndexById(pattern_->GetLeftCaptureId())));
1791 EXPECT_NE(leftCaptureNode, nullptr);
1792 if (leftCaptureNode) {
1793 auto size = leftCaptureNode->GetGeometryNode()->GetFrameRect();
1794 auto offset = leftCaptureNode->GetGeometryNode()->GetFrameOffset();
1795 EXPECT_EQ(offset.GetX(), CAPTURE_MARGIN_SIZE - size.Width());
1796 }
1797 }
1798
1799 /**
1800 * @tc.name: FadeOverScroll001
1801 * @tc.desc: Test SwiperPattern FadeOverScroll
1802 * @tc.type: FUNC
1803 */
1804 HWTEST_F(SwiperTestNg, FadeOverScroll001, TestSize.Level1)
1805 {
__anonf92747112f02(SwiperModelNG model) 1806 CreateWithItem([](SwiperModelNG model) {});
1807 LayoutConstraintF layoutConstraint;
1808 layoutConstraint.maxSize = SizeF(720.f, 1136.f);
1809 layoutConstraint.percentReference = SizeF(720.f, 1136.f);
1810 layoutConstraint.parentIdealSize.SetSize(SizeF(720.f, 1136.f));
1811 layoutConstraint.selfIdealSize = OptionalSize(SizeF(720.f, 1200.f));
1812 layoutProperty_->UpdateLayoutConstraint(layoutConstraint);
1813 layoutProperty_->UpdateContentConstraint();
1814 /**
1815 * @tc.steps: step1. set data.
1816 */
1817 struct SwiperItemInfo swiperItemInfo1;
1818 struct SwiperItemInfo swiperItemInfo2;
1819 struct SwiperItemInfo swiperItemInfo3;
1820 struct SwiperItemInfo swiperItemInfo4;
1821 pattern_->itemPosition_.clear();
1822 swiperItemInfo1.startPos = 0.0f;
1823 swiperItemInfo1.endPos = 180.0f;
1824 pattern_->itemPosition_.emplace(std::make_pair(0, swiperItemInfo1));
1825 swiperItemInfo2.startPos = 180.0f;
1826 swiperItemInfo2.endPos = 360.0f;
1827 pattern_->itemPosition_.emplace(std::make_pair(1, swiperItemInfo2));
1828 swiperItemInfo3.startPos = 360.0f;
1829 swiperItemInfo3.endPos = 540.0f;
1830 pattern_->itemPosition_.emplace(std::make_pair(2, swiperItemInfo3));
1831 swiperItemInfo4.startPos = 540.0f;
1832 swiperItemInfo4.endPos = 720.0f;
1833 pattern_->itemPosition_.emplace(std::make_pair(3, swiperItemInfo4));
1834 layoutProperty_->UpdateDisplayCount(4);
1835 auto swiperLayoutAlgorithm = AceType::DynamicCast<SwiperLayoutAlgorithm>(pattern_->CreateLayoutAlgorithm());
1836 auto totalCount = pattern_->TotalCount();
1837 EXPECT_EQ(totalCount, 4);
1838 EXPECT_FALSE(pattern_->IsLoop());
1839 EXPECT_FALSE(pattern_->itemPosition_.empty());
1840 /**
1841 * @tc.steps: step2. call no mirror func.
1842 */
1843 EXPECT_FALSE(pattern_->IsOutOfBoundary(0.0f));
1844 layoutProperty_->UpdateLoop(false);
1845 EXPECT_TRUE(pattern_->IsOutOfBoundary(10.0f));
1846
1847 float offset = 0.0f;
1848 EXPECT_FALSE(pattern_->FadeOverScroll(offset));
1849 offset = 10.0f;
1850 EXPECT_FALSE(pattern_->IsVisibleChildrenSizeLessThanSwiper());
1851 EXPECT_TRUE(pattern_->FadeOverScroll(offset));
1852 /**
1853 * @tc.steps: step3. call mirror func.
1854 */
1855 layoutProperty_->UpdateLayoutDirection(TextDirection::RTL);
1856 layoutProperty_->UpdateDirection(Axis::HORIZONTAL);
1857 pattern_->fadeOffset_ = 0.0f;
1858 offset = 0.0f;
1859 EXPECT_FALSE(pattern_->FadeOverScroll(offset));
1860 EXPECT_FALSE(pattern_->IsVisibleChildrenSizeLessThanSwiper());
1861 offset = -10.0f;
1862 EXPECT_TRUE(pattern_->FadeOverScroll(offset));
1863 }
1864
1865 /**
1866 * @tc.name: IsOutOfStart001
1867 * @tc.desc: Test SwiperPattern IsOutOfStart
1868 * @tc.type: FUNC
1869 */
1870 HWTEST_F(SwiperTestNg, IsOutOfStart001, TestSize.Level1)
1871 {
__anonf92747113002(SwiperModelNG model) 1872 CreateWithItem([](SwiperModelNG model) {});
1873 float offset = 10.0f;
1874 layoutProperty_->UpdateLoop(false);
1875 layoutProperty_->UpdateDisplayCount(4);
1876 auto totalCount = pattern_->TotalCount();
1877 pattern_->currentIndex_ = 0;
1878 EXPECT_EQ(totalCount, 4);
1879 EXPECT_FALSE(pattern_->itemPosition_.empty());
1880 /**
1881 * @tc.steps: step1. call no mirror func.
1882 */
1883 layoutProperty_->UpdateLayoutDirection(TextDirection::LTR);
1884 offset = 10.0f;
1885 EXPECT_TRUE(pattern_->IsOutOfStart(offset));
1886 /**
1887 * @tc.steps: step2. call mirror func.
1888 */
1889 layoutProperty_->UpdateLayoutDirection(TextDirection::RTL);
1890 offset = -10.0f;
1891 EXPECT_TRUE(pattern_->IsOutOfStart(offset));
1892 }
1893
1894 /**
1895 * @tc.name: GetCustomPropertyTargetOffset001
1896 * @tc.desc: Test SwiperPattern GetCustomPropertyTargetOffset
1897 * @tc.type: FUNC
1898 */
1899 HWTEST_F(SwiperTestNg, GetCustomPropertyTargetOffset001, TestSize.Level1)
1900 {
__anonf92747113102(SwiperModelNG model) 1901 CreateWithItem([](SwiperModelNG model) {});
1902 auto paddingAndBorder = layoutProperty_->CreatePaddingAndBorder();
1903 auto paddingAndBorderValue = paddingAndBorder.top.value_or(0.0) + pattern_->tabsPaddingAndBorder_.top.value_or(0.0);
1904 layoutProperty_->UpdatePrevMargin(Dimension(10));
1905 float offset = Dimension(paddingAndBorderValue - 10.0f, DimensionUnit::PX).ConvertToVp();
1906 /**
1907 * @tc.steps: step1. call no mirror func.
1908 */
1909 layoutProperty_->UpdateLayoutDirection(TextDirection::LTR);
1910 offset = Dimension(paddingAndBorderValue + 10.0f, DimensionUnit::PX).ConvertToVp();
1911 EXPECT_EQ(pattern_->GetCustomPropertyTargetOffset(), offset);
1912 /**
1913 * @tc.steps: step2. call mirror func.
1914 */
1915 layoutProperty_->UpdateLayoutDirection(TextDirection::RTL);
1916 offset = Dimension(paddingAndBorderValue - 10.0f, DimensionUnit::PX).ConvertToVp();
1917 EXPECT_EQ(pattern_->GetCustomPropertyTargetOffset(), offset);
1918 }
1919
1920 /**
1921 * @tc.name: IsOutOfBoundary001
1922 * @tc.desc: Test SwiperPattern IsOutOfBoundary
1923 * @tc.type: FUNC
1924 */
1925 HWTEST_F(SwiperTestNg, IsOutOfBoundary001, TestSize.Level1)
1926 {
__anonf92747113202(SwiperModelNG model) 1927 CreateWithItem([](SwiperModelNG model) {});
1928 layoutProperty_->UpdateLoop(false);
1929 EXPECT_FALSE(pattern_->itemPosition_.empty());
1930 /**
1931 * @tc.steps: step1. call no mirror func.
1932 */
1933 layoutProperty_->UpdateLayoutDirection(TextDirection::LTR);
1934 EXPECT_TRUE(pattern_->IsOutOfBoundary(10.0f));
1935 /**
1936 * @tc.steps: step2. call mirror func.
1937 */
1938 layoutProperty_->UpdateLayoutDirection(TextDirection::RTL);
1939 EXPECT_TRUE(pattern_->IsOutOfBoundary(-10.0f));
1940 }
1941
1942 /**
1943 * @tc.name: CheckTargetIndex001
1944 * @tc.desc: Test SwiperPattern CheckTargetIndex
1945 * @tc.type: FUNC
1946 */
1947 HWTEST_F(SwiperTestNg, CheckTargetIndexheckTargetIndex001, TestSize.Level1)
1948 {
__anonf92747113302(SwiperModelNG model) 1949 CreateWithItem([](SwiperModelNG model) {});
1950 auto dimension = Dimension(1);
1951 layoutProperty_->UpdateMinSize(dimension);
1952 layoutProperty_->UpdateDisplayCount(4);
1953 layoutProperty_->UpdateDisplayMode(SwiperDisplayMode::AUTO_LINEAR);
1954 EXPECT_TRUE(pattern_->IsAutoLinear());
1955 pattern_->currentIndex_ = 1;
1956 int32_t targetIndex = 0;
1957 EXPECT_TRUE(pattern_->GetLoopIndex(targetIndex) != pattern_->GetLoopIndex(pattern_->currentIndex_));
1958 auto currentFrameNode = pattern_->GetCurrentFrameNode(pattern_->GetLoopIndex(targetIndex));
1959 EXPECT_NE(currentFrameNode, nullptr);
1960 auto swiperLayoutProperty = currentFrameNode->GetLayoutProperty<LayoutProperty>();
1961 EXPECT_NE(swiperLayoutProperty, nullptr);
1962 swiperLayoutProperty->UpdateVisibility(VisibleType::GONE);
1963 /**
1964 * @tc.steps: step1. call no mirror func.
1965 */
1966 layoutProperty_->UpdateLayoutDirection(TextDirection::LTR);
1967 EXPECT_EQ(pattern_->CheckTargetIndex(targetIndex, true), targetIndex + 1);
1968 EXPECT_EQ(pattern_->CheckTargetIndex(targetIndex, false), targetIndex - 1);
1969 /**
1970 * @tc.steps: step2. call mirror func.
1971 */
1972 layoutProperty_->UpdateLayoutDirection(TextDirection::RTL);
1973 EXPECT_EQ(pattern_->CheckTargetIndex(targetIndex, true), targetIndex - 1);
1974 EXPECT_EQ(pattern_->CheckTargetIndex(targetIndex, false), targetIndex + 1);
1975 }
1976
1977 /**
1978 * @tc.name: SwiperSetFrameRateTest001
1979 * @tc.desc: Test SetFrameRate
1980 * @tc.type: FUNC
1981 */
1982 HWTEST_F(SwiperTestNg, SwiperSetFrameRateTest001, TestSize.Level1)
1983 {
__anonf92747113402(SwiperModelNG model) 1984 CreateWithItem([](SwiperModelNG model) {});
1985 int32_t expectedRate = 60;
1986 auto frameRateRange = AceType::MakeRefPtr<FrameRateRange>(0, 120, expectedRate);
1987 pattern_->SetFrameRateRange(frameRateRange, SwiperDynamicSyncSceneType::GESTURE);
1988 auto frameRateManager = MockPipelineContext::GetCurrentContext()->GetFrameRateManager();
1989 int32_t nodeId = frameNode_->GetId();
1990 frameRateManager->AddNodeRate(nodeId, 1);
1991 frameRateManager->isRateChanged_ = false;
1992 pattern_->UpdateNodeRate();
1993 auto iter = frameRateManager->nodeRateMap_.find(nodeId);
1994 EXPECT_EQ(iter->second, expectedRate);
1995 EXPECT_TRUE(frameRateManager->isRateChanged_);
1996 }
1997 } // namespace OHOS::Ace::NG
1998