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::LIST_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_1);
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
__anona226d20b0202(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 * @tc.steps: step3. Invoke GetChildren.
1266 * @tc.expected: LazyForEachNode ids_ will be cleared.
1267 */
1268 lazyForEachNode->GetChildren(true);
1269 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1270 }
1271
1272 /**
1273 * @tc.name: ForEachSyntaxOnDataBulkAddedTest001
1274 * @tc.desc: Create LazyForEach, update its Items and invoke :OnDataBulkAdded function.
1275 * @tc.type: FUNC
1276 */
1277 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxOnDataBulkAddedTest001, TestSize.Level1)
1278 {
1279 /**
1280 * @tc.steps: step1. Create Text and push it to view stack processor.
1281 * @tc.expected: Make Text as LazyForEach parent.
1282 */
1283 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1284
1285 /**
1286 * @tc.steps: step2. Invoke lazyForEach Create function.
1287 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1288 */
1289 LazyForEachModelNG lazyForEach;
1290 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1291 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1292 lazyForEach.Create(mockLazyForEachActuator);
1293 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1294
1295 /**
1296 * @tc.steps: step3. Invoke OnDataBulkAdded.
1297 * @tc.expected: LazyForEachNode ids_ will be cleared.
1298 */
1299 lazyForEachNode->OnDataBulkAdded(INDEX_0, INDEX_0);
1300 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1301
1302 /**
1303 * @tc.steps: step4. Invoke OnDataBulkAdded.
1304 * @tc.expected: LazyForEachNode ids_ will be cleared.
1305 */
1306 lazyForEachNode->builder_=nullptr;
1307 lazyForEachNode->OnDataBulkAdded(INDEX_0, INDEX_0);
1308 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1309 }
1310
1311 /**
1312 * @tc.name: ForEachSyntaxOnDataBulkDeletedTest001
1313 * @tc.desc: Create LazyForEach, update its Items and invoke :OnDataBulkDeleted function.
1314 * @tc.type: FUNC
1315 */
1316 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxOnDataBulkDeletedTest001, TestSize.Level1)
1317 {
1318 /**
1319 * @tc.steps: step1. Create Text and push it to view stack processor.
1320 * @tc.expected: Make Text as LazyForEach parent.
1321 */
1322 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1323
1324 /**
1325 * @tc.steps: step2. Invoke lazyForEach Create function.
1326 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1327 */
1328 LazyForEachModelNG lazyForEach;
1329 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1330 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1331 lazyForEach.Create(mockLazyForEachActuator);
1332 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1333 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1334
1335
1336 lazyForEachBuilder->OnDataBulkDeleted(INDEX_0, INDEX_0);
1337 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1338 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1339 }
1340 lazyForEachBuilder->OnDataChanged(INDEX_1);
1341 lazyForEachNode->OnDataBulkDeleted(INDEX_0, INDEX_1);
1342
1343 /**
1344 * @tc.steps: step3. Invoke OnDataBulkDeleted.
1345 * @tc.expected: LazyForEachNode ids_ will be cleared.
1346 */
1347 lazyForEachNode->OnDataBulkDeleted(INDEX_0, INDEX_0);
1348 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1349
1350 /**
1351 * @tc.steps: step3. Invoke OnDataBulkDeleted.
1352 * @tc.expected: LazyForEachNode ids_ will be cleared.
1353 */
1354 lazyForEachNode->OnDataBulkDeleted(INDEX_5, INDEX_5);
1355 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1356
1357 /**
1358 * @tc.steps: step3. Invoke OnDataBulkDeleted.
1359 * @tc.expected: LazyForEachNode ids_ will be cleared.
1360 */
1361 lazyForEachNode->builder_=nullptr;
1362 lazyForEachNode->OnDataBulkDeleted(INDEX_0, INDEX_0);
1363 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1364 }
1365
1366 /**
1367 * @tc.name: ForEachSyntaxNotifyDataCountChangedTest001
1368 * @tc.desc: Create LazyForEach, update its Items and invoke :NotifyDataCountChanged function.
1369 * @tc.type: FUNC
1370 */
1371 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxNotifyDataCountChangedTest001, TestSize.Level1)
1372 {
1373 /**
1374 * @tc.steps: step1. Create Text and push it to view stack processor.
1375 * @tc.expected: Make Text as LazyForEach parent.
1376 */
1377 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1378
1379 /**
1380 * @tc.steps: step2. Invoke lazyForEach Create function.
1381 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1382 */
1383 LazyForEachModelNG lazyForEach;
1384 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1385 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1386 lazyForEach.Create(mockLazyForEachActuator);
1387 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1388
1389 /**
1390 * @tc.steps: step3. Invoke NotifyDataCountChanged.
1391 * @tc.expected: LazyForEachNode ids_ will be cleared.
1392 */
1393 lazyForEachNode->NotifyChangeWithCount(INDEX_0, 0, UINode::NotificationType::START_CHANGE_POSITION);
1394 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1395 }
1396
1397 /**
1398 * @tc.name: ForEachSyntaxMarkNeedSyncRenderTreeTest001
1399 * @tc.desc: Create LazyForEach, update its Items and invoke :MarkNeedSyncRenderTree function.
1400 * @tc.type: FUNC
1401 */
1402 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxMarkNeedSyncRenderTreeTest001, TestSize.Level1)
1403 {
1404 /**
1405 * @tc.steps: step1. Create Text and push it to view stack processor.
1406 * @tc.expected: Make Text as LazyForEach parent.
1407 */
1408 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1409
1410 /**
1411 * @tc.steps: step2. Invoke lazyForEach Create function.
1412 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1413 */
1414 LazyForEachModelNG lazyForEach;
1415 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1416 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1417 lazyForEach.Create(mockLazyForEachActuator);
1418 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1419
1420 /**
1421 * @tc.steps: step3. Invoke MarkNeedSyncRenderTree.
1422 * @tc.expected: LazyForEachNode ids_ will be cleared.
1423 */
1424 lazyForEachNode->needMarkParent_ = true;
1425 lazyForEachNode->MarkNeedSyncRenderTree(true);
1426
1427 lazyForEachNode->needMarkParent_ = false;
1428 lazyForEachNode->MarkNeedSyncRenderTree(true);
1429 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1430 }
1431
1432 /**
1433 * @tc.name: ForEachSyntaxRecycleItemsTest001
1434 * @tc.desc: Create LazyForEach, update its Items and invoke :RecycleItems function.
1435 * @tc.type: FUNC
1436 */
1437 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxRecycleItemsTest001, TestSize.Level1)
1438 {
1439 /**
1440 * @tc.steps: step1. Create Text and push it to view stack processor.
1441 * @tc.expected: Make Text as LazyForEach parent.
1442 */
1443 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1444
1445 /**
1446 * @tc.steps: step2. Invoke lazyForEach Create function.
1447 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1448 */
1449 LazyForEachModelNG lazyForEach;
1450 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1451 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1452 lazyForEach.Create(mockLazyForEachActuator);
1453 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1454 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
1455
1456 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
1457
1458 /**
1459 * @tc.steps: step3. Invoke RecycleItems.
1460 * @tc.expected: LazyForEachNode ids_ will be cleared.
1461 */
1462 lazyForEachNode->startIndex_ = 1;
1463 lazyForEachNode->count_ = 1;
1464 lazyForEachNode->RecycleItems(0, 6);
1465 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1466
1467 /**
1468 * @tc.steps: step3. Invoke RecycleItems.
1469 * @tc.expected: LazyForEachNode ids_ will be cleared.
1470 */
1471 lazyForEachNode->startIndex_ = 7;
1472 lazyForEachNode->count_ = 1;
1473 lazyForEachNode->RecycleItems(0, 6);
1474 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1475
1476 /**
1477 * @tc.steps: step3. Invoke RecycleItems.
1478 * @tc.expected: LazyForEachNode ids_ will be cleared.
1479 */
1480 lazyForEachNode->builder_ = nullptr;
1481 lazyForEachNode->RecycleItems(0, 6);
1482 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1483 }
1484
1485 /**
1486 * @tc.name: ForEachSyntaxDoSetActiveChildRangeTest001
1487 * @tc.desc: Create LazyForEach, update its Items and invoke :DoSetActiveChildRange function.
1488 * @tc.type: FUNC
1489 */
1490 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxDoSetActiveChildRangeTest001, TestSize.Level1)
1491 {
1492 /**
1493 * @tc.steps: step1. Create Text and push it to view stack processor.
1494 * @tc.expected: Make Text as LazyForEach parent.
1495 */
1496 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1497
1498 /**
1499 * @tc.steps: step2. Invoke lazyForEach Create function.
1500 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1501 */
1502 LazyForEachModelNG lazyForEach;
1503 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1504 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1505 lazyForEach.Create(mockLazyForEachActuator);
1506 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1507 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
1508
1509 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
1510
1511 /**
1512 * @tc.steps: step3. Invoke DoSetActiveChildRange.
1513 * @tc.expected: LazyForEachNode ids_ will be cleared.
1514 */
1515 lazyForEachNode->DoSetActiveChildRange(0, 0, 0, 0);
1516 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1517
1518 /**
1519 * @tc.steps: step3. Invoke DoSetActiveChildRange.
1520 * @tc.expected: LazyForEachNode ids_ will be cleared.
1521 */
1522 lazyForEachNode->builder_ = nullptr;
1523 lazyForEachNode->DoSetActiveChildRange(0, 0, 0, 0);
1524 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1525 }
1526
1527 /**
1528 * @tc.name: ForEachSyntaxOnConfigurationUpdateTest001
1529 * @tc.desc: Create LazyForEach, update its Items and invoke :OnConfigurationUpdate function.
1530 * @tc.type: FUNC
1531 */
1532 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxOnConfigurationUpdateTest001, TestSize.Level1)
1533 {
1534 /**
1535 * @tc.steps: step1. Create Text and push it to view stack processor.
1536 * @tc.expected: Make Text as LazyForEach parent.
1537 */
1538 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1539
1540 /**
1541 * @tc.steps: step2. Invoke lazyForEach Create function.
1542 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1543 */
1544 LazyForEachModelNG lazyForEach;
1545 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1546 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1547 lazyForEach.Create(mockLazyForEachActuator);
1548 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
1549 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
1550 ConfigurationChange configurationChange;
1551
1552 auto lazyForEachBuilder = lazyForEachNode->builder_;
1553
1554 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
1555
1556 /**
1557 * @tc.steps: step3. Invoke configurationChange.IsNeedUpdate() = true and builder_ is not null
1558 */
1559 lazyForEachBuilder->expiringItem_["0"] = LazyForEachCacheChild(0, nullptr);
1560 configurationChange.colorModeUpdate = true;
1561 lazyForEachNode->OnConfigurationUpdate(configurationChange);
1562 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1563
1564
1565 /**
1566 * @tc.steps: step4. configurationChange.IsNeedUpdate() = false and builder_ is not null
1567 */
1568 configurationChange.colorModeUpdate = false;
1569 lazyForEachNode->OnConfigurationUpdate(configurationChange);
1570 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1571
1572 lazyForEachNode->builder_=nullptr;
1573
1574 /**
1575 * @tc.steps: step5. configurationChange.IsNeedUpdate() = true and builder_ is null
1576 */
1577 configurationChange.colorModeUpdate = true;
1578 lazyForEachNode->OnConfigurationUpdate(configurationChange);
1579 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1580
1581 /**
1582 * @tc.steps: step6. configurationChange.IsNeedUpdate() = true and builder_ is null
1583 */
1584 configurationChange.colorModeUpdate = false;
1585 lazyForEachNode->OnConfigurationUpdate(configurationChange);
1586 EXPECT_TRUE(lazyForEachNode->ids_.empty());
1587 }
1588
1589 /**
1590 * @tc.name: LazyForEachSyntaxOnDataReloadedTest001
1591 * @tc.desc: Create LazyForEach.
1592 * @tc.type: FUNC
1593 */
1594 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataReloadedTest001, TestSize.Level1)
1595 {
1596 /**
1597 * @tc.steps: step1. Create Text and push it to view stack processor.
1598 * @tc.expected: Make Text as LazyForEach parent.
1599 */
1600 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1601
1602 /**
1603 * @tc.steps: step2. Invoke lazyForEach Create function.
1604 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1605 */
1606 LazyForEachModelNG lazyForEach;
1607 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1608 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1609 lazyForEach.Create(mockLazyForEachActuator);
1610 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1611
1612 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1613 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1614 }
1615 lazyForEachBuilder->OnDataReloaded();
1616 lazyForEachBuilder->OnDataChanged(INDEX_1);
1617 lazyForEachBuilder->OnDataReloaded();
1618 }
1619
1620 /**
1621 * @tc.name: LazyForEachSyntaxOnDataReloadedTest002
1622 * @tc.desc: Create LazyForEach.
1623 * @tc.type: FUNC
1624 */
1625 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataReloadedTest002, TestSize.Level1)
1626 {
1627 /**
1628 * @tc.steps: step1. Create Text and push it to view stack processor.
1629 * @tc.expected: Make Text as LazyForEach parent.
1630 */
1631 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1632
1633 /**
1634 * @tc.steps: step2. Invoke lazyForEach Create function.
1635 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1636 */
1637 LazyForEachModelNG lazyForEach;
1638 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1639 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1640 lazyForEach.Create(mockLazyForEachActuator);
1641 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1642
1643 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1644 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1645 }
1646 std::list<V2::Operation> DataOperations;
1647 V2::Operation operation1 = {.type = "reload"};
1648 DataOperations.push_back(operation1);
1649 lazyForEachBuilder->OnDatasetChange(DataOperations);
1650 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 0);
1651 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1652 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1653 }
1654 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 7);
1655 }
1656
1657 /**
1658 * @tc.name: LazyForEachSyntaxOnDataAddedTest001
1659 * @tc.desc: Create LazyForEach.
1660 * @tc.type: FUNC
1661 */
1662 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataAddedTest001, TestSize.Level1)
1663 {
1664 /**
1665 * @tc.steps: step1. Create Text and push it to view stack processor.
1666 * @tc.expected: Make Text as LazyForEach parent.
1667 */
1668 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1669
1670 /**
1671 * @tc.steps: step2. Invoke lazyForEach Create function.
1672 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1673 */
1674 LazyForEachModelNG lazyForEach;
1675 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1676 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1677 lazyForEach.Create(mockLazyForEachActuator);
1678 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1679
1680 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1681 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1682 }
1683 lazyForEachBuilder->useNewInterface_ = true;
1684 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1685 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true, true);
1686 }
1687 lazyForEachBuilder->OnDataAdded(INDEX_0);
1688 lazyForEachBuilder->OnDataChanged(INDEX_1);
1689 lazyForEachBuilder->OnDataAdded(INDEX_0);
1690 }
1691
1692 /**
1693 * @tc.name: LazyForEachSyntaxOnDataAddedTest002
1694 * @tc.desc: Create LazyForEach.
1695 * @tc.type: FUNC
1696 */
1697 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataAddedTest002, TestSize.Level1)
1698 {
1699 /**
1700 * @tc.steps: step1. Create Text and push it to view stack processor.
1701 * @tc.expected: Make Text as LazyForEach parent.
1702 */
1703 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1704
1705 /**
1706 * @tc.steps: step2. Invoke lazyForEach Create function.
1707 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1708 */
1709 LazyForEachModelNG lazyForEach;
1710 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1711 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1712 lazyForEach.Create(mockLazyForEachActuator);
1713 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1714
1715 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1716 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1717 }
1718 std::list<V2::Operation> DataOperations;
1719 V2::Operation operation1 = {.type = "add", .index = INDEX_0, .count = 1};
1720 DataOperations.push_back(operation1);
1721 lazyForEachBuilder->OnDatasetChange(DataOperations);
1722 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1723 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1724 }
1725 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 8);
1726 DataOperations.clear();
1727 V2::Operation operation2 = {.type = "add", .index = INDEX_0, .count = 2};
1728 DataOperations.push_back(operation2);
1729 lazyForEachBuilder->OnDatasetChange(DataOperations);
1730 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1731 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1732 }
1733 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 10);
1734 }
1735
1736 /**
1737 * @tc.name: LazyForEachSyntaxOnDataBulkAddedTest001
1738 * @tc.desc: Create LazyForEach.
1739 * @tc.type: FUNC
1740 */
1741 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataBulkAddedTest001, TestSize.Level1)
1742 {
1743 /**
1744 * @tc.steps: step1. Create Text and push it to view stack processor.
1745 * @tc.expected: Make Text as LazyForEach parent.
1746 */
1747 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1748
1749 /**
1750 * @tc.steps: step2. Invoke lazyForEach Create function.
1751 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1752 */
1753 LazyForEachModelNG lazyForEach;
1754 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1755 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1756 lazyForEach.Create(mockLazyForEachActuator);
1757 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1758
1759 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1760 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1761 }
1762 lazyForEachBuilder->OnDataBulkAdded(INDEX_0, INDEX_0);
1763 lazyForEachBuilder->OnDataChanged(INDEX_1);
1764 lazyForEachBuilder->OnDataBulkAdded(INDEX_0, INDEX_0);
1765 }
1766
1767 /**
1768 * @tc.name: LazyForEachSyntaxOnDataDeletedTest001
1769 * @tc.desc: Create LazyForEach.
1770 * @tc.type: FUNC
1771 */
1772 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataDeletedTest001, TestSize.Level1)
1773 {
1774 /**
1775 * @tc.steps: step1. Create Text and push it to view stack processor.
1776 * @tc.expected: Make Text as LazyForEach parent.
1777 */
1778 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1779
1780 /**
1781 * @tc.steps: step2. Invoke lazyForEach Create function.
1782 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1783 */
1784 LazyForEachModelNG lazyForEach;
1785 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1786 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1787 lazyForEach.Create(mockLazyForEachActuator);
1788 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1789
1790 lazyForEachBuilder->OnDataDeleted(INDEX_0);
1791 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1792 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1793 }
1794 lazyForEachBuilder->OnDataDeleted(INDEX_0);
1795 lazyForEachBuilder->OnDataChanged(INDEX_1);
1796 lazyForEachBuilder->OnDataDeleted(INDEX_1);
1797 lazyForEachBuilder->OnDataDeleted(BUILDER_INDEX_ONDATADELETED_END);
1798 }
1799
1800 /**
1801 * @tc.name: LazyForEachSyntaxOnDataDeletedTest002
1802 * @tc.desc: Create LazyForEach.
1803 * @tc.type: FUNC
1804 */
1805 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataDeletedTest002, TestSize.Level1)
1806 {
1807 /**
1808 * @tc.steps: step1. Create Text and push it to view stack processor.
1809 * @tc.expected: Make Text as LazyForEach parent.
1810 */
1811 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1812
1813 /**
1814 * @tc.steps: step2. Invoke lazyForEach Create function.
1815 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1816 */
1817 LazyForEachModelNG lazyForEach;
1818 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1819 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1820 lazyForEach.Create(mockLazyForEachActuator);
1821 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1822
1823 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1824 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1825 }
1826 // init historicalTotalCount_
1827 lazyForEachBuilder->UpdateHistoricalTotalCount(lazyForEachBuilder->GetTotalCount());
1828 std::list<V2::Operation> DataOperations;
1829 V2::Operation operation1 = {.type = "delete", .index = INDEX_0, .count = 1};
1830 DataOperations.push_back(operation1);
1831 lazyForEachBuilder->OnDatasetChange(DataOperations);
1832 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 6);
1833 DataOperations.clear();
1834 // update historicalTotalCount_
1835 lazyForEachBuilder->UpdateHistoricalTotalCount(lazyForEachBuilder->GetTotalCount());
1836 V2::Operation operation2 = {.type = "delete", .index = INDEX_0, .count = 2};
1837 DataOperations.push_back(operation2);
1838 lazyForEachBuilder->OnDatasetChange(DataOperations);
1839 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 4);
1840 }
1841
1842 /**
1843 * @tc.name: LazyForEachSyntaxOnDataBulkDeletedTest001
1844 * @tc.desc: Create LazyForEach.
1845 * @tc.type: FUNC
1846 */
1847 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataBulkDeletedTest001, TestSize.Level1)
1848 {
1849 /**
1850 * @tc.steps: step1. Create Text and push it to view stack processor.
1851 * @tc.expected: Make Text as LazyForEach parent.
1852 */
1853 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1854
1855 /**
1856 * @tc.steps: step2. Invoke lazyForEach Create function.
1857 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1858 */
1859 LazyForEachModelNG lazyForEach;
1860 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1861 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1862 lazyForEach.Create(mockLazyForEachActuator);
1863 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1864
1865
1866 lazyForEachBuilder->OnDataBulkDeleted(INDEX_0, INDEX_0);
1867 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1868 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1869 }
1870 lazyForEachBuilder->OnDataChanged(INDEX_1);
1871 lazyForEachBuilder->OnDataBulkDeleted(INDEX_0, INDEX_1);
1872 }
1873
1874 /**
1875 * @tc.name: LazyForEachSyntaxOnDataChangedTest001
1876 * @tc.desc: Create LazyForEach.
1877 * @tc.type: FUNC
1878 */
1879 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataChangedTest001, TestSize.Level1)
1880 {
1881 /**
1882 * @tc.steps: step1. Create Text and push it to view stack processor.
1883 * @tc.expected: Make Text as LazyForEach parent.
1884 */
1885 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1886
1887 /**
1888 * @tc.steps: step2. Invoke lazyForEach Create function.
1889 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1890 */
1891 LazyForEachModelNG lazyForEach;
1892 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1893 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1894 lazyForEach.Create(mockLazyForEachActuator);
1895 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1896
1897 lazyForEachBuilder->OnDataChanged(INDEX_0);
1898 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1899 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1900 }
1901 lazyForEachBuilder->OnDataChanged(INDEX_1);
1902 lazyForEachBuilder->OnDataChanged(INDEX_7);
1903 }
1904
1905 /**
1906 * @tc.name: LazyForEachSyntaxOnDataChangedTest002
1907 * @tc.desc: Create LazyForEach.
1908 * @tc.type: FUNC
1909 */
1910 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataChangedTest002, TestSize.Level1)
1911 {
1912 /**
1913 * @tc.steps: step1. Create Text and push it to view stack processor.
1914 * @tc.expected: Make Text as LazyForEach parent.
1915 */
1916 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1917
1918 /**
1919 * @tc.steps: step2. Invoke lazyForEach Create function.
1920 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1921 */
1922 LazyForEachModelNG lazyForEach;
1923 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1924 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1925 lazyForEach.Create(mockLazyForEachActuator);
1926 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1927 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1928 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1929 }
1930 std::list<V2::Operation> DataOperations;
1931 V2::Operation operation1 = {.type = "change", .index = INDEX_0};
1932 DataOperations.push_back(operation1);
1933 lazyForEachBuilder->OnDatasetChange(DataOperations);
1934 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 7);
1935 }
1936
1937 /**
1938 * @tc.name: LazyForEachSyntaxOnDataMovedTest001
1939 * @tc.desc: Create LazyForEach.
1940 * @tc.type: FUNC
1941 */
1942 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataMovedTest001, TestSize.Level1)
1943 {
1944 /**
1945 * @tc.steps: step1. Create Text and push it to view stack processor.
1946 * @tc.expected: Make Text as LazyForEach parent.
1947 */
1948 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1949
1950 /**
1951 * @tc.steps: step2. Invoke lazyForEach Create function.
1952 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1953 */
1954 LazyForEachModelNG lazyForEach;
1955 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1956 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1957 lazyForEach.Create(mockLazyForEachActuator);
1958 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1959
1960 lazyForEachBuilder->OnDataMoved(INDEX_0, INDEX_0);
1961 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1962 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1963 }
1964 lazyForEachBuilder->OnDataMoved(INDEX_0, INDEX_1);
1965 lazyForEachBuilder->OnDataMoved(INDEX_0, INDEX_7);
1966 lazyForEachBuilder->OnDataMoved(INDEX_7, INDEX_1);
1967 lazyForEachBuilder->OnDataMoved(INDEX_7, INDEX_EQUAL_WITH_START_INDEX_DELETED);
1968 }
1969
1970 /**
1971 * @tc.name: LazyForEachSyntaxOnDataMovedTest002
1972 * @tc.desc: Create LazyForEach.
1973 * @tc.type: FUNC
1974 */
1975 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataMovedTest002, TestSize.Level1)
1976 {
1977 /**
1978 * @tc.steps: step1. Create Text and push it to view stack processor.
1979 * @tc.expected: Make Text as LazyForEach parent.
1980 */
1981 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
1982
1983 /**
1984 * @tc.steps: step2. Invoke lazyForEach Create function.
1985 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
1986 */
1987 LazyForEachModelNG lazyForEach;
1988 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
1989 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
1990 lazyForEach.Create(mockLazyForEachActuator);
1991 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
1992 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
1993 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
1994 }
1995 std::list<V2::Operation> DataOperations;
1996 V2::Operation operation1 = {.type = "move", .coupleIndex = std::pair(0, 2)};
1997 DataOperations.push_back(operation1);
1998 lazyForEachBuilder->OnDatasetChange(DataOperations);
1999 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 7);
2000 }
2001
2002 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxOnDataExchangeTest001, TestSize.Level1)
2003 {
2004 /**
2005 * @tc.steps: step1. Create Text and push it to view stack processor.
2006 * @tc.expected: Make Text as LazyForEach parent.
2007 */
2008 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
2009
2010 /**
2011 * @tc.steps: step2. Invoke lazyForEach Create function.
2012 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
2013 */
2014 LazyForEachModelNG lazyForEach;
2015 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
2016 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
2017 lazyForEach.Create(mockLazyForEachActuator);
2018 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
2019 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
2020 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
2021 }
2022 std::list<V2::Operation> DataOperations;
2023 V2::Operation operation1 = {.type = "exchange", .coupleIndex = std::pair(1, 3)};
2024 DataOperations.push_back(operation1);
2025 lazyForEachBuilder->OnDatasetChange(DataOperations);
2026 EXPECT_EQ(lazyForEachBuilder->OnGetTotalCount(), 7);
2027 }
2028
2029 /**
2030 * @tc.name: LazyForEachSyntaxRecycleChildByIndexTest001
2031 * @tc.desc: Create LazyForEach.
2032 * @tc.type: FUNC
2033 */
2034 HWTEST_F(LazyForEachSyntaxTestNg, LazyForEachSyntaxRecycleChildByIndexTest001, TestSize.Level1)
2035 {
2036 /**
2037 * @tc.steps: step1. Create Text and push it to view stack processor.
2038 * @tc.expected: Make Text as LazyForEach parent.
2039 */
2040 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
2041
2042 /**
2043 * @tc.steps: step2. Invoke lazyForEach Create function.
2044 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
2045 */
2046 LazyForEachModelNG lazyForEach;
2047 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
2048 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
2049 lazyForEach.Create(mockLazyForEachActuator);
2050 auto lazyForEachBuilder = AceType::DynamicCast<LazyForEachBuilder>(mockLazyForEachActuator);
2051
2052 lazyForEachBuilder->RecycleChildByIndex(INDEX_0);
2053 for (auto iter : LAZY_FOR_EACH_NODE_IDS_INT) {
2054 lazyForEachBuilder->GetChildByIndex(iter.value_or(0), true);
2055 }
2056 lazyForEachBuilder->RecycleChildByIndex(INDEX_1);
2057 }
2058
2059 /**
2060 * @tc.name: ForEachSyntaxInitDragManagerTest001
2061 * @tc.desc: Create LazyForEach, update its Items and invoke InitDragManager function.
2062 * @tc.type: FUNC
2063 */
2064 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxInitDragManagerTest001, TestSize.Level1)
2065 {
2066 /**
2067 * @tc.steps: step1. Create Text and push it to view stack processor.
2068 * @tc.expected: Make Text as LazyForEach parent.
2069 */
2070 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
2071
2072 /**
2073 * @tc.steps: step2. Invoke lazyForEach Create function.
2074 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
2075 */
2076 LazyForEachModelNG lazyForEach;
2077 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
2078 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
2079 lazyForEach.Create(mockLazyForEachActuator);
2080 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
2081 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
2082
2083 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
2084
2085 /**
2086 * @tc.steps: step3. Invoke NotifyCountChange.
2087 * @tc.expected: LazyForEachNode ids_ will be cleared.
2088 */
2089 auto frameChild = AceType::DynamicCast<FrameNode>(lazyForEachNode->GetFrameChildByIndex(0, true));
2090 lazyForEachNode->InitDragManager(frameChild);
2091 EXPECT_TRUE(lazyForEachNode->ids_.empty());
2092 }
2093
2094 /**
2095 * @tc.name: ForEachSyntaxGetFrameNodeIndexTest001
2096 * @tc.desc: Create LazyForEach, update its Items and invoke GetFrameNodeIndex function.
2097 * @tc.type: FUNC
2098 */
2099 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxGetFrameNodeIndexTest001, TestSize.Level1)
2100 {
2101 /**
2102 * @tc.steps: step1. Create Text and push it to view stack processor.
2103 * @tc.expected: Make Text as LazyForEach parent.
2104 */
2105 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
2106
2107 /**
2108 * @tc.steps: step2. Invoke lazyForEach Create function.
2109 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
2110 */
2111 LazyForEachModelNG lazyForEach;
2112 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
2113 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
2114 lazyForEach.Create(mockLazyForEachActuator);
2115 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
2116 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
2117
2118 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
2119
2120 /**
2121 * @tc.steps: step3. Invoke NotifyCountChange.
2122 * @tc.expected: LazyForEachNode ids_ will be cleared.
2123 */
2124 auto frameChild = AceType::DynamicCast<FrameNode>(lazyForEachNode->GetFrameChildByIndex(0, true));
2125 lazyForEachNode->GetFrameNodeIndex(frameChild, true);
2126 lazyForEachNode->GetFrameNodeIndex(frameChild, false);
2127 EXPECT_TRUE(lazyForEachNode->ids_.empty());
2128 }
2129
2130 /**
2131 * @tc.name: ForEachSyntaxNotifyCountChangeTest001
2132 * @tc.desc: Create LazyForEach, update its Items and invoke NotifyCountChange function.
2133 * @tc.type: FUNC
2134 */
2135 HWTEST_F(LazyForEachSyntaxTestNg, ForEachSyntaxNotifyCountChangeTest001, TestSize.Level1)
2136 {
2137 /**
2138 * @tc.steps: step1. Create Text and push it to view stack processor.
2139 * @tc.expected: Make Text as LazyForEach parent.
2140 */
2141 auto frameNode = CreateNode(V2::TEXT_ETS_TAG);
2142
2143 /**
2144 * @tc.steps: step2. Invoke lazyForEach Create function.
2145 * @tc.expected: Create LazyForEachNode and can be pop from ViewStackProcessor.
2146 */
2147 LazyForEachModelNG lazyForEach;
2148 const RefPtr<LazyForEachActuator> mockLazyForEachActuator =
2149 AceType::MakeRefPtr<OHOS::Ace::Framework::MockLazyForEachBuilder>();
2150 lazyForEach.Create(mockLazyForEachActuator);
2151 auto lazyForEachNode = AceType::DynamicCast<LazyForEachNode>(ViewStackProcessor::GetInstance()->Finish());
2152 EXPECT_TRUE(lazyForEachNode != nullptr && lazyForEachNode->GetTag() == V2::JS_LAZY_FOR_EACH_ETS_TAG);
2153
2154 UpdateItems(lazyForEachNode, mockLazyForEachActuator);
2155
2156 /**
2157 * @tc.steps: step3. Invoke NotifyCountChange.
2158 * @tc.expected: LazyForEachNode ids_ will be cleared.
2159 */
2160 lazyForEachNode->NotifyChangeWithCount(0, 0, UINode::NotificationType::END_CHANGE_POSITION);
2161 EXPECT_TRUE(lazyForEachNode->ids_.empty());
2162 }
2163
2164 } // namespace OHOS::Ace::NG
2165