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 "grid_test_ng.h"
17 #include "test/mock/core/pipeline/mock_pipeline_context.h"
18 #include "test/mock/core/render/mock_render_context.h"
19 #include "test/mock/core/rosen/mock_canvas.h"
20 
21 #include "core/components_ng/pattern/grid/grid_item_pattern.h"
22 #include "core/components_ng/pattern/grid/grid_layout/grid_layout_algorithm.h"
23 #include "core/components_ng/pattern/text_field/text_field_manager.h"
24 #include "core/components_ng/pattern/grid/grid_scroll/grid_scroll_layout_algorithm.h"
25 
26 namespace OHOS::Ace::NG {
27 
28 namespace {} // namespace
29 
30 class GridLayoutTestNg : public GridTestNg {
31 public:
32     void UpdateLayoutInfo();
33     void UpdateLayoutWrapper(RefPtr<FrameNode>& frameNode, float width = GRID_WIDTH, float height = GRID_HEIGHT);
34 };
35 
UpdateLayoutInfo()36 void GridLayoutTestNg::UpdateLayoutInfo()
37 {
38     GetGrid();
39     ViewStackProcessor::GetInstance()->Finish();
40     FlushLayoutTask(frameNode_);
41     pattern_->gridLayoutInfo_.lineHeightMap_[0] = ITEM_HEIGHT;
42     pattern_->gridLayoutInfo_.gridMatrix_[0][0] = 0;
43     pattern_->gridLayoutInfo_.gridMatrix_[0][1] = 1;
44     pattern_->gridLayoutInfo_.gridMatrix_[1][0] = 0;
45     pattern_->gridLayoutInfo_.gridMatrix_[1][1] = 1;
46 }
47 
UpdateLayoutWrapper(RefPtr<FrameNode> & frameNode,float width,float height)48 void GridLayoutTestNg::UpdateLayoutWrapper(RefPtr<FrameNode>& frameNode, float width, float height)
49 {
50     LayoutConstraintF LayoutConstraint;
51     LayoutConstraint.parentIdealSize = { GRID_WIDTH, GRID_HEIGHT };
52     LayoutConstraint.percentReference = { GRID_WIDTH, GRID_HEIGHT };
53     LayoutConstraint.selfIdealSize = { width, height };
54     LayoutConstraint.maxSize = { width, GRID_HEIGHT };
55     frameNode->Measure(LayoutConstraint);
56     frameNode->Layout();
57 }
58 
59 /**
60  * @tc.name: GridPaintMethodTest001
61  * @tc.desc: Test grid paint method GetForegroundDrawFunction function
62  * @tc.type: FUNC
63  */
64 HWTEST_F(GridLayoutTestNg, GridPaintMethodTest001, TestSize.Level1)
65 {
66     GridModelNG model = CreateGrid();
67     model.SetRowsTemplate("1fr 1fr");
68     CreateFixedItems(10);
69     CreateDone(frameNode_);
70     auto paintMethod = AceType::DynamicCast<GridPaintMethod>(pattern_->CreateNodePaintMethod());
71     auto paintProperty = pattern_->CreatePaintProperty();
72     PaintWrapper paintWrapper(frameNode_->GetRenderContext(), frameNode_->GetGeometryNode(), paintProperty);
73     auto drawFunction = paintMethod->GetForegroundDrawFunction(&paintWrapper);
74     Testing::MockCanvas rsCanvas;
75     EXPECT_CALL(rsCanvas, DetachPen()).WillRepeatedly(ReturnRef(rsCanvas));
76     EXPECT_CALL(rsCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rsCanvas));
77     EXPECT_CALL(rsCanvas, DrawRect(_)).WillRepeatedly(Return());
78     drawFunction(rsCanvas);
79     paintMethod = nullptr;
80     drawFunction(rsCanvas);
81 
82     /**
83      * @tc.steps: step1. When EdgeEffect::SPRING
84      * @tc.expected: CreateNodePaintMethod would not trigger SetEdgeEffect
85      */
86     pattern_->SetEdgeEffect(EdgeEffect::SPRING);
87     paintMethod = AceType::DynamicCast<GridPaintMethod>(pattern_->CreateNodePaintMethod());
88     EXPECT_EQ(paintMethod->edgeEffect_.Upgrade(), nullptr);
89 
90     /**
91      * @tc.steps: step2. When EdgeEffect::FADE
92      * @tc.expected: CreateNodePaintMethod would trigger SetEdgeEffect
93      */
94     pattern_->SetEdgeEffect(EdgeEffect::FADE);
95     paintMethod = AceType::DynamicCast<GridPaintMethod>(pattern_->CreateNodePaintMethod());
96     EXPECT_NE(paintMethod->edgeEffect_.Upgrade(), nullptr);
97 }
98 
99 /**
100  * @tc.name: ScrollLayout001
101  * @tc.desc: Test UpdateOffsetOnVirtualKeyboardHeightChange
102  * @tc.type: FUNC
103  */
104 HWTEST_F(GridLayoutTestNg, ScrollLayout001, TestSize.Level1)
105 {
106     auto textFieldManager = AceType::MakeRefPtr<TextFieldManagerNG>();
107     MockPipelineContext::GetCurrent()->SetTextFieldManager(textFieldManager);
108     auto textFieldPattern = AceType::MakeRefPtr<Pattern>();
109     textFieldManager->SetOnFocusTextField(textFieldPattern);
110     const Offset clickPosition = Offset(100.f, GRID_HEIGHT + ITEM_HEIGHT);
111     textFieldManager->SetClickPosition(clickPosition);
112 
113     GridModelNG model = CreateGrid();
114     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
115     model.SetMaxCount(2);
116     CreateFixedItems(18);
117     CreateDone(frameNode_);
118     const float smallerHeight = GRID_HEIGHT - ITEM_HEIGHT;
119     RectF gridRect(0.f, 0.f, GRID_WIDTH, smallerHeight);
120     auto mockRenderContext = AceType::DynamicCast<MockRenderContext>(frameNode_->renderContext_);
121     mockRenderContext->rect_ = gridRect;
122 
123     /**
124      * @tc.steps: step1. Change to smaller mainSize
125      * @tc.expected: The mainSize is correct
126      */
127     auto gridFocus = frameNode_->GetOrCreateFocusHub();
128     gridFocus->RequestFocusImmediately();
129     // change grid height and trigger Measure
130     UpdateLayoutWrapper(frameNode_, GRID_WIDTH, smallerHeight);
131     float gridHeight = frameNode_->GetGeometryNode()->GetFrameSize().Height();
132     EXPECT_FLOAT_EQ(gridHeight, smallerHeight);
133 }
134 
135 /**
136  * @tc.name: ScrollLayout002
137  * @tc.desc: Test UpdateOffsetOnVirtualKeyboardHeightChange that currentOffset wuold not change
138  * @tc.type: FUNC
139  */
140 HWTEST_F(GridLayoutTestNg, ScrollLayout002, TestSize.Level1)
141 {
142     auto textFieldManager = AceType::MakeRefPtr<TextFieldManagerNG>();
143     MockPipelineContext::GetCurrent()->SetTextFieldManager(textFieldManager);
144     auto textFieldPattern = AceType::MakeRefPtr<Pattern>();
145     textFieldManager->SetOnFocusTextField(textFieldPattern);
146     const Offset clickPosition = Offset(100.f, 100.f);
147     textFieldManager->SetClickPosition(clickPosition);
148 
149     GridModelNG model = CreateGrid();
150     model.SetRowsTemplate("1fr 1fr 1fr 1fr");
151     model.SetMaxCount(2);
152     CreateFixedItems(18);
153     CreateDone(frameNode_);
154 
155     /**
156      * @tc.steps: step1. While axis_ == Axis::HORIZONTAL
157      * @tc.expected: currentOffset_ would not change
158      */
159     pattern_->gridLayoutInfo_.axis_ = Axis::HORIZONTAL;
160     const float smallerHeight = GRID_HEIGHT - ITEM_HEIGHT;
161     // change grid height and trigger Measure
162     UpdateLayoutWrapper(frameNode_, GRID_WIDTH, smallerHeight);
163     float currentOffset = pattern_->gridLayoutInfo_.currentOffset_;
164     EXPECT_FLOAT_EQ(currentOffset, 0.f);
165 
166     /**
167      * @tc.steps: step2. While Grid !IsCurrentFocus()
168      * @tc.expected: currentOffset_ would not change
169      */
170     UpdateLayoutWrapper(frameNode_, GRID_WIDTH, GRID_HEIGHT); // reset Grid height
171     pattern_->gridLayoutInfo_.axis_ = Axis::VERTICAL;
172     // change grid height and trigger Measure
173     UpdateLayoutWrapper(frameNode_, GRID_WIDTH, smallerHeight);
174     currentOffset = pattern_->gridLayoutInfo_.currentOffset_;
175     EXPECT_FLOAT_EQ(currentOffset, 0.f);
176 
177     /**
178      * @tc.steps: step3. While clickPosition is in Grid
179      * @tc.expected: currentOffset_ would not change
180      */
181     UpdateLayoutWrapper(frameNode_, GRID_WIDTH, GRID_HEIGHT); // reset Grid height
182     pattern_->gridLayoutInfo_.axis_ = Axis::VERTICAL;
183     // change grid height and trigger Measure
184     UpdateLayoutWrapper(frameNode_, GRID_WIDTH, smallerHeight);
185     currentOffset = pattern_->gridLayoutInfo_.currentOffset_;
186     EXPECT_FLOAT_EQ(currentOffset, 0.f);
187 }
188 
189 /**
190  * @tc.name: AdaptiveLayout001
191  * @tc.desc: Test property AdaptiveLayout
192  * @tc.type: FUNC
193  */
194 HWTEST_F(GridLayoutTestNg, AdaptiveLayout001, TestSize.Level1)
195 {
196     float itemWidth = 100.f;
197     GridModelNG model = CreateGrid();
198     model.SetLayoutDirection(FlexDirection::ROW);
199     model.SetEditable(true);
200     model.SetCellLength(ITEM_HEIGHT);
201     model.SetMinCount(4);
202     model.SetMaxCount(2);
203     CreateGridItems(10, itemWidth, ITEM_HEIGHT);
204     CreateDone(frameNode_);
205 
206     /**
207      * @tc.steps: step1. While the before set minCount > maxCount
208      * @tc.expected: would let minCount = 1, maxCount = Infinity;
209      */
210     int32_t colsNumber = 4; // 4 * 100(itemWidth) < 480(gridWidth)
211     for (int32_t index = 0; index < 10; index++) {
212         RectF childRect = GetChildRect(frameNode_, index);
213         float offsetX = index % colsNumber * itemWidth;
214         float offsetY = floor(index / colsNumber) * ITEM_HEIGHT;
215         RectF expectRect = RectF(offsetX, offsetY, itemWidth, ITEM_HEIGHT);
216         EXPECT_TRUE(IsEqual(childRect, expectRect)) << "index: " << index;
217     }
218 }
219 
220 /**
221  * @tc.name: GridScrollTest001
222  * @tc.desc: Test FireOnScrollBarUpdate Function.
223  * @tc.type: FUNC
224  */
225 HWTEST_F(GridLayoutTestNg, GridScrollTest001, TestSize.Level1)
226 {
227     GridModelNG model = CreateGrid();
__anon80cf7a3e0202(int32_t index, Dimension offset) 228     ScrollBarUpdateFunc scrollFunc = [](int32_t index, Dimension offset) {
229         std::optional<float> horizontalOffset = offset.ConvertToPx();
230         std::optional<float> verticalOffset = offset.ConvertToPx();
231         return std::make_pair(horizontalOffset, verticalOffset);
232     };
233     model.SetRowsTemplate("1fr 1fr");
234     model.SetRowsGap(Dimension(5));
235     model.SetOnScrollBarUpdate(std::move(scrollFunc));
236     CreateBigItem(1, 1, 1, 2);
237     CreateFixedItems(2);
238     CreateDone(frameNode_);
239     Dimension offset(1.0);
240     auto fireOnScroll = eventHub_->FireOnScrollBarUpdate(1.0, offset);
241     EXPECT_FLOAT_EQ(fireOnScroll.first.value(), 1.0f);
242     EXPECT_FLOAT_EQ(fireOnScroll.second.value(), 1.0f);
243 }
244 
245 /**
246  * @tc.name: GridScrollTest002
247  * @tc.desc: Test CalculateLargeItemOffset Function.
248  * @tc.type: FUNC
249  */
250 HWTEST_F(GridLayoutTestNg, GridScrollTest002, TestSize.Level1)
251 {
252     /**
253      * @tc.steps: step1. Create gridItem and initialize related properties.
254      */
255     GridModelNG model;
256     model.Create(nullptr, nullptr);
257     ViewAbstract::SetWidth(CalcLength(GRID_WIDTH));
258     ViewAbstract::SetHeight(CalcLength(GRID_HEIGHT));
259     model.SetRowsTemplate("1fr 1fr");
260     model.SetRowsGap(Dimension(5));
261     UpdateLayoutInfo();
262     auto gridScrollLayoutAlgorithm = AceType::MakeRefPtr<GridScrollLayoutAlgorithm>(pattern_->gridLayoutInfo_, 2, 0);
263     ASSERT_NE(gridScrollLayoutAlgorithm, nullptr);
264     auto ret = gridScrollLayoutAlgorithm->CalculateLargeItemOffset(OffsetF(100, 100), 0, 1, 0);
265     EXPECT_EQ(ret.GetY(), 100.f - ITEM_HEIGHT);
266     EXPECT_EQ(ret.GetX(), 100.f);
267 }
268 
269 /**
270  * @tc.name: GridScrollTest003
271  * @tc.desc: Test CalculateLargeItemOffset Function.
272  * @tc.type: FUNC
273  */
274 HWTEST_F(GridLayoutTestNg, GridScrollTest003, TestSize.Level1)
275 {
276     /**
277      * @tc.steps: step1. Create gridItem and initialize related properties.
278      */
279     GridModelNG model;
280     model.Create(nullptr, nullptr);
281     ViewAbstract::SetWidth(CalcLength(GRID_WIDTH));
282     ViewAbstract::SetHeight(CalcLength(GRID_HEIGHT));
283     model.SetColumnsTemplate("1fr 1fr");
284     model.SetRowsGap(Dimension(5));
285     CreateFixedItems(10);
286     UpdateLayoutInfo();
287     auto gridScrollLayoutAlgorithm = AceType::MakeRefPtr<GridScrollLayoutAlgorithm>(pattern_->gridLayoutInfo_, 2, 0);
288     ASSERT_NE(gridScrollLayoutAlgorithm, nullptr);
289     auto ret = gridScrollLayoutAlgorithm->CalculateLargeItemOffset(OffsetF(0, 100), 1, 1, 0);
290     EXPECT_EQ(ret.GetY(), 100.0f);
291     EXPECT_EQ(ret.GetX(), 0.0f);
292 }
293 
294 /**
295  * @tc.name: GridScrollTest004
296  * @tc.desc: Test CalculateLargeItemOffset Function.
297  * @tc.type: FUNC
298  */
299 HWTEST_F(GridLayoutTestNg, GridScrollTest004, TestSize.Level1)
300 {
301     /**
302      * @tc.steps: step1. Create gridItem and initialize related properties.
303      */
304     GridModelNG model;
305     model.Create(nullptr, nullptr);
306     ViewAbstract::SetWidth(CalcLength(GRID_WIDTH));
307     ViewAbstract::SetHeight(CalcLength(GRID_HEIGHT));
308     model.SetRowsTemplate("1fr 1fr");
309     model.SetRowsGap(Dimension(5));
310     UpdateLayoutInfo();
311     auto gridScrollLayoutAlgorithm = AceType::MakeRefPtr<GridScrollLayoutAlgorithm>(pattern_->gridLayoutInfo_, 2, 0);
312     auto ret1 = gridScrollLayoutAlgorithm->CalculateLargeItemOffset(OffsetF(0, 100), 1, 1, 0);
313     EXPECT_EQ(ret1.GetY(), 100.0f);
314     EXPECT_EQ(ret1.GetX(), 0.0f);
315 }
316 
317 /**
318  * @tc.name: GridScrollTest005
319  * @tc.desc: Test AdjustRowColSpan Function.
320  * @tc.type: FUNC
321  */
322 HWTEST_F(GridLayoutTestNg, GridScrollTest005, TestSize.Level1)
323 {
324     GridModelNG model = CreateGrid();
325     model.SetRowsTemplate("1fr 1fr");
326     GridItemModelNG itemModel;
327     itemModel.Create(GridItemStyle::NONE);
328     itemModel.SetRowStart(NULL_VALUE);
329     itemModel.SetRowEnd(NULL_VALUE);
330     itemModel.SetColumnStart(NULL_VALUE);
331     itemModel.SetColumnEnd(NULL_VALUE);
332     ViewStackProcessor::GetInstance()->Pop();
333     CreateDone(frameNode_);
334     auto layoutProperty = GetChildLayoutProperty<GridItemLayoutProperty>(frameNode_, 0);
335     EXPECT_EQ(layoutProperty->GetRowStart(), NULL_VALUE);
336     EXPECT_EQ(layoutProperty->GetRowEnd(), NULL_VALUE);
337     EXPECT_EQ(layoutProperty->GetColumnStart(), NULL_VALUE);
338     EXPECT_EQ(layoutProperty->GetColumnEnd(), NULL_VALUE);
339 }
340 
341 /**
342  * @tc.name: GetTotalHeight001
343  * @tc.desc: Test GetTotalHeight Function.
344  * @tc.type: FUNC
345  */
346 HWTEST_F(GridLayoutTestNg, GetTotalHeight001, TestSize.Level1)
347 {
348     /**
349      * @tc.steps: step1. Create 10 gridItem
350      */
351     GridModelNG model = CreateGrid();
352     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
353     CreateFixedItems(10);
354     CreateDone(frameNode_);
355     EXPECT_EQ(pattern_->GetTotalHeight(), ITEM_HEIGHT * 3);
356 
357     /**
358      * @tc.steps: step2. Create 20 gridItem
359      */
360     model = CreateGrid();
361     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
362     CreateFixedItems(20);
363     CreateDone(frameNode_);
364     EXPECT_EQ(pattern_->GetTotalHeight(), ITEM_HEIGHT * 5);
365 }
366 
367 /**
368  * @tc.name: GetAverageHeight001
369  * @tc.desc: Test GetAverageHeight Function.
370  * @tc.type: FUNC
371  */
372 HWTEST_F(GridLayoutTestNg, GetAverageHeight001, TestSize.Level1)
373 {
374     /**
375      * @tc.steps: step1. Create 10 gridItem
376      */
377     GridModelNG model = CreateGrid();
378     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
379     CreateFixedItems(10);
380     CreateDone(frameNode_);
381     EXPECT_EQ(pattern_->GetAverageHeight(), 60);
382 
383     /**
384      * @tc.steps: step2. Create 20 gridItem
385      */
386     ClearOldNodes();
387     model = CreateGrid();
388     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
389     CreateFixedItems(20);
390     CreateDone(frameNode_);
391     EXPECT_EQ(pattern_->GetAverageHeight(), 50);
392 }
393 
394 /**
395  * @tc.name: GridItemGetInnerFocusPaintRectTest001
396  * @tc.desc: GridItem GetInnerFocusPaintRect test.
397  * @tc.type: FUNC
398  */
399 HWTEST_F(GridLayoutTestNg, GridItemGetInnerFocusPaintRectTest001, TestSize.Level1)
400 {
401     CreateGrid();
402     CreateFixedItems(10);
403     CreateDone(frameNode_);
404     auto gridItemNode = GetChildFrameNode(frameNode_, 0);
405     auto focusHub = GetChildFocusHub(frameNode_, 0);
406     auto GetInnerFocusPaintRect = focusHub->getInnerFocusRectFunc_;
407 
408     /**
409      * @tc.steps: step1. Set paintRect when grid item does not have border radius.
410      * @tc.expected: Focus border radius is equal to 4.0_vp.
411      */
412     RoundRect paintRect;
413     GetInnerFocusPaintRect(paintRect);
414     EdgeF radius = paintRect.GetCornerRadius(RoundRect::CornerPos::TOP_LEFT_POS);
415     float expectRadius = GRIDITEM_FOCUS_INTERVAL.ConvertToPx();
416     EXPECT_EQ(radius.x, expectRadius);
417     EXPECT_EQ(radius.y, expectRadius);
418 
419     /**
420      * @tc.steps: step2. Set paintRect when grid item has border radius.
421      * @tc.expected: Focus border radius is equal to 11.0_vp.
422      */
423     auto renderContext = gridItemNode->GetRenderContext();
424     renderContext->UpdateBorderRadius({ BORDER_RADIUS, BORDER_RADIUS, BORDER_RADIUS, BORDER_RADIUS });
425     GetInnerFocusPaintRect(paintRect);
426     radius = paintRect.GetCornerRadius(RoundRect::CornerPos::TOP_LEFT_POS);
427     expectRadius = (GRIDITEM_FOCUS_INTERVAL + BORDER_RADIUS).ConvertToPx();
428     EXPECT_EQ(radius.x, expectRadius);
429     EXPECT_EQ(radius.y, expectRadius);
430 }
431 
432 /**
433  * @tc.name: SearchIrregularFocusableChildInNormalGrid001
434  * @tc.desc: Test ability of a fixed shape grid to obtain irregular shape focal item.
435  * @tc.type: FUNC
436  */
437 HWTEST_F(GridLayoutTestNg, SearchIrregularFocusableChildInNormalGrid001, TestSize.Level1)
438 {
439     /**
440      * @tc.steps: step1. Create gridItems with irregular shape in fixed shape grid.
441      */
442     GridModelNG model = CreateGrid();
443     model.SetRowsTemplate("1fr 1fr 1fr 1fr");
444     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
445     CreateBigItem(1, 2, 1, 2);
446     CreateFocusableGridItems(10, ITEM_WIDTH, ITEM_HEIGHT);
447     CreateDone(frameNode_);
448 
449     /**
450      * @tc.steps: step2. Find target child with specified index parameters.
451      * @tc.expected: Can find the target focus child.
452      */
453     int32_t tarMainIndex = 1;
454     int32_t tarCrossIndex = 1;
455     pattern_->isLeftStep_ = true;
456     auto IrregularFocusableChild = pattern_->SearchIrregularFocusableChild(tarMainIndex, tarCrossIndex);
457     RefPtr<FocusHub> result = IrregularFocusableChild.Upgrade();
458     EXPECT_NE(result, nullptr);
459     pattern_->isLeftStep_ = false;
460 
461     /**
462      * @tc.steps: step3. Call the function when isRightStep_ is true.
463      * @tc.expected: Can find the target focus child.
464      */
465     pattern_->isRightStep_ = true;
466     IrregularFocusableChild = pattern_->SearchIrregularFocusableChild(tarMainIndex, tarCrossIndex);
467     result = IrregularFocusableChild.Upgrade();
468     EXPECT_NE(result, nullptr);
469     pattern_->isRightStep_ = false;
470 
471     /**
472      * @tc.steps: step4. Call the function when isUpStep_ is true.
473      * @tc.expected: Can find the target focus child.
474      */
475     pattern_->isUpStep_ = true;
476     IrregularFocusableChild = pattern_->SearchIrregularFocusableChild(tarMainIndex, tarCrossIndex);
477     result = IrregularFocusableChild.Upgrade();
478     EXPECT_NE(result, nullptr);
479     pattern_->isUpStep_ = false;
480 
481     /**
482      * @tc.steps: step5. Call the function when isDownStep_ is true.
483      * @tc.expected: Can find the target focus child.
484      */
485     pattern_->isDownStep_ = true;
486     IrregularFocusableChild = pattern_->SearchIrregularFocusableChild(tarMainIndex, tarCrossIndex);
487     result = IrregularFocusableChild.Upgrade();
488     EXPECT_NE(result, nullptr);
489     pattern_->isDownStep_ = false;
490 }
491 
492 /**
493  * @tc.name: ChangeItemNumber001
494  * @tc.desc: Test ChangeItemNumber
495  * @tc.type: FUNC
496  */
497 HWTEST_F(GridLayoutTestNg, ChangeItemNumber001, TestSize.Level1)
498 {
499     GridModelNG model = CreateGrid();
500     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
501     CreateFixedItems(5);
502     CreateDone(frameNode_);
503 
504     /**
505      * @tc.steps: step1. Add item
506      * @tc.expected: The added item in the correct position
507      */
508     for (int32_t i = 0; i < 4; i++) {
509         GridItemModelNG itemModel;
510         itemModel.Create(GridItemStyle::NONE);
511         ViewAbstract::SetHeight(CalcLength(Dimension(ITEM_HEIGHT)));
512         RefPtr<UINode> currentNode = ViewStackProcessor::GetInstance()->Finish();
513         auto currentFrameNode = AceType::DynamicCast<FrameNode>(currentNode);
514         currentFrameNode->MountToParent(frameNode_);
515     }
516     frameNode_->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
517     FlushLayoutTask(frameNode_);
518     EXPECT_TRUE(IsEqual(GetChildOffset(frameNode_, 6), OffsetF(ITEM_WIDTH * 2, ITEM_HEIGHT)));
519     EXPECT_TRUE(IsEqual(GetChildOffset(frameNode_, 8), OffsetF(0, ITEM_HEIGHT * 2)));
520 }
521 
522 /**
523  * @tc.name: ItemAboveViewport001
524  * @tc.desc: Test GridLayoutInfo::ItemAboveViewport
525  * @tc.type: FUNC
526  */
527 HWTEST_F(GridLayoutTestNg, ItemAboveViewport001, TestSize.Level1)
528 {
529     GridLayoutInfo info;
530     info.gridMatrix_ = {
531         { 0, { { 0, 0 }, { 1, 1 } } },
532         { 1, { { 0, 2 }, { 1, 3 } } },
533         { 2, { { 0, 4 }, { 1, 5 } } },
534     };
535     info.lineHeightMap_ = { { 0, 200.0f }, { 1, 500.0f }, { 2, 300.0f } };
536     info.crossCount_ = 2;
537 
538     info.startMainLineIndex_ = 0;
539     info.endMainLineIndex_ = 2;
540     info.startIndex_ = 0;
541     info.endIndex_ = 5;
542 
543     info.currentOffset_ = 0.0f;
544     EXPECT_FALSE(Negative(info.GetItemTopPos(0, 5.0f)));
545 
546     info.currentOffset_ = -50.0f;
547     EXPECT_TRUE(Negative(info.GetItemTopPos(0, 5.0f)));
548 
549     info.currentOffset_ = -200.0f;
550     EXPECT_TRUE(Negative(info.GetItemTopPos(0, 5.0f)));
551     EXPECT_FALSE(Negative(info.GetItemTopPos(1, 5.0f)));
552 
553     // adding gap length
554     info.currentOffset_ = -205.0f;
555     EXPECT_TRUE(Negative(info.GetItemTopPos(0, 5.0f)));
556     EXPECT_FALSE(Negative(info.GetItemTopPos(1, 5.0f)));
557 
558     EXPECT_TRUE(Negative(info.GetItemTopPos(1, 0.0f)));
559 
560     info.startMainLineIndex_ = 1;
561     info.endMainLineIndex_ = 1;
562     info.startIndex_ = 2;
563     info.endIndex_ = 3;
564 
565     info.currentOffset_ = 0.0f;
566     EXPECT_FALSE(Negative(info.GetItemTopPos(1, 5.0f)));
567 
568     info.currentOffset_ = -1.0f;
569     EXPECT_TRUE(Negative(info.GetItemTopPos(1, 5.0f)));
570 }
571 
572 /**
573  * @tc.name: ItemBelowViewport001
574  * @tc.desc: Test GridLayoutInfo::ItemBelowViewport
575  * @tc.type: FUNC
576  */
577 HWTEST_F(GridLayoutTestNg, ItemBelowViewport001, TestSize.Level1)
578 {
579     GridLayoutInfo info;
580     info.gridMatrix_ = {
581         { 0, { { 0, 0 }, { 1, 1 } } },
582         { 1, { { 0, 2 }, { 1, 3 } } },
583         { 2, { { 0, 4 }, { 1, -1 } } },
584     };
585     info.lineHeightMap_ = { { 0, 200.0f }, { 1, 500.0f }, { 2, 300.0f } };
586     info.crossCount_ = 2;
587 
588     info.startMainLineIndex_ = 0;
589     info.endMainLineIndex_ = 2;
590     info.startIndex_ = 0;
591     info.endIndex_ = 4;
592 
593     info.currentOffset_ = 0.0f;
594     EXPECT_TRUE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 100.0f));
595     EXPECT_TRUE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 700.0f));
596     EXPECT_TRUE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 705.0f));
597     EXPECT_TRUE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 710.0f));
598     EXPECT_TRUE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 1005.0f));
599     EXPECT_FALSE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 1010.0f));
600 
601     info.currentOffset_ = -50.0f;
602     EXPECT_TRUE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 100.0f));
603     EXPECT_TRUE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 700.0f));
604     EXPECT_TRUE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 705.0f));
605     EXPECT_TRUE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 710.0f));
606     EXPECT_TRUE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 955.0f));
607     EXPECT_FALSE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 960.0f));
608     EXPECT_FALSE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 1005.0f));
609     EXPECT_FALSE(GreatNotEqual(info.GetItemBottomPos(1, 2, 5.0f), 1010.0f));
610 }
611 
612 /**
613  * @tc.name: UpdateGridMatrix001
614  * @tc.desc: Test UpdateGridMatrix
615  * @tc.type: FUNC
616  */
617 HWTEST_F(GridLayoutTestNg, UpdateGridMatrix001, TestSize.Level1)
618 {
619     /**
620      * @tc.steps: step1. Create 100 items
621      * @tc.expected: The added item in the correct position
622      */
623     GridModelNG model = CreateGrid();
624     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
625     CreateGridItems(100, ITEM_WIDTH, NULL_VALUE, GridItemStyle::NONE);
626     CreateDone(frameNode_);
627 
628     /**
629      * @tc.steps: step2. Scroll To 99 item
630      * @tc.expected: Scroll to the correct position,lineHeightMap_ size is 25
631      */
632     pattern_->ScrollToIndex(99, true, ScrollAlign::END);
633     EXPECT_TRUE(IsEqual<int32_t>(pattern_->gridLayoutInfo_.lineHeightMap_.size(), 25));
634 }
635 
636 /**
637  * @tc.name: GridLayout001
638  * @tc.desc: Test GridLayoutAlgorithm for coverage
639  * @tc.type: FUNC
640  */
641 HWTEST_F(GridLayoutTestNg, GridLayout001, TestSize.Level1)
642 {
643     GridModelNG model = CreateGrid();
644     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
645     model.SetRowsTemplate("1fr 1fr 1fr 1fr");
646     CreateFixedItems(16);
647     CreateDone(frameNode_);
648 
649     /**
650      * @tc.steps: step1. call InitGridCeils
651      * @tc.expected: The GetLayoutProperty is !nullptr
652      */
653     auto pattern = frameNode_->GetPattern<GridPattern>();
654     auto algorithm = AceType::MakeRefPtr<GridLayoutAlgorithm>(GridLayoutInfo {}, 4, 4);
655     algorithm->InitGridCeils(AceType::RawPtr(frameNode_), { 0.0f, 0.0f });
656     algorithm->crossCount_ = 5;
657     algorithm->mainCount_ = 5;
658     algorithm->InitGridCeils(AceType::RawPtr(frameNode_), { 0.0f, 0.0f });
659     EXPECT_NE(pattern->GetLayoutProperty<GridLayoutProperty>(), nullptr);
660 }
661 
662 /**
663  * @tc.name: GridLayout002
664  * @tc.desc: Test GridLayoutAlgorithm for coverage
665  * @tc.type: FUNC
666  */
667 HWTEST_F(GridLayoutTestNg, GridLayout002, TestSize.Level1)
668 {
669     GridModelNG model = CreateGrid();
670     model.SetColumnsTemplate("");
671     model.SetRowsTemplate("");
672     CreateFixedItems(16);
673     CreateDone(frameNode_);
674 
675     /**
676      * @tc.steps: step1. Change to smaller mainSize
677      * @tc.expected: The GetLayoutProperty is correct
678      */
679     auto pattern = frameNode_->GetPattern<GridPattern>();
680     auto algorithm = AceType::MakeRefPtr<GridLayoutAlgorithm>(GridLayoutInfo {}, 4, 4);
681     algorithm->InitGridCeils(AceType::RawPtr(frameNode_), { 0.0f, 0.0f });
682     algorithm->crossCount_ = 5;
683     algorithm->mainCount_ = 5;
684     algorithm->InitGridCeils(AceType::RawPtr(frameNode_), { 0.0f, 0.0f });
685     EXPECT_NE(pattern->GetLayoutProperty<GridLayoutProperty>(), nullptr);
686 }
687 
688 /**
689  * @tc.name: GridLayout003
690  * @tc.desc: Test GridLayoutAlgorithm for coverage
691  * @tc.type: FUNC
692  */
693 HWTEST_F(GridLayoutTestNg, GridLayout003, TestSize.Level1)
694 {
695     GridModelNG model = CreateGrid();
696     std::string emptyString;
697     model.SetColumnsTemplate(emptyString);
698     model.SetRowsTemplate(emptyString);
699     CreateFixedItems(16);
700     CreateDone(frameNode_);
701 
702     /**
703      * @tc.steps: step1. Change to smaller mainSize
704      * @tc.expected: The GetLayoutProperty is correct
705      */
706     auto pattern = frameNode_->GetPattern<GridPattern>();
707     auto algorithm = AceType::MakeRefPtr<GridLayoutAlgorithm>(GridLayoutInfo {}, 4, 4);
708     algorithm->gridLayoutInfo_.currentOffset_ = 0.0f;
709     auto layoutProperty = pattern->CreateLayoutProperty();
710     algorithm->InitGridCeils(AceType::RawPtr(frameNode_), { 0.0f, 0.0f });
711     algorithm->crossCount_ = 5;
712     algorithm->mainCount_ = 5;
713     algorithm->InitGridCeils(AceType::RawPtr(frameNode_), { 0.0f, 0.0f });
714     EXPECT_NE(layoutProperty, nullptr);
715 }
716 
717 /**
718  * @tc.name: GridLayout004
719  * @tc.desc: Test GridLayoutAlgorithm for coverage
720  * @tc.type: FUNC
721  */
722 HWTEST_F(GridLayoutTestNg, GridLayout004, TestSize.Level1)
723 {
724     GridModelNG model = CreateGrid();
725     model.SetColumnsTemplate("1fr 1fr");
726     CreateFixedItems(10);
727     CreateDone(frameNode_);
728 
729     /**
730      * @tc.steps: step1. isVertical_ is true
731      * @tc.expected: The curRow and curCol is correct
732      */
733     int32_t curRow = 0;
734     int32_t curCol = 0;
735     auto pattern = frameNode_->GetPattern<GridPattern>();
736     auto algorithm = AceType::MakeRefPtr<GridLayoutAlgorithm>(GridLayoutInfo {}, 2, 5);
737     EXPECT_EQ(algorithm->crossCount_, 2);
738     EXPECT_EQ(algorithm->mainCount_, 5);
739     algorithm->GetNextGrid(curRow, curCol);
740     EXPECT_EQ(curRow, 0);
741     EXPECT_EQ(curCol, 1);
742     EXPECT_TRUE(algorithm->isVertical_);
743     algorithm->GetNextGrid(curRow, curCol);
744     EXPECT_EQ(curRow, 1);
745     EXPECT_EQ(curCol, 0);
746     curRow = 1;
747     curCol = 1;
748 
749     /**
750      * @tc.steps: step2. isVertical_ is false
751      * @tc.expected: The curRow and curCol is correct
752      */
753     algorithm->isVertical_ = false;
754     algorithm->GetNextGrid(curRow, curCol);
755     EXPECT_EQ(curRow, 2);
756     EXPECT_EQ(curCol, 1);
757     algorithm->GetNextGrid(curRow, curCol);
758     EXPECT_EQ(curRow, 3);
759     EXPECT_EQ(curCol, 1);
760     curRow = 5;
761     algorithm->GetNextGrid(curRow, curCol);
762     EXPECT_EQ(curRow, 0);
763     EXPECT_EQ(curCol, 2);
764 }
765 
766 /**
767  * @tc.name: UpdateOverlayModifier001
768  * @tc.desc: Test grid paint method UpdateOverlayModifier function
769  * @tc.type: FUNC
770  */
771 HWTEST_F(GridLayoutTestNg, UpdateOverlayModifier001, TestSize.Level1)
772 {
773     GridModelNG model = CreateGrid();
774     model.SetRowsTemplate("1fr 1fr");
775     CreateFixedItems(10);
776     CreateDone(frameNode_);
777 
778     /**
779      * @tc.steps: step1. create paintMethod
780      */
781     auto paintMethod = AceType::DynamicCast<GridPaintMethod>(pattern_->CreateNodePaintMethod());
782     auto paintProperty = pattern_->CreatePaintProperty();
783     PaintWrapper paintWrapper(frameNode_->GetRenderContext(), frameNode_->GetGeometryNode(), paintProperty);
784     paintMethod->UpdateOverlayModifier(nullptr);
785 
786     /**
787      * @tc.steps: step2. call UpdateOverlayModifier
788      * @tc.expected: scrollBar is nullptr
789      */
790     paintMethod->UpdateOverlayModifier(&paintWrapper);
791     auto scrollBar = paintMethod->scrollBar_.Upgrade();
792     EXPECT_EQ(scrollBar, nullptr);
793 }
794 
795 /**
796  * @tc.name: UpdateOverlayModifier002
797  * @tc.desc: Test grid paint method UpdateOverlayModifier function
798  * @tc.type: FUNC
799  */
800 HWTEST_F(GridLayoutTestNg, UpdateOverlayModifier002, TestSize.Level1)
801 {
802     GridModelNG model = CreateGrid();
803     model.SetRowsTemplate("1fr 1fr");
804     CreateFixedItems(10);
805     CreateDone(frameNode_);
806 
807     /**
808      * @tc.steps: step1. create scrollBar and paintMethod
809      * @tc.expected: scrollBar is !nullptr
810      */
811     pattern_->scrollBar_ = AceType::MakeRefPtr<ScrollBar>(DisplayMode::AUTO);
812     auto paintMethod = AceType::DynamicCast<GridPaintMethod>(pattern_->CreateNodePaintMethod());
813     auto paintProperty = pattern_->CreatePaintProperty();
814     PaintWrapper paintWrapper(frameNode_->GetRenderContext(), frameNode_->GetGeometryNode(), paintProperty);
815     paintMethod->UpdateOverlayModifier(nullptr);
816     auto scrollBar = paintMethod->scrollBar_.Upgrade();
817     EXPECT_NE(scrollBar, nullptr);
818 
819     /**
820      * @tc.steps: step2. call UpdateOverlayModifier
821      * @tc.expected: AnimationTyp is correct
822      */
823     paintMethod->UpdateOverlayModifier(&paintWrapper);
824     EXPECT_EQ(scrollBar->GetOpacityAnimationType(), OpacityAnimationType::NONE);
825     EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
826 
827     /**
828      * @tc.steps: step3. call UpdateOverlayModifier when scrollBarOverlayModifier is seted
829      * @tc.expected: AnimationTyp is correct
830      */
831     pattern_->CreateScrollBarOverlayModifier();
832     EXPECT_EQ(pattern_->scrollBarOverlayModifier_, nullptr);
833     paintMethod->SetScrollBarOverlayModifier(pattern_->GetScrollBarOverlayModifier());
834     auto scrollBarOverlayModifier = paintMethod->scrollBarOverlayModifier_.Upgrade();
835     EXPECT_EQ(scrollBarOverlayModifier, nullptr);
836     paintMethod->UpdateOverlayModifier(&paintWrapper);
837     EXPECT_EQ(scrollBar->GetOpacityAnimationType(), OpacityAnimationType::NONE);
838     EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
839     scrollBar = nullptr;
840 }
841 
842 /**
843  * @tc.name: UpdateOverlayModifier003
844  * @tc.desc: Test grid paint method UpdateOverlayModifier function
845  * @tc.type: FUNC
846  */
847 HWTEST_F(GridLayoutTestNg, UpdateOverlayModifier003, TestSize.Level1)
848 {
849     GridModelNG model = CreateGrid();
850     model.SetRowsTemplate("1fr 1fr");
851     CreateFixedItems(10);
852     CreateDone(frameNode_);
853 
854     /**
855      * @tc.steps: step1. create scrollBar and paintMethod and ScrollBarOverlayModifier
856      * @tc.expected: scrollBar is !nullptr
857      */
858     pattern_->scrollBar_ = AceType::MakeRefPtr<ScrollBar>(DisplayMode::AUTO);
859     pattern_->scrollBar_->SetScrollable(true);
860     auto paintMethod = AceType::DynamicCast<GridPaintMethod>(pattern_->CreateNodePaintMethod());
861     auto paintProperty = pattern_->CreatePaintProperty();
862     PaintWrapper paintWrapper(frameNode_->GetRenderContext(), frameNode_->GetGeometryNode(), paintProperty);
863     EXPECT_TRUE(pattern_->scrollBar_->NeedPaint());
864     pattern_->CreateScrollBarOverlayModifier();
865     EXPECT_NE(pattern_->scrollBarOverlayModifier_, nullptr);
866     paintMethod->SetScrollBarOverlayModifier(pattern_->GetScrollBarOverlayModifier());
867     auto scrollBarOverlayModifier = paintMethod->scrollBarOverlayModifier_.Upgrade();
868     EXPECT_NE(scrollBarOverlayModifier, nullptr);
869     auto scrollBar = paintMethod->scrollBar_.Upgrade();
870     EXPECT_NE(scrollBar, nullptr);
871 
872     /**
873      * @tc.steps: step2. call UpdateOverlayModifier
874      * @tc.expected: AnimationTyp is correct
875      */
876     paintMethod->UpdateOverlayModifier(&paintWrapper);
877     EXPECT_EQ(scrollBar->GetOpacityAnimationType(), OpacityAnimationType::NONE);
878     EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
879 
880     /**
881      * @tc.steps: step3. change PositionMode and call UpdateOverlayModifier
882      * @tc.expected: AnimationTyp is correct
883      */
884     scrollBar->SetPositionMode(PositionMode::BOTTOM);
885     paintMethod->UpdateOverlayModifier(&paintWrapper);
886     scrollBar = paintMethod->scrollBar_.Upgrade();
887     EXPECT_EQ(scrollBar->GetOpacityAnimationType(), OpacityAnimationType::NONE);
888     EXPECT_EQ(scrollBar->GetHoverAnimationType(), HoverAnimationType::NONE);
889     scrollBar = nullptr;
890 }
891 
892 /**
893  * @tc.name: PaintEdgeEffect001
894  * @tc.desc: Test grid paint method PaintEdgeEffect function
895  * @tc.type: FUNC
896  */
897 HWTEST_F(GridLayoutTestNg, PaintEdgeEffect001, TestSize.Level1)
898 {
899     GridModelNG model = CreateGrid();
900     model.SetRowsTemplate("1fr 1fr");
901     CreateFixedItems(10);
902     CreateDone(frameNode_);
903 
904     /**
905      * @tc.steps: step1. init scrollBar
906      * @tc.expected: scrollBar is !nullptr
907      */
908     pattern_->scrollBar_ = AceType::MakeRefPtr<ScrollBar>(DisplayMode::AUTO);
909     pattern_->scrollBar_->SetScrollable(true);
910     auto paintMethod = AceType::DynamicCast<GridPaintMethod>(pattern_->CreateNodePaintMethod());
911     auto paintProperty = pattern_->CreatePaintProperty();
912     PaintWrapper paintWrapper(frameNode_->GetRenderContext(), frameNode_->GetGeometryNode(), paintProperty);
913     EXPECT_TRUE(pattern_->scrollBar_->NeedPaint());
914     pattern_->CreateScrollBarOverlayModifier();
915     EXPECT_NE(pattern_->scrollBarOverlayModifier_, nullptr);
916     paintMethod->SetScrollBarOverlayModifier(pattern_->GetScrollBarOverlayModifier());
917     auto scrollBarOverlayModifier = paintMethod->scrollBarOverlayModifier_.Upgrade();
918     EXPECT_NE(scrollBarOverlayModifier, nullptr);
919     auto scrollBar = paintMethod->scrollBar_.Upgrade();
920     EXPECT_NE(scrollBar, nullptr);
921 
922     /**
923      * @tc.steps: step2. call PaintEdgeEffect
924      * @tc.expected: edgeEffect_ is !nullptr
925      */
926     auto scrollEdgeEffect = AceType::MakeRefPtr<ScrollEdgeEffect>();
927     paintMethod->SetEdgeEffect(scrollEdgeEffect);
928     Testing::MockCanvas rsCanvas;
929     EXPECT_CALL(rsCanvas, DetachPen()).WillRepeatedly(ReturnRef(rsCanvas));
930     EXPECT_CALL(rsCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rsCanvas));
931     EXPECT_CALL(rsCanvas, DrawRect(_)).WillRepeatedly(Return());
932     EXPECT_CALL(rsCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rsCanvas));
933     paintMethod->PaintEdgeEffect(nullptr, rsCanvas);
934     paintMethod->PaintEdgeEffect(&paintWrapper, rsCanvas);
935     EXPECT_NE(paintMethod->edgeEffect_.Upgrade(), nullptr);
936 }
937 
938 /**
939  * @tc.name: GridScrollTest006
940  * @tc.desc: Test SetOnScrollBarUpdate Function.
941  * @tc.type: FUNC
942  */
943 HWTEST_F(GridLayoutTestNg, GridScrollTest006, TestSize.Level1)
944 {
945     GridModelNG model = CreateGrid();
__anon80cf7a3e0302(int32_t index, Dimension offset) 946     ScrollBarUpdateFunc scrollFunc = [](int32_t index, Dimension offset) {
947         std::optional<float> horizontalOffset = offset.ConvertToPx();
948         std::optional<float> verticalOffset = offset.ConvertToPx();
949         return std::make_pair(horizontalOffset, verticalOffset);
950     };
951     model.SetRowsTemplate("1fr 1fr");
952     CreateFixedItems(2);
953     model.SetGridHeight(Dimension(5));
954     model.SetScrollBarMode(DisplayMode::AUTO);
955     model.SetScrollBarColor("#FF0000");
956     model.SetScrollBarWidth("10vp");
957     model.SetIsRTL(TextDirection::LTR);
958 
959     NestedScrollOptions nestedOpt;
960     model.SetNestedScroll(std::move(nestedOpt));
961     ScrollToIndexFunc value;
962     model.SetOnScrollToIndex(std::move(value));
963     CreateDone(frameNode_);
964     auto paintProperty = frameNode_->GetPaintProperty<ScrollablePaintProperty>();
965     EXPECT_EQ(paintProperty->GetBarStateString(), "BarState.Auto");
966 
967     auto pattern = frameNode_->GetPattern<GridPattern>();
968     EXPECT_TRUE(pattern->isConfigScrollable_);
969     auto eventHub = frameNode_->GetEventHub<GridEventHub>();
970     EXPECT_FALSE(eventHub->onScrollToIndex_);
971 }
972 
973 /**
974  * @tc.name: GridSCroll001
975  * @tc.desc: Test SetSelected Function.
976  * @tc.type: FUNC
977  */
978 HWTEST_F(GridLayoutTestNg, GridSCroll001, TestSize.Level1)
979 {
980     /**
981      * @tc.steps: step1. Create GridItemModelNG object
982      */
983     GridModelNG model = CreateGrid();
984     model.SetRowsTemplate("1fr 1fr");
985     GridItemModelNG itemModel;
986     itemModel.Create(GridItemStyle::NONE);
987     itemModel.SetRowStart(NULL_VALUE);
988     itemModel.SetRowEnd(NULL_VALUE);
989     itemModel.SetColumnStart(NULL_VALUE);
990     itemModel.SetColumnEnd(NULL_VALUE);
991     ViewStackProcessor::GetInstance()->Pop();
992 
993     /**
994      * @tc.steps: step2. Test Create function
995      */
__anon80cf7a3e0402(int32_t innerNodeId) 996     std::function<void(int32_t)> deepRenderFunc = [](int32_t innerNodeId) {};
997     bool isLazy = true;
998     itemModel.Create(std::move(deepRenderFunc), isLazy, GridItemStyle::PLAIN);
999 
1000     /**
1001      * @tc.steps: step3. invoke SetSelected function
1002      */
1003     itemModel.SetSelected(true);
1004     CreateDone(frameNode_);
1005 
1006     /**
1007      * @tc.expected: gridItemPattern->isSelected_ is true
1008      */
1009     auto gridItemPattern = GetChildPattern<GridItemPattern>(frameNode_, 1);
1010     EXPECT_TRUE(gridItemPattern->isSelected_);
1011 }
1012 
1013 /**
1014  * @tc.name: SupplyAllData2ZeroIndex001
1015  * @tc.desc: Test GridScrollLayoutAlgorithm::SupplyAllData2ZeroIndex
1016  * @tc.type: FUNC
1017  */
1018 HWTEST_F(GridLayoutTestNg, SupplyAllData2ZeroIndex001, TestSize.Level1)
1019 {
1020     GridModelNG model = CreateGrid();
1021     model.SetColumnsTemplate("1fr 1fr 1fr");
1022     CreateFixedItems(30);
1023     CreateDone(frameNode_);
1024 
1025     pattern_->ScrollToIndex(20, true, ScrollAlign::END);
1026     FlushLayoutTask(frameNode_);
1027 
1028     EXPECT_EQ(pattern_->GetGridLayoutInfo().gridMatrix_.size(), 4);
1029     EXPECT_EQ(pattern_->GetGridLayoutInfo().lineHeightMap_.size(), 4);
1030     EXPECT_EQ(pattern_->GetGridLayoutInfo().gridMatrix_.at(0).at(0), 0);
1031     EXPECT_EQ(pattern_->GetGridLayoutInfo().gridMatrix_.at(3).at(2), 11);
1032 }
1033 
1034 /**
1035  * @tc.name: SupplyAllData2ZeroIndex002
1036  * @tc.desc: Test GridScrollLayoutAlgorithm::SupplyAllData2ZeroIndex
1037  * @tc.type: FUNC
1038  */
1039 HWTEST_F(GridLayoutTestNg, SupplyAllData2ZeroIndex002, TestSize.Level1)
1040 {
1041     GridModelNG model = CreateGrid();
1042     model.SetColumnsTemplate("1fr 1fr 1fr");
1043     CreateFixedItems(30);
1044     CreateDone(frameNode_);
1045 
1046     pattern_->ScrollToIndex(20, true, ScrollAlign::START);
1047     FlushLayoutTask(frameNode_);
1048     pattern_->ScrollToIndex(10, true, ScrollAlign::CENTER);
1049     FlushLayoutTask(frameNode_);
1050 
1051     EXPECT_EQ(pattern_->GetGridLayoutInfo().gridMatrix_.size(), 4);
1052     EXPECT_EQ(pattern_->GetGridLayoutInfo().lineHeightMap_.size(), 4);
1053     EXPECT_EQ(pattern_->GetGridLayoutInfo().gridMatrix_.at(0).at(0), 0);
1054     EXPECT_EQ(pattern_->GetGridLayoutInfo().gridMatrix_.at(3).at(2), 11);
1055 }
1056 
1057 /**
1058  * @tc.name: OnModifyDone001
1059  * @tc.desc: Test OnModifyDone
1060  * @tc.type: FUNC
1061  */
1062 HWTEST_F(GridLayoutTestNg, OnModifyDone001, TestSize.Level1)
1063 {
1064     /**
1065      * @tc.steps: step1. Test OnModifyDone
1066      */
1067     GridModelNG model = CreateGrid();
1068     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
1069     model.SetMultiSelectable(true);
1070     CreateFixedItems(10);
1071     CreateDone(frameNode_);
1072     auto paintProperty = pattern_->GetPaintProperty<ScrollablePaintProperty>();
1073     EXPECT_TRUE(pattern_->multiSelectable_);
1074     EXPECT_TRUE(pattern_->isMouseEventInit_);
1075     EXPECT_TRUE(pattern_->GetScrollableEvent());
1076     EXPECT_TRUE(paintProperty->GetScrollBarProperty());
1077     EXPECT_TRUE(frameNode_->GetFocusHub());
1078     EXPECT_TRUE(pattern_->GetScrollableEvent()->GetScrollable());
1079     EXPECT_TRUE(pattern_->IsNeedInitClickEventRecorder());
1080 
1081     /**
1082      * @tc.steps: step2. Call OnModifyDone
1083      */
1084     pattern_->OnModifyDone();
1085     EXPECT_TRUE(pattern_->multiSelectable_);
1086     EXPECT_TRUE(pattern_->isMouseEventInit_);
1087     EXPECT_TRUE(pattern_->GetScrollableEvent());
1088     EXPECT_TRUE(paintProperty->GetScrollBarProperty());
1089     EXPECT_TRUE(frameNode_->GetFocusHub());
1090     EXPECT_TRUE(pattern_->GetScrollableEvent()->GetScrollable());
1091     EXPECT_TRUE(pattern_->IsNeedInitClickEventRecorder());
1092 
1093     /**
1094      * @tc.steps: step3. Change MultiSelectable and Call OnModifyDone
1095      */
1096     pattern_->SetMultiSelectable(false);
1097     pattern_->OnModifyDone();
1098     EXPECT_FALSE(pattern_->multiSelectable_);
1099     EXPECT_FALSE(pattern_->isMouseEventInit_);
1100 }
1101 
1102 /**
1103  * @tc.name: GetEndOffset001
1104  * @tc.desc: Test GetEndOffset
1105  * @tc.type: FUNC
1106  */
1107 HWTEST_F(GridLayoutTestNg, GetEndOffset001, TestSize.Level1)
1108 {
1109     GridModelNG model = CreateGrid();
1110     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
1111     CreateFixedItems(10);
1112     CreateDone(frameNode_);
1113     EXPECT_EQ(pattern_->GetEndOffset(), ITEM_HEIGHT);
1114 }
1115 
1116 /**
1117  * @tc.name: GetEndOffset002
1118  * @tc.desc: Test GetEndOffset
1119  * @tc.type: FUNC
1120  */
1121 HWTEST_F(GridLayoutTestNg, GetEndOffset002, TestSize.Level1)
1122 {
1123     GridModelNG model = CreateGrid();
1124     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
1125     CreateFixedItems(10);
1126     CreateDone(frameNode_);
1127     pattern_->SetEdgeEffect(EdgeEffect::SPRING, true);
1128     EXPECT_EQ(pattern_->GetEndOffset(), 0.f);
1129 }
1130 
1131 /**
1132  * @tc.name: GetEndOffset003
1133  * @tc.desc: Test GetEndOffset
1134  * @tc.type: FUNC
1135  */
1136 HWTEST_F(GridLayoutTestNg, GetEndOffset003, TestSize.Level1)
1137 {
1138     GridModelNG model = CreateGrid();
1139     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
1140     CreateFixedItems(20);
1141     CreateDone(frameNode_);
1142     pattern_->SetEdgeEffect(EdgeEffect::SPRING, true);
1143     EXPECT_EQ(pattern_->GetEndOffset(), 0.f);
1144 }
1145 
1146 /**
1147  * @tc.name: GetVisibleSelectedItems001
1148  * @tc.desc: Test GetVisibleSelectedItems
1149  * @tc.type: FUNC
1150  */
1151 HWTEST_F(GridLayoutTestNg, GetVisibleSelectedItems001, TestSize.Level1)
1152 {
1153     /**
1154      * @tc.cases: Set item(index:1) isSelected and call GetVisibleSelectedItems
1155      * @tc.expected: Has 1 item selected
1156      */
1157     GridModelNG model = CreateGrid();
1158     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
1159     CreateFixedItems(20);
1160     CreateDone(frameNode_);
1161     GetChildPattern<GridItemPattern>(frameNode_, 1)->SetSelected(true);
1162     EXPECT_EQ(pattern_->GetVisibleSelectedItems().size(), 1);
1163     EXPECT_FALSE(pattern_->irregular_);
1164 }
1165 
1166 /**
1167  * @tc.name: AdaptToChildMainSize001
1168  * @tc.desc: Test AdaptToChildMainSize
1169  * @tc.type: FUNC
1170  */
1171 HWTEST_F(GridLayoutTestNg, AdaptToChildMainSize001, TestSize.Level1)
1172 {
1173     /**
1174      * @tc.cases: Set ColumnsTemplate, not set grid height
1175      */
1176     GridModelNG model;
1177     RefPtr<ScrollControllerBase> positionController = model.CreatePositionController();
1178     RefPtr<ScrollProxy> scrollBarProxy = model.CreateScrollBarProxy();
1179     model.Create(positionController, scrollBarProxy);
1180     ViewAbstract::SetWidth(CalcLength(GRID_WIDTH));
1181     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
1182     model.SetCellLength(ITEM_HEIGHT);
1183     model.SetMaxCount(4);
1184     CreateFixedItems(20);
1185     GetGrid();
1186     CreateDone(frameNode_);
1187     EXPECT_EQ(pattern_->GetGridLayoutInfo().lastMainSize_, 1000.f);
1188 }
1189 
1190 /**
1191  * @tc.name: AdaptToChildMainSize002
1192  * @tc.desc: Test AdaptToChildMainSize
1193  * @tc.type: FUNC
1194  */
1195 HWTEST_F(GridLayoutTestNg, AdaptToChildMainSize002, TestSize.Level1)
1196 {
1197     /**
1198      * @tc.cases: Set RowsTemplate, not set grid width
1199      */
1200     GridModelNG model;
1201     RefPtr<ScrollControllerBase> positionController = model.CreatePositionController();
1202     RefPtr<ScrollProxy> scrollBarProxy = model.CreateScrollBarProxy();
1203     model.Create(positionController, scrollBarProxy);
1204     ViewAbstract::SetHeight(CalcLength(GRID_HEIGHT));
1205     model.SetRowsTemplate("1fr 1fr 1fr 1fr");
1206     model.SetCellLength(ITEM_WIDTH);
1207     model.SetMaxCount(4);
1208     CreateFixedItems(20);
1209     GetGrid();
1210     CreateDone(frameNode_);
1211     EXPECT_EQ(pattern_->GetGridLayoutInfo().lastMainSize_, 600.f);
1212 }
1213 
1214 /**
1215  * @tc.name: LayoutCachedItem001
1216  * @tc.desc: Test LayoutCachedItem
1217  * @tc.type: FUNC
1218  */
1219 HWTEST_F(GridLayoutTestNg, LayoutCachedItem001, TestSize.Level1)
1220 {
1221     /**
1222      * @tc.steps: step1. Set CachedCount:1
1223      * @tc.expected: The item(index:16) below view is active, no item above view
1224      */
1225     GridModelNG model = CreateGrid();
1226     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
1227     model.SetCachedCount(1);
1228     CreateFixedItems(40);
1229     CreateDone(frameNode_);
1230     EXPECT_FALSE(GetChildFrameNode(frameNode_, 16)->IsActive()); // the fifth row
1231     EXPECT_FALSE(GetChildFrameNode(frameNode_, 20)->IsActive()); // the sixth row
1232 
1233     /**
1234      * @tc.steps: step2. Scroll down
1235      * @tc.expected: The item(index:0) above view is active, the item(index:20) below view is active
1236      */
1237     pattern_->UpdateCurrentOffset(-ITEM_HEIGHT, SCROLL_FROM_UPDATE);
1238     pattern_->ScrollToIndex(4, false, ScrollAlign::START);
1239     FlushLayoutTask(frameNode_);
1240     EXPECT_FALSE(GetChildFrameNode(frameNode_, 0)->IsActive());
1241     EXPECT_FALSE(GetChildFrameNode(frameNode_, 20)->IsActive());
1242 
1243     /**
1244      * @tc.steps: step3. Scroll down
1245      * @tc.expected: The item(index:4) above view is active, the item(index:24) below view is active
1246      */
1247     pattern_->ScrollToIndex(8, false, ScrollAlign::START);
1248     FlushLayoutTask(frameNode_);
1249     EXPECT_FALSE(GetChildFrameNode(frameNode_, 0)->IsActive());
1250     EXPECT_FALSE(GetChildFrameNode(frameNode_, 4)->IsActive());
1251     EXPECT_FALSE(GetChildFrameNode(frameNode_, 24)->IsActive()); // th seventh row
1252 
1253     /**
1254      * @tc.steps: step4. Scroll up
1255      * @tc.expected: The item(index:0) above view is active, the item(index:20) below view is active
1256      */
1257     pattern_->ScrollToIndex(4, false, ScrollAlign::START);
1258     FlushLayoutTask(frameNode_);
1259     EXPECT_FALSE(GetChildFrameNode(frameNode_, 0)->IsActive());
1260     EXPECT_FALSE(GetChildFrameNode(frameNode_, 20)->IsActive());
1261     EXPECT_FALSE(GetChildFrameNode(frameNode_, 24)->IsActive());
1262 
1263     /**
1264      * @tc.steps: step5. Scroll up
1265      * @tc.expected: The item(index:16) below view is active, no item above view
1266      */
1267     pattern_->ScrollToIndex(0, false, ScrollAlign::START);
1268     FlushLayoutTask(frameNode_);
1269     EXPECT_FALSE(GetChildFrameNode(frameNode_, 16)->IsActive());
1270     EXPECT_FALSE(GetChildFrameNode(frameNode_, 20)->IsActive());
1271 }
1272 
1273 /**
1274  * @tc.name: LayoutRTL001
1275  * @tc.desc: Test property ayout with Direction RTL
1276  * @tc.type: FUNC
1277  */
1278 HWTEST_F(GridLayoutTestNg, LayoutRTL001, TestSize.Level1)
1279 {
1280     float itemWidth = 120.f;
1281     GridModelNG model = CreateGrid();
1282     model.SetIsRTL(TextDirection::RTL);
1283     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
1284     model.SetRowsTemplate("1fr 1fr 1fr 1fr");
1285     CreateGridItems(12, itemWidth, ITEM_HEIGHT);
1286     CreateDone(frameNode_);
1287 
1288     int32_t colsNumber = 4; // 4 * 120(itemWidth) = 480(gridWidth)
1289     for (int32_t index = 0; index < 10; index++) {
1290         RectF childRect = GetChildRect(frameNode_, index);
1291         float offsetX = GRID_WIDTH - index % colsNumber * itemWidth - itemWidth;
1292         float offsetY = floor(index / colsNumber) * ITEM_HEIGHT;
1293         RectF expectRect = RectF(offsetX, offsetY, itemWidth, ITEM_HEIGHT);
1294         EXPECT_TRUE(IsEqual(childRect, expectRect)) << "index: " << index;
1295     }
1296 }
1297 
1298 /**
1299  * @tc.name: AdaptiveLayoutRTL001
1300  * @tc.desc: Test property AdaptiveLayout with GridDirection Row and Direction RTL
1301  * @tc.type: FUNC
1302  */
1303 HWTEST_F(GridLayoutTestNg, AdaptiveLayoutRTL001, TestSize.Level1)
1304 {
1305     float itemWidth = 100.f;
1306     GridModelNG model = CreateGrid();
1307     model.SetLayoutDirection(FlexDirection::ROW);
1308     model.SetEditable(true);
1309     model.SetCellLength(ITEM_HEIGHT);
1310     model.SetMinCount(4);
1311     model.SetMaxCount(2);
1312     model.SetIsRTL(TextDirection::RTL);
1313     CreateGridItems(10, itemWidth, ITEM_HEIGHT);
1314     CreateDone(frameNode_);
1315 
1316     /**
1317      * @tc.steps: step1. While the before set minCount > maxCount
1318      * @tc.expected: would let minCount = 1, maxCount = Infinity;
1319      */
1320     int32_t colsNumber = 4; // 4 * 100(itemWidth) < 480(gridWidth)
1321     for (int32_t index = 0; index < 10; index++) {
1322         RectF childRect = GetChildRect(frameNode_, index);
1323         float offsetX = GRID_WIDTH - index % colsNumber * itemWidth - itemWidth;
1324         float offsetY = floor(index / colsNumber) * ITEM_HEIGHT;
1325         RectF expectRect = RectF(offsetX, offsetY, itemWidth, ITEM_HEIGHT);
1326         EXPECT_TRUE(IsEqual(childRect, expectRect)) << "index: " << index;
1327     }
1328 }
1329 
1330 /**
1331  * @tc.name: AdaptiveLayoutRTL002
1332  * @tc.desc: Test property AdaptiveLayout with GridDirection Column and Direction RTL
1333  * @tc.type: FUNC
1334  */
1335 HWTEST_F(GridLayoutTestNg, AdaptiveLayoutRTL002, TestSize.Level1)
1336 {
1337     float itemWidth = 100.f;
1338     GridModelNG model = CreateGrid();
1339     model.SetLayoutDirection(FlexDirection::COLUMN);
1340     model.SetEditable(true);
1341     model.SetCellLength(ITEM_HEIGHT);
1342     model.SetMinCount(4);
1343     model.SetMaxCount(2);
1344     model.SetIsRTL(TextDirection::RTL);
1345     CreateGridItems(10, itemWidth, ITEM_HEIGHT);
1346     CreateDone(frameNode_);
1347 
1348     /**
1349      * @tc.steps: step1. While the before set minCount > maxCount
1350      * @tc.expected: would let minCount = 1, maxCount = Infinity;
1351      */
1352     int32_t colsNumber = 4; // 4 * 100(itemWidth) < 480(gridWidth)
1353     int32_t rowsNumber = 4;
1354     for (int32_t index = 0; index < 8; index++) {
1355         RectF childRect = GetChildRect(frameNode_, index);
1356         float offsetX = GRID_WIDTH - floor(index / rowsNumber) * itemWidth * 2 - itemWidth;
1357         float offsetY = index % colsNumber * ITEM_HEIGHT;
1358         RectF expectRect = RectF(offsetX, offsetY, itemWidth, ITEM_HEIGHT);
1359         EXPECT_TRUE(IsEqual(childRect, expectRect)) << "index: " << index;
1360     }
1361 }
1362 
1363 /**
1364  * @tc.name: AdaptiveLayoutRTL003
1365  * @tc.desc: Test property AdaptiveLayout with GridDirection RowReverse and Direction RTL
1366  * @tc.type: FUNC
1367  */
1368 HWTEST_F(GridLayoutTestNg, AdaptiveLayoutRTL003, TestSize.Level1)
1369 {
1370     float itemWidth = 100.f;
1371     GridModelNG model = CreateGrid();
1372     model.SetLayoutDirection(FlexDirection::ROW_REVERSE);
1373     model.SetEditable(true);
1374     model.SetCellLength(ITEM_HEIGHT);
1375     model.SetMinCount(4);
1376     model.SetMaxCount(2);
1377     model.SetIsRTL(TextDirection::RTL);
1378     CreateGridItems(10, itemWidth, ITEM_HEIGHT);
1379     CreateDone(frameNode_);
1380 
1381     /**
1382      * @tc.steps: step1. While the before set minCount > maxCount
1383      * @tc.expected: would let minCount = 1, maxCount = Infinity;
1384      */
1385     int32_t colsNumber = 4; // 4 * 100(itemWidth) < 480(gridWidth)
1386     for (int32_t index = 0; index < 10; index++) {
1387         RectF childRect = GetChildRect(frameNode_, index);
1388         float offsetX = index % colsNumber * itemWidth + (GRID_WIDTH - colsNumber * itemWidth);
1389         float offsetY = floor(index / colsNumber) * ITEM_HEIGHT;
1390         RectF expectRect = RectF(offsetX, offsetY, itemWidth, ITEM_HEIGHT);
1391         EXPECT_TRUE(IsEqual(childRect, expectRect)) << "index: " << index;
1392     }
1393 }
1394 
1395 /**
1396  * @tc.name: AdaptiveLayoutRTL004
1397  * @tc.desc: Test property AdaptiveLayout with GridDirection ColumnReverse and Direction RTL
1398  * @tc.type: FUNC
1399  */
1400 HWTEST_F(GridLayoutTestNg, AdaptiveLayoutRTL004, TestSize.Level1)
1401 {
1402     float itemWidth = 100.f;
1403     GridModelNG model = CreateGrid();
1404     model.SetLayoutDirection(FlexDirection::COLUMN_REVERSE);
1405     model.SetEditable(true);
1406     model.SetCellLength(ITEM_HEIGHT);
1407     model.SetMinCount(4);
1408     model.SetMaxCount(2);
1409     model.SetIsRTL(TextDirection::RTL);
1410     CreateGridItems(10, itemWidth, ITEM_HEIGHT);
1411     CreateDone(frameNode_);
1412 
1413     /**
1414      * @tc.steps: step1. While the before set minCount > maxCount
1415      * @tc.expected: would let minCount = 1, maxCount = Infinity;
1416      */
1417     int32_t colsNumber = 4; // 4 * 100(itemWidth) < 480(gridWidth)
1418     int32_t rowsNumber = 4;
1419     for (int32_t index = 0; index < 8; index++) {
1420         RectF childRect = GetChildRect(frameNode_, index);
1421         float offsetX = GRID_WIDTH - floor(index / rowsNumber) * itemWidth * 2 - itemWidth;
1422         float offsetY = GRID_HEIGHT - index % colsNumber * ITEM_HEIGHT - ITEM_HEIGHT;
1423         RectF expectRect = RectF(offsetX, offsetY, itemWidth, ITEM_HEIGHT);
1424         EXPECT_TRUE(IsEqual(childRect, expectRect)) << "index: " << index;
1425     }
1426 }
1427 
1428 /**
1429  * @tc.name: ScrollLayoutRTL001
1430  * @tc.desc: Test Vertical Grid with Direction RTL
1431  * @tc.type: FUNC
1432  */
1433 HWTEST_F(GridLayoutTestNg, ScrollLayoutRTL001, TestSize.Level1)
1434 {
1435     float itemWidth = 120.0f;
1436     GridModelNG model = CreateGrid();
1437     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
1438     model.SetIsRTL(TextDirection::RTL);
1439     CreateFixedItems(18);
1440     CreateDone(frameNode_);
1441 
1442     int32_t colsNumber = 4;
1443     for (int32_t index = 0; index < 8; index++) {
1444         RectF childRect = GetChildRect(frameNode_, index);
1445         float offsetX = GRID_WIDTH - index % colsNumber * itemWidth - itemWidth;
1446         float offsetY = floor(index / colsNumber) * ITEM_HEIGHT;
1447         RectF expectRect = RectF(offsetX, offsetY, itemWidth, ITEM_HEIGHT);
1448         EXPECT_TRUE(IsEqual(childRect, expectRect)) << "index: " << index;
1449     }
1450 }
1451 
1452 /**
1453  * @tc.name: ScrollLayoutRTL002
1454  * @tc.desc: Test Horizontal Grid with Direction RTL
1455  * @tc.type: FUNC
1456  */
1457 HWTEST_F(GridLayoutTestNg, ScrollLayoutRTL002, TestSize.Level1)
1458 {
1459     float itemWidth = 120.0f;
1460     GridModelNG model = CreateGrid();
1461     model.SetRowsTemplate("1fr 1fr 1fr 1fr");
1462     model.SetIsRTL(TextDirection::RTL);
1463     CreateFixedItems(18);
1464     CreateDone(frameNode_);
1465 
1466     int32_t rowsNumber = 4;
1467     for (int32_t index = 0; index < 8; index++) {
1468         RectF childRect = GetChildRect(frameNode_, index);
1469         float offsetX = GRID_WIDTH - floor(index / rowsNumber) * itemWidth - itemWidth;
1470         float offsetY = index % rowsNumber * ITEM_HEIGHT;
1471         RectF expectRect = RectF(offsetX, offsetY, itemWidth, ITEM_HEIGHT);
1472         EXPECT_TRUE(IsEqual(childRect, expectRect)) << "index: " << index;
1473     }
1474 }
1475 
1476 /**
1477  * @tc.name: AdaptToChildMainSize003
1478  * @tc.desc: Test Horizontal Grid with Infinity mainSize
1479  * @tc.type: FUNC
1480  */
1481 HWTEST_F(GridLayoutTestNg, AdaptToChildMainSize003, TestSize.Level1)
1482 {
1483     GridModelNG model = CreateGrid();
1484     model.SetRowsTemplate("1fr 1fr 1fr 1fr");
1485     ViewAbstract::SetWidth(CalcLength(Infinity<int32_t>()));
1486     CreateFixedItems(8);
1487     CreateDone(frameNode_);
1488     EXPECT_EQ(pattern_->GetGridLayoutInfo().lastMainSize_, ITEM_WIDTH * 2);
1489 }
1490 
1491 /**
1492  * @tc.name: AdaptToChildMainSize004
1493  * @tc.desc: Test Vertical Grid with Infinity mainSize
1494  * @tc.type: FUNC
1495  */
1496 HWTEST_F(GridLayoutTestNg, AdaptToChildMainSize004, TestSize.Level1)
1497 {
1498     GridModelNG model = CreateGrid();
1499     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
1500     ViewAbstract::SetHeight(CalcLength(Infinity<int32_t>()));
1501     CreateFixedItems(8);
1502     CreateDone(frameNode_);
1503     EXPECT_EQ(pattern_->GetGridLayoutInfo().lastMainSize_, ITEM_HEIGHT * 2);
1504 }
1505 
1506 /**
1507  * @tc.name: AdaptToChildMainSize005
1508  * @tc.desc: Test Vertical Grid with maxcount and 0 itemHeight
1509  * @tc.type: FUNC
1510  */
1511 HWTEST_F(GridLayoutTestNg, AdaptToChildMainSize005, TestSize.Level1)
1512 {
1513     GridModelNG model = CreateGrid();
1514     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
1515     ViewAbstract::SetHeight(CalcLength(100));
1516     model.SetMaxCount(1);
1517     CreateGridItems(1, 0, 0);
1518     CreateDone(frameNode_);
1519     EXPECT_EQ(pattern_->GetGridLayoutInfo().lastMainSize_, 100);
1520 }
1521 
1522 /*
1523  * @tc.name: GetResetMode001
1524  * @tc.desc: Test Reset Function when have bigItem
1525  * @tc.type: FUNC
1526  */
1527 HWTEST_F(GridLayoutTestNg, GetResetMode001, TestSize.Level1)
1528 {
1529     GridModelNG model = CreateGrid();
1530     model.SetColumnsTemplate("1fr 1fr 1fr 1fr");
1531     CreateFixedItems(40);
1532     CreateDone(frameNode_);
1533 
1534     auto layoutAlgorithmWrapper = AceType::DynamicCast<LayoutAlgorithmWrapper>(frameNode_->GetLayoutAlgorithm());
1535     auto layoutAlgorithm =
1536         AceType::DynamicCast<GridScrollLayoutAlgorithm>(layoutAlgorithmWrapper->GetLayoutAlgorithm());
1537     auto* wrapper = AceType::RawPtr(frameNode_);
1538     EXPECT_EQ(layoutAlgorithm->GetResetMode(wrapper, -1), std::make_pair(false, false));
1539     EXPECT_EQ(layoutAlgorithm->GetResetMode(wrapper, 1), std::make_pair(true, false));
1540 
1541     pattern_->ScrollToIndex(30, false, ScrollAlign::START);
1542     layoutAlgorithm->gridLayoutInfo_.startIndex_ = 30;
1543     frameNode_->childrenUpdatedFrom_ = 20;
1544     FlushLayoutTask(frameNode_);
1545 
1546     EXPECT_EQ(layoutAlgorithm->GetResetMode(wrapper, 0), std::make_pair(true, false));
1547     EXPECT_EQ(layoutAlgorithm->GetResetMode(wrapper, 10), std::make_pair(true, false));
1548     EXPECT_EQ(layoutAlgorithm->GetResetMode(wrapper, 25), std::make_pair(true, false));
1549 
1550     layoutAlgorithm->gridLayoutInfo_.hasBigItem_ = true;
1551 
1552     EXPECT_EQ(layoutAlgorithm->GetResetMode(wrapper, 0), std::make_pair(true, false));
1553     EXPECT_EQ(layoutAlgorithm->GetResetMode(wrapper, 10), std::make_pair(true, false));
1554     EXPECT_EQ(layoutAlgorithm->GetResetMode(wrapper, 25), std::make_pair(false, true));
1555 }
1556 
1557 /**
1558  * @tc.name: LayoutWithAutoStretch001
1559  * @tc.desc: Test Grid Layout with auto-stretch
1560  * @tc.type: FUNC
1561  */
1562 HWTEST_F(GridLayoutTestNg, LayoutWithAutoStretch001, TestSize.Level1)
1563 {
1564     float itemWidth = 80.0f;
1565     float itemHeight = 150.0f;
1566     GridModelNG model = CreateGrid();
1567     model.SetColumnsTemplate("repeat(auto-stretch, 80)");
1568     model.SetRowsTemplate("repeat(auto-stretch, 150)");
1569     model.SetRowsGap(Dimension(10));
1570     model.SetColumnsGap(Dimension(10));
1571     CreateGridItems(25, itemWidth, itemHeight);
1572     CreateDone(frameNode_);
1573 
1574     int32_t rowsNumber = 5;
1575     int32_t columnsNumber = 5;
1576     float realColumnsGap = 20.f;
1577     float realRowsGap = 12.5f;
1578     for (int32_t index = 0; index < 25; index++) {
1579         RectF childRect = GetChildRect(frameNode_, index);
1580         float offsetX = index % columnsNumber * (itemWidth + realColumnsGap);
1581         float offsetY = index / rowsNumber * (itemHeight + realRowsGap);
1582         RectF expectRect = RectF(offsetX, offsetY, itemWidth, itemHeight);
1583         EXPECT_TRUE(IsEqual(childRect, expectRect)) << "index: " << index;
1584     }
1585 }
1586 
1587 /**
1588  * @tc.name: LayoutWithAutoStretch002
1589  * @tc.desc: Test Vertical Grid Layout with auto-stretch
1590  * @tc.type: FUNC
1591  */
1592 HWTEST_F(GridLayoutTestNg, LayoutWithAutoStretch002, TestSize.Level1)
1593 {
1594     float itemWidth = 80.0f;
1595     float itemHeight = 150.0f;
1596     GridModelNG model = CreateGrid();
1597     model.SetRowsTemplate("repeat(auto-stretch, 150)");
1598     model.SetRowsGap(Dimension(10));
1599     model.SetColumnsGap(Dimension(10));
1600     CreateGridItems(25, itemWidth, itemHeight);
1601     CreateDone(frameNode_);
1602 
1603     int32_t rowsNumber = 5;
1604     int32_t columnsNumber = 5;
1605     float realColumnsGap = 10.f;
1606     float realRowsGap = 12.5f;
1607     for (int32_t index = 0; index < 25; index++) {
1608         RectF childRect = GetChildRect(frameNode_, index);
1609         float offsetX = index / columnsNumber * (itemWidth + realColumnsGap);
1610         float offsetY = index % rowsNumber * (itemHeight + realRowsGap);
1611         RectF expectRect = RectF(offsetX, offsetY, itemWidth, itemHeight);
1612         EXPECT_TRUE(IsEqual(childRect, expectRect)) << "index: " << index;
1613     }
1614 }
1615 
1616 /**
1617  * @tc.name: LayoutWithAutoStretch003
1618  * @tc.desc: Test Horizental Grid Layout with auto-stretch
1619  * @tc.type: FUNC
1620  */
1621 HWTEST_F(GridLayoutTestNg, LayoutWithAutoStretch003, TestSize.Level1)
1622 {
1623     float itemWidth = 80.0f;
1624     float itemHeight = 150.0f;
1625     GridModelNG model = CreateGrid();
1626     model.SetColumnsTemplate("repeat(auto-stretch, 80)");
1627     model.SetRowsGap(Dimension(10));
1628     model.SetColumnsGap(Dimension(10));
1629     CreateGridItems(25, itemWidth, itemHeight);
1630     CreateDone(frameNode_);
1631 
1632     int32_t rowsNumber = 5;
1633     int32_t columnsNumber = 5;
1634     float realColumnsGap = 20.f;
1635     float realRowsGap = 10.f;
1636     for (int32_t index = 0; index < 25; index++) {
1637         RectF childRect = GetChildRect(frameNode_, index);
1638         float offsetX = index % columnsNumber * (itemWidth + realColumnsGap);
1639         float offsetY = index / rowsNumber * (itemHeight + realRowsGap);
1640         RectF expectRect = RectF(offsetX, offsetY, itemWidth, itemHeight);
1641         EXPECT_TRUE(IsEqual(childRect, expectRect)) << "index: " << index;
1642     }
1643 }
1644 
1645 /**
1646  * @tc.name: Cache001
1647  * @tc.desc: Test Grid preload items
1648  * @tc.type: FUNC
1649  */
1650 HWTEST_F(GridLayoutTestNg, Cache001, TestSize.Level1)
1651 {
__anon80cf7a3e0502(uint32_t idx) 1652     GridModelNG model = CreateRepeatGrid(50, [](uint32_t idx) { return 200.0f; });
1653     model.SetColumnsTemplate("1fr 1fr 1fr");
1654     model.SetRowsGap(Dimension(10));
1655     model.SetColumnsGap(Dimension(10));
1656     model.SetCachedCount(2); // 2 lines
1657     CreateDone(frameNode_);
1658     EXPECT_EQ(frameNode_->GetTotalChildCount(), 50);
1659     const auto& info = pattern_->gridLayoutInfo_;
1660     EXPECT_EQ(info.startIndex_, 0);
1661     EXPECT_EQ(info.endIndex_, 11);
1662     const std::list<int32_t> preloadList = { 12, 13, 14 };
1663     for (const int32_t i : preloadList) {
1664         EXPECT_FALSE(frameNode_->GetChildByIndex(i));
1665     }
1666     CheckPreloadListEqual(preloadList);
1667     PipelineContext::GetCurrentContext()->OnIdle(INT64_MAX);
1668     EXPECT_TRUE(pattern_->preloadItemList_.empty());
1669     for (const int32_t i : preloadList) {
1670         EXPECT_TRUE(frameNode_->GetChildByIndex(i));
1671         EXPECT_EQ(GetChildRect(frameNode_, i).Height(), 200.0f);
1672     }
1673     FlushLayoutTask(frameNode_);
1674     // preload next line
1675     const std::list<int32_t> preloadList2 = { 15, 16, 17 };
1676     CheckPreloadListEqual(preloadList2);
1677     PipelineContext::GetCurrentContext()->OnIdle(INT64_MAX);
1678     EXPECT_TRUE(pattern_->preloadItemList_.empty());
1679     for (const int32_t i : preloadList2) {
1680         EXPECT_TRUE(frameNode_->GetChildByIndex(i));
1681         EXPECT_EQ(GetChildRect(frameNode_, i).Height(), 200.0f);
1682     }
1683     FlushLayoutTask(frameNode_);
1684     EXPECT_TRUE(pattern_->preloadItemList_.empty());
1685 
1686     pattern_->ScrollToIndex(49);
1687     FlushLayoutTask(frameNode_);
1688     EXPECT_EQ(info.startIndex_, 39);
1689     // GridScroll algo currently not capable of preloading backward
1690     EXPECT_TRUE(pattern_->preloadItemList_.empty());
1691 }
1692 
1693 /**
1694  * @tc.name: Stretch001
1695  * @tc.desc: Test Grid AlignItems STRETCH
1696  * @tc.type: FUNC
1697  */
1698 HWTEST_F(GridLayoutTestNg, Stretch001, TestSize.Level1)
1699 {
1700     /**
1701      * 0: [0], [1]
1702      *
1703      * 1 will stretch
1704      */
1705     GridModelNG model = CreateGrid();
1706     model.SetAlignItems(GridItemAlignment::STRETCH);
1707     model.SetColumnsTemplate("1fr 1fr");
1708 
1709     CreateFixedHeightItems(1, 150);
1710     CreateAdaptChildSizeGridItems(1);
1711 
1712     CreateDone(frameNode_);
1713     FlushLayoutTask(frameNode_);
1714 
1715     auto childRect0 = pattern_->GetItemRect(0);
1716     auto childRect1 = pattern_->GetItemRect(1);
1717     EXPECT_EQ(childRect0.Height(), childRect1.Height());
1718 }
1719 
1720 /**
1721  * @tc.name: Stretch002
1722  * @tc.desc: Test Grid AlignItems STRETCH
1723  * @tc.type: FUNC
1724  */
1725 HWTEST_F(GridLayoutTestNg, Stretch002, TestSize.Level1)
1726 {
1727     /**
1728      * 0: [0], [1]
1729      * 1: [0]
1730      *
1731      * 1 will not stretch
1732      */
1733     GridModelNG model = CreateGrid();
1734     model.SetAlignItems(GridItemAlignment::STRETCH);
1735     model.SetColumnsTemplate("1fr 1fr");
1736 
1737     CreateBigItem(0, 1, 0, 0, ITEM_WIDTH, 200);
1738     CreateAdaptChildSizeGridItems(1);
1739 
1740     CreateDone(frameNode_);
1741     FlushLayoutTask(frameNode_);
1742 
1743     auto childRect1 = pattern_->GetItemRect(1);
1744     EXPECT_EQ(childRect1.Height(), 0);
1745 }
1746 
1747 /**
1748  * @tc.name: Stretch003
1749  * @tc.desc: Test Grid AlignItems STRETCH
1750  * @tc.type: FUNC
1751  */
1752 HWTEST_F(GridLayoutTestNg, Stretch003, TestSize.Level1)
1753 {
1754     /**
1755      * 0: [0], [1]
1756      * 1: [0], [2]
1757      * 2: [3], [4]
1758      *
1759      * 1 and 2 will not stretch
1760      * 3 will stretch
1761      */
1762     GridModelNG model = CreateGrid();
1763     model.SetAlignItems(GridItemAlignment::STRETCH);
1764     model.SetColumnsTemplate("1fr 1fr");
1765 
1766     CreateBigItem(0, 1, 0, 0, ITEM_WIDTH, 200);
1767     CreateAdaptChildSizeGridItems(3);
1768     CreateFixedHeightItems(1, 150);
1769 
1770     CreateDone(frameNode_);
1771     FlushLayoutTask(frameNode_);
1772 
1773     auto childRect1 = pattern_->GetItemRect(1);
1774     EXPECT_EQ(childRect1.Height(), 0);
1775 
1776     auto childRect3 = pattern_->GetItemRect(3);
1777     auto childRect4 = pattern_->GetItemRect(4);
1778     EXPECT_EQ(childRect4.Height(), childRect3.Height());
1779 }
1780 
1781 /**
1782  * @tc.name: Stretch004
1783  * @tc.desc: Test Grid AlignItems STRETCH
1784  * @tc.type: FUNC
1785  */
1786 HWTEST_F(GridLayoutTestNg, Stretch004, TestSize.Level1)
1787 {
1788     /**
1789      * 0: [0], [0], [1]
1790      *
1791      * 1 will not stretch
1792      */
1793     GridModelNG model = CreateGrid();
1794     model.SetAlignItems(GridItemAlignment::STRETCH);
1795     model.SetColumnsTemplate("1fr 1fr 1fr");
1796 
1797     CreateBigItem(0, 1, 0, 1, ITEM_WIDTH, 200);
1798     CreateAdaptChildSizeGridItems(1);
1799 
1800     CreateDone(frameNode_);
1801     FlushLayoutTask(frameNode_);
1802 
1803     auto childRect1 = pattern_->GetItemRect(1);
1804     EXPECT_EQ(childRect1.Height(), 0);
1805     auto childRect2 = pattern_->GetItemRect(2);
1806     EXPECT_EQ(childRect2.Height(), 0);
1807 }
1808 
1809 /**
1810  * @tc.name: Stretch005
1811  * @tc.desc: Test Grid AlignItems STRETCH
1812  * @tc.type: FUNC
1813  */
1814 HWTEST_F(GridLayoutTestNg, Stretch005, TestSize.Level1)
1815 {
1816     /**
1817      *  0
1818      * [0]
1819      * [1]
1820      *
1821      * 1 will stretch
1822      */
1823     GridModelNG model = CreateGrid();
1824     model.SetAlignItems(GridItemAlignment::STRETCH);
1825     model.SetRowsTemplate("1fr 1fr");
1826 
1827     CreateFixedHeightItems(1, 150);
1828     CreateAdaptChildSizeGridItems(1);
1829 
1830     CreateDone(frameNode_);
1831     FlushLayoutTask(frameNode_);
1832 
1833     auto childRect0 = pattern_->GetItemRect(0);
1834     auto childRect1 = pattern_->GetItemRect(1);
1835     EXPECT_EQ(childRect0.Width(), childRect1.Width());
1836 }
1837 
1838 /**
1839  * @tc.name: Stretch006
1840  * @tc.desc: Test Grid AlignItems STRETCH
1841  * @tc.type: FUNC
1842  */
1843 HWTEST_F(GridLayoutTestNg, Stretch006, TestSize.Level1)
1844 {
1845     /**
1846      *  0
1847      * [0]
1848      * [0]
1849      * [1]
1850      *
1851      * 1 will not stretch
1852      */
1853     GridModelNG model = CreateGrid();
1854     model.SetAlignItems(GridItemAlignment::STRETCH);
1855     model.SetRowsTemplate("1fr 1fr 1fr");
1856 
1857     CreateBigItem(0, 1, 0, 0, ITEM_WIDTH, ITEM_HEIGHT);
1858     CreateAdaptChildSizeGridItems(1);
1859 
1860     CreateDone(frameNode_);
1861     FlushLayoutTask(frameNode_);
1862 
1863     auto childRect1 = pattern_->GetItemRect(1);
1864     EXPECT_EQ(childRect1.Width(), 0);
1865 }
1866 
1867 /**
1868  * @tc.name: Stretch007
1869  * @tc.desc: Test Grid AlignItems STRETCH
1870  * @tc.type: FUNC
1871  */
1872 HWTEST_F(GridLayoutTestNg, Stretch007, TestSize.Level1)
1873 {
1874     /**
1875      *  0    1    2
1876      * [0], [0], [3]
1877      * [1], [2], [4]
1878      *
1879      * 1 and 2 will not stretch
1880      * 3 will stretch
1881      */
1882     GridModelNG model = CreateGrid();
1883     model.SetAlignItems(GridItemAlignment::STRETCH);
1884     model.SetRowsTemplate("1fr 1fr");
1885 
1886     CreateBigItem(0, 0, 0, 1, ITEM_WIDTH, ITEM_HEIGHT);
1887     CreateAdaptChildSizeGridItems(3);
1888     CreateFixedHeightItems(1, 150);
1889 
1890     CreateDone(frameNode_);
1891     FlushLayoutTask(frameNode_);
1892 
1893     auto childRect1 = pattern_->GetItemRect(1);
1894     EXPECT_EQ(childRect1.Width(), 0);
1895 
1896     auto childRect3 = pattern_->GetItemRect(3);
1897     auto childRect4 = pattern_->GetItemRect(4);
1898     EXPECT_EQ(childRect4.Width(), childRect3.Width());
1899 }
1900 
1901 /**
1902  * @tc.name: Stretch008
1903  * @tc.desc: Test Grid AlignItems STRETCH
1904  * @tc.type: FUNC
1905  */
1906 HWTEST_F(GridLayoutTestNg, Stretch008, TestSize.Level1)
1907 {
1908     /**
1909      *  0    1
1910      * [0], [0]
1911      * [0], [0]
1912      * [1], [2]
1913      *
1914      * 1 and 2 will not stretch
1915      */
1916     GridModelNG model = CreateGrid();
1917     model.SetAlignItems(GridItemAlignment::STRETCH);
1918     model.SetRowsTemplate("1fr 1fr 1fr");
1919 
1920     CreateBigItem(0, 1, 0, 1, ITEM_WIDTH, ITEM_HEIGHT);
1921     CreateAdaptChildSizeGridItems(2);
1922 
1923     CreateDone(frameNode_);
1924     FlushLayoutTask(frameNode_);
1925 
1926     auto childRect1 = pattern_->GetItemRect(1);
1927     EXPECT_EQ(childRect1.Width(), 0);
1928     auto childRect2 = pattern_->GetItemRect(2);
1929     EXPECT_EQ(childRect2.Width(), 0);
1930 }
1931 
1932 /*
1933  * @tc.name: GridItemDisableEventTest002
1934  * @tc.desc: GirdItem disable event test.
1935  * @tc.type: FUNC
1936  */
1937 HWTEST_F(GridLayoutTestNg, GridItemDisableEventTest002, TestSize.Level1)
1938 {
1939     GridModelNG model = CreateGrid();
1940     CreateFixedItems(10, GridItemStyle::PLAIN);
1941     CreateDone(frameNode_);
1942 
1943     /**
1944      * @tc.steps: step2. Get girdItem frameNode and pattern, set callback function.
1945      * @tc.expected: Related function is called.
1946      */
1947     auto gridItemPattern = GetChildPattern<GridItemPattern>(frameNode_, 0);
1948     auto gridItemEventHub = GetChildEventHub<GridItemEventHub>(frameNode_, 0);
1949     auto gridItemFrameNode = GetChildFrameNode(frameNode_, 0);
1950     auto renderContext = gridItemFrameNode->renderContext_;
1951     auto mockRenderContext = AceType::DynamicCast<MockRenderContext>(renderContext);
1952     EXPECT_EQ(mockRenderContext->opacityMultiplier_, 1.0f);
1953     gridItemEventHub->SetEnabled(false);
1954     gridItemPattern->InitDisableStyle();
1955     EXPECT_EQ(mockRenderContext->opacityMultiplier_, 0.4f);
1956     gridItemPattern->InitDisableStyle();
1957     EXPECT_EQ(mockRenderContext->opacityMultiplier_, 0.4f);
1958 }
1959 
1960 /**
1961  * @tc.name: MarginPadding001
1962  * @tc.desc: Test margin/padding
1963  * @tc.type: FUNC
1964  */
1965 HWTEST_F(GridLayoutTestNg, MarginPadding001, TestSize.Level1)
1966 {
1967     ColumnModelNG colModel;
1968     colModel.Create(Dimension(0), nullptr, "");
1969     auto colNode = AceType::Claim(ViewStackProcessor::GetInstance()->GetMainFrameNode());
1970     GridModelNG model = CreateGrid();
1971     model.SetColumnsTemplate("1fr 1fr");
1972     CreateFixedItems(4);
1973     CreateDone(colNode);
1974 
1975     MarginProperty margin = { CalcLength(1), CalcLength(3), CalcLength(5), CalcLength(7) };
1976     PaddingProperty padding = { CalcLength(2), CalcLength(4), CalcLength(6), CalcLength(8) };
1977     layoutProperty_->UpdateMargin(margin);
1978     layoutProperty_->UpdatePadding(padding);
1979     auto itemLayoutProperty = GetChildLayoutProperty<GridItemLayoutProperty>(frameNode_, 2);
1980     itemLayoutProperty->UpdateMargin(margin);
1981     itemLayoutProperty->UpdatePadding(padding);
1982     FlushLayoutTask(colNode, true);
1983     EXPECT_TRUE(IsEqual(frameNode_->GetGeometryNode()->GetFrameRect(), RectF(1, 5, 480, 800)));
1984     EXPECT_TRUE(IsEqual(GetChildRect(frameNode_, 2), RectF(3, 211, 233, 200)));
1985 }
1986 } // namespace OHOS::Ace::NG
1987