diff --git a/test/unittest/core/pattern/list/list_pattern_test_ng_two.cpp b/test/unittest/core/pattern/list/list_pattern_test_ng_two.cpp index 40a705501cbed99ad0f6672baa0401d5f6b6c760..c35f0bb41aad1c8bc797eb12246768e5200c33c5 100644 --- a/test/unittest/core/pattern/list/list_pattern_test_ng_two.cpp +++ b/test/unittest/core/pattern/list/list_pattern_test_ng_two.cpp @@ -171,10 +171,9 @@ HWTEST_F(ListPatternTwoTestNg, ScrollToItemInGroup001, TestSize.Level1) /** * @tc.steps: step3. Set index to 1 and IndexInGroup to 1 * and Set smooth to false and align to AUTO - * @tc.expected: The scrollAlign_ of listPattern to END and isScrollEnd_ of listPattern to true + * @tc.expected: The isScrollEnd_ of listPattern to true */ listPattern->ScrollToItemInGroup(1, 1, false, ScrollAlign::AUTO); - EXPECT_EQ(listPattern->scrollAlign_, ScrollAlign::END); EXPECT_TRUE(listPattern->isScrollEnd_); } @@ -719,4 +718,137 @@ HWTEST_F(ListPatternTwoTestNg, SetFocusWrapMode, TestSize.Level1) listPattern->SetFocusWrapMode(focusWrapMode); EXPECT_EQ(listPattern->focusWrapMode_, FocusWrapMode::DEFAULT); } + +/** + * @tc.name: HandleTargetIndex + * @tc.desc: Test ListPattern HandleTargetIndex + * @tc.type: FUNC + */ +HWTEST_F(ListPatternTwoTestNg, HandleTargetIndex, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr listPattern = AceType::MakeRefPtr(); + auto listNode = FrameNode::CreateFrameNode(V2::LIST_ETS_TAG, 1, listPattern); + ASSERT_NE(listNode, nullptr); + RefPtr layoutProperty = AceType::MakeRefPtr(); + listNode->layoutProperty_ = layoutProperty; + listPattern->frameNode_ = listNode; + + /** + * @tc.steps: Set crossMatchChild_ of listPattern to true + * and set propertyChangeFlag_ to PROPERTY_UPDATE_NORMAL + */ + listPattern->frameNode_.Upgrade()->layoutProperty_->UpdatePropertyChangeFlag(PROPERTY_UPDATE_NORMAL); + listPattern->crossMatchChild_ = true; + + /** + * @tc.steps: step3. Calling the HandleTargetIndex function + * @tc.expected: the propertyChangeFlag_ to be PROPERTY_UPDATE_MEASURE_SELF_AND_PARENT and result return true + */ + auto result = listPattern->HandleTargetIndex(true); + EXPECT_EQ(listNode->layoutProperty_->propertyChangeFlag_, PROPERTY_UPDATE_MEASURE_SELF_AND_PARENT); + EXPECT_TRUE(result); +} + +/** + * @tc.name: CalculateTargetPos_topOffset_equal_bottomOffset + * @tc.desc: Test ListPattern CalculateTargetPos + * @tc.type: FUNC + */ +HWTEST_F(ListPatternTwoTestNg, CalculateTargetPos_topOffset_equal_bottomOffset, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr listPattern = AceType::MakeRefPtr(); + auto listNode = FrameNode::CreateFrameNode(V2::LIST_ETS_TAG, 1, listPattern); + ASSERT_NE(listNode, nullptr); + RefPtr layoutProperty = AceType::MakeRefPtr(); + layoutProperty->UpdateScrollSnapAlign(ScrollSnapAlign::CENTER); + listNode->layoutProperty_ = layoutProperty; + listPattern->frameNode_ = listNode; + + /** + * @tc.steps: Set contentMainSize_ of listPattern to 2.0f + */ + listPattern->contentMainSize_ = 2.0f; + + /** + * @tc.steps: step3. Set startPos to 2.0f and endPos to 4.0f + * @tc.expected: The result of this function returns the difference between endPos and contentMainSize_ + */ + auto result = listPattern->CalculateTargetPos(2.0f, 4.0f); + EXPECT_EQ(result, 2.0f); +} + +/** + * @tc.name: UpdateCurrentOffset_IsOutOfBoundary + * @tc.desc: Test ListPattern UpdateCurrentOffset + * @tc.type: FUNC + */ +HWTEST_F(ListPatternTwoTestNg, UpdateCurrentOffset_IsOutOfBoundary, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr listPattern = AceType::MakeRefPtr(); + auto listNode = FrameNode::CreateFrameNode(V2::LIST_ETS_TAG, 1, listPattern); + ASSERT_NE(listNode, nullptr); + RefPtr layoutProperty = AceType::MakeRefPtr(); + listNode->layoutProperty_ = layoutProperty; + listPattern->frameNode_ = listNode; + + /** + * @tc.steps: Change the value of the list member variable to make the IsOutOfBoundary function return true + */ + listPattern->jumpIndex_ = std::nullopt; + listPattern->targetIndex_ = std::nullopt; + listPattern->isStackFromEnd_ = false; + listPattern->startIndex_ = 0; + listPattern->startMainPos_ = 18.0f; + listPattern->endMainPos_ = 20.0f; + listPattern->currentDelta_ = 2.0f; + listPattern->contentStartOffset_ = 4.0f; + listPattern->canStayOverScroll_ = false; + ListItemGroupLayoutInfo itemGroupInfo = { true, true }; + listPattern->itemPosition_[0] = { 2, 2.0f, 4.0f, true, false, 1.0f, 0.0f, itemGroupInfo }; + listPattern->frameNode_.Upgrade()->layoutProperty_->UpdatePropertyChangeFlag(PROPERTY_UPDATE_NORMAL); + listPattern->crossMatchChild_ = true; + + /** + * @tc.steps: step3. Set offset to 2.0f and source to SCROLL_FROM_JUMP + * @tc.expected: The result of this function returns false and propertyChangeFlag_ to be + * PROPERTY_UPDATE_MEASURE_SELF_AND_PARENT + */ + auto result = listPattern->UpdateCurrentOffset(2.0f, SCROLL_FROM_JUMP); + EXPECT_EQ(listNode->layoutProperty_->propertyChangeFlag_, PROPERTY_UPDATE_MEASURE_SELF_AND_PARENT); + EXPECT_FALSE(result); +} + +/** + * @tc.name: ScrollToSnapIndex_ScrollSnapAlign_NONE + * @tc.desc: Test ListPattern ScrollToSnapIndex + * @tc.type: FUNC + */ +HWTEST_F(ListPatternTwoTestNg, ScrollToSnapIndex_ScrollSnapAlign_NONE, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr listPattern = AceType::MakeRefPtr(); + + /** + * @tc.steps: Set startIndex_ of listPattern to 2 + */ + listPattern->startIndex_ = 2; + + /** + * @tc.steps: step3. Set snapDirection to FORWARD and scrollSnapAlign to NONE + * @tc.expected: The result of this function returns false + */ + auto result = listPattern->ScrollToSnapIndex(SnapDirection::FORWARD, ScrollSnapAlign::NONE); + EXPECT_FALSE(result); +} } // namespace OHOS::Ace::NG \ No newline at end of file diff --git a/test/unittest/core/pattern/scroll/scroll_effect_test_ng.cpp b/test/unittest/core/pattern/scroll/scroll_effect_test_ng.cpp index cfa81e18e8ba732ae085ec50960be00cb9ecea95..ed24877887547580ccb6f6f2aee3f3898646bf14 100644 --- a/test/unittest/core/pattern/scroll/scroll_effect_test_ng.cpp +++ b/test/unittest/core/pattern/scroll/scroll_effect_test_ng.cpp @@ -768,29 +768,6 @@ HWTEST_F(ScrollEffectTestNg, FadingEdge002, TestSize.Level1) EXPECT_FALSE(paintMethod->isFadingBottom_); } -/** - * @tc.name: CalculateOverScroll001 - * @tc.desc: Test ScrollFadeEffect CalculateOverScroll - * @tc.type: FUNC - */ -HWTEST_F(ScrollEffectTestNg, CalculateOverScroll001, TestSize.Level1) -{ - /** - * @tc.steps: step1. Construct the objects for test preparation - */ - RefPtr scrollFadeEffect = AceType::MakeRefPtr(Color::RED); - - /** - * @tc.steps: step2. Set currentPositionCallback, leadingCallback, trailingCallback - * @tc.expected: The result return 0.0 - */ - scrollFadeEffect->currentPositionCallback_ = []() { return 2.0; }; - scrollFadeEffect->leadingCallback_ = []() { return 1.0; }; - scrollFadeEffect->trailingCallback_ = nullptr; - auto result = scrollFadeEffect->CalculateOverScroll(2.0, true); - EXPECT_EQ(result, 0.0); -} - /** * @tc.name: SetPaintDirection001 * @tc.desc: Test ScrollFadeEffect SetPaintDirection @@ -881,4 +858,312 @@ HWTEST_F(ScrollEffectTestNg, ChangeStateDefault, TestSize.Level1) controller->ChangeState(); EXPECT_EQ(controller->pullDistance_, 0.0); } + +/** + * @tc.name: CalculateOverScroll001 + * @tc.desc: Test ScrollFadeEffect CalculateOverScroll + * @tc.type: FUNC + */ +HWTEST_F(ScrollEffectTestNg, CalculateOverScroll001, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr scrollFadeEffect = AceType::MakeRefPtr(Color::RED); + + /** + * @tc.steps: step2. Set currentPositionCallback_ to nullptr + * set leadingCallback_ and trailingCallback_ + */ + scrollFadeEffect->currentPositionCallback_ = nullptr; + scrollFadeEffect->leadingCallback_ = []() { return -2.0; }; + scrollFadeEffect->trailingCallback_ = []() { return -8.0; }; + + /** + * @tc.steps: step3. Set oldPostion to 2.0 and isReachMax to false + * @tc.expected: The result of this function returns 0 + */ + auto result = scrollFadeEffect->CalculateOverScroll(2.0, false); + EXPECT_EQ(result, 0.0); +} + +/** + * @tc.name: CalculateOverScroll002 + * @tc.desc: Test ScrollFadeEffect CalculateOverScroll + * @tc.type: FUNC + */ +HWTEST_F(ScrollEffectTestNg, CalculateOverScroll002, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr scrollFadeEffect = AceType::MakeRefPtr(Color::RED); + + /** + * @tc.steps: step2. Set currentPositionCallback_ and leadingCallback_ + * set trailingCallback_ to nullptr + */ + scrollFadeEffect->currentPositionCallback_ = []() { return -4.0; }; + scrollFadeEffect->leadingCallback_ = []() { return -2.0; }; + scrollFadeEffect->trailingCallback_ = nullptr; + + /** + * @tc.steps: step3. Set oldPostion to 2.0 and isReachMax to false + * @tc.expected: The result of this function returns 0 + */ + auto result = scrollFadeEffect->CalculateOverScroll(2.0, false); + EXPECT_EQ(result, 0.0); +} + +/** + * @tc.name: CalculateOverScroll003 + * @tc.desc: Test ScrollFadeEffect CalculateOverScroll + * @tc.type: FUNC + */ +HWTEST_F(ScrollEffectTestNg, CalculateOverScroll003, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr scrollFadeEffect = AceType::MakeRefPtr(Color::RED); + + /** + * @tc.steps: step2. Set trailingCallback_ and leadingCallback_ to nullptr + * set currentPositionCallback_ + */ + scrollFadeEffect->currentPositionCallback_ = []() { return -4.0; }; + scrollFadeEffect->leadingCallback_ = nullptr; + scrollFadeEffect->trailingCallback_ = nullptr; + + /** + * @tc.steps: step3. Set oldPostion to 2.0 and isReachMax to false + * @tc.expected: The result of this function returns 0 + */ + auto result = scrollFadeEffect->CalculateOverScroll(2.0, false); + EXPECT_EQ(result, 0.0); +} + +/** + * @tc.name: CalculateOverScroll004 + * @tc.desc: Test ScrollFadeEffect CalculateOverScroll + * @tc.type: FUNC + */ +HWTEST_F(ScrollEffectTestNg, CalculateOverScroll004, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr scrollFadeEffect = AceType::MakeRefPtr(Color::RED); + + /** + * @tc.steps: step2. Set currentPositionCallback_, leadingCallback_ and trailingCallback_ + * set -currentPositionCallback_() less than oldPosition and oldPosition less or equal to -trailingCallback_() + */ + scrollFadeEffect->currentPositionCallback_ = []() { return -4.0; }; + scrollFadeEffect->leadingCallback_ = []() { return -2.0; }; + scrollFadeEffect->trailingCallback_ = []() { return -8.0; }; + + /** + * @tc.steps: step3. Set oldPostion to 6.0 and isReachMax to true + * @tc.expected: The result of this function returns -2 + */ + auto result = scrollFadeEffect->CalculateOverScroll(6.0, true); + EXPECT_EQ(result, -2.0); +} + +/** + * @tc.name: CalculateOverScroll005 + * @tc.desc: Test ScrollFadeEffect CalculateOverScroll + * @tc.type: FUNC + */ +HWTEST_F(ScrollEffectTestNg, CalculateOverScroll005, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr scrollFadeEffect = AceType::MakeRefPtr(Color::RED); + + /** + * @tc.steps: step2. Set currentPositionCallback_, leadingCallback_ and trailingCallback_ + * set -currentPositionCallback_() greater than oldPosition and oldPosition greater or equal to -leadingCallback_() + */ + scrollFadeEffect->currentPositionCallback_ = []() { return -7.0; }; + scrollFadeEffect->leadingCallback_ = []() { return -2.0; }; + scrollFadeEffect->trailingCallback_ = []() { return -8.0; }; + + /** + * @tc.steps: step3. Set oldPostion to 6.0 and isReachMax to true + * @tc.expected: The result of this function returns 1 + */ + auto result = scrollFadeEffect->CalculateOverScroll(6.0, true); + EXPECT_EQ(result, 1.0); +} + +/** + * @tc.name: CalculateOverScroll006 + * @tc.desc: Test ScrollFadeEffect CalculateOverScroll + * @tc.type: FUNC + */ +HWTEST_F(ScrollEffectTestNg, CalculateOverScroll006, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr scrollFadeEffect = AceType::MakeRefPtr(Color::RED); + + /** + * @tc.steps: step2. Set currentPositionCallback_, leadingCallback_ and trailingCallback_ + * set -currentPositionCallback_() less than -trailingCallback_() and -trailingCallback_() less than oldPostion + */ + scrollFadeEffect->currentPositionCallback_ = []() { return -4.0; }; + scrollFadeEffect->leadingCallback_ = []() { return -2.0; }; + scrollFadeEffect->trailingCallback_ = []() { return -8.0; }; + + /** + * @tc.steps: step3. Set oldPostion to 10.0 and isReachMax to true + * @tc.expected: The result of this function returns 4 + */ + auto result = scrollFadeEffect->CalculateOverScroll(10.0, true); + EXPECT_EQ(result, 4.0); +} + +/** + * @tc.name: CalculateOverScroll007 + * @tc.desc: Test ScrollFadeEffect CalculateOverScroll + * @tc.type: FUNC + */ +HWTEST_F(ScrollEffectTestNg, CalculateOverScroll007, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr scrollFadeEffect = AceType::MakeRefPtr(Color::RED); + + /** + * @tc.steps: step2. Set currentPositionCallback_, leadingCallback_ and trailingCallback_ + * set -currentPositionCallback_() greater than oldPostion and oldPostion less than -leadingCallback_() + */ + scrollFadeEffect->currentPositionCallback_ = []() { return -4.0; }; + scrollFadeEffect->leadingCallback_ = []() { return -10.0; }; + scrollFadeEffect->trailingCallback_ = []() { return -8.0; }; + + /** + * @tc.steps: step3. Set oldPostion to 2.0 and isReachMax to true + * @tc.expected: The result of this function returns 0 + */ + auto result = scrollFadeEffect->CalculateOverScroll(2.0, true); + EXPECT_EQ(result, 0.0); +} + +/** + * @tc.name: CalculateOverScroll008 + * @tc.desc: Test ScrollFadeEffect CalculateOverScroll + * @tc.type: FUNC + */ +HWTEST_F(ScrollEffectTestNg, CalculateOverScroll008, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr scrollFadeEffect = AceType::MakeRefPtr(Color::RED); + + /** + * @tc.steps: step2. Set currentPositionCallback_, leadingCallback_ and trailingCallback_ + * set -currentPositionCallback_() greater than -leadingCallback_() and oldPostion less than -leadingCallback_() + */ + scrollFadeEffect->currentPositionCallback_ = []() { return -10.0; }; + scrollFadeEffect->leadingCallback_ = []() { return -8.0; }; + scrollFadeEffect->trailingCallback_ = []() { return -2.0; }; + + /** + * @tc.steps: step3. Set oldPostion to 4.0 and isReachMax to true + * @tc.expected: The result of this function returns 2 + */ + auto result = scrollFadeEffect->CalculateOverScroll(4.0, true); + EXPECT_EQ(result, 2.0); +} + +/** + * @tc.name: CalculateOverScroll009 + * @tc.desc: Test ScrollFadeEffect CalculateOverScroll + * @tc.type: FUNC + */ +HWTEST_F(ScrollEffectTestNg, CalculateOverScroll009, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr scrollFadeEffect = AceType::MakeRefPtr(Color::RED); + + /** + * @tc.steps: step2. Set currentPositionCallback_, leadingCallback_ and trailingCallback_ + * set -currentPositionCallback_() greater than -leadingCallback_() and oldPostion less than -leadingCallback_() + */ + scrollFadeEffect->currentPositionCallback_ = []() { return -10.0; }; + scrollFadeEffect->leadingCallback_ = []() { return -8.0; }; + scrollFadeEffect->trailingCallback_ = []() { return -2.0; }; + + /** + * @tc.steps: step3. Set oldPostion to 4.0 and isReachMax to false + * @tc.expected: The result of this function returns 0 + */ + auto result = scrollFadeEffect->CalculateOverScroll(4.0, false); + EXPECT_EQ(result, 0.0); +} + +/** + * @tc.name: CalculateOverScroll010 + * @tc.desc: Test ScrollFadeEffect CalculateOverScroll + * @tc.type: FUNC + */ +HWTEST_F(ScrollEffectTestNg, CalculateOverScroll010, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr scrollFadeEffect = AceType::MakeRefPtr(Color::RED); + + /** + * @tc.steps: step2. Set currentPositionCallback_, leadingCallback_ and trailingCallback_ + * set -trailingCallback_() greater than oldPostion and -currentPositionCallback_() less than -leadingCallback_() + */ + scrollFadeEffect->currentPositionCallback_ = []() { return -6.0; }; + scrollFadeEffect->leadingCallback_ = []() { return -4.0; }; + scrollFadeEffect->trailingCallback_ = []() { return -2.0; }; + + /** + * @tc.steps: step3. Set oldPostion to 6.0 and isReachMax to false + * @tc.expected: The result of this function returns 0 + */ + auto result = scrollFadeEffect->CalculateOverScroll(6.0, false); + EXPECT_EQ(result, 0.0); +} + +/** + * @tc.name: CalculateOverScroll011 + * @tc.desc: Test ScrollFadeEffect CalculateOverScroll + * @tc.type: FUNC + */ +HWTEST_F(ScrollEffectTestNg, CalculateOverScroll011, TestSize.Level1) +{ + /** + * @tc.steps: step1. Construct the objects for test preparation + */ + RefPtr scrollFadeEffect = AceType::MakeRefPtr(Color::RED); + + /** + * @tc.steps: step2. Set currentPositionCallback_, leadingCallback_ and trailingCallback_ + * set -trailingCallback_() greater than oldPostion and -currentPositionCallback_() less than -leadingCallback_() + */ + scrollFadeEffect->currentPositionCallback_ = []() { return -10.0; }; + scrollFadeEffect->leadingCallback_ = []() { return -10.0; }; + scrollFadeEffect->trailingCallback_ = []() { return -10.0; }; + + /** + * @tc.steps: step3. Set oldPostion to 8.0 and isReachMax to false + * @tc.expected: The result of this function returns 0 + */ + auto result = scrollFadeEffect->CalculateOverScroll(10.0, false); + EXPECT_EQ(result, 0.0); +} } // namespace OHOS::Ace::NG