1 /*
2 * Copyright (c) 2022 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 <optional>
17 #include <utility>
18
19 #include "gtest/gtest.h"
20
21 #include "base/memory/ace_type.h"
22 #include "base/memory/referenced.h"
23
24 #define private public
25 #define protected public
26 #include "mock_lazy_for_each_actuator.h"
27 #include "mock_lazy_for_each_builder.h"
28 #include "test/mock/core/pipeline/mock_pipeline_context.h"
29
30 #include "core/components_ng/base/view_stack_processor.h"
31 #include "core/components_ng/syntax/lazy_for_each_model_ng.h"
32 #include "core/components_ng/syntax/lazy_for_each_node.h"
33 #include "core/components_ng/syntax/lazy_layout_wrapper_builder.h"
34 #undef private
35 #undef protected
36
37 using namespace testing;
38 using namespace testing::ext;
39
40 namespace OHOS::Ace::NG {
41 namespace {
42 const std::list<std::optional<std::string>> LAZY_FOR_EACH_NODE_IDS = { "0", "1", "2", "3", "4", "5", "6" };
43 const std::list<std::optional<std::string>> DEFAULT_LAZY_FOR_EACH_NODE_IDS = {};
44 const std::list<std::optional<int32_t>> LAZY_FOR_EACH_NODE_IDS_INT = { 0, 1, 2, 3, 4, 5, 6 };
45 const std::unordered_map<int32_t, std::optional<std::string>> LAZY_FOR_EACH_CACHED_ITEMS = { { 0, "0" }, { 1, "1" } };
46 const std::list<int32_t> LAZY_FOR_EACH_ITEMS = { 0, 1, 2, 3, 4, 5 };
47 constexpr bool IS_ATOMIC_NODE = false;
48 constexpr int32_t NEW_START_ID = 0;
49 constexpr int32_t NEW_END_ID = 6;
50 constexpr int32_t INDEX_MIDDLE = 3;
51 constexpr int32_t INDEX_MIDDLE_2 = 4;
52 constexpr int32_t INDEX_2 = 2;
53 constexpr int32_t INDEX_8 = 8;
54 constexpr int32_t INDEX_1 = 1;
55 constexpr int32_t DEFAULT_INDEX = 0;
56 constexpr int32_t INDEX_4 = 4;
57 constexpr int32_t INDEX_3 = 3;
58 constexpr int32_t INDEX_5 = 5;
59 constexpr int32_t INDEX_0 = 0;
60 constexpr int32_t INDEX_7 = 7;
61 constexpr int32_t DEFAULT_SIZE = 0;
62 constexpr int32_t CACHE_COUNT = 5;
63 constexpr int32_t START_ID = 7;
64 constexpr int32_t INVALID_START_ID_LESS_THAN_0 = -1;
65 constexpr int32_t INVALID_START_ID_GREATER_THAN_TOTAL = 7;
66 constexpr int32_t INDEX_GREATER_THAN_END_INDEX = 20;
67 constexpr int32_t INDEX_LESS_THAN_START_INDEX = -1;
68 constexpr int32_t INDEX_EQUAL_WITH_START_INDEX = 1;
69 constexpr int32_t INDEX_EQUAL_WITH_START_INDEX_DELETED = -1;
70 constexpr int32_t LAZY_FOR_EACH_NODE_ID = 1;
71 constexpr size_t BUILDER_INDEX_ONDATADELETED_END = 4294967295;
72 } // namespace
73
74 class LazyForEachSyntaxTestNg : public testing::Test {
75 public:
76 void SetUp() override;
77 void TearDown() override;
78
79 RefPtr<FrameNode> CreateNode(const std::string& tag);
80
UpdateItems(const RefPtr<LazyForEachNode> & lazyForEachNode,const RefPtr<LazyForEachActuator> & mockLazyForEachActuator)81 static void UpdateItems(
82 const RefPtr<LazyForEachNode>& lazyForEachNode, const RefPtr<LazyForEachActuator>& mockLazyForEachActuator)
83 {
84 /**
85 * @tc.steps: step1. Add child found in generatedItem_.
86 */
87 auto ids = LAZY_FOR_EACH_NODE_IDS;
88 auto builder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
89 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
90 builder->GetChildByIndex(iter.value_or(0), true);
91 }
92 }
93
CreateLazyForEachNode()94 static RefPtr<LazyForEachNode> CreateLazyForEachNode()
95 {
96 /**
97 * @tc.steps: step1. Create Text and push it to view stack processor.
98 * @tc.expected: Make Text as LazyForEach parent.
99 */
100 auto pattern = AceType::MakeRefPtr<Pattern>();
101 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, pattern);
102 pattern->AttachToFrameNode(frameNode);
103 ViewStackProcessor::GetInstance()->Push(frameNode);
104
105 /**
106 * @tc.steps: step2. Invoke lazyForEach Create function.
107 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
108 */
109 LazyForEachModelNG lazyForEach;
110 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
111 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
112 lazyForEach.Create(mockLazyForEachActuator);
113 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
114 /**
115 * @tc.steps: step3. Add children items to lazyForEachNode.
116 */
117 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
118 return lazyForEachNode;
119 }
120 };
121
SetUp()122 void LazyForEachSyntaxTestNg::SetUp()
123 {
124 MockPipelineContext::SetUp();
125 }
126
TearDown()127 void LazyForEachSyntaxTestNg::TearDown()
128 {
129 MockPipelineContext::TearDown();
130 }
131
CreateNode(const std::string & tag)132 RefPtr<FrameNode> LazyForEachSyntaxTestNg::CreateNode(const std::string& tag)
133 {
134 auto pattern = AceType::MakeRefPtr<Pattern>();
135 auto frameNode = AceType::MakeRefPtr<FrameNode>(tag, -1, pattern);
136 pattern->AttachToFrameNode(frameNode);
137 ViewStackProcessor::GetInstance()->Push(frameNode);
138 return frameNode;
139 }
140
141 /**
142 * @tc.name: LazyForEachSyntaxCreateTest001
143 * @tc.desc: Create LazyForEach.
144 * @tc.type: FUNC
145 */
146 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxCreateTest001, TestSize.Level1)
147 {
148 /**
149 * @tc.steps: step1. Create Text and push it to view stack processor.
150 * @tc.expected: Make Text as LazyForEach parent.
151 */
152 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
153
154 /**
155 * @tc.steps: step2. Invoke lazyForEach Create function.
156 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
157 */
158 LazyForEachModelNG lazyForEach;
159 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
160 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
161 lazyForEach.Create(mockLazyForEachActuator);
162 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
163 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
164
165 EXPECT_EQ(lazyForEachNode->IsAtomicNode(), IS_ATOMIC_NODE);
166 EXPECT_EQ(lazyForEachNode->FrameCount(), 0);
167 }
168
169 /**
170 * @tc.name: ForEachSyntaxCreateTest002
171 * @tc.desc: Create LazyForEach and its parent node is Tabs.
172 * @tc.type: FUNC
173 */
174 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxCreateTest002, TestSize.Level1)
175 {
176 /**
177 * @tc.steps: step1. Create Tabs and push it to view stack processor.
178 * @tc.expected: Make Tabs as LazyForEach parent.
179 */
180 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
181
182 /**
183 * @tc.steps: step2. Invoke lazyForEach Create function.
184 * @tc.expected: LazyForEachNode will not be created when its parent is Tabs.
185 */
186 LazyForEachModelNG lazyForEach;
187 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
188 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
189 lazyForEach.Create(mockLazyForEachActuator);
190 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
191 EXPECT_NE(lazyForEachNode, nullptr);
192 }
193
194 /**
195 * @tc.name: ForEachSyntaxUpdateTest003
196 * @tc.desc: Create LazyForEach and its Update its Items.
197 * @tc.type: FUNC
198 */
199 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxUpdateTest003, TestSize.Level1)
200 {
201 /**
202 * @tc.steps: step1. Create Text and push it to view stack processor.
203 * @tc.expected: Make Text as LazyForEach parent.
204 */
205 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
206
207 /**
208 * @tc.steps: step2. Invoke lazyForEach Create function.
209 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
210 */
211 LazyForEachModelNG lazyForEach;
212 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
213 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
214 lazyForEach.Create(mockLazyForEachActuator);
215 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
216 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
217 }
218
219 /**
220 * @tc.name: ForEachSyntaxAddDataFunctionTest004
221 * @tc.desc: Create LazyForEach, update its Items and invoke OnDataAdded function.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxFunctionTest004, TestSize.Level1)
225 {
226 /**
227 * @tc.steps: step1. Create Text and push it to view stack processor.
228 * @tc.expected: Make Text as LazyForEach parent.
229 */
230 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
231
232 /**
233 * @tc.steps: step2. Invoke lazyForEach Create function.
234 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
235 */
236 LazyForEachModelNG lazyForEach;
237 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
238 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
239 lazyForEach.Create(mockLazyForEachActuator);
240 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
241 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
242
243 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
244
245 /**
246 * @tc.steps: step3. Add index which is less than start index.
247 * @tc.expected: LazyForEachNode ids_ will not be added.
248 */
249 lazyForEachNode->OnDataAdded(INDEX_LESS_THAN_START_INDEX);
250 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
251
252 /**
253 * @tc.steps: step4. Add index which is greater than end index.
254 * @tc.expected: LazyForEachNode ids_ will not be added.
255 */
256 lazyForEachNode->OnDataAdded(INDEX_GREATER_THAN_END_INDEX);
257 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
258
259 /**
260 * @tc.steps: step5. Add index which is equal with start index.
261 * @tc.expected: LazyForEachNode ids_ will be added the item.
262 */
263 lazyForEachNode->OnDataAdded(INDEX_EQUAL_WITH_START_INDEX);
264 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
265
266 /**
267 * @tc.steps: step6. builder_ is null.
268 * @tc.expected: LazyForEachNode ids_ will be added the item.
269 */
270 lazyForEachNode->builder_ = nullptr;
271 lazyForEachNode->OnDataAdded(INDEX_EQUAL_WITH_START_INDEX);
272 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
273 }
274
275 /**
276 * @tc.name: ForEachSyntaxReloadDataFunctionTest005
277 * @tc.desc: Create LazyForEach, update its Items and invoke OnDataReloaded function.
278 * @tc.type: FUNC
279 */
280 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxReloadDataFunctionTest005, TestSize.Level1)
281 {
282 /**
283 * @tc.steps: step1. Create Text and push it to view stack processor.
284 * @tc.expected: Make Text as LazyForEach parent.
285 */
286 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
287
288 /**
289 * @tc.steps: step2. Invoke lazyForEach Create function.
290 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
291 */
292 LazyForEachModelNG lazyForEach;
293 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
294 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
295 lazyForEach.Create(mockLazyForEachActuator);
296 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
297 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
298
299 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
300
301 /**
302 * @tc.steps: step3. Invoke OnDataReloaded.
303 * @tc.expected: LazyForEachNode ids_ will be cleared.
304 */
305 lazyForEachNode->OnDataReloaded();
306 EXPECT_TRUE(lazyForEachNode->ids_.empty());
307
308 /**
309 * @tc.steps: step4. builder_ is null.
310 * @tc.expected: LazyForEachNode ids_ will be cleared.
311 */
312 lazyForEachNode->builder_ = nullptr;
313 lazyForEachNode->OnDataReloaded();
314 EXPECT_TRUE(lazyForEachNode->ids_.empty());
315 }
316
317 /**
318 * @tc.name: ForEachSyntaxDeleteDataFunctionTest006
319 * @tc.desc: Create LazyForEach, update its Items and invoke OnDataDeleted function.
320 * @tc.type: FUNC
321 */
322 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxDeleteDataFunctionTest006, TestSize.Level1)
323 {
324 /**
325 * @tc.steps: step1. Create Text and push it to view stack processor.
326 * @tc.expected: Make Text as LazyForEach parent.
327 */
328 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
329
330 /**
331 * @tc.steps: step2. Invoke lazyForEach Create function.
332 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
333 */
334 LazyForEachModelNG lazyForEach;
335 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
336 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
337 lazyForEach.Create(mockLazyForEachActuator);
338 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
339 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
340
341 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
342
343 /**
344 * @tc.steps: step3. Delete index which is greater than end index.
345 * @tc.expected: LazyForEachNode ids_ will not be deleted.
346 */
347 lazyForEachNode->OnDataDeleted(INDEX_GREATER_THAN_END_INDEX);
348 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
349
350 /**
351 * @tc.steps: step4. Delete index which is less than start index.
352 * @tc.expected: LazyForEachNode ids_ will not be deleted.
353 */
354 lazyForEachNode->OnDataDeleted(INDEX_LESS_THAN_START_INDEX);
355 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
356
357 /**
358 * @tc.steps: step5. Delete index which is equal with start index.
359 * @tc.expected: LazyForEachNode ids_ will be deleted the item.
360 */
361 lazyForEachNode->OnDataDeleted(INDEX_EQUAL_WITH_START_INDEX_DELETED);
362 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
363
364 /**
365 * @tc.steps: step6. builder_ is null.
366 * @tc.expected: LazyForEachNode ids_ will be deleted the item.
367 */
368 lazyForEachNode->builder_ = nullptr;
369 lazyForEachNode->OnDataDeleted(INDEX_EQUAL_WITH_START_INDEX_DELETED);
370 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
371 }
372
373 /**
374 * @tc.name: ForEachSyntaxChangeDataFunctionTest007
375 * @tc.desc: Create LazyForEach, update its Items and invoke OnDataChanged function.
376 * @tc.type: FUNC
377 */
378 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxChangeDataFunctionTest007, TestSize.Level1)
379 {
380 /**
381 * @tc.steps: step1. Create Text and push it to view stack processor.
382 * @tc.expected: Make Text as LazyForEach parent.
383 */
384 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
385
386 /**
387 * @tc.steps: step2. Invoke lazyForEach Create function.
388 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
389 */
390 LazyForEachModelNG lazyForEach;
391 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
392 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
393 lazyForEach.Create(mockLazyForEachActuator);
394 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
395 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
396
397 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
398
399 /**
400 * @tc.steps: step3. Change index which is less than start index.
401 * @tc.expected: changeIndex is out of range, ignored.
402 */
403 lazyForEachNode->OnDataChanged(INDEX_LESS_THAN_START_INDEX);
404 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
405
406 /**
407 * @tc.steps: step4. Change index which is greater than end index.
408 * @tc.expected: changeIndex is out of range, ignored.
409 */
410 lazyForEachNode->OnDataChanged(INDEX_GREATER_THAN_END_INDEX);
411 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
412
413 /**
414 * @tc.steps: step5. Change index which is in the middle with start and end.
415 * @tc.expected: changeIndex is not out of range, change the index data.
416 */
417 lazyForEachNode->OnDataChanged(INDEX_MIDDLE);
418 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
419
420 /**
421 * @tc.steps: step6. builder_ is null.
422 * @tc.expected: changeIndex is not out of range, change the index data.
423 */
424 lazyForEachNode->builder_ = nullptr;
425 lazyForEachNode->OnDataChanged(INDEX_MIDDLE);
426 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
427 }
428
429 /**
430 * @tc.name: ForEachSyntaxSetOnMoveFunctionTest001
431 * @tc.desc: Create LazyForEach, update its Items and invoke SetOnMove function.
432 * @tc.type: FUNC
433 */
434 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxSetOnMoveFunctionTest001, TestSize.Level1)
435 {
436 /**
437 * @tc.steps: step1. Create Text and push it to view stack processor.
438 * @tc.expected: Make Text as LazyForEach parent.
439 */
440 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
441
442 /**
443 * @tc.steps: step2. Invoke lazyForEach Create function.
444 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
445 */
446 LazyForEachModelNG lazyForEach;
447 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
448 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
449 lazyForEach.Create(mockLazyForEachActuator);
450 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
451 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
452
453 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
454
__anon8fc4d7d30202(int32_t a, int32_t b) 455 std::function<void(int32_t, int32_t)> lambda = [](int32_t a, int32_t b) {};
456
457 /**
458 * @tc.steps: step3. onMove not null and onMoveEvent_ not null.
459 */
460 lazyForEachNode->SetOnMove(std::move(lambda));
461 lazyForEachNode->onMoveEvent_ = std::move(lambda);
462 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
463
464 /**
465 * @tc.steps: step4. onMove not null and onMoveEvent_ is null.
466 */
467 lazyForEachNode->SetOnMove(std::move(lambda));
468 lazyForEachNode->onMoveEvent_ = nullptr;
469 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
470
471 /**
472 * @tc.steps: step5. onMove is null and onMoveEvent_ not null.
473 */
474 lazyForEachNode->SetOnMove(nullptr);
475 lazyForEachNode->onMoveEvent_ = std::move(lambda);
476 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
477
478 /**
479 * @tc.steps: step6. onMove is null and onMoveEvent_ is null.
480 */
481 lazyForEachNode->SetOnMove(nullptr);
482 lazyForEachNode->onMoveEvent_ = nullptr;
483 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
484 }
485
486 /**
487 * @tc.name: ForEachSyntaxMoveDataFunctionTest001
488 * @tc.desc: Create LazyForEach, update its Items and invoke MoveData function.
489 * @tc.type: FUNC
490 */
491 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxMoveDataFunctionTest001, TestSize.Level1)
492 {
493 /**
494 * @tc.steps: step1. Create Text and push it to view stack processor.
495 * @tc.expected: Make Text as LazyForEach parent.
496 */
497 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
498
499 /**
500 * @tc.steps: step2. Invoke lazyForEach Create function.
501 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
502 */
503 LazyForEachModelNG lazyForEach;
504 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
505 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
506 lazyForEach.Create(mockLazyForEachActuator);
507 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
508 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
509
510 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
511
512
513 lazyForEachNode->MoveData(INDEX_LESS_THAN_START_INDEX, INDEX_GREATER_THAN_END_INDEX);
514 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
515
516 /**
517 * @tc.steps: step4. builder_ is null.
518 */
519 lazyForEachNode->builder_ = nullptr;
520 lazyForEachNode->MoveData(INDEX_LESS_THAN_START_INDEX, INDEX_GREATER_THAN_END_INDEX);
521 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
522 }
523
524 /**
525 * @tc.name: ForEachSyntaxFireOnMoveFunctionTest001
526 * @tc.desc: Create LazyForEach, update its Items and invoke FireOnMove function.
527 * @tc.type: FUNC
528 */
529 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxFireOnMoveFunctionTest001, TestSize.Level1)
530 {
531 /**
532 * @tc.steps: step1. Create Text and push it to view stack processor.
533 * @tc.expected: Make Text as LazyForEach parent.
534 */
535 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
536
537 /**
538 * @tc.steps: step2. Invoke lazyForEach Create function.
539 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
540 */
541 LazyForEachModelNG lazyForEach;
542 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
543 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
544 lazyForEach.Create(mockLazyForEachActuator);
545 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
546 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
547
548 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
549
550 /**
551 * @tc.steps: step3. From index is less than start index, and to index is greater than end index.
552 * @tc.expected: Both out of range, ignored.
553 */
554 lazyForEachNode->FireOnMove(INDEX_LESS_THAN_START_INDEX, INDEX_GREATER_THAN_END_INDEX);
555 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
556
557 /**
558 * @tc.steps: step4. builder_ is null.
559 */
560 lazyForEachNode->builder_ = nullptr;
561 lazyForEachNode->FireOnMove(INDEX_LESS_THAN_START_INDEX, INDEX_MIDDLE);
562 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
563 }
564
565 /**
566 * @tc.name: ForEachSyntaxMoveDataFunctionTest008
567 * @tc.desc: Create LazyForEach, update its Items and invoke OnDataMoved function.
568 * @tc.type: FUNC
569 */
570 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxMoveDataFunctionTest008, TestSize.Level1)
571 {
572 /**
573 * @tc.steps: step1. Create Text and push it to view stack processor.
574 * @tc.expected: Make Text as LazyForEach parent.
575 */
576 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
577
578 /**
579 * @tc.steps: step2. Invoke lazyForEach Create function.
580 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
581 */
582 LazyForEachModelNG lazyForEach;
583 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
584 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
585 lazyForEach.Create(mockLazyForEachActuator);
586 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
587 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
588
589 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
590
591 /**
592 * @tc.steps: step3. From index is less than start index, and to index is greater than end index.
593 * @tc.expected: Both out of range, ignored.
594 */
595 lazyForEachNode->OnDataMoved(INDEX_LESS_THAN_START_INDEX, INDEX_GREATER_THAN_END_INDEX);
596 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
597
598 /**
599 * @tc.steps: step4. From index is in middle of range, and to index is greater than end index..
600 */
601 lazyForEachNode->OnDataMoved(INDEX_MIDDLE, INDEX_GREATER_THAN_END_INDEX);
602 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
603
604 /**
605 * @tc.steps: step5. From index is in middle of range, and to index is in middle of range.
606 */
607 lazyForEachNode->OnDataMoved(INDEX_MIDDLE_2, INDEX_MIDDLE);
608 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
609
610 /**
611 * @tc.steps: step6. From index is less than start index, and to index is in middle of range.
612 */
613 lazyForEachNode->OnDataMoved(INDEX_LESS_THAN_START_INDEX, INDEX_MIDDLE);
614 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
615
616 /**
617 * @tc.steps: step7. builder_ is null.
618 */
619 lazyForEachNode->builder_ = nullptr;
620 lazyForEachNode->OnDataMoved(INDEX_LESS_THAN_START_INDEX, INDEX_MIDDLE);
621 EXPECT_EQ(lazyForEachNode->ids_.size(), DEFAULT_SIZE);
622 }
623
624 /**
625 * @tc.name: ForEachSyntaxWrapperBuilderTest009
626 * @tc.desc: Create LazyForEach, update its Items and update LazyLayoutWrapperBuilder layout range.
627 * @tc.type: FUNC
628 */
629 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxWrapperBuilderTest009, TestSize.Level1)
630 {
631 /**
632 * @tc.steps: step1. Create Text and push it to view stack processor.
633 * @tc.expected: Make Text as LazyForEach parent.
634 */
635 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
636
637 /**
638 * @tc.steps: step2. Invoke lazyForEach Create function.
639 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
640 */
641 LazyForEachModelNG lazyForEach;
642 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
643 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
644 lazyForEach.Create(mockLazyForEachActuator);
645 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
646 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
647
648 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
649
650 /**
651 * @tc.steps: step3. Create Parent LayoutWrapper.
652 */
653 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
654 EXPECT_FALSE(geometryNode == nullptr);
655 auto parentLayoutWrapper =
656 AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
657 /**
658 * @tc.steps: step4. Invoke AdjustLayoutWrapperTree, update lazyLayoutWrapperBuilder index range and its
659 * currentChildCount_.
660 * @tc.expected: lazyLayoutWrapperBuilder preNodeIds_ is equal with lazyForEachNode ids_.
661 */
662 lazyForEachNode->AdjustLayoutWrapperTree(parentLayoutWrapper, false, false);
663 auto lazyLayoutWrapperBuilder =
664 AceType::DynamicCast<LazyLayoutWrapperBuilder>(parentLayoutWrapper->layoutWrapperBuilder_);
665 EXPECT_EQ(parentLayoutWrapper->GetTotalChildCount(), LAZY_FOR_EACH_NODE_IDS.size());
666 EXPECT_EQ(lazyLayoutWrapperBuilder->preNodeIds_, DEFAULT_LAZY_FOR_EACH_NODE_IDS);
667 }
668
669 /**
670 * @tc.name: ForEachSyntaxWrapperBuilderTest010
671 * @tc.desc: Create LazyForEach, update its Items and update LazyLayoutWrapperBuilder layout range.
672 * @tc.type: FUNC
673 */
674 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxWrapperBuilderTest010, TestSize.Level1)
675 {
676 /**
677 * @tc.steps: step1. Create Swiper and push it to view stack processor.
678 * @tc.expected: Make Swiper as LazyForEach parent.
679 */
680 auto frameNode = CreateNode(V2::SWIPER_ETS_TAG);
681
682 /**
683 * @tc.steps: step2. Invoke lazyForEach Create function.
684 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
685 */
686 LazyForEachModelNG lazyForEach;
687 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
688 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
689 lazyForEach.Create(mockLazyForEachActuator);
690 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
691 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
692
693 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
694
695 /**
696 * @tc.steps: step3. Create Parent LayoutWrapper.
697 */
698 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
699 EXPECT_FALSE(geometryNode == nullptr);
700 auto parentLayoutWrapper =
701 AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
702 /**
703 * @tc.steps: step4. Invoke AdjustLayoutWrapperTree, update lazyLayoutWrapperBuilder index range and its
704 * currentChildCount_.
705 * @tc.expected: lazyLayoutWrapperBuilder preNodeIds_ is equal with lazyForEachNode ids_.
706 */
707 lazyForEachNode->AdjustLayoutWrapperTree(parentLayoutWrapper, false, false);
708
709 auto lazyLayoutWrapperBuilder =
710 AceType::DynamicCast<LazyLayoutWrapperBuilder>(parentLayoutWrapper->layoutWrapperBuilder_);
711 EXPECT_EQ(parentLayoutWrapper->GetTotalChildCount(), static_cast<int32_t>(LAZY_FOR_EACH_NODE_IDS.size()));
712 EXPECT_EQ(lazyLayoutWrapperBuilder->preNodeIds_, DEFAULT_LAZY_FOR_EACH_NODE_IDS);
713 }
714
715 /**
716 * @tc.name: ForEachSyntaxWrapperBuilderOnExpandChildLayoutWrapperTest001
717 * @tc.desc: Create LazyForEach, and invoke OnExpandChildLayoutWrapper.
718 * @tc.type: FUNC
719 */
720 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxWrapperBuilderOnExpandChildLayoutWrapperTest001, TestSize.Level1)
721 {
722 /**
723 * @tc.steps: step1. Create lazyLayoutWrapperBuilder and invoke OnExpandChildLayoutWrapper when the childWrappers_
724 * is empty.
725 * @tc.expected: Create childWrapper and add it to childWrappers_.
726 */
727 auto lazyForEachNode = CreateLazyForEachNode();
728 auto lazyLayoutWrapperBuilder = AceType::MakeRefPtr<LazyLayoutWrapperBuilder>(
729 lazyForEachNode->builder_, AceType::WeakClaim(AceType::RawPtr(lazyForEachNode)));
730 lazyLayoutWrapperBuilder->OnExpandChildLayoutWrapper();
731 lazyLayoutWrapperBuilder->AdjustGridOffset();
732 EXPECT_EQ(lazyLayoutWrapperBuilder->childWrappers_.size(), LAZY_FOR_EACH_NODE_IDS.size());
733
734 /**
735 * @tc.steps: step2. Invoke OnExpandChildLayoutWrapper when the childWrappers_ is not empty.
736 * @tc.expected: Return childWrappers_ directly.
737 */
738 EXPECT_EQ(lazyLayoutWrapperBuilder->OnExpandChildLayoutWrapper().size(), LAZY_FOR_EACH_NODE_IDS.size());
739 EXPECT_FALSE(lazyLayoutWrapperBuilder->childWrappers_.empty());
740
741 /**
742 * @tc.steps: step3. Invoke OnExpandChildLayoutWrapper when the childWrappers_ size is not equal with total.
743 * @tc.expected: Return childWrappers_ directly after clear it.
744 */
745 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
746 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
747 lazyLayoutWrapperBuilder->childWrappers_.push_back(
748 AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty()));
749 lazyLayoutWrapperBuilder->OnExpandChildLayoutWrapper();
750 EXPECT_TRUE(lazyLayoutWrapperBuilder->childWrappers_.empty());
751 }
752
753 /**
754 * @tc.name: ForEachSyntaxWrapperBuilderOnGetOrCreateWrapperByIndexTest002
755 * @tc.desc: Create LazyForEach, and invoke OnGetOrCreateWrapperByIndex.
756 * @tc.type: FUNC
757 */
758 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxWrapperBuilderOnExpandChildLayoutWrapperTest002, TestSize.Level1)
759 {
760 /**
761 * @tc.steps: step1. Create lazyLayoutWrapperBuilder and invoke OnExpandChildLayoutWrapper when the childWrappers_
762 * is empty.
763 * @tc.expected: Create childWrapper and add it to childWrappers_.
764 */
765 auto lazyForEachNode = CreateLazyForEachNode();
766 auto lazyLayoutWrapperBuilder = AceType::MakeRefPtr<LazyLayoutWrapperBuilder>(
767 lazyForEachNode->builder_, AceType::WeakClaim(AceType::RawPtr(lazyForEachNode)));
768 lazyLayoutWrapperBuilder->OnExpandChildLayoutWrapper();
769
770 /**
771 * @tc.steps: step2. Invoke OnGetOrCreateWrapperByIndex when the index is invalid or not.
772 * @tc.expected: Return nullptr when index is invalid and return the corresponding wrapper when it is valid.
773 */
774 EXPECT_EQ(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INVALID_START_ID_LESS_THAN_0), nullptr);
775 EXPECT_EQ(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INVALID_START_ID_GREATER_THAN_TOTAL), nullptr);
776 ASSERT_NE(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_2), nullptr);
777
778 /**
779 * @tc.steps: step3. Invoke OnGetOrCreateWrapperByIndex when the startIndex_ is null.
780 */
781 lazyLayoutWrapperBuilder->startIndex_ = std::nullopt;
782 ASSERT_NE(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_2), nullptr);
783 EXPECT_EQ(lazyLayoutWrapperBuilder->startIndex_.value_or(DEFAULT_INDEX), INDEX_2);
784 EXPECT_EQ(lazyLayoutWrapperBuilder->endIndex_.value_or(DEFAULT_INDEX), INDEX_2);
785
786 /**
787 * @tc.steps: step4. Invoke OnGetOrCreateWrapperByIndex when the index is not in the range of the starIndex and
788 * endIndex.
789 */
790 EXPECT_EQ(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_4), nullptr);
791 EXPECT_EQ(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_0), nullptr);
792
793 /**
794 * @tc.steps: step5. Invoke OnGetOrCreateWrapperByIndex when the index is not in the range of the starIndex and
795 * endIndex.
796 */
797 EXPECT_EQ(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_4), nullptr);
798 EXPECT_EQ(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_0), nullptr);
799
800 /**
801 * @tc.steps: step6. Invoke OnGetOrCreateWrapperByIndex when the index is not in the range of the starIndex and
802 * endIndex.
803 */
804 lazyLayoutWrapperBuilder->UpdateIndexRange(INDEX_2, INDEX_8, LAZY_FOR_EACH_NODE_IDS);
805 lazyLayoutWrapperBuilder->startIndex_ = std::nullopt;
806 ASSERT_NE(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_4), nullptr);
807 lazyLayoutWrapperBuilder->UpdateIndexRange(INDEX_2, INDEX_8, LAZY_FOR_EACH_NODE_IDS);
808 lazyLayoutWrapperBuilder->startIndex_ = std::nullopt;
809 ASSERT_NE(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_1), nullptr);
810 ASSERT_NE(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_0), nullptr);
811 }
812
813 /**
814 * @tc.name: ForEachSyntaxWrapperBuilderSwapDirtyAndUpdateBuildCacheTest003
815 * @tc.desc: Create LazyForEach, and invoke SwapDirtyAndUpdateBuildCache.
816 * @tc.type: FUNC
817 */
818 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxWrapperBuilderSwapDirtyAndUpdateBuildCacheTest003, TestSize.Level1)
819 {
820 /**
821 * @tc.steps: step1. Create lazyLayoutWrapperBuilder and invoke SwapDirtyAndUpdateBuildCache when the childWrappers_
822 * is empty or not.
823 */
824 auto lazyForEachNode = CreateLazyForEachNode();
825 auto lazyLayoutWrapperBuilder = AceType::MakeRefPtr<LazyLayoutWrapperBuilder>(
826 lazyForEachNode->builder_, AceType::WeakClaim(AceType::RawPtr(lazyForEachNode)));
827 EXPECT_EQ(lazyLayoutWrapperBuilder->startIndex_.value_or(DEFAULT_INDEX), NEW_START_ID);
828 EXPECT_EQ(lazyLayoutWrapperBuilder->endIndex_.value_or(DEFAULT_INDEX), NEW_START_ID);
829
830 lazyLayoutWrapperBuilder->OnExpandChildLayoutWrapper();
831 lazyLayoutWrapperBuilder->SwapDirtyAndUpdateBuildCache();
832 EXPECT_EQ(lazyLayoutWrapperBuilder->endIndex_.value_or(DEFAULT_INDEX), NEW_END_ID);
833
834 /**
835 * @tc.steps: step1. Create lazyLayoutWrapperBuilder and invoke SwapDirtyAndUpdateBuildCache when cacheCount is not
836 * 0.
837 */
838 auto lazyForEachNode1 = CreateLazyForEachNode();
839 auto lazyLayoutWrapperBuilder1 = AceType::MakeRefPtr<LazyLayoutWrapperBuilder>(
840 lazyForEachNode1->builder_, AceType::WeakClaim(AceType::RawPtr(lazyForEachNode1)));
841 lazyLayoutWrapperBuilder1->OnExpandChildLayoutWrapper();
842 /**
843 * @tc.steps: step2. Invoke SwapDirtyAndUpdateBuildCache when cacheCount is not empty and frontNodeIds is not empty
844 * but backNodeIds is not empty.
845 */
846 lazyLayoutWrapperBuilder1->SetCacheCount(CACHE_COUNT);
847 lazyLayoutWrapperBuilder1->SwapDirtyAndUpdateBuildCache();
848
849 /**
850 * @tc.steps: step3. Set [3, 5] is active.
851 */
852 auto lazyForEachNode2 = CreateLazyForEachNode();
853 auto lazyLayoutWrapperBuilder2 = AceType::MakeRefPtr<LazyLayoutWrapperBuilder>(
854 lazyForEachNode2->builder_, AceType::WeakClaim(AceType::RawPtr(lazyForEachNode2)));
855 lazyLayoutWrapperBuilder2->OnExpandChildLayoutWrapper();
856 auto childWrapper = lazyLayoutWrapperBuilder2->childWrappers_;
857 auto childWrapperIter = childWrapper.begin();
858 int32_t index = 0;
859 while (childWrapperIter != childWrapper.end()) {
860 if (index >= INDEX_3 && index <= INDEX_5) {
861 (*childWrapperIter)->SetActive(true);
862 }
863 index++;
864 childWrapperIter++;
865 }
866 lazyLayoutWrapperBuilder2->SetCacheCount(CACHE_COUNT);
867 lazyLayoutWrapperBuilder2->SwapDirtyAndUpdateBuildCache();
868 }
869
870 /**
871 * @tc.name: ForEachSyntaxWrapperBuilderOnGetOrCreateWrapperByIndexTest004
872 * @tc.desc: Create LazyForEach, and invoke OnGetOrCreateWrapperByIndex.
873 * @tc.type: FUNC
874 */
875 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxWrapperBuilderOnGetOrCreateWrapperByIndexTest004, TestSize.Level1)
876 {
877 /**
878 * @tc.steps: step1. Create lazyLayoutWrapperBuilder and invoke OnExpandChildLayoutWrapper when the childWrappers_
879 * is empty.
880 * @tc.expected: Create childWrapper and add it to childWrappers_.
881 */
882 auto lazyForEachNode = CreateLazyForEachNode();
883 auto lazyLayoutWrapperBuilder = AceType::MakeRefPtr<LazyLayoutWrapperBuilder>(
884 lazyForEachNode->builder_, AceType::WeakClaim(AceType::RawPtr(lazyForEachNode)));
885 lazyLayoutWrapperBuilder->OnExpandChildLayoutWrapper();
886
887 /**
888 * @tc.steps: step2. Invoke OnGetOrCreateWrapperByIndex when the index is invalid or not.
889 * @tc.expected: Return nullptr when index is invalid and return the corresponding wrapper when it is valid.
890 */
891 lazyLayoutWrapperBuilder->lazySwiper_ = false;
892 lazyLayoutWrapperBuilder->startIndex_ = std::nullopt;
893 EXPECT_NE(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_2), nullptr);
894
895 /**
896 * @tc.steps: step3. Invoke OnGetOrCreateWrapperByIndex when the startIndex_ is null.
897 */
898 lazyLayoutWrapperBuilder->startIndex_ = INDEX_2;
899 EXPECT_NE(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_2), nullptr);
900 EXPECT_EQ(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(DEFAULT_INDEX), nullptr);
901
902 /**
903 * @tc.steps: step4. Invoke OnGetOrCreateWrapperByIndex when the index is not in the range of the starIndex and
904 * endIndex.
905 */
906 lazyLayoutWrapperBuilder->lazySwiper_ = true;
907 lazyLayoutWrapperBuilder->startIndex_ = std::nullopt;
908 EXPECT_NE(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_2), nullptr);
909 EXPECT_EQ(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_0), nullptr);
910
911 /**
912 * @tc.steps: step5. Invoke OnGetOrCreateWrapperByIndex when the index is not in the range of the starIndex and
913 * endIndex.
914 */
915 lazyLayoutWrapperBuilder->lazySwiper_ = true;
916 lazyLayoutWrapperBuilder->startIndex_ = INDEX_2;
917 EXPECT_NE(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_2), nullptr);
918 EXPECT_EQ(lazyLayoutWrapperBuilder->OnGetOrCreateWrapperByIndex(INDEX_0), nullptr);
919 }
920
921 /**
922 * @tc.name: ForEachSyntaxWrapperBuilderGetKeyByIndexFromPreNodesTest005
923 * @tc.desc: Create LazyForEach, and invoke GetKeyByIndexFromPreNodes.
924 * @tc.type: FUNC
925 */
926 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxWrapperBuilderGetKeyByIndexFromPreNodesTest005, TestSize.Level1)
927 {
928 /**
929 * @tc.steps: step1. Create lazyLayoutWrapperBuilder and invoke SwapDirtyAndUpdateBuildCache when the childWrappers_
930 * is empty or not.
931 */
932 auto lazyForEachNode = CreateLazyForEachNode();
933 auto lazyLayoutWrapperBuilder = AceType::MakeRefPtr<LazyLayoutWrapperBuilder>(
934 lazyForEachNode->builder_, AceType::WeakClaim(AceType::RawPtr(lazyForEachNode)));
935 EXPECT_EQ(lazyLayoutWrapperBuilder->startIndex_.value_or(DEFAULT_INDEX), NEW_START_ID);
936 EXPECT_EQ(lazyLayoutWrapperBuilder->endIndex_.value_or(DEFAULT_INDEX), NEW_START_ID);
937
938 lazyLayoutWrapperBuilder->OnExpandChildLayoutWrapper();
939 lazyLayoutWrapperBuilder->SwapDirtyAndUpdateBuildCache();
940 EXPECT_EQ(lazyLayoutWrapperBuilder->endIndex_.value_or(DEFAULT_INDEX), NEW_END_ID);
941
942 /**
943 * @tc.steps: step1. Create lazyLayoutWrapperBuilder and invoke SwapDirtyAndUpdateBuildCache when cacheCount is not
944 * 0.
945 */
946 lazyLayoutWrapperBuilder->preStartIndex_ = START_ID;
947 lazyLayoutWrapperBuilder->preEndIndex_ = INDEX_5;
948 auto key = lazyLayoutWrapperBuilder->GetKeyByIndexFromPreNodes(NEW_END_ID);
949 EXPECT_EQ(key, std::nullopt);
950
951 key = lazyLayoutWrapperBuilder->GetKeyByIndexFromPreNodes(INDEX_8);
952 EXPECT_EQ(key, std::nullopt);
953
954 lazyLayoutWrapperBuilder->preEndIndex_ = INDEX_8;
955 key = lazyLayoutWrapperBuilder->GetKeyByIndexFromPreNodes(START_ID);
956 key = lazyLayoutWrapperBuilder->GetKeyByIndexFromPreNodes(NEW_END_ID);
957 lazyForEachNode->BuildAllChildren();
958 EXPECT_EQ(key, std::nullopt);
959 }
960
961 /**
962 * @tc.name: LazyForEachSyntaxAbnormalCreateTest001
963 * @tc.desc: Create LazyForEach in abnormal condition.
964 * @tc.type: FUNC
965 */
966 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxAbnormalCreateTest001, TestSize.Level1)
967 {
968 /**
969 * @tc.steps: step1. Create Text and push it to view stack processor.
970 * @tc.expected: Make Text as LazyForEach parent.
971 */
972 const RefPtr<LazyForEachBuilder> mockLazyForEachBuilder =
973 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
974 auto frameNode = LazyForEachNode::GetOrCreateLazyForEachNode(LAZY_FOR_EACH_NODE_ID, mockLazyForEachBuilder);
975 auto firstrFrameNode = LazyForEachNode::GetOrCreateLazyForEachNode(LAZY_FOR_EACH_NODE_ID, mockLazyForEachBuilder);
976 const RefPtr<LazyForEachBuilder> anothermockLazyForEachBuilder =
977 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
978 auto secondFrameNode =
979 LazyForEachNode::GetOrCreateLazyForEachNode(LAZY_FOR_EACH_NODE_ID, anothermockLazyForEachBuilder);
980 auto thirdFrameNode =
981 LazyForEachNode::GetOrCreateLazyForEachNode(LAZY_FOR_EACH_NODE_ID, anothermockLazyForEachBuilder);
982
983 /**
984 * @tc.steps: step2. Invoke lazyForEach Create function.
985 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
986 */
987 EXPECT_TRUE(frameNode == firstrFrameNode);
988 EXPECT_TRUE(frameNode == secondFrameNode);
989 }
990
991 /**
992 * @tc.name: ForEachSyntaxBuildAllChildrenTest001
993 * @tc.desc: Create LazyForEach, update its Items and invoke BuildAllChildren function.
994 * @tc.type: FUNC
995 */
996 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxBuildAllChildrenTest001, TestSize.Level1)
997 {
998 /**
999 * @tc.steps: step1. Create Text and push it to view stack processor.
1000 * @tc.expected: Make Text as LazyForEach parent.
1001 */
1002 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1003
1004 /**
1005 * @tc.steps: step2. Invoke lazyForEach Create function.
1006 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1007 */
1008 LazyForEachModelNG lazyForEach;
1009 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1010 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1011 lazyForEach.Create(mockLazyForEachActuator);
1012 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1013 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
1014
1015 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
1016
1017 /**
1018 * @tc.steps: step3. Invoke BuildAllChildren.
1019 * @tc.expected: LazyForEachNode ids_ will be cleared.
1020 */
1021 lazyForEachNode->BuildAllChildren();
1022 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1023 }
1024
1025 /**
1026 * @tc.name: ForEachSyntaxPostIdleTaskTest001
1027 * @tc.desc: Create LazyForEach, update its Items and invoke PostIdleTask function.
1028 * @tc.type: FUNC
1029 */
1030 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxPostIdleTaskTest001, TestSize.Level1)
1031 {
1032 /**
1033 * @tc.steps: step1. Create Text and push it to view stack processor.
1034 * @tc.expected: Make Text as LazyForEach parent.
1035 */
1036 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1037
1038 /**
1039 * @tc.steps: step2. Invoke lazyForEach Create function.
1040 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1041 */
1042 LazyForEachModelNG lazyForEach;
1043 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1044 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1045 lazyForEach.Create(mockLazyForEachActuator);
1046 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1047 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
1048
1049 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
1050
1051 /**
1052 * @tc.steps: step3. Invoke PostIdleTask.
1053 * @tc.expected: LazyForEachNode ids_ will be cleared.
1054 */
1055 lazyForEachNode->needPredict_ = false;
1056 lazyForEachNode->PostIdleTask();
1057 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1058
1059 /**
1060 * @tc.steps: step3. Invoke PostIdleTask.
1061 * @tc.expected: LazyForEachNode ids_ will be cleared.
1062 */
1063 lazyForEachNode->needPredict_ = true;
1064 lazyForEachNode->PostIdleTask();
1065 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1066 }
1067
1068 /**
1069 * @tc.name: ForEachSyntaxGetFrameChildByIndexTest001
1070 * @tc.desc: Create LazyForEach, update its Items and invoke :GetFrameChildByIndex function.
1071 * @tc.type: FUNC
1072 */
1073 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxGetFrameChildByIndexTest001, TestSize.Level1)
1074 {
1075 /**
1076 * @tc.steps: step1. Create Text and push it to view stack processor.
1077 * @tc.expected: Make Text as LazyForEach parent.
1078 */
1079 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1080
1081 /**
1082 * @tc.steps: step2. Invoke lazyForEach Create function.
1083 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1084 */
1085 LazyForEachModelNG lazyForEach;
1086 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1087 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1088 lazyForEach.Create(mockLazyForEachActuator);
1089 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1090 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
1091
1092 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
1093
1094 /**
1095 * @tc.steps: step3. Invoke GetFrameChildByIndex.
1096 * @tc.expected: LazyForEachNode ids_ will be cleared.
1097 */
1098 lazyForEachNode->needPredict_ = false;
1099 lazyForEachNode->GetFrameChildByIndex(0, true);
1100 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1101
1102 /**
1103 * @tc.steps: step3. Invoke GetFrameChildByIndex.
1104 * @tc.expected: LazyForEachNode ids_ will be cleared.
1105 */
1106 lazyForEachNode->needPredict_ = true;
1107 lazyForEachNode->GetFrameChildByIndex(0, false);
1108 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1109
1110 /**
1111 * @tc.steps: step3. Invoke GetFrameChildByIndex.
1112 * @tc.expected: LazyForEachNode ids_ will be cleared.
1113 */
1114 lazyForEachNode->GetFrameChildByIndex(INDEX_EQUAL_WITH_START_INDEX_DELETED, true);
1115 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1116 }
1117
1118 /**
1119 * @tc.name: ForEachSyntaxGetIndexByUINodeTest001
1120 * @tc.desc: Create LazyForEach, update its Items and invoke :GetIndexByUINode function.
1121 * @tc.type: FUNC
1122 */
1123 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxGetIndexByUINodeTest001, TestSize.Level1)
1124 {
1125 /**
1126 * @tc.steps: step1. Create Text and push it to view stack processor.
1127 * @tc.expected: Make Text as LazyForEach parent.
1128 */
1129 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1130
1131 /**
1132 * @tc.steps: step2. Invoke lazyForEach Create function.
1133 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1134 */
1135 LazyForEachModelNG lazyForEach;
1136 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1137 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1138 lazyForEach.Create(mockLazyForEachActuator);
1139 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1140 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
1141
1142 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
1143
1144 /**
1145 * @tc.steps: step3. Invoke GetIndexByUINode.
1146 * @tc.expected: LazyForEachNode ids_ will be cleared.
1147 */
1148 lazyForEachNode->needPredict_ = false;
1149 lazyForEachNode->GetIndexByUINode(frameNode);
1150 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1151
1152 /**
1153 * @tc.steps: step3. Invoke GetIndexByUINode.
1154 * @tc.expected: LazyForEachNode ids_ will be cleared.
1155 */
1156 lazyForEachNode->needPredict_ = true;
1157 lazyForEachNode->GetIndexByUINode(frameNode);
1158 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1159
1160 /**
1161 * @tc.steps: step3. Invoke GetIndexByUINode.
1162 * @tc.expected: LazyForEachNode ids_ will be cleared.
1163 */
1164 lazyForEachNode->builder_ = nullptr;
1165 lazyForEachNode->needPredict_ = true;
1166 lazyForEachNode->GetIndexByUINode(frameNode);
1167 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1168 }
1169
1170 /**
1171 * @tc.name: ForEachSyntaxDoRemoveChildInRenderTreeTest001
1172 * @tc.desc: Create LazyForEach, update its Items and invoke :DoRemoveChildInRenderTree function.
1173 * @tc.type: FUNC
1174 */
1175 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxDoRemoveChildInRenderTreeTest001, TestSize.Level1)
1176 {
1177 /**
1178 * @tc.steps: step1. Create Text and push it to view stack processor.
1179 * @tc.expected: Make Text as LazyForEach parent.
1180 */
1181 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1182
1183 /**
1184 * @tc.steps: step2. Invoke lazyForEach Create function.
1185 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1186 */
1187 LazyForEachModelNG lazyForEach;
1188 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1189 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1190 lazyForEach.Create(mockLazyForEachActuator);
1191 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1192 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
1193
1194 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
1195
1196 /**
1197 * @tc.steps: step3. Invoke DoRemoveChildInRenderTree.
1198 * @tc.expected: LazyForEachNode ids_ will be cleared.
1199 */
1200 lazyForEachNode->needPredict_ = false;
1201 lazyForEachNode->DoRemoveChildInRenderTree(0, true);
1202 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1203
1204 /**
1205 * @tc.steps: step3. Invoke DoRemoveChildInRenderTree.
1206 * @tc.expected: LazyForEachNode ids_ will be cleared.
1207 */
1208 lazyForEachNode->needPredict_ = true;
1209 lazyForEachNode->DoRemoveChildInRenderTree(0, false);
1210 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1211
1212 /**
1213 * @tc.steps: step3. Invoke DoRemoveChildInRenderTree.
1214 * @tc.expected: LazyForEachNode ids_ will be cleared.
1215 */
1216 lazyForEachNode->needPredict_ = true;
1217 lazyForEachNode->builder_ = nullptr; ///
1218 lazyForEachNode->DoRemoveChildInRenderTree(0, false);
1219 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1220 }
1221
1222 /**
1223 * @tc.name: ForEachSyntaxGetChildrenTest001
1224 * @tc.desc: Create LazyForEach, update its Items and invoke :GetChildren function.
1225 * @tc.type: FUNC
1226 */
1227 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxGetChildrenTest001, TestSize.Level1)
1228 {
1229 /**
1230 * @tc.steps: step1. Create Text and push it to view stack processor.
1231 * @tc.expected: Make Text as LazyForEach parent.
1232 */
1233 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1234
1235 /**
1236 * @tc.steps: step2. Invoke lazyForEach Create function.
1237 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1238 */
1239 LazyForEachModelNG lazyForEach;
1240 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1241 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1242 lazyForEach.Create(mockLazyForEachActuator);
1243 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1244 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
1245
1246 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
1247
1248 /**
1249 * @tc.steps: step3. Invoke GetChildren.
1250 * @tc.expected: LazyForEachNode ids_ will be cleared.
1251 */
1252 lazyForEachNode->needPredict_ = false;
1253 lazyForEachNode->GetChildren();
1254 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1255
1256 /**
1257 * @tc.steps: step3. Invoke GetChildren.
1258 * @tc.expected: LazyForEachNode ids_ will be cleared.
1259 */
1260 lazyForEachNode->needPredict_ = true;
1261 lazyForEachNode->GetChildren();
1262 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1263 }
1264
1265 /**
1266 * @tc.name: ForEachSyntaxOnDataBulkAddedTest001
1267 * @tc.desc: Create LazyForEach, update its Items and invoke :OnDataBulkAdded function.
1268 * @tc.type: FUNC
1269 */
1270 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxOnDataBulkAddedTest001, TestSize.Level1)
1271 {
1272 /**
1273 * @tc.steps: step1. Create Text and push it to view stack processor.
1274 * @tc.expected: Make Text as LazyForEach parent.
1275 */
1276 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1277
1278 /**
1279 * @tc.steps: step2. Invoke lazyForEach Create function.
1280 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1281 */
1282 LazyForEachModelNG lazyForEach;
1283 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1284 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1285 lazyForEach.Create(mockLazyForEachActuator);
1286 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1287
1288 /**
1289 * @tc.steps: step3. Invoke GetChildren.
1290 * @tc.expected: LazyForEachNode ids_ will be cleared.
1291 */
1292 lazyForEachNode->OnDataBulkAdded(INDEX_0, INDEX_0);
1293 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1294 }
1295
1296 /**
1297 * @tc.name: ForEachSyntaxOnDataBulkDeletedTest001
1298 * @tc.desc: Create LazyForEach, update its Items and invoke :OnDataBulkDeleted function.
1299 * @tc.type: FUNC
1300 */
1301 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxOnDataBulkDeletedTest001, TestSize.Level1)
1302 {
1303 /**
1304 * @tc.steps: step1. Create Text and push it to view stack processor.
1305 * @tc.expected: Make Text as LazyForEach parent.
1306 */
1307 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1308
1309 /**
1310 * @tc.steps: step2. Invoke lazyForEach Create function.
1311 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1312 */
1313 LazyForEachModelNG lazyForEach;
1314 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1315 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1316 lazyForEach.Create(mockLazyForEachActuator);
1317 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1318 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1319
1320
1321 lazyForEachBuilder->OnDataBulkDeleted(INDEX_0, INDEX_0);
1322 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1323 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1324 }
1325 lazyForEachBuilder->OnDataChanged(INDEX_1);
1326 lazyForEachNode->OnDataBulkDeleted(INDEX_0, INDEX_1);
1327
1328 /**
1329 * @tc.steps: step3. Invoke OnDataBulkDeleted.
1330 * @tc.expected: LazyForEachNode ids_ will be cleared.
1331 */
1332 lazyForEachNode->OnDataBulkDeleted(INDEX_0, INDEX_0);
1333 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1334 }
1335
1336 /**
1337 * @tc.name: ForEachSyntaxNotifyDataCountChangedTest001
1338 * @tc.desc: Create LazyForEach, update its Items and invoke :NotifyDataCountChanged function.
1339 * @tc.type: FUNC
1340 */
1341 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxNotifyDataCountChangedTest001, TestSize.Level1)
1342 {
1343 /**
1344 * @tc.steps: step1. Create Text and push it to view stack processor.
1345 * @tc.expected: Make Text as LazyForEach parent.
1346 */
1347 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1348
1349 /**
1350 * @tc.steps: step2. Invoke lazyForEach Create function.
1351 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1352 */
1353 LazyForEachModelNG lazyForEach;
1354 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1355 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1356 lazyForEach.Create(mockLazyForEachActuator);
1357 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1358
1359 /**
1360 * @tc.steps: step3. Invoke NotifyDataCountChanged.
1361 * @tc.expected: LazyForEachNode ids_ will be cleared.
1362 */
1363 lazyForEachNode->NotifyChangeWithCount(INDEX_0, 0, UINode::NotificationType::START_CHANGE_POSITION);
1364 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1365 }
1366
1367 /**
1368 * @tc.name: ForEachSyntaxMarkNeedSyncRenderTreeTest001
1369 * @tc.desc: Create LazyForEach, update its Items and invoke :MarkNeedSyncRenderTree function.
1370 * @tc.type: FUNC
1371 */
1372 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxMarkNeedSyncRenderTreeTest001, TestSize.Level1)
1373 {
1374 /**
1375 * @tc.steps: step1. Create Text and push it to view stack processor.
1376 * @tc.expected: Make Text as LazyForEach parent.
1377 */
1378 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1379
1380 /**
1381 * @tc.steps: step2. Invoke lazyForEach Create function.
1382 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1383 */
1384 LazyForEachModelNG lazyForEach;
1385 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1386 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1387 lazyForEach.Create(mockLazyForEachActuator);
1388 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1389
1390 /**
1391 * @tc.steps: step3. Invoke MarkNeedSyncRenderTree.
1392 * @tc.expected: LazyForEachNode ids_ will be cleared.
1393 */
1394 lazyForEachNode->needMarkParent_ = true;
1395 lazyForEachNode->MarkNeedSyncRenderTree(true);
1396
1397 lazyForEachNode->needMarkParent_ = false;
1398 lazyForEachNode->MarkNeedSyncRenderTree(true);
1399 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1400 }
1401
1402 /**
1403 * @tc.name: ForEachSyntaxRecycleItemsTest001
1404 * @tc.desc: Create LazyForEach, update its Items and invoke :RecycleItems function.
1405 * @tc.type: FUNC
1406 */
1407 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxRecycleItemsTest001, TestSize.Level1)
1408 {
1409 /**
1410 * @tc.steps: step1. Create Text and push it to view stack processor.
1411 * @tc.expected: Make Text as LazyForEach parent.
1412 */
1413 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1414
1415 /**
1416 * @tc.steps: step2. Invoke lazyForEach Create function.
1417 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1418 */
1419 LazyForEachModelNG lazyForEach;
1420 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1421 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1422 lazyForEach.Create(mockLazyForEachActuator);
1423 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1424 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
1425
1426 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
1427
1428 /**
1429 * @tc.steps: step3. Invoke RecycleItems.
1430 * @tc.expected: LazyForEachNode ids_ will be cleared.
1431 */
1432 lazyForEachNode->startIndex_ = 1;
1433 lazyForEachNode->count_ = 1;
1434 lazyForEachNode->RecycleItems(0, 6);
1435 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1436
1437 /**
1438 * @tc.steps: step3. Invoke RecycleItems.
1439 * @tc.expected: LazyForEachNode ids_ will be cleared.
1440 */
1441 lazyForEachNode->startIndex_ = 7;
1442 lazyForEachNode->count_ = 1;
1443 lazyForEachNode->RecycleItems(0, 6);
1444 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1445
1446 /**
1447 * @tc.steps: step3. Invoke RecycleItems.
1448 * @tc.expected: LazyForEachNode ids_ will be cleared.
1449 */
1450 lazyForEachNode->builder_ = nullptr;
1451 lazyForEachNode->RecycleItems(0, 6);
1452 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1453 }
1454
1455 /**
1456 * @tc.name: ForEachSyntaxDoSetActiveChildRangeTest001
1457 * @tc.desc: Create LazyForEach, update its Items and invoke :DoSetActiveChildRange function.
1458 * @tc.type: FUNC
1459 */
1460 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxDoSetActiveChildRangeTest001, TestSize.Level1)
1461 {
1462 /**
1463 * @tc.steps: step1. Create Text and push it to view stack processor.
1464 * @tc.expected: Make Text as LazyForEach parent.
1465 */
1466 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1467
1468 /**
1469 * @tc.steps: step2. Invoke lazyForEach Create function.
1470 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1471 */
1472 LazyForEachModelNG lazyForEach;
1473 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1474 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1475 lazyForEach.Create(mockLazyForEachActuator);
1476 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1477 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
1478
1479 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
1480
1481 /**
1482 * @tc.steps: step3. Invoke DoSetActiveChildRange.
1483 * @tc.expected: LazyForEachNode ids_ will be cleared.
1484 */
1485 lazyForEachNode->DoSetActiveChildRange(0, 0, 0, 0);
1486 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1487
1488 /**
1489 * @tc.steps: step3. Invoke DoSetActiveChildRange.
1490 * @tc.expected: LazyForEachNode ids_ will be cleared.
1491 */
1492 lazyForEachNode->builder_ = nullptr;
1493 lazyForEachNode->DoSetActiveChildRange(0, 0, 0, 0);
1494 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1495 }
1496
1497 /**
1498 * @tc.name: ForEachSyntaxOnConfigurationUpdateTest001
1499 * @tc.desc: Create LazyForEach, update its Items and invoke :OnConfigurationUpdate function.
1500 * @tc.type: FUNC
1501 */
1502 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxOnConfigurationUpdateTest001, TestSize.Level1)
1503 {
1504 /**
1505 * @tc.steps: step1. Create Text and push it to view stack processor.
1506 * @tc.expected: Make Text as LazyForEach parent.
1507 */
1508 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1509
1510 /**
1511 * @tc.steps: step2. Invoke lazyForEach Create function.
1512 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1513 */
1514 LazyForEachModelNG lazyForEach;
1515 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1516 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1517 lazyForEach.Create(mockLazyForEachActuator);
1518 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1519 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
1520 ConfigurationChange configurationChange;
1521
1522 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
1523
1524 /**
1525 * @tc.steps: step3. Invoke OnConfigurationUpdate.
1526 * @tc.expected: LazyForEachNode ids_ will be cleared.
1527 */
1528 lazyForEachNode->OnConfigurationUpdate(configurationChange);
1529 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1530
1531 /**
1532 * @tc.steps: step3. Invoke OnConfigurationUpdate.
1533 * @tc.expected: LazyForEachNode ids_ will be cleared.
1534 */
1535 configurationChange.colorModeUpdate = true;
1536 lazyForEachNode->OnConfigurationUpdate(configurationChange);
1537 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1538 }
1539
1540 /**
1541 * @tc.name: LazyForEachSyntaxOnDataReloadedTest001
1542 * @tc.desc: Create LazyForEach.
1543 * @tc.type: FUNC
1544 */
1545 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataReloadedTest001, TestSize.Level1)
1546 {
1547 /**
1548 * @tc.steps: step1. Create Text and push it to view stack processor.
1549 * @tc.expected: Make Text as LazyForEach parent.
1550 */
1551 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1552
1553 /**
1554 * @tc.steps: step2. Invoke lazyForEach Create function.
1555 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1556 */
1557 LazyForEachModelNG lazyForEach;
1558 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1559 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1560 lazyForEach.Create(mockLazyForEachActuator);
1561 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1562
1563 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1564 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1565 }
1566 lazyForEachBuilder->OnDataReloaded();
1567 lazyForEachBuilder->OnDataChanged(INDEX_1);
1568 lazyForEachBuilder->OnDataReloaded();
1569 }
1570
1571 /**
1572 * @tc.name: LazyForEachSyntaxOnDataReloadedTest002
1573 * @tc.desc: Create LazyForEach.
1574 * @tc.type: FUNC
1575 */
1576 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataReloadedTest002, TestSize.Level1)
1577 {
1578 /**
1579 * @tc.steps: step1. Create Text and push it to view stack processor.
1580 * @tc.expected: Make Text as LazyForEach parent.
1581 */
1582 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1583
1584 /**
1585 * @tc.steps: step2. Invoke lazyForEach Create function.
1586 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1587 */
1588 LazyForEachModelNG lazyForEach;
1589 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1590 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1591 lazyForEach.Create(mockLazyForEachActuator);
1592 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1593
1594 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1595 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1596 }
1597 std::list<V2::Operation> DataOperations;
1598 V2::Operation operation1 = {.type = "reload"};
1599 DataOperations.push_back(operation1);
1600 lazyForEachBuilder->OnDatasetChange(DataOperations);
1601 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 0);
1602 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1603 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1604 }
1605 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 7);
1606 }
1607
1608 /**
1609 * @tc.name: LazyForEachSyntaxOnDataAddedTest001
1610 * @tc.desc: Create LazyForEach.
1611 * @tc.type: FUNC
1612 */
1613 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataAddedTest001, TestSize.Level1)
1614 {
1615 /**
1616 * @tc.steps: step1. Create Text and push it to view stack processor.
1617 * @tc.expected: Make Text as LazyForEach parent.
1618 */
1619 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1620
1621 /**
1622 * @tc.steps: step2. Invoke lazyForEach Create function.
1623 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1624 */
1625 LazyForEachModelNG lazyForEach;
1626 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1627 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1628 lazyForEach.Create(mockLazyForEachActuator);
1629 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1630
1631 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1632 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1633 }
1634 lazyForEachBuilder->useNewInterface_ = true;
1635 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1636 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true, true);
1637 }
1638 lazyForEachBuilder->OnDataAdded(INDEX_0);
1639 lazyForEachBuilder->OnDataChanged(INDEX_1);
1640 lazyForEachBuilder->OnDataAdded(INDEX_0);
1641 }
1642
1643 /**
1644 * @tc.name: LazyForEachSyntaxOnDataAddedTest002
1645 * @tc.desc: Create LazyForEach.
1646 * @tc.type: FUNC
1647 */
1648 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataAddedTest002, TestSize.Level1)
1649 {
1650 /**
1651 * @tc.steps: step1. Create Text and push it to view stack processor.
1652 * @tc.expected: Make Text as LazyForEach parent.
1653 */
1654 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1655
1656 /**
1657 * @tc.steps: step2. Invoke lazyForEach Create function.
1658 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1659 */
1660 LazyForEachModelNG lazyForEach;
1661 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1662 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1663 lazyForEach.Create(mockLazyForEachActuator);
1664 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1665
1666 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1667 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1668 }
1669 std::list<V2::Operation> DataOperations;
1670 V2::Operation operation1 = {.type = "add", .index = INDEX_0, .count = 1};
1671 DataOperations.push_back(operation1);
1672 lazyForEachBuilder->OnDatasetChange(DataOperations);
1673 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1674 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1675 }
1676 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 8);
1677 DataOperations.clear();
1678 V2::Operation operation2 = {.type = "add", .index = INDEX_0, .count = 2};
1679 DataOperations.push_back(operation2);
1680 lazyForEachBuilder->OnDatasetChange(DataOperations);
1681 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1682 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1683 }
1684 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 10);
1685 }
1686
1687 /**
1688 * @tc.name: LazyForEachSyntaxOnDataBulkAddedTest001
1689 * @tc.desc: Create LazyForEach.
1690 * @tc.type: FUNC
1691 */
1692 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataBulkAddedTest001, TestSize.Level1)
1693 {
1694 /**
1695 * @tc.steps: step1. Create Text and push it to view stack processor.
1696 * @tc.expected: Make Text as LazyForEach parent.
1697 */
1698 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1699
1700 /**
1701 * @tc.steps: step2. Invoke lazyForEach Create function.
1702 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1703 */
1704 LazyForEachModelNG lazyForEach;
1705 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1706 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1707 lazyForEach.Create(mockLazyForEachActuator);
1708 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1709
1710 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1711 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1712 }
1713 lazyForEachBuilder->OnDataBulkAdded(INDEX_0, INDEX_0);
1714 lazyForEachBuilder->OnDataChanged(INDEX_1);
1715 lazyForEachBuilder->OnDataBulkAdded(INDEX_0, INDEX_0);
1716 }
1717
1718 /**
1719 * @tc.name: LazyForEachSyntaxOnDataDeletedTest001
1720 * @tc.desc: Create LazyForEach.
1721 * @tc.type: FUNC
1722 */
1723 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataDeletedTest001, TestSize.Level1)
1724 {
1725 /**
1726 * @tc.steps: step1. Create Text and push it to view stack processor.
1727 * @tc.expected: Make Text as LazyForEach parent.
1728 */
1729 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1730
1731 /**
1732 * @tc.steps: step2. Invoke lazyForEach Create function.
1733 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1734 */
1735 LazyForEachModelNG lazyForEach;
1736 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1737 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1738 lazyForEach.Create(mockLazyForEachActuator);
1739 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1740
1741 lazyForEachBuilder->OnDataDeleted(INDEX_0);
1742 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1743 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1744 }
1745 lazyForEachBuilder->OnDataDeleted(INDEX_0);
1746 lazyForEachBuilder->OnDataChanged(INDEX_1);
1747 lazyForEachBuilder->OnDataDeleted(INDEX_1);
1748 lazyForEachBuilder->OnDataDeleted(BUILDER_INDEX_ONDATADELETED_END);
1749 }
1750
1751 /**
1752 * @tc.name: LazyForEachSyntaxOnDataDeletedTest002
1753 * @tc.desc: Create LazyForEach.
1754 * @tc.type: FUNC
1755 */
1756 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataDeletedTest002, TestSize.Level1)
1757 {
1758 /**
1759 * @tc.steps: step1. Create Text and push it to view stack processor.
1760 * @tc.expected: Make Text as LazyForEach parent.
1761 */
1762 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1763
1764 /**
1765 * @tc.steps: step2. Invoke lazyForEach Create function.
1766 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1767 */
1768 LazyForEachModelNG lazyForEach;
1769 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1770 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1771 lazyForEach.Create(mockLazyForEachActuator);
1772 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1773
1774 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1775 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1776 }
1777 std::list<V2::Operation> DataOperations;
1778 V2::Operation operation1 = {.type = "delete", .index = INDEX_0, .count = 1};
1779 DataOperations.push_back(operation1);
1780 lazyForEachBuilder->OnDatasetChange(DataOperations);
1781 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 6);
1782 DataOperations.clear();
1783 V2::Operation operation2 = {.type = "delete", .index = INDEX_0, .count = 2};
1784 DataOperations.push_back(operation2);
1785 lazyForEachBuilder->OnDatasetChange(DataOperations);
1786 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 4);
1787 }
1788
1789 /**
1790 * @tc.name: LazyForEachSyntaxOnDataBulkDeletedTest001
1791 * @tc.desc: Create LazyForEach.
1792 * @tc.type: FUNC
1793 */
1794 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataBulkDeletedTest001, TestSize.Level1)
1795 {
1796 /**
1797 * @tc.steps: step1. Create Text and push it to view stack processor.
1798 * @tc.expected: Make Text as LazyForEach parent.
1799 */
1800 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1801
1802 /**
1803 * @tc.steps: step2. Invoke lazyForEach Create function.
1804 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1805 */
1806 LazyForEachModelNG lazyForEach;
1807 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1808 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1809 lazyForEach.Create(mockLazyForEachActuator);
1810 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1811
1812
1813 lazyForEachBuilder->OnDataBulkDeleted(INDEX_0, INDEX_0);
1814 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1815 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1816 }
1817 lazyForEachBuilder->OnDataChanged(INDEX_1);
1818 lazyForEachBuilder->OnDataBulkDeleted(INDEX_0, INDEX_1);
1819 }
1820
1821 /**
1822 * @tc.name: LazyForEachSyntaxOnDataChangedTest001
1823 * @tc.desc: Create LazyForEach.
1824 * @tc.type: FUNC
1825 */
1826 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataChangedTest001, TestSize.Level1)
1827 {
1828 /**
1829 * @tc.steps: step1. Create Text and push it to view stack processor.
1830 * @tc.expected: Make Text as LazyForEach parent.
1831 */
1832 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1833
1834 /**
1835 * @tc.steps: step2. Invoke lazyForEach Create function.
1836 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1837 */
1838 LazyForEachModelNG lazyForEach;
1839 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1840 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1841 lazyForEach.Create(mockLazyForEachActuator);
1842 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1843
1844 lazyForEachBuilder->OnDataChanged(INDEX_0);
1845 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1846 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1847 }
1848 lazyForEachBuilder->OnDataChanged(INDEX_1);
1849 lazyForEachBuilder->OnDataChanged(INDEX_7);
1850 }
1851
1852 /**
1853 * @tc.name: LazyForEachSyntaxOnDataChangedTest002
1854 * @tc.desc: Create LazyForEach.
1855 * @tc.type: FUNC
1856 */
1857 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataChangedTest002, TestSize.Level1)
1858 {
1859 /**
1860 * @tc.steps: step1. Create Text and push it to view stack processor.
1861 * @tc.expected: Make Text as LazyForEach parent.
1862 */
1863 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1864
1865 /**
1866 * @tc.steps: step2. Invoke lazyForEach Create function.
1867 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1868 */
1869 LazyForEachModelNG lazyForEach;
1870 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1871 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1872 lazyForEach.Create(mockLazyForEachActuator);
1873 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1874 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1875 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1876 }
1877 std::list<V2::Operation> DataOperations;
1878 V2::Operation operation1 = {.type = "change", .index = INDEX_0};
1879 DataOperations.push_back(operation1);
1880 lazyForEachBuilder->OnDatasetChange(DataOperations);
1881 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 7);
1882 }
1883
1884 /**
1885 * @tc.name: LazyForEachSyntaxOnDataMovedTest001
1886 * @tc.desc: Create LazyForEach.
1887 * @tc.type: FUNC
1888 */
1889 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataMovedTest001, TestSize.Level1)
1890 {
1891 /**
1892 * @tc.steps: step1. Create Text and push it to view stack processor.
1893 * @tc.expected: Make Text as LazyForEach parent.
1894 */
1895 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1896
1897 /**
1898 * @tc.steps: step2. Invoke lazyForEach Create function.
1899 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1900 */
1901 LazyForEachModelNG lazyForEach;
1902 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1903 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1904 lazyForEach.Create(mockLazyForEachActuator);
1905 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1906
1907 lazyForEachBuilder->OnDataMoved(INDEX_0, INDEX_0);
1908 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1909 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1910 }
1911 lazyForEachBuilder->OnDataMoved(INDEX_0, INDEX_1);
1912 lazyForEachBuilder->OnDataMoved(INDEX_0, INDEX_7);
1913 lazyForEachBuilder->OnDataMoved(INDEX_7, INDEX_1);
1914 lazyForEachBuilder->OnDataMoved(INDEX_7, INDEX_EQUAL_WITH_START_INDEX_DELETED);
1915 }
1916
1917 /**
1918 * @tc.name: LazyForEachSyntaxOnDataMovedTest002
1919 * @tc.desc: Create LazyForEach.
1920 * @tc.type: FUNC
1921 */
1922 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataMovedTest002, TestSize.Level1)
1923 {
1924 /**
1925 * @tc.steps: step1. Create Text and push it to view stack processor.
1926 * @tc.expected: Make Text as LazyForEach parent.
1927 */
1928 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1929
1930 /**
1931 * @tc.steps: step2. Invoke lazyForEach Create function.
1932 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1933 */
1934 LazyForEachModelNG lazyForEach;
1935 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1936 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1937 lazyForEach.Create(mockLazyForEachActuator);
1938 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1939 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1940 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1941 }
1942 std::list<V2::Operation> DataOperations;
1943 V2::Operation operation1 = {.type = "move", .coupleIndex = std::pair(0, 2)};
1944 DataOperations.push_back(operation1);
1945 lazyForEachBuilder->OnDatasetChange(DataOperations);
1946 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 7);
1947 }
1948
1949 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataExchangeTest001, TestSize.Level1)
1950 {
1951 /**
1952 * @tc.steps: step1. Create Text and push it to view stack processor.
1953 * @tc.expected: Make Text as LazyForEach parent.
1954 */
1955 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1956
1957 /**
1958 * @tc.steps: step2. Invoke lazyForEach Create function.
1959 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1960 */
1961 LazyForEachModelNG lazyForEach;
1962 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1963 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1964 lazyForEach.Create(mockLazyForEachActuator);
1965 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1966 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1967 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1968 }
1969 std::list<V2::Operation> DataOperations;
1970 V2::Operation operation1 = {.type = "exchange", .coupleIndex = std::pair(1, 3)};
1971 DataOperations.push_back(operation1);
1972 lazyForEachBuilder->OnDatasetChange(DataOperations);
1973 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 7);
1974 }
1975
1976 /**
1977 * @tc.name: LazyForEachSyntaxRecycleChildByIndexTest001
1978 * @tc.desc: Create LazyForEach.
1979 * @tc.type: FUNC
1980 */
1981 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxRecycleChildByIndexTest001, TestSize.Level1)
1982 {
1983 /**
1984 * @tc.steps: step1. Create Text and push it to view stack processor.
1985 * @tc.expected: Make Text as LazyForEach parent.
1986 */
1987 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1988
1989 /**
1990 * @tc.steps: step2. Invoke lazyForEach Create function.
1991 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1992 */
1993 LazyForEachModelNG lazyForEach;
1994 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1995 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1996 lazyForEach.Create(mockLazyForEachActuator);
1997 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1998
1999 lazyForEachBuilder->RecycleChildByIndex(INDEX_0);
2000 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
2001 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
2002 }
2003 lazyForEachBuilder->RecycleChildByIndex(INDEX_1);
2004 }
2005 } // namespace OHOS::Ace::NG
2006