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 <memory>
17 #include <ostream>
18 #include <utility>
19
20 #include "gtest/gtest.h"
21
22 #define protected public
23 #define private public
24
25 #include "test/mock/core/pipeline/mock_pipeline_context.h"
26
27 #include "base/log/dump_log.h"
28 #include "base/log/log_wrapper.h"
29 #include "core/components_ng/base/frame_node.h"
30 #include "core/components_ng/base/ui_node.h"
31 #include "core/components_ng/event/event_hub.h"
32 #include "core/components_ng/event/focus_hub.h"
33 #include "core/components_ng/pattern/pattern.h"
34 #include "core/components_ng/property/property.h"
35 #include "core/pipeline_ng/pipeline_context.h"
36
37 using namespace testing;
38 using namespace testing::ext;
39
40 namespace OHOS::Ace::NG {
41 namespace {
42 const RefPtr<FrameNode> TEN0 = FrameNode::CreateFrameNode("zero", 10, AceType::MakeRefPtr<Pattern>(), true);
43 const RefPtr<FrameNode> ZERO = FrameNode::CreateFrameNode("zero", 0, AceType::MakeRefPtr<Pattern>(), true);
44 const RefPtr<FrameNode> ONE = FrameNode::CreateFrameNode("one", 1, AceType::MakeRefPtr<Pattern>(), true);
45 const RefPtr<FrameNode> TWO = FrameNode::CreateFrameNode("two", 2, AceType::MakeRefPtr<Pattern>());
46 const RefPtr<FrameNode> THREE = FrameNode::CreateFrameNode("three", 3, AceType::MakeRefPtr<Pattern>());
47 const RefPtr<FrameNode> FOUR = FrameNode::CreateFrameNode("four", 4, AceType::MakeRefPtr<Pattern>());
48 const RefPtr<FrameNode> FIVE = FrameNode::CreateFrameNode("five", 5, AceType::MakeRefPtr<Pattern>());
49 const RefPtr<FrameNode> F_ONE = FrameNode::CreateFrameNode("one", 5, AceType::MakeRefPtr<Pattern>());
50 const int32_t TEST_ID_ONE = 21;
51 const int32_t TEST_ID_TWO = 22;
52 } // namespace
53
54 class TestNode : public UINode {
55 DECLARE_ACE_TYPE(TestNode, UINode);
56
57 public:
CreateTestNode(int32_t nodeId)58 static RefPtr<TestNode> CreateTestNode(int32_t nodeId)
59 {
60 auto spanNode = MakeRefPtr<TestNode>(nodeId);
61 return spanNode;
62 }
63
IsAtomicNode() const64 bool IsAtomicNode() const override
65 {
66 return true;
67 }
68
TestNode(int32_t nodeId)69 explicit TestNode(int32_t nodeId) : UINode("TestNode", nodeId) {}
70
TouchTest(const PointF & globalPoint,const PointF & parentLocalPoint,const PointF & parentRevertPoint,TouchRestrict & touchRestrict,TouchTestResult & result,int32_t touchId,ResponseLinkResult & responseLinkResult,bool isDispatch=false)71 HitTestResult TouchTest(const PointF& globalPoint, const PointF& parentLocalPoint, const PointF& parentRevertPoint,
72 TouchRestrict& touchRestrict, TouchTestResult& result, int32_t touchId, ResponseLinkResult& responseLinkResult,
73 bool isDispatch = false) override
74 {
75 return hitTestResult_;
76 }
77
MouseTest(const PointF & globalPoint,const PointF & parentLocalPoint,MouseTestResult & onMouseResult,MouseTestResult & onHoverResult,RefPtr<FrameNode> & hoverNode)78 HitTestResult MouseTest(const PointF& globalPoint, const PointF& parentLocalPoint, MouseTestResult& onMouseResult,
79 MouseTestResult& onHoverResult, RefPtr<FrameNode>& hoverNode) override
80 {
81 return hitTestResult_;
82 }
83
AxisTest(const PointF & globalPoint,const PointF & parentLocalPoint,const PointF & parentRevertPoint,TouchRestrict & touchRestrict,AxisTestResult & axisResult)84 HitTestResult AxisTest(const PointF &globalPoint, const PointF &parentLocalPoint, const PointF &parentRevertPoint,
85 TouchRestrict &touchRestrict, AxisTestResult &axisResult) override
86 {
87 return hitTestResult_;
88 }
89
90 ~TestNode() override = default;
91
92 private:
93 HitTestResult hitTestResult_;
94 };
95
96 class UINodeTestNg : public testing::Test {
97 public:
98 static void SetUpTestSuite();
99 static void TearDownTestSuite();
100 };
101
SetUpTestSuite()102 void UINodeTestNg::SetUpTestSuite()
103 {
104 MockPipelineContext::SetUp();
105 }
106
TearDownTestSuite()107 void UINodeTestNg::TearDownTestSuite()
108 {
109 MockPipelineContext::TearDown();
110 }
111
112 /**
113 * @tc.name: UINodeTestNg001
114 * @tc.desc: Test ui node method
115 * @tc.type: FUNC
116 */
117 HWTEST_F(UINodeTestNg, UINodeTestNg001, TestSize.Level1)
118 {
119 /**
120 * @tc.steps: step1. AddChild
121 * @tc.expected: children_.size = 2
122 */
123 ONE->AddChild(TWO, 1, false);
124 auto testNode = TestNode::CreateTestNode(TEST_ID_ONE);
125 auto testNode2 = TestNode::CreateTestNode(TEST_ID_TWO);
126 ONE->AddChild(testNode, 1, false);
127 ONE->AddChild(testNode, 1, false);
128 ONE->AddChild(testNode2, 1, false);
129 EXPECT_EQ(ONE->children_.size(), 3);
130 /**
131 * @tc.steps: step2. remove child three
132 */
133 auto iter = ONE->RemoveChild(FOUR);
134 EXPECT_EQ(iter, ONE->children_.end());
135 ONE->RemoveChild(testNode);
136 ONE->RemoveChild(testNode2, true);
137 /**
138 * @tc.steps: step3. remove child two
139 * @tc.expected: distance = 0
140 */
141 auto distance = ONE->RemoveChildAndReturnIndex(TWO);
142 EXPECT_EQ(distance, 0);
143 }
144
145 /**
146 * @tc.name: UINodeTestNg002
147 * @tc.desc: Test ui node method
148 * @tc.type: FUNC
149 */
150 HWTEST_F(UINodeTestNg, UINodeTestNg002, TestSize.Level1)
151 {
152 ONE->RemoveChildAtIndex(-1);
153 ONE->AddChild(TWO, 1, false);
154 /**
155 * @tc.steps: step1. RemoveChildAtIndex
156 * @tc.expected: children_.size = 0
157 */
158 ONE->RemoveChildAtIndex(0);
159 EXPECT_EQ(ONE->children_.size(), 0);
160 /**
161 * @tc.steps: step2. GetChildAtIndex
162 * @tc.expected: return nullptr
163 */
164 auto result = ONE->GetChildAtIndex(0);
165 EXPECT_EQ(result, nullptr);
166 ONE->AddChild(TWO, 1, false);
167 auto node = ONE->GetChildAtIndex(0);
168 EXPECT_EQ(strcmp(node->GetTag().c_str(), "two"), 0);
169 }
170
171 /**
172 * @tc.name: UINodeTestNg003
173 * @tc.desc: Test ui node method
174 * @tc.type: FUNC
175 */
176 HWTEST_F(UINodeTestNg, UINodeTestNg003, TestSize.Level1)
177 {
178 ONE->AddChild(TWO, 1, false);
179 /**
180 * @tc.steps: step1. ReplaceChild
181 * @tc.expected: size = 2
182 */
183 ONE->ReplaceChild(nullptr, THREE);
184 ONE->ReplaceChild(TWO, FOUR);
185 EXPECT_EQ(ONE->children_.size(), 2);
186 /**
187 * @tc.steps: step2. set TWO's hostPageId_ 1 and Clean
188 * @tc.expected: children_ = 0
189 */
190 TWO->hostPageId_ = 1;
191 ONE->MountToParent(TWO, 1, false);
192 ONE->Clean();
193 EXPECT_EQ(ONE->children_.size(), 0);
194 }
195
196 /**
197 * @tc.name: UINodeTestNg004
198 * @tc.desc: Test ui node method
199 * @tc.type: FUNC
200 */
201 HWTEST_F(UINodeTestNg, UINodeTestNg004, TestSize.Level1)
202 {
203 /**
204 * @tc.steps: step1. GetFocusParent
205 * @tc.expected: parent is nullptr
206 */
207 auto frameNode = ONE->GetFocusParent();
208 EXPECT_EQ(frameNode, nullptr);
209 FocusType focusTypes[3] = { FocusType::SCOPE, FocusType::NODE, FocusType::DISABLE };
210 auto parent = FrameNode::CreateFrameNode("parent", 2, AceType::MakeRefPtr<Pattern>());
211 RefPtr<FrameNode> frameNodes[3] = { parent, nullptr, nullptr };
212 /**
213 * @tc.steps: step2. GetFocusParent adjust FocusType
214 * @tc.expected: result is parent and nullptr
215 */
216 for (int i = 0; i < 3; ++i) {
217 auto eventHub = AceType::MakeRefPtr<EventHub>();
218 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub, focusTypes[i]);
219 eventHub->focusHub_ = focusHub;
220 parent->eventHub_ = eventHub;
221 ONE->parent_ = parent;
222 auto result = ONE->GetFocusParent();
223 EXPECT_EQ(result, frameNodes[i]);
224 }
225 /**
226 * @tc.steps: step3. create test node and try GetFirstFocusHubChild
227 * @tc.expected: result is null
228 */
229 auto testNode = TestNode::CreateTestNode(TEST_ID_ONE);
230 EXPECT_EQ(testNode->GetFirstFocusHubChild(), nullptr);
231 /**
232 * @tc.steps: step4. config node parent and GetFocusParent;
233 * @tc.expected: result is null
234 */
235 ONE->parent_ = testNode;
236 testNode->parent_ = parent;
237 auto result = ONE->GetFocusParent();
238 EXPECT_EQ(result, nullptr);
239 }
240
241 /**
242 * @tc.name: UINodeTestNg005
243 * @tc.desc: Test ui node method
244 * @tc.type: FUNC
245 */
246 HWTEST_F(UINodeTestNg, UINodeTestNg005, TestSize.Level1)
247 {
248 /**
249 * @tc.steps: step1. GetFocusChildren
250 * @tc.expected: THREE's children size is 2
251 */
252 std::list<RefPtr<FrameNode>> children;
253 auto eventHubTwo = AceType::MakeRefPtr<EventHub>();
254 auto focusHubTwo = AceType::MakeRefPtr<FocusHub>(eventHubTwo, FocusType::NODE);
255 auto eventHubFour = AceType::MakeRefPtr<EventHub>();
256 auto focusHubFour = AceType::MakeRefPtr<FocusHub>(eventHubFour, FocusType::DISABLE);
257 eventHubTwo->focusHub_ = focusHubTwo;
258 TWO->eventHub_ = eventHubTwo;
259 eventHubFour->focusHub_ = focusHubFour;
260 FOUR->eventHub_ = eventHubFour;
261 THREE->AddChild(TWO, 1, false);
262 THREE->AddChild(FOUR, 1, false);
263 THREE->AddChild(TestNode::CreateTestNode(TEST_ID_ONE), 1, false);
264 THREE->GetFocusChildren(children);
265 EXPECT_EQ(THREE->children_.size(), 3);
266 THREE->Clean();
267 }
268
269 /**
270 * @tc.name: UINodeTestNg006
271 * @tc.desc: Test ui node method
272 * @tc.type: FUNC
273 */
274 HWTEST_F(UINodeTestNg, UINodeTestNg006, TestSize.Level1)
275 {
276 /**
277 * @tc.steps: step1. AttachToMainTree and DetachFromMainTree
278 * @tc.expected: onMainTree_ is false
279 */
280 bool mainTrees[2] = { true, false };
281 TWO->AddChild(THREE, 1, false);
282 for (int i = 0; i < 2; ++i) {
283 TWO->onMainTree_ = mainTrees[i];
284 TWO->AttachToMainTree();
285 TWO->DetachFromMainTree();
286 EXPECT_FALSE(TWO->onMainTree_);
287 }
288 TWO->Clean();
289 }
290
291 /**
292 * @tc.name: UINodeTestNg007
293 * @tc.desc: Test ui node method
294 * @tc.type: FUNC
295 */
296 HWTEST_F(UINodeTestNg, UINodeTestNg007, TestSize.Level1)
297 {
298 /**
299 * @tc.steps: step1. MovePosition
300 * @tc.expected: children_.size is 2
301 */
302 int32_t slots[4] = { 1, -1, 1, 2 };
303 THREE->AddChild(FOUR);
304 THREE->AddChild(FIVE);
305 TWO->parent_ = THREE;
306 for (int i = 0; i < 4; ++i) {
307 TWO->MovePosition(slots[i]);
308 }
309 EXPECT_EQ(THREE->children_.size(), 3);
310 THREE->Clean();
311 }
312
313 /**
314 * @tc.name: UINodeTestNg008
315 * @tc.desc: Test ui node method
316 * @tc.type: FUNC
317 */
318 HWTEST_F(UINodeTestNg, UINodeTestNg008, TestSize.Level1)
319 {
320 PropertyChangeFlag FLAG = 1;
321 ONE->children_.clear();
322 TWO->children_.clear();
323 THREE->children_.clear();
324 ONE->AddChild(TWO, 1, false);
325 ONE->parent_ = THREE;
326 ONE->UINode::UpdateLayoutPropertyFlag();
327 ONE->UINode::AdjustParentLayoutFlag(FLAG);
328 ONE->UINode::MarkNeedSyncRenderTree();
329 ONE->UINode::RebuildRenderContextTree();
330 ONE->DumpTree(0);
331 EXPECT_EQ(ONE->children_.size(), 1);
332 }
333
334 /**
335 * @tc.name: UINodeTestNg009
336 * @tc.desc: Test ui node method
337 * @tc.type: FUNC
338 */
339 HWTEST_F(UINodeTestNg, UINodeTestNg009, TestSize.Level1)
340 {
341 /**
342 * @tc.steps: step1. FrameCount and GetChildIndexById
343 * @tc.expected: count is 2, pos is 0
344 */
345 int32_t count = ONE->FrameCount();
346 EXPECT_EQ(count, 1);
347 int32_t id1 = ONE->GetChildIndexById(4);
348 int32_t id2 = ONE->GetChildIndexById(2);
349 EXPECT_EQ(id1, -1);
350 EXPECT_EQ(id2, 0);
351 /**
352 * @tc.steps: step2. GetChildFlatIndex
353 * @tc.expected: count is 2, pos is 0
354 */
355 auto pair1 = ONE->GetChildFlatIndex(1);
356 EXPECT_EQ(pair1.second, 0);
357 auto pair2 = ONE->GetChildFlatIndex(2);
358 EXPECT_EQ(pair2.second, 0);
359 }
360
361 /**
362 * @tc.name: UINodeTestNg010
363 * @tc.desc: Test ui node method
364 * @tc.type: FUNC
365 */
366 HWTEST_F(UINodeTestNg, UINodeTestNg010, TestSize.Level1)
367 {
368 /**
369 * @tc.steps: step1. call the GetChildIndex and set input is null
370 * @tc.expected: the return value is -1
371 */
372 int retIndex = ZERO->GetChildIndex(nullptr);
373 EXPECT_EQ(retIndex, -1);
374 /**
375 * @tc.steps: step2. add one child for ZERO and call GetChildIndex
376 * @tc.expected: step2. the return value is 0
377 */
378 ZERO->AddChild(ONE);
379 retIndex = ZERO->GetChildIndex(ONE);
380 EXPECT_EQ(retIndex, 0);
381 /**
382 * @tc.steps: step3. add two child for ZERO and call GetChildIndex
383 * @tc.expected: the return value is 1
384 */
385 ZERO->AddChild(TWO);
386 retIndex = ZERO->GetChildIndex(TWO);
387 EXPECT_EQ(retIndex, 1);
388 /**
389 * @tc.steps: step4. add three child for ZERO and call GetChildIndex
390 * @tc.expected: the return value is 2
391 */
392 ZERO->AddChild(THREE);
393 retIndex = ZERO->GetChildIndex(THREE);
394 EXPECT_EQ(retIndex, 2);
395 ZERO->Clean();
396 }
397
398 /**
399 * @tc.name: UINodeTestNg011
400 * @tc.desc: Test ui node method
401 * @tc.type: FUNC
402 */
403 HWTEST_F(UINodeTestNg, UINodeTestNg011, TestSize.Level1)
404 {
405 /**
406 * @tc.steps: step1. call the MountToParent and set hostPageId_ is 0
407 * @tc.expected: step2. mount failure
408 */
409 ZERO->hostPageId_ = 0;
410 ONE->MountToParent(ZERO, 1, false);
411 int retPageId = ONE->GetPageId();
412 EXPECT_NE(retPageId, 0);
413 ONE->Clean();
414 /**
415 * @tc.steps: step2. call the MountToParent and set hostPageId_ is 0
416 * @tc.expected: mount sucess and pageid is 1
417 */
418 ZERO->hostPageId_ = 1;
419 ZERO->SetInDestroying();
420 ONE->MountToParent(ZERO, 1, false);
421 retPageId = ONE->GetPageId();
422 EXPECT_EQ(retPageId, 1);
423 ONE->Clean();
424 ZERO->Clean();
425 }
426
427 /**
428 * @tc.name: UINodeTestNg012
429 * @tc.desc: Test ui node method
430 * @tc.type: FUNC
431 */
432 HWTEST_F(UINodeTestNg, UINodeTestNg012, TestSize.Level1)
433 {
434 /**
435 * @tc.steps: step1. call the GetFirstFocusHubChild function
436 * @tc.expected: the return value is null
437 */
438 RefPtr<FocusHub> retFirstFocusHubChild = ZERO->GetFirstFocusHubChild();
439 EXPECT_EQ(retFirstFocusHubChild, nullptr);
440 /**
441 * @tc.steps: step2. call the GetFirstFocusHubChild functionand and set focus type is DISABLE
442 * @tc.expected: the return value is null
443 */
444 auto eventHubZero = AceType::MakeRefPtr<EventHub>();
445 auto focusHubZero = AceType::MakeRefPtr<FocusHub>(eventHubZero, FocusType::DISABLE);
446
447 eventHubZero->focusHub_ = focusHubZero;
448 ZERO->eventHub_ = eventHubZero;
449 retFirstFocusHubChild = ZERO->GetFirstFocusHubChild();
450 EXPECT_EQ(retFirstFocusHubChild, nullptr);
451 /**
452 * @tc.steps: step3. call the GetFirstFocusHubChild functionand set focus type is NODE
453 * @tc.expected: the return focusHub type is NODE
454 */
455 focusHubZero = AceType::MakeRefPtr<FocusHub>(eventHubZero, FocusType::NODE);
456
457 eventHubZero->focusHub_ = focusHubZero;
458 ZERO->eventHub_ = eventHubZero;
459 retFirstFocusHubChild = ZERO->GetFirstFocusHubChild();
460 EXPECT_EQ(retFirstFocusHubChild->GetFocusType(), FocusType::NODE);
461 ZERO->Clean();
462 /**
463 * @tc.steps: step4. call the GetFirstFocusHubChild functionand set focus type is SCOPE
464 * @tc.expected: the return focusHub type is SCOPE
465 */
466 focusHubZero = AceType::MakeRefPtr<FocusHub>(eventHubZero, FocusType::SCOPE);
467
468 eventHubZero->focusHub_ = focusHubZero;
469 ZERO->eventHub_ = eventHubZero;
470 retFirstFocusHubChild = ZERO->GetFirstFocusHubChild();
471 EXPECT_EQ(retFirstFocusHubChild->GetFocusType(), FocusType::SCOPE);
472 ZERO->Clean();
473 }
474
475 /**
476 * @tc.name: UINodeTestNg013
477 * @tc.desc: Test ui node method
478 * @tc.type: FUNC
479 */
480 HWTEST_F(UINodeTestNg, UINodeTestNg013, TestSize.Level1)
481 {
482 /**
483 * @tc.steps: step1. add one child to ZERO and set focus type is NODE
484 * @tc.expected: the return focusHub type is NODE
485 */
486 auto eventHubZero = AceType::MakeRefPtr<EventHub>();
487 auto focusHubZero = AceType::MakeRefPtr<FocusHub>(eventHubZero, FocusType::DISABLE);
488 auto eventHubOne = AceType::MakeRefPtr<EventHub>();
489 auto focusHubOne = AceType::MakeRefPtr<FocusHub>(eventHubOne, FocusType::NODE);
490
491 eventHubZero->focusHub_ = focusHubZero;
492 ZERO->eventHub_ = eventHubZero;
493 eventHubOne->focusHub_ = focusHubOne;
494 ONE->eventHub_ = eventHubOne;
495
496 ZERO->AddChild(ONE, 1, false);
497 RefPtr<FocusHub> retFirstFocusHubChild = ZERO->GetFirstFocusHubChild();
498 EXPECT_EQ(retFirstFocusHubChild->GetFocusType(), FocusType::NODE);
499 ZERO->Clean();
500 /**
501 * @tc.steps: step2. add one child to ZERO and set focus type is DISABLE
502 * @tc.expected: the return value is null
503 */
504 focusHubOne = AceType::MakeRefPtr<FocusHub>(eventHubOne, FocusType::DISABLE);
505
506 eventHubOne->focusHub_ = focusHubOne;
507 ONE->eventHub_ = eventHubOne;
508 ZERO->AddChild(ONE, 1, false);
509 retFirstFocusHubChild = ZERO->GetFirstFocusHubChild();
510 EXPECT_EQ(retFirstFocusHubChild, nullptr);
511 ZERO->Clean();
512 }
513
514 /**
515 * @tc.name: UINodeTestNg014
516 * @tc.desc: Test ui node method
517 * @tc.type: FUNC
518 */
519 HWTEST_F(UINodeTestNg, UINodeTestNg014, TestSize.Level1)
520 {
521 /**
522 * @tc.steps: step1. add one child to ZERO and set focus type is SCOPE
523 * @tc.expected: the return focusHub type is SCOPE
524 */
525 auto eventHubZero = AceType::MakeRefPtr<EventHub>();
526 auto focusHubZero = AceType::MakeRefPtr<FocusHub>(eventHubZero, FocusType::DISABLE);
527 auto eventHubOne = AceType::MakeRefPtr<EventHub>();
528 auto focusHubOne = AceType::MakeRefPtr<FocusHub>(eventHubOne, FocusType::SCOPE);
529
530 eventHubZero->focusHub_ = focusHubZero;
531 ZERO->eventHub_ = eventHubZero;
532 eventHubOne->focusHub_ = focusHubOne;
533 ONE->eventHub_ = eventHubOne;
534
535 ZERO->AddChild(ONE, 1, false);
536 RefPtr<FocusHub> retFirstFocusHubChild = ZERO->GetFirstFocusHubChild();
537 EXPECT_EQ(retFirstFocusHubChild->GetFocusType(), FocusType::SCOPE);
538 ZERO->Clean();
539 /**
540 * @tc.steps: step2. add one child to ZERO and set focus type is DISABLE
541 * @tc.expected: the return value is null
542 */
543 focusHubOne = AceType::MakeRefPtr<FocusHub>(eventHubOne, FocusType::DISABLE);
544
545 eventHubOne->focusHub_ = focusHubOne;
546 ONE->eventHub_ = eventHubOne;
547 ZERO->AddChild(ONE, 1, false);
548 retFirstFocusHubChild = ZERO->GetFirstFocusHubChild();
549 EXPECT_EQ(retFirstFocusHubChild, nullptr);
550 ZERO->Clean();
551 }
552
553 /**
554 * @tc.name: UINodeTestNg015
555 * @tc.desc: Test ui node method
556 * @tc.type: FUNC
557 */
558 HWTEST_F(UINodeTestNg, UINodeTestNg015, TestSize.Level1)
559 {
560 /**
561 * @tc.steps: step1. call the MovePosition and set parent_ is null
562 * @tc.expected: parentNode is null
563 */
564 ZERO->parent_ = nullptr;
565 ZERO->MovePosition(1);
566 RefPtr<UINode> retParent = ZERO->GetParent();
567 EXPECT_EQ(retParent, nullptr);
568 }
569
570 /**
571 * @tc.name: UINodeTestNg016
572 * @tc.desc: Test ui node method
573 * @tc.type: FUNC
574 */
575 HWTEST_F(UINodeTestNg, UINodeTestNg016, TestSize.Level1)
576 {
577 /**
578 * @tc.steps: step1. set propertyChangeFlag_ is PROPERTY_UPDATE_NORMAL and call the MarkDirtyNode
579 * @tc.expected: the MarkDirtyNode function is run ok and children_.size() is 1
580 */
581 PropertyChangeFlag extraFLAG = PROPERTY_UPDATE_NORMAL;
582 ZERO->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_NORMAL;
583 ONE->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_NORMAL;
584
585 ZERO->AddChild(ONE, 1, false);
586 ZERO->UINode::MarkDirtyNode(extraFLAG);
587 EXPECT_EQ(ZERO->children_.size(), 1);
588 ZERO->Clean();
589 /**
590 * @tc.steps: step2. set propertyChangeFlag_ is PROPERTY_UPDATE_MEASURE and call the MarkDirtyNode
591 * @tc.expected: the MarkDirtyNode function is run ok and children_.size() is 1
592 */
593 extraFLAG = PROPERTY_UPDATE_MEASURE;
594 ZERO->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_MEASURE;
595 ONE->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_MEASURE;
596 ZERO->AddChild(ONE, 1, false);
597 ZERO->UINode::MarkDirtyNode(extraFLAG);
598 EXPECT_EQ(ZERO->children_.size(), 1);
599 ZERO->Clean();
600 /**
601 * @tc.steps: step3. set propertyChangeFlag_ is PROPERTY_UPDATE_LAYOUT and call the MarkDirtyNode
602 * @tc.expected: the MarkDirtyNode function is run ok and children_.size() is 1
603 */
604 extraFLAG = PROPERTY_UPDATE_LAYOUT;
605 ZERO->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_LAYOUT;
606 ONE->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_LAYOUT;
607 ZERO->AddChild(ONE, 1, false);
608 ZERO->UINode::MarkDirtyNode(extraFLAG);
609 EXPECT_EQ(ZERO->children_.size(), 1);
610 ZERO->Clean();
611 }
612
613 /**
614 * @tc.name: UINodeTestNg017
615 * @tc.desc: Test ui node method
616 * @tc.type: FUNC
617 */
618 HWTEST_F(UINodeTestNg, UINodeTestNg017, TestSize.Level1)
619 {
620 /**
621 * @tc.steps: step1. set propertyChangeFlag_ is PROPERTY_UPDATE_NORMAL and call the MarkNeedFrameFlushDirty
622 * @tc.expected: the MarkNeedFrameFlushDirty function is run ok
623 */
624 PropertyChangeFlag extraFLAG = PROPERTY_UPDATE_NORMAL;
625 ZERO->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_NORMAL;
626 ONE->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_NORMAL;
627
628 ZERO->UINode::MarkNeedFrameFlushDirty(extraFLAG);
629 EXPECT_EQ(ZERO->parent_.Upgrade(), nullptr);
630 /**
631 * @tc.steps: step2. set one parent_ for ONE and call the MarkNeedFrameFlushDirty
632 * @tc.expected: the MarkNeedFrameFlushDirty function is run ok and parent_ is not null
633 */
634 ZERO->parent_ = ONE;
635 ZERO->UINode::MarkNeedFrameFlushDirty(extraFLAG);
636 ASSERT_NE(ZERO->parent_.Upgrade(), nullptr);
637 ZERO->Clean();
638 ZERO->parent_.Reset();
639 /**
640 * @tc.steps: step3. set propertyChangeFlag_ is PROPERTY_UPDATE_MEASURE and call the MarkNeedFrameFlushDirty
641 * @tc.expected: the MarkNeedFrameFlushDirty function is run ok
642 */
643 extraFLAG = PROPERTY_UPDATE_MEASURE;
644 ZERO->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_MEASURE;
645 ONE->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_MEASURE;
646
647 ZERO->UINode::MarkNeedFrameFlushDirty(extraFLAG);
648 EXPECT_EQ(ZERO->parent_.Upgrade(), nullptr);
649 /**
650 * @tc.steps: step4. set one parent_ for ONE and call the MarkNeedFrameFlushDirty
651 * @tc.expected: the MarkNeedFrameFlushDirty function is run ok and parent_ is not null
652 */
653 ZERO->parent_ = ONE;
654 ZERO->UINode::MarkNeedFrameFlushDirty(extraFLAG);
655 ASSERT_NE(ZERO->parent_.Upgrade(), nullptr);
656 ZERO->Clean();
657 ZERO->parent_.Reset();
658 /**
659 * @tc.steps: step5. set propertyChangeFlag_ is PROPERTY_UPDATE_LAYOUT and call the MarkNeedFrameFlushDirty
660 * @tc.expected: the MarkNeedFrameFlushDirty function is run ok
661 */
662 extraFLAG = PROPERTY_UPDATE_LAYOUT;
663 ZERO->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_LAYOUT;
664 ONE->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_LAYOUT;
665
666 ZERO->UINode::MarkNeedFrameFlushDirty(extraFLAG);
667 EXPECT_EQ(ZERO->parent_.Upgrade(), nullptr);
668 /**
669 * @tc.steps: step6. set one parent_ for ONE and call the MarkNeedFrameFlushDirty
670 * @tc.expected: the MarkNeedFrameFlushDirty function is run ok and parent_ is not null
671 */
672 ZERO->parent_ = ONE;
673 ZERO->UINode::MarkNeedFrameFlushDirty(extraFLAG);
674 ASSERT_NE(ZERO->parent_.Upgrade(), nullptr);
675 ZERO->Clean();
676 ZERO->parent_.Reset();
677 }
678
679 /**
680 * @tc.name: UINodeTestNg018
681 * @tc.desc: Test ui node method
682 * @tc.type: FUNC
683 */
684 HWTEST_F(UINodeTestNg, UINodeTestNg018, TestSize.Level1)
685 {
686 /**
687 * @tc.steps: step1. set ZERO->parent_ is null and call MarkNeedSyncRenderTree
688 * @tc.expected: the MarkNeedSyncRenderTree function is run ok
689 */
690 ZERO->UINode::MarkNeedSyncRenderTree();
691 EXPECT_EQ(ZERO->parent_.Upgrade(), nullptr);
692 /**
693 * @tc.steps: step2. set ZERO->parent_ is null and call RebuildRenderContextTree
694 * @tc.expected: the RebuildRenderContextTree function is run ok
695 */
696 ZERO->UINode::RebuildRenderContextTree();
697 EXPECT_EQ(ZERO->parent_.Upgrade(), nullptr);
698 }
699
700 /**
701 * @tc.name: UINodeTestNg019
702 * @tc.desc: Test ui node method
703 * @tc.type: FUNC
704 */
705 HWTEST_F(UINodeTestNg, UINodeTestNg019, TestSize.Level1)
706 {
707 /**
708 * @tc.steps: step1. call the DetachFromMainTree
709 * @tc.expected: onMainTree_ is false
710 */
711 bool mainTree = true;
712 ZERO->onMainTree_ = mainTree;
713 ZERO->DetachFromMainTree();
714 EXPECT_FALSE(ZERO->onMainTree_);
715 ZERO->Clean();
716 ZERO->UINode::OnDetachFromMainTree();
717 }
718
719 /**
720 * @tc.name: UINodeTestNg020
721 * @tc.desc: Test ui node method
722 * @tc.type: FUNC
723 */
724 HWTEST_F(UINodeTestNg, UINodeTestNg020, TestSize.Level1)
725 {
726 /**
727 * @tc.steps: step1. add one child for ZERO and call AdjustLayoutWrapperTree
728 * @tc.expected: children_.size is 1 and the AdjustLayoutWrapperTree function is run ok
729 */
730 ZERO->AddChild(ONE, 1, false);
731 RefPtr<LayoutWrapperNode> retLayoutWrapper = ZERO->UINode::CreateLayoutWrapper(true, true);
732 ZERO->UINode::AdjustLayoutWrapperTree(retLayoutWrapper, true, true);
733 EXPECT_EQ(ZERO->children_.size(), 1);
734 ZERO->Clean();
735 }
736
737 /**
738 * @tc.name: UINodeTestNg021
739 * @tc.desc: Test ui node method
740 * @tc.type: FUNC
741 */
742 HWTEST_F(UINodeTestNg, UINodeTestNg021, TestSize.Level1)
743 {
744 /**
745 * @tc.steps: step1. add one child for ZERO and call GenerateOneDepthVisibleFrame
746 * @tc.expected: children_.size is 1 and the GenerateOneDepthVisibleFrame function is run ok
747 */
748 std::list<RefPtr<FrameNode>> visibleList;
749
750 ZERO->AddChild(ONE, 1, false);
751 ZERO->GenerateOneDepthVisibleFrame(visibleList);
752 EXPECT_EQ(ZERO->children_.size(), 1);
753 ZERO->Clean();
754 }
755
756 /**
757 * @tc.name: UINodeTestNg022
758 * @tc.desc: Test ui node method
759 * @tc.type: FUNC
760 */
761 HWTEST_F(UINodeTestNg, UINodeTestNg022, TestSize.Level1)
762 {
763 /**
764 * @tc.steps: step1. add one child for ZERO and call GenerateOneDepthAllFrame
765 * @tc.expected: children_.size is 1 and the GenerateOneDepthAllFrame function is run ok
766 */
767 std::list<RefPtr<FrameNode>> visibleList;
768
769 ZERO->AddChild(ONE, 1, false);
770 ZERO->GenerateOneDepthAllFrame(visibleList);
771 EXPECT_EQ(ZERO->children_.size(), 1);
772 ZERO->Clean();
773 }
774
775 /**
776 * @tc.name: UINodeTestNg023
777 * @tc.desc: Test ui node method
778 * @tc.type: FUNC
779 */
780 HWTEST_F(UINodeTestNg, UINodeTestNg023, TestSize.Level1)
781 {
782 /**
783 * @tc.steps: step1. add one child for ZERO and call TouchTest
784 * @tc.expected: the return value is meetings expectations
785 */
786 TouchTestResult result;
787 ResponseLinkResult responseLinkResult;
788 TouchRestrict restrict;
789 const PointF GLOBAL_POINT { 20.0f, 20.0f };
790 const PointF LOCAL_POINT { 15.0f, 15.0f };
791 auto testNode = TestNode::CreateTestNode(TEST_ID_ONE);
792 ZERO->AddChild(testNode, 1, false);
793 HitTestResult retResult =
794 ZERO->UINode::TouchTest(GLOBAL_POINT, LOCAL_POINT, LOCAL_POINT, restrict, result, 1, responseLinkResult);
795 EXPECT_EQ(retResult, HitTestResult::OUT_OF_REGION);
796 testNode->hitTestResult_ = HitTestResult::STOP_BUBBLING;
797 retResult =
798 ZERO->UINode::TouchTest(GLOBAL_POINT, LOCAL_POINT, LOCAL_POINT, restrict, result, 1, responseLinkResult);
799 EXPECT_EQ(retResult, HitTestResult::STOP_BUBBLING);
800 testNode->hitTestResult_ = HitTestResult::BUBBLING;
801 retResult =
802 ZERO->UINode::TouchTest(GLOBAL_POINT, LOCAL_POINT, LOCAL_POINT, restrict, result, 1, responseLinkResult);
803 EXPECT_EQ(retResult, HitTestResult::BUBBLING);
804 ZERO->Clean();
805 }
806
807 /**
808 * @tc.name: UINodeTestNg026
809 * @tc.desc: Test ui node method
810 * @tc.type: FUNC
811 */
812 HWTEST_F(UINodeTestNg, UINodeTestNg026, TestSize.Level1)
813 {
814 /**
815 * @tc.steps: step1. add one child for ZERO and call TotalChildCount
816 * @tc.expected: the return retCount is 1
817 */
818 ZERO->AddChild(ONE, 1, false);
819 int32_t retCount = ZERO->UINode::FrameCount();
820 EXPECT_EQ(retCount, 1);
821 /**
822 * @tc.steps: step2. add two child for ZERO and call TotalChildCount
823 * @tc.expected: the return retCount is 2
824 */
825 ZERO->AddChild(TWO, 2, false);
826 retCount = ZERO->TotalChildCount();
827 EXPECT_EQ(retCount, 2);
828 /**
829 * @tc.steps: step3. add three child for ZERO and call TotalChildCount
830 * @tc.expected: the return retCount is 3
831 */
832 ZERO->AddChild(THREE, 3, false);
833 retCount = ZERO->TotalChildCount();
834 EXPECT_EQ(retCount, 3);
835 /**
836 * @tc.steps: step4. add four child for ZERO and call TotalChildCount
837 * @tc.expected: the return retCount is 4
838 */
839 ZERO->AddChild(FOUR, 4, false);
840 retCount = ZERO->TotalChildCount();
841 EXPECT_EQ(retCount, 4);
842 ZERO->Clean();
843 /**
844 * @tc.steps: step5. clean ZERO's child and TotalChildCount
845 * @tc.expected: the return retCount is 0
846 */
847 retCount = ZERO->TotalChildCount();
848 EXPECT_EQ(retCount, 0);
849 }
850
851 /**
852 * @tc.name: UINodeTestNg027
853 * @tc.desc: Test ui node method
854 * @tc.type: FUNC
855 */
856 HWTEST_F(UINodeTestNg, UINodeTestNg027, TestSize.Level1)
857 {
858 /**
859 * @tc.steps: step1. add one child for ZERO and call Build
860 * @tc.expected: the Build function is run ok
861 */
862 ZERO->AddChild(ONE, 1, false);
863 ZERO->Build(nullptr);
864 EXPECT_EQ(ZERO->children_.size(), 1);
865 ZERO->Clean();
866 }
867
868 /**
869 * @tc.name: UINodeTestNg028
870 * @tc.desc: Test ui node method
871 * @tc.type: FUNC
872 */
873 HWTEST_F(UINodeTestNg, UINodeTestNg028, TestSize.Level1)
874 {
875 /**
876 * @tc.steps: step1. add one child for ZERO and call SetActive
877 * @tc.expected: the SetActive function is run ok
878 */
879 ZERO->AddChild(ONE, 1, false);
880 ZERO->UINode::SetActive(true);
881 EXPECT_EQ(ZERO->children_.size(), 1);
882 ZERO->Clean();
883 }
884
885 /**
886 * @tc.name: UINodeTestNg029
887 * @tc.desc: Test ui node method
888 * @tc.type: FUNC
889 */
890 HWTEST_F(UINodeTestNg, UINodeTestNg029, TestSize.Level1)
891 {
892 /**
893 * @tc.steps: step1. add one child for ZERO and call TryVisibleChangeOnDescendant
894 * @tc.expected: the TryVisibleChangeOnDescendant function is run ok
895 */
896 ZERO->AddChild(ONE, 1, false);
897 ZERO->UINode::TryVisibleChangeOnDescendant(VisibleType::INVISIBLE, VisibleType::VISIBLE);
898 EXPECT_EQ(ZERO->children_.size(), 1);
899 ZERO->Clean();
900 }
901
902 /**
903 * @tc.name: UINodeTestNg030
904 * @tc.desc: Test ui node method
905 * @tc.type: FUNC
906 */
907 HWTEST_F(UINodeTestNg, UINodeTestNg030, TestSize.Level1)
908 {
909 /**
910 * @tc.steps: step1. add ONE child for ZERO and call GetChildFlatIndex
911 * @tc.expected: pair1.second is 0
912 */
913 ZERO->AddChild(ONE, 1, false);
914 auto pair = ZERO->GetChildFlatIndex(1);
915 EXPECT_TRUE(pair.first);
916 EXPECT_EQ(pair.second, 0);
917 ZERO->Clean();
918 /**
919 * @tc.steps: step1. AddChild TESTUINode to ZERO and GetChildFlatIndex
920 * @tc.expected: the return pair1.first is false and pair1.second is 1
921 */
922 ZERO->AddChild(TEN0, 1, false);
923 pair = ZERO->GetChildFlatIndex(10);
924 EXPECT_FALSE(pair.first);
925 EXPECT_EQ(pair.second, 1);
926 ZERO->Clean();
927 }
928
929 /**
930 * @tc.name: UINodeTestNg031
931 * @tc.desc: Test ui node method
932 * @tc.type: FUNC
933 */
934 HWTEST_F(UINodeTestNg, UINodeTestNg031, TestSize.Level1)
935 {
936 /**
937 * @tc.steps: step1. add one child to ZERO and ChildrenUpdatedFrom
938 * @tc.expected: childrenUpdatedFrom_ is 1
939 */
940 ZERO->ChildrenUpdatedFrom(1);
941 EXPECT_EQ(ZERO->childrenUpdatedFrom_, 1);
942 ZERO->Clean();
943 }
944
945 /**
946 * @tc.name: UINodeTestNg032
947 * @tc.desc: Test ui node method
948 * @tc.type: FUNC
949 */
950 HWTEST_F(UINodeTestNg, UINodeTestNg032, TestSize.Level1)
951 {
952 /**
953 * @tc.steps: step1. add one child to ZERO and MarkRemoving
954 * @tc.expected: the return retMark is false
955 */
956 ZERO->AddChild(ONE, 1, false);
957 bool retMark = ZERO->UINode::MarkRemoving();
958 EXPECT_FALSE(retMark);
959 ZERO->Clean();
960 }
961
962 /**
963 * @tc.name: UINodeTestNg033
964 * @tc.desc: Test ui node method
965 * @tc.type: FUNC
966 */
967 HWTEST_F(UINodeTestNg, UINodeTestNg033, TestSize.Level1)
968 {
969 /**
970 * @tc.steps: step1. call the SetChildrenInDestroying
971 * @tc.expected: children_.size = 0
972 */
973 ZERO->SetChildrenInDestroying();
974 EXPECT_EQ(ZERO->children_.size(), 0);
975 ZERO->Clean();
976 /**
977 * @tc.steps: step1. add two child to ZERO and call SetChildrenInDestroying
978 * @tc.expected: step1. children_.size = 3
979 */
980 ZERO->AddChild(ONE, 1, false);
981 ZERO->AddChild(TWO, 2, false);
982 ZERO->children_.emplace_back(nullptr);
983 ZERO->SetChildrenInDestroying();
984 EXPECT_EQ(ZERO->children_.size(), 3);
985 ZERO->children_.clear();
986 ZERO->Clean();
987 }
988
989 /**
990 * @tc.name: UINodeTestNg034
991 * @tc.desc: Test ui node method
992 * @tc.type: FUNC
993 */
994 HWTEST_F(UINodeTestNg, UINodeTestNg034, TestSize.Level1)
995 {
996 /**
997 * @tc.steps: step1. add two child to ZERO and call RemoveChildAtIndex
998 * @tc.expected: children_.size = 1
999 */
1000 ZERO->AddChild(ONE, 1, false);
1001 ZERO->RemoveChildAtIndex(1);
1002 EXPECT_EQ(ZERO->children_.size(), 1);
1003 ZERO->Clean();
1004 }
1005
1006 /**
1007 * @tc.name: UINodeTestNg035
1008 * @tc.desc: Test ui node method
1009 * @tc.type: FUNC
1010 */
1011 HWTEST_F(UINodeTestNg, UINodeTestNg035, TestSize.Level1)
1012 {
1013 /**
1014 * @tc.steps: step1. call the AddChild funtion and set child is null
1015 * @tc.expected: children_.size = 0
1016 */
1017 ZERO->AddChild(nullptr, 1, false);
1018 EXPECT_EQ(ZERO->children_.size(), 0);
1019 /**
1020 * @tc.steps: step2. AddChild
1021 * @tc.expected: children_.size = 1
1022 */
1023 ZERO->AddChild(TWO, 1, false);
1024 EXPECT_EQ(ZERO->children_.size(), 1);
1025 /**
1026 * @tc.steps: step3. call the RemoveChild funtion and set input is null
1027 * @tc.expected: the return value is children_.end()
1028 */
1029 auto interator = ZERO->RemoveChild(nullptr);
1030 EXPECT_EQ(interator, ZERO->children_.end());
1031 ZERO->Clean();
1032 }
1033
1034 /**
1035 * @tc.name: UINodeTestNg036
1036 * @tc.desc: Test ui node method
1037 * @tc.type: FUNC
1038 */
1039 HWTEST_F(UINodeTestNg, UINodeTestNg036, TestSize.Level1)
1040 {
1041 /**
1042 * @tc.steps: step1. GetChildAtIndex and set input is -1
1043 * @tc.expected: the return value is return nullptr
1044 */
1045 RefPtr<UINode> retChildAtIndex = ZERO->GetChildAtIndex(-1);
1046 EXPECT_EQ(retChildAtIndex, nullptr);
1047 }
1048
1049 /**
1050 * @tc.name: UINodeTestNg037
1051 * @tc.desc: Test ui node method
1052 * @tc.type: FUNC
1053 */
1054 HWTEST_F(UINodeTestNg, UINodeTestNg037, TestSize.Level1)
1055 {
1056 /**
1057 * @tc.steps: step1. ReplaceChild
1058 * @tc.expected: children_.size() is 0
1059 */
1060 ZERO->ReplaceChild(nullptr, nullptr);
1061 EXPECT_EQ(ZERO->children_.size(), 0);
1062 }
1063
1064 /**
1065 * @tc.name: UINodeTestNg038
1066 * @tc.desc: Test ui node method
1067 * @tc.type: FUNC
1068 */
1069 HWTEST_F(UINodeTestNg, UINodeTestNg038, TestSize.Level1)
1070 {
1071 /**
1072 * @tc.steps: step1. call the MarkDirtyNode.
1073 * @tc.expected: the MarkDirtyNode function is run ok.
1074 */
1075 PropertyChangeFlag FLAG = PROPERTY_UPDATE_NORMAL;
1076 ZERO->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_NORMAL;
1077 ONE->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_NORMAL;
1078 TWO->layoutProperty_->propertyChangeFlag_ = PROPERTY_UPDATE_NORMAL;
1079
1080 ONE->parent_ = ZERO;
1081 TWO->parent_ = ONE;
1082 ZERO->MarkNeedFrameFlushDirty(FLAG);
1083 EXPECT_NE(ONE->parent_.Upgrade(), nullptr);
1084 EXPECT_NE(TWO->parent_.Upgrade(), nullptr);
1085 ZERO->Clean();
1086 }
1087
1088 /**
1089 * @tc.name: UINodeTestNg039
1090 * @tc.desc: Test ui node method
1091 * @tc.type: FUNC
1092 */
1093 HWTEST_F(UINodeTestNg, UINodeTestNg039, TestSize.Level1)
1094 {
1095 /**
1096 * @tc.steps: step1. call the CreateLayoutWrapper
1097 * @tc.expected: the return value is null
1098 */
1099 RefPtr<LayoutWrapperNode> retLayoutWrapper = ZERO->UINode::CreateLayoutWrapper(true, true);
1100 EXPECT_EQ(retLayoutWrapper, nullptr);
1101 /**
1102 * @tc.steps: step2. add one child for ZERO and call CreateLayoutWrapper
1103 * @tc.expected: the return value is null
1104 */
1105 auto testNode = TestNode::CreateTestNode(TEST_ID_ONE);
1106 ZERO->AddChild(testNode, 1, false);
1107 retLayoutWrapper = ZERO->UINode::CreateLayoutWrapper(true, true);
1108 testNode->AddChild(ONE, 1, false);
1109 retLayoutWrapper = ZERO->UINode::CreateLayoutWrapper(true, true);
1110 EXPECT_NE(retLayoutWrapper, nullptr);
1111 ZERO->Clean();
1112 }
1113
1114 /**
1115 * @tc.name: UINodeTestNg040
1116 * @tc.desc: Test ui node method
1117 * @tc.type: FUNC
1118 */
1119 HWTEST_F(UINodeTestNg, UINodeTestNg040, TestSize.Level1)
1120 {
1121 /**
1122 * @tc.steps: step1. set onMainTree_ is true and call AddChild
1123 * @tc.expected: children_.size() is 2
1124 */
1125 auto context = MockPipelineContext::GetCurrent();
1126 ASSERT_NE(context, nullptr);
1127 auto it = std::find(ZERO->children_.begin(), ZERO->children_.end(), ZERO);
1128 ZERO->onMainTree_ = true;
1129 ZERO->context_ = AceType::RawPtr(context);
1130 ZERO->DoAddChild(it, ONE, false);
1131 ZERO->DoAddChild(it, TWO, true);
1132 EXPECT_EQ(ZERO->children_.size(), 2);
1133 ZERO->onMainTree_ = false;
1134 ZERO->context_ = nullptr;
1135 }
1136
1137 /**
1138 * @tc.name: UINodeTestNg042
1139 * @tc.desc: Test ui node method
1140 * @tc.type: FUNC
1141 */
1142 HWTEST_F(UINodeTestNg, UINodeTestNg042, TestSize.Level1)
1143 {
1144 /**
1145 * @tc.steps: step1. create some node
1146 */
1147 auto parent = FrameNode::CreateFrameNode(V2::COMMON_VIEW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>(), true);
1148 auto child = FrameNode::CreateFrameNode(V2::COMMON_VIEW_ETS_TAG, 3, AceType::MakeRefPtr<Pattern>());
1149 auto child2 = FrameNode::CreateFrameNode(V2::COMMON_VIEW_ETS_TAG, 4, AceType::MakeRefPtr<Pattern>());
1150 /**
1151 * @tc.steps: step2. call AddDisappearingChild with different condition
1152 * @tc.expected: disappearingChildren_.size() is 2
1153 */
1154 parent->AddDisappearingChild(child);
1155 child2->isDisappearing_ = true;
1156 parent->AddDisappearingChild(child2);
1157 parent->AddDisappearingChild(child);
1158 EXPECT_EQ(parent->disappearingChildren_.size(), 2);
1159 /**
1160 * @tc.steps: step3. call RemoveDisappearingChild with different condition
1161 * @tc.expected: disappearingChildren_.size() is 1
1162 */
1163 parent->RemoveDisappearingChild(child);
1164 child->isDisappearing_ = true;
1165 parent->RemoveDisappearingChild(child);
1166 EXPECT_EQ(parent->disappearingChildren_.size(), 1);
1167 }
1168
1169 /**
1170 * @tc.name: UINodeTestNg043
1171 * @tc.desc: Test ui node method
1172 * @tc.type: FUNC
1173 */
1174 HWTEST_F(UINodeTestNg, UINodeTestNg043, TestSize.Level1)
1175 {
1176 /**
1177 * @tc.steps: step1. create some node
1178 */
1179 auto parent = FrameNode::CreateFrameNode("parent", 1, AceType::MakeRefPtr<Pattern>(), true);
1180 auto child = FrameNode::CreateFrameNode("child", 3, AceType::MakeRefPtr<Pattern>());
1181 parent->AddChild(child);
1182 /**
1183 * @tc.steps: step2. call GetFrameChildByIndex
1184 * @tc.expected: return nullptr
1185 */
1186
1187 LayoutConstraintF parentLayoutConstraint;
1188 parentLayoutConstraint.maxSize.SetWidth(0);
1189 parentLayoutConstraint.maxSize.SetHeight(0);
1190 PerformanceCheckNodeMap un_Map;
1191 un_Map.emplace(0, PerformanceCheckNode());
1192 parent->UINode::OnSetCacheCount(3, parentLayoutConstraint);
1193 parent->UINode::DoRemoveChildInRenderTree(0, true);
1194 parent->UINode::DoRemoveChildInRenderTree(0, false);
1195 parent->UINode::DoRemoveChildInRenderTree(5, false);
1196 parent->UINode::GetFrameChildByIndex(0, false);
1197 EXPECT_FALSE(parent->UINode::GetDisappearingChildById("", 0));
1198 EXPECT_FALSE(parent->UINode::GetFrameChildByIndex(5, false));
1199 }
1200
1201 /**
1202 * @tc.name: UINodeTestNg044
1203 * @tc.desc: Test ui node method of instanceid
1204 * @tc.type: FUNC
1205 */
1206 HWTEST_F(UINodeTestNg, UINodeTestNg044, TestSize.Level1)
1207 {
1208 /**
1209 * @tc.steps: step1. create a uinode
1210 */
1211 auto context = MockPipelineContext::GetCurrent();
1212 ASSERT_NE(context, nullptr);
1213 auto testNode = TestNode::CreateTestNode(TEST_ID_ONE);
1214 ASSERT_NE(testNode, nullptr);
1215
1216 int32_t testId = 0;
__anon24dcb5e60202(int32_t newId) 1217 testNode->RegisterUpdateJSInstanceCallback([&testId](int32_t newId) { testId = newId; });
1218
1219 /**
1220 * @tc.steps: step2. attach context
1221 */
1222 testNode->AttachContext(AceType::RawPtr(context), true);
1223 EXPECT_EQ(testNode->context_, AceType::RawPtr(context));
1224 EXPECT_EQ(testNode->instanceId_, context->GetInstanceId());
1225 EXPECT_EQ(testId, context->GetInstanceId());
1226
1227 /**
1228 * @tc.steps: step3. detach context
1229 */
1230 testNode->DetachContext(true);
1231 EXPECT_EQ(testNode->context_, nullptr);
1232 }
1233
1234 /**
1235 * @tc.name: GetCurrentCustomNodeInfo001
1236 * @tc.desc: Test ui node method GetCurrentCustomNodeInfo
1237 * @tc.type: FUNC
1238 */
1239 HWTEST_F(UINodeTestNg, GetCurrentCustomNodeInfo001, TestSize.Level1)
1240 {
1241 /**
1242 * @tc.steps: step1. create frame node
1243 */
1244 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
1245 auto childId = ElementRegister::GetInstance()->MakeUniqueId();
1246 auto parent = FrameNode::CreateFrameNode("parent_test", parentId, AceType::MakeRefPtr<Pattern>(), true);
1247 auto child = FrameNode::CreateFrameNode("child_test", childId, AceType::MakeRefPtr<Pattern>());
1248 parent->AddChild(child);
1249
1250 /**
1251 * @tc.steps: step2. call GetCurrentCustomNodeInfo
1252 * @tc.expected: return ""
1253 */
1254 std::string rusult = parent->UINode::GetCurrentCustomNodeInfo();
1255 EXPECT_EQ(rusult, "");
1256 }
1257
1258 /**
1259 * @tc.name: GetCurrentCustomNodeInfo002
1260 * @tc.desc: Test ui node method GetCurrentCustomNodeInfo
1261 * @tc.type: FUNC
1262 */
1263 HWTEST_F(UINodeTestNg, GetCurrentCustomNodeInfo002, TestSize.Level1)
1264 {
1265 /**
1266 * @tc.steps: step1. create custome node
1267 */
1268 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
1269 auto childId = ElementRegister::GetInstance()->MakeUniqueId();
1270 auto childTwoId = ElementRegister::GetInstance()->MakeUniqueId();
1271 auto parent = CustomNode::CreateCustomNode(parentId, "parent");
1272 auto child = CustomNode::CreateCustomNode(childId, "child");
1273 auto childTwo = CustomNode::CreateCustomNode(childTwoId, "child_two");
1274 parent->AddChild(child);
1275 parent->AddChild(childTwo);
1276
1277 /**
1278 * @tc.steps: step2. cover branch parent is custome and call GetCurrentCustomNodeInfo
1279 * @tc.expected: return ""
1280 */
1281 std::string rusult = parent->UINode::GetCurrentCustomNodeInfo();
1282 EXPECT_EQ(rusult, "");
1283 }
1284
1285 /**
1286 * @tc.name: GetPerformanceCheckData001
1287 * @tc.desc: Test ui node method GetCurrentCustomNodeInfo
1288 * @tc.type: FUNC
1289 */
1290 HWTEST_F(UINodeTestNg, GetPerformanceCheckData001, TestSize.Level1)
1291 {
1292 /**
1293 * @tc.steps: step1. create frame node
1294 */
1295 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
1296 auto parent = FrameNode::CreateFrameNode("parent", parentId, AceType::MakeRefPtr<Pattern>(), true);
1297 parent->tag_ = V2::COMMON_VIEW_ETS_TAG;
1298 parent->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1299
1300 /**
1301 * @tc.steps: step2. construct parameter performanceCheckNodeMap and call GetPerformanceCheckData
1302 * @tc.expected: isBuildByJS_ is false
1303 */
1304 auto nodeId = ElementRegister::GetInstance()->MakeUniqueId();
1305 PerformanceCheckNodeMap nodeMap;
1306 PerformanceCheckNode performanceCheckNode = PerformanceCheckNode();
1307 nodeMap.emplace(nodeId, performanceCheckNode);
1308
1309 parent->UINode::GetPerformanceCheckData(nodeMap);
1310 EXPECT_FALSE(parent->isBuildByJS_);
1311
1312 /**
1313 * @tc.steps: step3. change parent tag_ and call GetPerformanceCheckData
1314 * @tc.expected: isBuildByJS_ is true
1315 */
1316 parent->tag_ = V2::MENU_ETS_TAG;
1317 parent->SetBuildByJs(true);
1318 parent->UINode::GetPerformanceCheckData(nodeMap);
1319 EXPECT_TRUE(parent->isBuildByJS_);
1320 }
1321
1322 /**
1323 * @tc.name: GetPerformanceCheckData002
1324 * @tc.desc: Test ui node method GetCurrentCustomNodeInfo
1325 * @tc.type: FUNC
1326 */
1327 HWTEST_F(UINodeTestNg, GetPerformanceCheckData002, TestSize.Level1)
1328 {
1329 /**
1330 * @tc.steps: step1. create parent and childframe node
1331 */
1332 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
1333 auto childId = ElementRegister::GetInstance()->MakeUniqueId();
1334 auto parent = FrameNode::CreateFrameNode("parent", parentId, AceType::MakeRefPtr<Pattern>(), true);
1335 auto child = FrameNode::CreateFrameNode("child", childId, AceType::MakeRefPtr<Pattern>(), true);
1336
1337 parent->tag_ = V2::JS_FOR_EACH_ETS_TAG;
1338 parent->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1339 child->tag_ = V2::COMMON_VIEW_ETS_TAG;
1340 child->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1341 parent->AddChild(child);
1342
1343 /**
1344 * @tc.steps: step2. construct parameter performanceCheckNodeMap and call GetPerformanceCheckData
1345 * @tc.expected: isBuildByJS_ is false
1346 */
1347 auto nodeId = ElementRegister::GetInstance()->MakeUniqueId();
1348 PerformanceCheckNodeMap nodeMap;
1349 PerformanceCheckNode performanceCheckNode = PerformanceCheckNode();
1350 nodeMap.emplace(nodeId, performanceCheckNode);
1351
1352 parent->UINode::GetPerformanceCheckData(nodeMap);
1353 EXPECT_FALSE(parent->isBuildByJS_);
1354
1355 /**
1356 * @tc.steps: step3. change child tag_ and call GetPerformanceCheckData
1357 * @tc.expected: isBuildByJS_ is false
1358 */
1359 child->tag_ = V2::JS_FOR_EACH_ETS_TAG;
1360 parent->UINode::GetPerformanceCheckData(nodeMap);
1361 EXPECT_FALSE(parent->isBuildByJS_);
1362 }
1363
1364 /**
1365 * @tc.name: GetPerformanceCheckData003
1366 * @tc.desc: Test ui node method GetCurrentCustomNodeInfo
1367 * @tc.type: FUNC
1368 */
1369 HWTEST_F(UINodeTestNg, GetPerformanceCheckData003, TestSize.Level1)
1370 {
1371 /**
1372 * @tc.steps: step1. create frame node
1373 */
1374 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
1375 auto childId = ElementRegister::GetInstance()->MakeUniqueId();
1376 auto childTwoId = ElementRegister::GetInstance()->MakeUniqueId();
1377 auto parent = FrameNode::CreateFrameNode("parent", parentId, AceType::MakeRefPtr<Pattern>(), true);
1378 auto child = FrameNode::CreateFrameNode("child", childId, AceType::MakeRefPtr<Pattern>(), true);
1379 auto childTwo = FrameNode::CreateFrameNode("childTwo", childTwoId, AceType::MakeRefPtr<Pattern>(), true);
1380 parent->tag_ = V2::JS_FOR_EACH_ETS_TAG;
1381 parent->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1382 child->tag_ = V2::COMMON_VIEW_ETS_TAG;
1383 child->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1384 childTwo->tag_ = V2::COMMON_VIEW_ETS_TAG;
1385 childTwo->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1386 parent->AddChild(child);
1387 parent->AddChild(childTwo);
1388
1389 /**
1390 * @tc.steps: step2. construct parameter performanceCheckNodeMap and call GetPerformanceCheckData
1391 * @tc.expected: isBuildByJS_ is false
1392 */
1393 auto nodeId = ElementRegister::GetInstance()->MakeUniqueId();
1394 PerformanceCheckNodeMap nodeMap;
1395 PerformanceCheckNode performanceCheckNode = PerformanceCheckNode();
1396 nodeMap.emplace(nodeId, performanceCheckNode);
1397
1398 parent->UINode::GetPerformanceCheckData(nodeMap);
1399 EXPECT_FALSE(parent->isBuildByJS_);
1400
1401 /**
1402 * @tc.steps: step3. change child tag_ and call GetPerformanceCheckData
1403 * @tc.expected: isBuildByJS_ is false
1404 */
1405 child->tag_ = V2::JS_FOR_EACH_ETS_TAG;
1406 parent->UINode::GetPerformanceCheckData(nodeMap);
1407 EXPECT_FALSE(parent->isBuildByJS_);
1408 }
1409
1410 /**
1411 * @tc.name: UpdateConfigurationUpdate001
1412 * @tc.desc: Test ui node method UpdateConfigurationUpdate
1413 * @tc.type: FUNC
1414 */
1415 HWTEST_F(UINodeTestNg, UpdateConfigurationUpdate001, TestSize.Level1)
1416 {
1417 /**
1418 * @tc.steps: step1. create frame node
1419 */
1420 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
1421 auto parent = FrameNode::CreateFrameNode("parent", parentId, AceType::MakeRefPtr<Pattern>(), true);
1422 parent->tag_ = V2::COMMON_VIEW_ETS_TAG;
1423 parent->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1424
1425 /**
1426 * @tc.steps: step2. construct parameter configurationChange and call UpdateConfigurationUpdate
1427 * @tc.expected: cover branch needCallChildrenUpdate_ is true
1428 */
1429 ConfigurationChange configurationChange;
1430 parent->UINode::UpdateConfigurationUpdate(configurationChange);
1431 EXPECT_TRUE(parent->needCallChildrenUpdate_);
1432
1433 /**
1434 * @tc.steps: step3. create child frame node and call UpdateConfigurationUpdate
1435 * @tc.expected: cover branch children is not empty
1436 */
1437 auto childId = ElementRegister::GetInstance()->MakeUniqueId();
1438 auto childTwoId = ElementRegister::GetInstance()->MakeUniqueId();
1439 auto child = FrameNode::CreateFrameNode("child", childId, AceType::MakeRefPtr<Pattern>(), true);
1440 auto childTwo = FrameNode::CreateFrameNode("childTwo", childTwoId, AceType::MakeRefPtr<Pattern>(), true);
1441 child->tag_ = V2::COMMON_VIEW_ETS_TAG;
1442 child->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1443 childTwo->tag_ = V2::COMMON_VIEW_ETS_TAG;
1444 childTwo->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1445 parent->AddChild(child);
1446 parent->AddChild(childTwo);
1447 parent->UINode::UpdateConfigurationUpdate(configurationChange);
1448 EXPECT_TRUE(parent->needCallChildrenUpdate_);
1449
1450 /**
1451 * @tc.steps: step4. set needCallChildrenUpdate_ and call UpdateConfigurationUpdate
1452 * @tc.expected: cover branch needCallChildrenUpdate_ is false
1453 */
1454 parent->SetNeedCallChildrenUpdate(false);
1455 parent->UINode::UpdateConfigurationUpdate(configurationChange);
1456 EXPECT_FALSE(parent->needCallChildrenUpdate_);
1457 }
1458
1459 /**
1460 * @tc.name: DumpTreeById001
1461 * @tc.desc: Test ui node method DumpTreeById
1462 * @tc.type: FUNC
1463 */
1464 HWTEST_F(UINodeTestNg, DumpTreeById001, TestSize.Level1)
1465 {
1466 /**
1467 * @tc.steps: step1. create frame node
1468 */
1469 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
1470 auto childId = ElementRegister::GetInstance()->MakeUniqueId();
1471 auto parent = FrameNode::CreateFrameNode("parent", parentId, AceType::MakeRefPtr<Pattern>(), true);
1472 auto child = FrameNode::CreateFrameNode("child", childId, AceType::MakeRefPtr<Pattern>(), true);
1473
1474 parent->tag_ = V2::JS_FOR_EACH_ETS_TAG;
1475 parent->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1476 child->tag_ = V2::COMMON_VIEW_ETS_TAG;
1477 child->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1478 parent->AddChild(child);
1479
1480 /**
1481 * @tc.steps: step2. call DumpTreeById
1482 * @tc.expected: cover branch GetDumpFile is nullptr and result is false
1483 */
1484 bool result = parent->UINode::DumpTreeById(0, "");
1485 EXPECT_FALSE(result);
1486
1487 /**
1488 * @tc.steps: step3. set DumpFile and call DumpTreeById
1489 * @tc.expected: cover branch GetDumpFile is not nullptr and result is true
1490 */
1491 std::unique_ptr<std::ostream> ostream = std::make_unique<std::ostringstream>();
1492 ASSERT_NE(ostream, nullptr);
1493 DumpLog::GetInstance().SetDumpFile(std::move(ostream));
1494
1495 result = parent->UINode::DumpTreeById(0, "");
1496 EXPECT_TRUE(result);
1497 }
1498
1499 /**
1500 * @tc.name: DumpTreeById002
1501 * @tc.desc: Test ui node method DumpTreeById
1502 * @tc.type: FUNC
1503 */
1504 HWTEST_F(UINodeTestNg, DumpTreeById002, TestSize.Level1)
1505 {
1506 /**
1507 * @tc.steps: step1. create frame node
1508 */
1509 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
1510 auto childId = ElementRegister::GetInstance()->MakeUniqueId();
1511 auto parent = FrameNode::CreateFrameNode("parent", parentId, AceType::MakeRefPtr<Pattern>(), true);
1512 auto child = FrameNode::CreateFrameNode("child", childId, AceType::MakeRefPtr<Pattern>(), true);
1513
1514 parent->tag_ = V2::JS_FOR_EACH_ETS_TAG;
1515 parent->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1516 child->tag_ = V2::COMMON_VIEW_ETS_TAG;
1517 child->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
1518 parent->AddChild(child);
1519
1520 std::unique_ptr<std::ostream> ostream = std::make_unique<std::ostringstream>();
1521 ASSERT_NE(ostream, nullptr);
1522 DumpLog::GetInstance().SetDumpFile(std::move(ostream));
1523
1524 /**
1525 * @tc.steps: step2. construt parameter and call DumpTreeById
1526 * @tc.expected: result is false
1527 */
1528 bool result = parent->UINode::DumpTreeById(0, "DumpTreeById002");
1529 EXPECT_FALSE(result);
1530
1531 /**
1532 * @tc.steps: step3. change parameter and call DumpTreeById
1533 * @tc.expected: result is false
1534 */
1535 result = parent->UINode::DumpTreeById(1, "");
1536 EXPECT_TRUE(result);
1537 }
1538
1539 /**
1540 * @tc.name: UINodeTestNg045
1541 * @tc.desc: IsContextTransparent()、GetPageNodeCountAndDepth()
1542 * @tc.type: FUNC
1543 */
1544 HWTEST_F(UINodeTestNg, UINodeTestNg045, TestSize.Level1)
1545 {
1546 /**
1547 * @tc.steps: step1. create frame node
1548 */
1549 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
1550 auto childId = ElementRegister::GetInstance()->MakeUniqueId();
1551 auto parent = FrameNode::CreateFrameNode("parent", parentId, AceType::MakeRefPtr<Pattern>(), true);
1552 auto child = FrameNode::CreateFrameNode("child", childId, AceType::MakeRefPtr<Pattern>(), true);
1553
1554 /**
1555 * @tc.steps: step2. call IsContextTransparent
1556 * @tc.expected: result is True
1557 */
1558 parent->AddChild(child);
1559 EXPECT_TRUE(parent->UINode::IsContextTransparent());
1560 int32_t count = 0;
1561 int32_t depth = 0;
1562
1563 parent->GetPageNodeCountAndDepth(&count, &depth);
1564 EXPECT_EQ(parent->depth_, INT32_MAX);
1565 EXPECT_EQ(parent->depth_, INT32_MAX);
1566
1567 auto child1 = FrameNode::CreateFrameNode(
1568 "child1", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), true);
1569 auto child2 = FrameNode::CreateFrameNode(
1570 "child2", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), true);
1571 child2->tag_ = V2::JS_VIEW_ETS_TAG;
1572 child1->AddChild(child2);
1573 child1->AddChild(ONE);
1574 std::list<int32_t> removedElmtId;
1575 parent->UINode::CollectRemovedChildren(child1->GetChildren(), removedElmtId, true);
1576 parent->UINode::GetFrameChildByIndexWithoutExpanded(0);
1577 parent->UINode::SetJSViewActive(false);
1578 parent->UINode::RenderCustomChild(0);
1579 std::vector<RefPtr<UINode>> res;
1580 parent->DFSAllChild(child1, res);
1581 EXPECT_EQ(res.size(), 2);
1582 }
1583
1584 /**
1585 * @tc.name: UINodeTestNg046
1586 * @tc.desc: IsContextTransparent()、GetPageNodeCountAndDepth()
1587 * @tc.type: FUNC
1588 */
1589 HWTEST_F(UINodeTestNg, UINodeTestNg046, TestSize.Level1)
1590 {
1591 /**
1592 * @tc.steps: step1. create frame node
1593 */
1594 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
1595 auto childId = ElementRegister::GetInstance()->MakeUniqueId();
1596 auto parent = FrameNode::CreateFrameNode("parent", parentId, AceType::MakeRefPtr<Pattern>(), true);
1597 auto child = FrameNode::CreateFrameNode("child", childId, AceType::MakeRefPtr<Pattern>(), true);
1598
1599 /**
1600 * @tc.steps: step2. call IsContextTransparent
1601 * @tc.expected: result is True
1602 */
1603 parent->AddChild(child);
1604 parent->AddChild(ONE);
1605
1606 auto child1 = FrameNode::CreateFrameNode(
1607 "child1", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), true);
1608 auto child2 = FrameNode::CreateFrameNode(
1609 "child2", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), true);
1610 child2->tag_ = V2::JS_VIEW_ETS_TAG;
1611 child1->AddChild(child2);
1612 std::list<int32_t> removedElmtId;
1613 EXPECT_TRUE(parent->UINode::GetContextWithCheck());
1614 EXPECT_EQ(parent->UINode::GetFrameNodeIndex(child, true), 0);
1615 EXPECT_EQ(parent->UINode::GetFrameNodeIndex(child1, false), -1);
1616 }
1617
1618 /**
1619 * @tc.name: UINodeTestNg047
1620 * @tc.desc: Test ui node method AddChildBefore
1621 * @tc.type: FUNC
1622 */
1623 HWTEST_F(UINodeTestNg, UINodeTestNg047, TestSize.Level1)
1624 {
1625 /**
1626 * @tc.steps: step1. AddChild,child not exsit and siblingNode exsit
1627 * @tc.expected: children_.size = 3
1628 */
1629 EXPECT_EQ(ONE->children_.size(), 0);
1630 ONE->Clean();
1631 EXPECT_EQ(ONE->children_.size(), 0);
1632 ONE->AddChild(TWO, 1, false);
1633 auto testNode = TestNode::CreateTestNode(TEST_ID_ONE);
1634 auto testNode2 = TestNode::CreateTestNode(TEST_ID_TWO);
1635 ONE->AddChild(testNode, 1, false);
1636 ONE->AddChildBefore(testNode2, testNode);
1637 EXPECT_EQ(ONE->children_.size(), 3);
1638 ONE->Clean();
1639
1640 /**
1641 * @tc.steps: step2. AddChild, both child and siblingNode not exsit
1642 * @tc.expected: children_.size = 3
1643 */
1644 ONE->AddChild(TWO, 1, false);
1645 const int32_t testId3 = 23;
1646 auto testNode3 = TestNode::CreateTestNode(testId3);
1647 ONE->AddChild(testNode, 1, false);
1648 ONE->AddChildBefore(testNode3, testNode2);
1649 EXPECT_EQ(ONE->children_.size(), 3);
1650 ONE->Clean();
1651
1652 /**
1653 * @tc.steps: step3. AddChild, child exsit
1654 * @tc.expected: children_.size = 3
1655 */
1656 ONE->AddChild(TWO, 1, false);
1657 ONE->AddChild(testNode, 1, false);
1658 ONE->AddChild(testNode3, 1, false);
1659 ONE->AddChildBefore(testNode, testNode3);
1660 EXPECT_EQ(ONE->children_.size(), 3);
1661 ONE->Clean();
1662 }
1663
1664 /**
1665 * @tc.name: UINodeTestNg048
1666 * @tc.desc: Test ui node method AddChildAfter
1667 * @tc.type: FUNC
1668 */
1669 HWTEST_F(UINodeTestNg, UINodeTestNg048, TestSize.Level1)
1670 {
1671 /**
1672 * @tc.steps: step1. AddChild,child exsit
1673 * @tc.expected: children_.size = 3
1674 */
1675 EXPECT_EQ(ONE->children_.size(), 0);
1676 ONE->Clean();
1677 EXPECT_EQ(ONE->children_.size(), 0);
1678 ONE->AddChild(TWO, 1, false);
1679 auto testNode = TestNode::CreateTestNode(TEST_ID_ONE);
1680 auto testNode2 = TestNode::CreateTestNode(TEST_ID_TWO);
1681 ONE->AddChild(testNode, 1, false);
1682 ONE->AddChildAfter(testNode2, testNode);
1683 EXPECT_EQ(ONE->children_.size(), 3);
1684 ONE->Clean();
1685
1686 /**
1687 * @tc.steps: step3. AddChild, both child and siblingNode not exsit
1688 * @tc.expected: children_.size = 3
1689 */
1690 ONE->AddChild(TWO, 1, false);
1691 const int32_t testId3 = 23;
1692 auto testNode3 = TestNode::CreateTestNode(testId3);
1693 ONE->AddChild(testNode, 1, false);
1694 ONE->AddChildBefore(testNode3, testNode2);
1695 EXPECT_EQ(ONE->children_.size(), 3);
1696 ONE->Clean();
1697
1698 /**
1699 * @tc.steps: step2. AddChild, addModalUiextension is false and modalUiextensionCount_ > 0
1700 * @tc.expected: children_.size = 0
1701 */
1702 ONE->UpdateModalUiextensionCount(true);
1703 ONE->AddChild(TWO, 1, false, false, false);
1704 ONE->RemoveImmediately();
1705 EXPECT_EQ(ONE->children_.size(), 0);
1706 }
1707
1708 /**
1709 * @tc.name: UINodeTestNg049
1710 * @tc.desc: Test ui node method UpdateGeometryTransition
1711 * @tc.type: FUNC
1712 */
1713 HWTEST_F(UINodeTestNg, UINodeTestNg049, TestSize.Level1)
1714 {
1715 /**
1716 * @tc.steps: step1. add child and update geometry transition
1717 * @tc.expected: children_.size = 3
1718 */
1719 ONE->AddChild(TWO, 1, false);
1720 auto testNode = TestNode::CreateTestNode(TEST_ID_ONE);
1721 auto testNode2 = TestNode::CreateTestNode(TEST_ID_TWO);
1722 ONE->AddChild(testNode, 1, false);
1723 ONE->AddChild(testNode2, 1, false);
1724 ONE->UpdateGeometryTransition();
1725 ONE->Clean();
1726 }
1727
1728 /**
1729 * @tc.name: UINodeTestNg050
1730 * @tc.desc: Test ui node method GetContextWithCheck
1731 * @tc.type: FUNC
1732 */
1733 HWTEST_F(UINodeTestNg, UINodeTestNg050, TestSize.Level1)
1734 {
1735 /**
1736 * @tc.steps: step1. add child and GetContextWithCheck
1737 * @tc.expected: ret != nullptr
1738 */
1739 ONE->AddChild(TWO, 1, false);
1740 PipelineContext* ret = ONE->GetContextWithCheck();
1741 ASSERT_TRUE(ret != nullptr);
1742 ONE->Clean();
1743 }
1744
1745 /**
1746 * @tc.name: UINodeTestNg051
1747 * @tc.desc: Test ui node method CurrentFrameCount/GenerateAccessibilityId
1748 * @tc.type: FUNC
1749 */
1750 HWTEST_F(UINodeTestNg, UINodeTestNg051, TestSize.Level1)
1751 {
1752 /**
1753 * @tc.steps: step1. add child and excute CurrentFrameCount
1754 * @tc.expected: count == 0
1755 */
1756 ONE->AddChild(TWO, 1, false);
1757 int32_t count = ONE->CurrentFrameCount();
1758 ASSERT_TRUE(count == 1);
1759 int64_t idCurrent = ONE->GenerateAccessibilityId();
1760 int64_t id = ONE->GenerateAccessibilityId();
1761 ASSERT_TRUE(id == idCurrent + 1);
1762 ONE->Clean();
1763 }
1764
1765 /**
1766 * @tc.name: UINodeTestNg052
1767 * @tc.desc: Test ui node method of AttachContext
1768 * @tc.type: FUNC
1769 */
1770 HWTEST_F(UINodeTestNg, UINodeTestNg052, TestSize.Level1)
1771 {
1772 /**
1773 * @tc.steps: step1. create a uinode
1774 */
1775 auto context = MockPipelineContext::GetCurrent();
1776 ASSERT_NE(context, nullptr);
1777 auto testNode = TestNode::CreateTestNode(TEST_ID_ONE);
1778 ASSERT_NE(testNode, nullptr);
1779 testNode->AddChild(TWO, 1, false);
1780 /**
1781 * @tc.steps: step2. attach context
1782 */
1783 testNode->AttachContext(AceType::RawPtr(context), true);
1784 EXPECT_EQ(testNode->context_, AceType::RawPtr(context));
1785 /**
1786 * @tc.steps: step3. detach context
1787 */
1788 testNode->DetachContext(true);
1789 EXPECT_EQ(testNode->context_, nullptr);
1790 }
1791
1792 /**
1793 * @tc.name: UINodeTestNg053
1794 * @tc.desc: Test ui node method GetBestBreakPoint1
1795 * @tc.type: FUNC
1796 */
1797 HWTEST_F(UINodeTestNg, UINodeTestNg053, TestSize.Level1)
1798 {
1799 /**
1800 * @tc.steps: step1. GetChildAtIndex and retParent nullptr 0000
1801 * @tc.expected: GetChildAtIndex and retParent nullptr
1802 */
1803 ZERO->parent_ = nullptr;
1804 RefPtr<UINode> retParent = ZERO->GetParent();
1805 RefPtr<UINode> retChildAtIndex = ZERO->GetChildAtIndex(-1);
1806 ZERO->GetBestBreakPoint(retChildAtIndex, retParent);
1807 EXPECT_EQ(retParent, nullptr);
1808 EXPECT_EQ(retChildAtIndex, nullptr);
1809
1810 /**
1811 * @tc.steps: step2. GetChildAtIndex and retParent not nullptr 1100
1812 * @tc.expected: retParent2 nullptr and retChildAtIndex2 point to ZERO
1813 */
1814 ZERO->parent_ = nullptr;
1815 auto testNode25 = TestNode::CreateTestNode(25);
1816 ZERO->AddChild(testNode25, 1, false);
1817 RefPtr<UINode> retChildAtIndex2 = ZERO->GetChildAtIndex(0);
1818 RefPtr<UINode> retParent2 = ZERO;
1819 testNode25->GetBestBreakPoint(retChildAtIndex2, retParent2);
1820 EXPECT_EQ(retParent2, 0);
1821 EXPECT_EQ(retChildAtIndex2->GetTag(), ZERO->GetTag());
1822 ZERO->Clean();
1823
1824 /**
1825 * @tc.steps: step3. GetChildAtIndex and retParent not nullptr,child IsDisappearing is true 1010
1826 * @tc.expected: retParent3 and retChildAtIndex3 point to ZERO
1827 */
1828 ASSERT_TRUE(ZERO->children_.size() == 0);
1829 ZERO->parent_ = nullptr;
1830 ZERO->AddChild(ONE, 1, false);
1831 ZERO->AddDisappearingChild(ONE, 0);
1832 RefPtr<UINode> retChildAtIndex3 = ZERO->GetChildAtIndex(0);
1833 RefPtr<UINode> retParent3 = ONE->GetParent();
1834 ONE->GetBestBreakPoint(retChildAtIndex3, retParent3);
1835 EXPECT_EQ(retParent3, 1);
1836 EXPECT_EQ(retChildAtIndex3->GetTag(), ONE->GetTag());
1837 ZERO->Clean();
1838
1839 /**
1840 * @tc.steps: step4. GetChildAtIndex and retParent not nullptr, child testNode IsDisappearing is true 1110
1841 * @tc.expected: retParent4 point to ZERO and retChildAtIndex4 point to testNode
1842 */
1843 ZERO->parent_ = nullptr;
1844 auto testNode = TestNode::CreateTestNode(TEST_ID_ONE);
1845 ZERO->AddChild(testNode, 1, false);
1846 testNode->AddChild(TWO, 1, false);
1847 ZERO->AddDisappearingChild(testNode, 0);
1848 RefPtr<UINode> retChildAtIndex4 = testNode->GetChildAtIndex(0);
1849 RefPtr<UINode> retParent4 = testNode;
1850 TWO->GetBestBreakPoint(retChildAtIndex4, retParent4);
1851 EXPECT_EQ(retParent4->GetTag(), ZERO->GetTag());
1852 EXPECT_EQ(retChildAtIndex4->GetTag(), testNode->GetTag());
1853 ZERO->Clean();
1854
1855 /**
1856 * @tc.steps: step5. GetChildAtIndex and retParent not nullptr,all child Disappearing true 1011
1857 * @tc.expected: retParent5 and retChildAtIndex5 do not change
1858 */
1859 ZERO->parent_ = nullptr;
1860 auto testNode1 = TestNode::CreateTestNode(TEST_ID_ONE);
1861 ZERO->AddChild(testNode1, 1, false);
1862 testNode1->AddChild(TWO, 1, false);
1863 ZERO->AddDisappearingChild(testNode1, 0);
1864 testNode1->AddDisappearingChild(TWO, 0);
1865 RefPtr<UINode> retChildAtIndex5 = testNode1->GetChildAtIndex(0);
1866 RefPtr<UINode> retParent5 = testNode1;
1867 TWO->GetBestBreakPoint(retChildAtIndex5, retParent5);
1868 EXPECT_EQ(retParent5->GetTag(), testNode1->GetTag());
1869 EXPECT_EQ(retChildAtIndex5->GetTag(), TWO->GetTag());
1870 ZERO->Clean();
1871 }
1872
1873 /**
1874 * @tc.name: UINodeTestNg054
1875 * @tc.desc: Test ui node method GetBestBreakPoint2
1876 * @tc.type: FUNC
1877 */
1878 HWTEST_F(UINodeTestNg, UINodeTestNg054, TestSize.Level1)
1879 {
1880 /**
1881 * @tc.steps: step1. GetChildAtIndex and retParent not nullptr,all child Disappearing true 1111
1882 * @tc.expected: retParent point to testNode3 and retChildAtIndex point to testNode4
1883 */
1884 ZERO->parent_ = nullptr;
1885 auto testNode3 = TestNode::CreateTestNode(TEST_ID_ONE);
1886 auto testNode4 = TestNode::CreateTestNode(TEST_ID_TWO);
1887 auto testNode5 = TestNode::CreateTestNode(23);
1888 ZERO->AddChild(testNode3, 1, false);
1889 testNode3->AddChild(testNode4, 1, false);
1890 testNode4->AddChild(testNode5, 1, false);
1891 ZERO->AddDisappearingChild(testNode3, 0);
1892 testNode3->AddDisappearingChild(testNode4, 0);
1893 RefPtr<UINode> retChildAtIndex = testNode4->GetChildAtIndex(0);
1894 RefPtr<UINode> retParent = testNode4;
1895 testNode4->GetBestBreakPoint(retChildAtIndex, retParent);
1896 EXPECT_EQ(retParent->GetTag(), testNode3->GetTag());
1897 EXPECT_EQ(retChildAtIndex->GetTag(), testNode4->GetTag());
1898 ZERO->Clean();
1899 }
1900
1901 /**
1902 * @tc.name: UINodeTestNg055
1903 * @tc.desc: Test ui node method RemoveFromParentCleanly
1904 * @tc.type: FUNC
1905 */
1906 HWTEST_F(UINodeTestNg, UINodeTestNg055, TestSize.Level1)
1907 {
1908 /**
1909 * @tc.steps: step1. child isDisappearing_ is false, not in ModifyChildren
1910 * @tc.expected: testNode3 has been deleted
1911 */
1912 ZERO->parent_ = nullptr;
1913 auto testNode1 = TestNode::CreateTestNode(TEST_ID_ONE);
1914 auto testNode2 = TestNode::CreateTestNode(TEST_ID_TWO);
1915 const RefPtr<FrameNode> testNode3 =
1916 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
1917 ZERO->AddChild(testNode1, 1, false);
1918 testNode1->AddChild(testNode2, 1, false);
1919 testNode2->AddChild(testNode3, 1, false);
1920 testNode3->RemoveFromParentCleanly(testNode3, testNode2);
1921 EXPECT_EQ(testNode2->children_.size(), 0);
1922 const RefPtr<FrameNode> testNode4 =
1923 FrameNode::CreateFrameNode("testNode4", 1, AceType::MakeRefPtr<Pattern>(), true);
1924 testNode2->AddChild(testNode3, 1, false);
1925 testNode4->RemoveFromParentCleanly(testNode4, testNode2);
1926 EXPECT_EQ(testNode2->children_.size(), 1);
1927 ZERO->Clean();
1928
1929 /**
1930 * @tc.steps: step2. child isDisappearing_ is true
1931 * @tc.expected: child isDisappearing_ is false
1932 */
1933 ZERO->parent_ = nullptr;
1934 auto testNode5 = TestNode::CreateTestNode(25);
1935 auto testNode6 = TestNode::CreateTestNode(26);
1936 const RefPtr<FrameNode> testNode7 =
1937 FrameNode::CreateFrameNode("testNode7", 1, AceType::MakeRefPtr<Pattern>(), true);
1938 ZERO->AddChild(testNode5, 1, false);
1939 testNode5->AddChild(testNode6, 1, false);
1940 testNode6->AddChild(testNode7, 1, false);
1941 testNode6->AddDisappearingChild(testNode7, 0);
1942 testNode7->RemoveFromParentCleanly(testNode7, testNode6);
1943 EXPECT_EQ(testNode7->isDisappearing_, false);
1944 ZERO->Clean();
1945 }
1946
1947 /**
1948 * @tc.name: UINodeTestNg056
1949 * @tc.desc: Test ui node method UpdateGeometryTransition
1950 * @tc.type: FUNC
1951 */
1952 HWTEST_F(UINodeTestNg, UINodeTestNg056, TestSize.Level1)
1953 {
1954 /**
1955 * @tc.steps: step1. construct a uinode and add child
1956 * @tc.expected: expect no exception
1957 */
1958 ZERO->parent_ = nullptr;
1959 const RefPtr<FrameNode> testNode1 =
1960 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
1961 const RefPtr<FrameNode> testNode2 =
1962 FrameNode::CreateFrameNode("testNode2", 1, AceType::MakeRefPtr<Pattern>(), true);
1963 ZERO->AddChild(testNode1, 1, false);
1964 testNode1->AddChild(testNode2, 1, false);
1965 testNode2->UpdateGeometryTransition();
1966 ZERO->Clean();
1967 }
1968
1969 /**
1970 * @tc.name: UINodeTestNg057
1971 * @tc.desc: Test ui node method DumpViewDataPageNodes
1972 * @tc.type: FUNC
1973 */
1974 HWTEST_F(UINodeTestNg, UINodeTestNg057, TestSize.Level1)
1975 {
1976 /**
1977 * @tc.steps: step1. construct a uinode and add child,skipSubAutoFillContainer is false
1978 * @tc.expected: expect no exception
1979 */
1980 const RefPtr<FrameNode> testNode1 =
1981 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
1982 const RefPtr<FrameNode> testNode2 =
1983 FrameNode::CreateFrameNode("testNode2", 1, AceType::MakeRefPtr<Pattern>(), true);
1984 testNode1->AddChild(testNode2, 1, false);
1985 testNode1->AddChild(nullptr, 1, false);
1986 std::cout << testNode1->children_.size() << std::endl;
1987 auto viewDataWrap = ViewDataWrap::CreateViewDataWrap();
1988 testNode1->DumpViewDataPageNodes(viewDataWrap, false);
1989 ZERO->Clean();
1990
1991 /**
1992 * @tc.steps: step2. construct a uinode and add child,skipSubAutoFillContainer is true
1993 * @tc.expected: expect no exception
1994 */
1995 const RefPtr<FrameNode> testNode3 =
1996 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
1997 const RefPtr<FrameNode> testNode4 =
1998 FrameNode::CreateFrameNode("testNode2", 1, AceType::MakeRefPtr<Pattern>(), true);
1999 const RefPtr<FrameNode> testNodePage = FrameNode::CreateFrameNode("page", 1, AceType::MakeRefPtr<Pattern>(), true);
2000 testNode3->AddChild(testNode4, 1, false);
2001 testNode3->AddChild(nullptr, 1, false);
2002 testNode3->AddChild(testNodePage, 1, false);
2003 std::cout << testNode3->children_.size() << std::endl;
2004 auto viewDataWrap2 = ViewDataWrap::CreateViewDataWrap();
2005 testNode3->DumpViewDataPageNodes(viewDataWrap2, true);
2006 ZERO->Clean();
2007 }
2008
2009 /**
2010 * @tc.name: UINodeTestNg058
2011 * @tc.desc: Test ui node method DumpTree
2012 * @tc.type: FUNC
2013 */
2014 HWTEST_F(UINodeTestNg, UINodeTestNg058, TestSize.Level1)
2015 {
2016 /**
2017 * @tc.steps: step1. construct a FrameNode with Disappearing child and OverlayNode child
2018 * @tc.expected: expect no exception
2019 */
2020 ZERO->parent_ = nullptr;
2021 const RefPtr<FrameNode> testNode1 =
2022 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
2023 const RefPtr<FrameNode> testNode2 =
2024 FrameNode::CreateFrameNode("testNode2", 1, AceType::MakeRefPtr<Pattern>(), true);
2025 const RefPtr<FrameNode> testNode3 =
2026 FrameNode::CreateFrameNode("testNode3", 1, AceType::MakeRefPtr<Pattern>(), true);
2027 const RefPtr<FrameNode> testNode4 =
2028 FrameNode::CreateFrameNode("testNode4", 1, AceType::MakeRefPtr<Pattern>(), true);
2029 ZERO->AddChild(testNode1, 1, false);
2030 ZERO->AddChild(testNode2, 1, false);
2031 ZERO->AddDisappearingChild(testNode1, 0);
2032 testNode1->SetOverlayNode(testNode3);
2033 testNode1->AddDisappearingChild(testNode4, 0);
2034 testNode1->DumpTree(0);
2035 ZERO->Clean();
2036 }
2037
2038 /**
2039 * @tc.name: UINodeTestNg059
2040 * @tc.desc: Test ui node method DumpTreeById
2041 * @tc.type: FUNC
2042 */
2043 HWTEST_F(UINodeTestNg, UINodeTestNg059, TestSize.Level1)
2044 {
2045 /**
2046 * @tc.steps: step1. construct a FrameNode with Disappearing child
2047 * @tc.expected: expect no exception
2048 */
2049 ZERO->parent_ = nullptr;
2050 const RefPtr<FrameNode> testNode1 =
2051 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
2052 const RefPtr<FrameNode> testNode2 =
2053 FrameNode::CreateFrameNode("testNode2", 2, AceType::MakeRefPtr<Pattern>(), true);
2054 const RefPtr<FrameNode> testNode3 =
2055 FrameNode::CreateFrameNode("testNode3", 3, AceType::MakeRefPtr<Pattern>(), true);
2056 const RefPtr<FrameNode> testNode4 =
2057 FrameNode::CreateFrameNode("testNode4", 4, AceType::MakeRefPtr<Pattern>(), true);
2058 ZERO->AddChild(testNode1, 1, false);
2059 ZERO->AddChild(testNode2, 1, false);
2060 ZERO->AddDisappearingChild(testNode1, 0);
2061 testNode1->AddChild(testNode3, 0);
2062 testNode1->AddDisappearingChild(testNode4, 0);
2063 testNode1->DumpTreeById(0, "3");
2064 testNode1->DumpTreeById(0, "4");
2065 ZERO->Clean();
2066 }
2067
2068 /**
2069 * @tc.name: UINodeTestNg060
2070 * @tc.desc: Test ui node method AdjustLayoutWrapperTree
2071 * @tc.type: FUNC
2072 */
2073 HWTEST_F(UINodeTestNg, UINodeTestNg060, TestSize.Level1)
2074 {
2075 /**
2076 * @tc.steps: step1. construct a FrameNode with child
2077 * @tc.expected: expect no exception
2078 */
2079 const RefPtr<FrameNode> testNode1 =
2080 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
2081 const RefPtr<FrameNode> testNode2 =
2082 FrameNode::CreateFrameNode("testNode2", 2, AceType::MakeRefPtr<Pattern>(), true);
2083 const RefPtr<FrameNode> testNode3 =
2084 FrameNode::CreateFrameNode("testNode3", 3, AceType::MakeRefPtr<Pattern>(), true);
2085 const RefPtr<FrameNode> testNode4 =
2086 FrameNode::CreateFrameNode("testNode4", 4, AceType::MakeRefPtr<Pattern>(), true);
2087 testNode1->AddChild(testNode2, 1, false);
2088 testNode1->AddChild(testNode3, 1, false);
2089 testNode1->AddChild(testNode4, 1, false);
2090 RefPtr<LayoutWrapperNode> retLayoutWrapper = testNode1->UINode::CreateLayoutWrapper(true, true);
2091 testNode1->UINode::AdjustLayoutWrapperTree(retLayoutWrapper, false, false);
2092 }
2093
2094 /**
2095 * @tc.name: UINodeTestNg061
2096 * @tc.desc: Test ui node method CreateExportTextureInfoIfNeeded
2097 * @tc.type: FUNC
2098 */
2099 HWTEST_F(UINodeTestNg, UINodeTestNg061, TestSize.Level1)
2100 {
2101 /**
2102 * @tc.steps: step1. construct a FrameNode
2103 * @tc.expected: expect no exception
2104 */
2105 const RefPtr<FrameNode> testNode1 =
2106 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
2107 testNode1->UINode::CreateExportTextureInfoIfNeeded();
2108 EXPECT_EQ(testNode1->GetExportTextureInfo() != nullptr, true);
2109 testNode1->UINode::CreateExportTextureInfoIfNeeded();
2110 EXPECT_EQ(testNode1->GetExportTextureInfo() != nullptr, true);
2111 }
2112
2113 /**
2114 * @tc.name: UINodeTestNg062
2115 * @tc.desc: Test ui node method SetJSViewActive
2116 * @tc.type: FUNC
2117 */
2118 HWTEST_F(UINodeTestNg, UINodeTestNg062, TestSize.Level1)
2119 {
2120 /**
2121 * @tc.steps: step1. create custome node,SetIsV2 false,isLazyForEachNode true
2122 */
2123 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
2124 auto childId = ElementRegister::GetInstance()->MakeUniqueId();
2125 auto childTwoId = ElementRegister::GetInstance()->MakeUniqueId();
2126 auto parent = CustomNode::CreateCustomNode(parentId, "parent");
2127 auto child = CustomNode::CreateCustomNode(childId, "child");
2128 auto childTwo = CustomNode::CreateCustomNode(childTwoId, "child_two");
2129 parent->AddChild(child);
2130 parent->AddChild(childTwo);
2131 parent->UINode::SetJSViewActive(true, true);
2132 child->SetIsV2(true);
2133 parent->UINode::SetJSViewActive(true, true);
2134 }
2135
2136 /**
2137 * @tc.name: UINodeTestNg063
2138 * @tc.desc: Test ui node method OnRecycle/OnReuse/PaintDebugBoundaryTreeAll/IsContextTransparent
2139 * @tc.type: FUNC
2140 */
2141 HWTEST_F(UINodeTestNg, UINodeTestNg063, TestSize.Level1)
2142 {
2143 /**
2144 * @tc.steps: step1. create custome node,SetIsV2 false,isLazyForEachNode true
2145 */
2146 const RefPtr<FrameNode> testNode1 =
2147 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
2148 const RefPtr<FrameNode> testNode2 =
2149 FrameNode::CreateFrameNode("testNode2", 2, AceType::MakeRefPtr<Pattern>(), true);
2150 const RefPtr<FrameNode> testNode3 =
2151 FrameNode::CreateFrameNode("testNode3", 3, AceType::MakeRefPtr<Pattern>(), true);
2152 const RefPtr<FrameNode> testNode4 =
2153 FrameNode::CreateFrameNode("testNode4", 4, AceType::MakeRefPtr<Pattern>(), true);
2154 testNode1->AddChild(testNode2, 1, false);
2155 testNode1->AddChild(testNode3, 1, false);
2156 testNode1->AddChild(testNode4, 1, false);
2157 testNode1->OnRecycle();
2158 testNode1->OnReuse();
2159 testNode1->PaintDebugBoundaryTreeAll(true);
2160 bool ret = testNode1->IsContextTransparent();
2161 EXPECT_EQ(ret, true);
2162 }
2163
2164 /**
2165 * @tc.name: UINodeTestNg064
2166 * @tc.desc: Test ui node method DFSAllChild
2167 * @tc.type: FUNC
2168 */
2169 HWTEST_F(UINodeTestNg, UINodeTestNg064, TestSize.Level1)
2170 {
2171 /**
2172 * @tc.steps: step1. create node without child
2173 */
2174 const RefPtr<FrameNode> testNode1 =
2175 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
2176 std::vector<RefPtr<UINode>> ret;
2177 testNode1->DFSAllChild(testNode1, ret);
2178 EXPECT_EQ(ret.size(), 1);
2179 ret.clear();
2180
2181 /**
2182 * @tc.steps: step2. create node with child
2183 */
2184 const RefPtr<FrameNode> testNode2 =
2185 FrameNode::CreateFrameNode("testNode2", 2, AceType::MakeRefPtr<Pattern>(), true);
2186 const RefPtr<FrameNode> testNode3 =
2187 FrameNode::CreateFrameNode("testNode3", 3, AceType::MakeRefPtr<Pattern>(), true);
2188 const RefPtr<FrameNode> testNode4 =
2189 FrameNode::CreateFrameNode("testNode4", 4, AceType::MakeRefPtr<Pattern>(), true);
2190 testNode1->AddChild(testNode2, 1, false);
2191 testNode1->AddChild(testNode3, 1, false);
2192 testNode1->AddChild(testNode4, 1, false);
2193 testNode1->DFSAllChild(testNode1, ret);
2194 EXPECT_EQ(ret.size(), 3);
2195 ret.clear();
2196 }
2197
2198 /**
2199 * @tc.name: UINodeTestNg065
2200 * @tc.desc: Test ui node method GetPageNodeCountAndDepth
2201 * @tc.type: FUNC
2202 */
2203 HWTEST_F(UINodeTestNg, UINodeTestNg065, TestSize.Level1)
2204 {
2205 /**
2206 * @tc.steps: step1. create FrameNode with child
2207 */
2208 const RefPtr<FrameNode> testNode1 =
2209 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
2210 const RefPtr<FrameNode> testNode2 =
2211 FrameNode::CreateFrameNode("testNode2", 2, AceType::MakeRefPtr<Pattern>(), true);
2212 const RefPtr<FrameNode> testNode3 =
2213 FrameNode::CreateFrameNode("testNode3", 3, AceType::MakeRefPtr<Pattern>(), true);
2214 const RefPtr<FrameNode> testNode4 =
2215 FrameNode::CreateFrameNode("testNode4", 4, AceType::MakeRefPtr<Pattern>(), true);
2216 testNode1->AddChild(testNode2, 1, false);
2217 testNode1->AddChild(testNode3, 1, false);
2218 testNode1->AddChild(testNode4, 1, false);
2219 int32_t* count = new int32_t(0);
2220 int32_t* depth = new int32_t(0);
2221 testNode1->GetPageNodeCountAndDepth(count, depth);
2222 EXPECT_EQ(*count, 4);
2223 delete count;
2224 delete depth;
2225 }
2226
2227 /**
2228 * @tc.name: UINodeTestNg066
2229 * @tc.desc: Test ui node method CollectRemovedChildren/UpdateNodeStatus
2230 * @tc.type: FUNC
2231 */
2232 HWTEST_F(UINodeTestNg, UINodeTestNg066, TestSize.Level1)
2233 {
2234 /**
2235 * @tc.steps: step1. create FrameNode with child
2236 */
2237 const RefPtr<FrameNode> testNode1 =
2238 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
2239 const RefPtr<FrameNode> testNode2 =
2240 FrameNode::CreateFrameNode("testNode2", 2, AceType::MakeRefPtr<Pattern>(), true);
2241 const RefPtr<FrameNode> testNode3 =
2242 FrameNode::CreateFrameNode("testNode3", 3, AceType::MakeRefPtr<Pattern>(), true);
2243 const RefPtr<FrameNode> testNode4 =
2244 FrameNode::CreateFrameNode("testNode4", 4, AceType::MakeRefPtr<Pattern>(), true);
2245 const RefPtr<FrameNode> testNode5 =
2246 FrameNode::CreateFrameNode("testNode5", 5, AceType::MakeRefPtr<Pattern>(), true);
2247 testNode1->AddChild(testNode2, 1, false);
2248 testNode1->AddChild(testNode3, 1, false);
2249 testNode1->AddChild(testNode4, 1, false);
2250 testNode2->AddChild(testNode5, 1, false);
2251 testNode2->SetIsRootBuilderNode(true);
2252 std::list<int32_t> removedElmtId;
2253 testNode1->CollectRemovedChildren(testNode1->GetChildren(), removedElmtId, true);
2254 EXPECT_EQ(removedElmtId.size(), 2);
2255 testNode2->CollectRemovedChildren(testNode2->GetChildren(), removedElmtId, true);
2256 EXPECT_EQ(removedElmtId.size(), 3);
2257 }
2258
2259 /**
2260 * @tc.name: UINodeTestNg067
2261 * @tc.desc: Test ui node method GetFrameChildByIndexWithoutExpanded
2262 * @tc.type: FUNC
2263 */
2264 HWTEST_F(UINodeTestNg, UINodeTestNg067, TestSize.Level1)
2265 {
2266 /**
2267 * @tc.steps: step1. create FrameNode with child
2268 */
2269 auto testNode1 = TestNode::CreateTestNode(21);
2270 auto testNode2 = TestNode::CreateTestNode(22);
2271 auto testNode3 = TestNode::CreateTestNode(23);
2272 auto testNode4 = TestNode::CreateTestNode(24);
2273 testNode1->AddChild(testNode2, 1, false);
2274 testNode1->AddChild(testNode3, 1, false);
2275 testNode1->AddChild(testNode4, 1, false);
2276 RefPtr<UINode> ret = testNode1->GetFrameChildByIndexWithoutExpanded(4);
2277 EXPECT_EQ(ret == nullptr, true);
2278 }
2279
2280 /**
2281 * @tc.name: UINodeTestNg068
2282 * @tc.desc: Test ui node method Build
2283 * @tc.type: FUNC
2284 */
2285 HWTEST_F(UINodeTestNg, UINodeTestNg068, TestSize.Level1)
2286 {
2287 /**
2288 * @tc.steps: step1. create custome node,SetIsV2 false,isLazyForEachNode true
2289 */
2290 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
2291 auto childId = ElementRegister::GetInstance()->MakeUniqueId();
2292 auto childTwoId = ElementRegister::GetInstance()->MakeUniqueId();
2293 auto parent = CustomNode::CreateCustomNode(parentId, "parent");
2294 auto child = CustomNode::CreateCustomNode(childId, "child");
2295 auto childTwo = CustomNode::CreateCustomNode(childTwoId, "child_two");
2296 auto childThree = TestNode::CreateTestNode(24);
2297 ExtraInfo extraInfo;
2298 extraInfo.page = "1";
2299 childTwo->SetExtraInfo(extraInfo);
2300 parent->AddChild(child);
2301 parent->AddChild(childTwo);
2302 parent->AddChild(childThree);
2303 std::shared_ptr<std::list<ExtraInfo>> extraInfos;
2304 parent->UINode::Build(extraInfos);
2305 extraInfos = std::make_shared<std::list<ExtraInfo>>();
2306 parent->UINode::Build(extraInfos);
2307 }
2308
2309 /**
2310 * @tc.name: UINodeTestNg069
2311 * @tc.desc: Test ui node method GenerateOneDepthVisibleFrameWithTransition/GenerateOneDepthVisibleFrameWithOffset
2312 * @tc.type: FUNC
2313 */
2314 HWTEST_F(UINodeTestNg, UINodeTestNg069, TestSize.Level1)
2315 {
2316 /**
2317 * @tc.steps: step1. create FrameNode node,AddChild,AddDisappearingChild
2318 */
2319 const RefPtr<FrameNode> testNode1 =
2320 FrameNode::CreateFrameNode("testNode1", 1, AceType::MakeRefPtr<Pattern>(), true);
2321 const RefPtr<FrameNode> testNode2 =
2322 FrameNode::CreateFrameNode("testNode2", 2, AceType::MakeRefPtr<Pattern>(), true);
2323 const RefPtr<FrameNode> testNode3 =
2324 FrameNode::CreateFrameNode("testNode3", 3, AceType::MakeRefPtr<Pattern>(), true);
2325 const RefPtr<FrameNode> testNode4 =
2326 FrameNode::CreateFrameNode("testNode4", 4, AceType::MakeRefPtr<Pattern>(), true);
2327 const RefPtr<FrameNode> testNode5 =
2328 FrameNode::CreateFrameNode("testNode5", 5, AceType::MakeRefPtr<Pattern>(), true);
2329 testNode1->AddChild(testNode2, 1, false);
2330 testNode1->AddChild(testNode3, 1, false);
2331 testNode1->AddChild(testNode4, 1, false);
2332 OffsetT<float> offset;
2333 std::list<RefPtr<FrameNode>> visibleList;
2334 testNode1->GenerateOneDepthVisibleFrameWithOffset(visibleList, offset);
2335 testNode1->AddDisappearingChild(testNode2, 1);
2336 testNode1->AddDisappearingChild(testNode3, 2);
2337 testNode1->AddDisappearingChild(testNode4, 3);
2338 testNode1->AddDisappearingChild(testNode5, 4);
2339 testNode1->GenerateOneDepthVisibleFrameWithTransition(visibleList);
2340 testNode1->GenerateOneDepthVisibleFrameWithOffset(visibleList, offset);
2341 EXPECT_EQ(testNode1->GetChildren().size(), 3);
2342 }
2343
2344 /**
2345 * @tc.name: UINodeTestNg070
2346 * @tc.desc: Test ui node method TouchTest/MouseTest
2347 * @tc.type: FUNC
2348 */
2349 HWTEST_F(UINodeTestNg, UINodeTestNg070, TestSize.Level1)
2350 {
2351 /**
2352 * @tc.steps: step1. create FrameNode node and construct params
2353 */
2354 auto testNode1 = TestNode::CreateTestNode(21);
2355 const RefPtr<FrameNode> testNode2 =
2356 FrameNode::CreateFrameNode("testNode2", 2, AceType::MakeRefPtr<Pattern>(), true);
2357 const RefPtr<FrameNode> testNode3 =
2358 FrameNode::CreateFrameNode("testNode3", 3, AceType::MakeRefPtr<Pattern>(), true);
2359 const RefPtr<FrameNode> testNode4 =
2360 FrameNode::CreateFrameNode("testNode4", 4, AceType::MakeRefPtr<Pattern>(), true);
2361 testNode1->AddChild(testNode2, 1, false);
2362 testNode1->AddChild(testNode3, 1, false);
2363 testNode1->AddChild(testNode4, 1, false);
2364 PointT<float> globalPoint;
2365 PointT<float> parentLocalPoint;
2366 PointT<float> parentRevertPoint;
2367 TouchRestrict touchRestrict;
2368 MouseTestResult onMouseResult;
2369 MouseTestResult onHoverResult;
2370 RefPtr<FrameNode> hoverNode;
2371 HitTestResult ret =
2372 testNode1->UINode::MouseTest(globalPoint, parentLocalPoint, onMouseResult, onHoverResult, hoverNode);
2373 EXPECT_EQ(ret == HitTestResult::BUBBLING, true);
2374 AxisTestResult onAxisResult;
2375 HitTestResult ret2 =
2376 testNode1->UINode::AxisTest(globalPoint, parentLocalPoint, parentRevertPoint, touchRestrict, onAxisResult);
2377 EXPECT_EQ(ret2 == HitTestResult::OUT_OF_REGION, true);
2378 }
2379
2380 /**
2381 * @tc.name: GetPerformanceCheckData004
2382 * @tc.desc: Test ui node method GetPerformanceCheckData
2383 * @tc.type: FUNC
2384 */
2385 HWTEST_F(UINodeTestNg, GetPerformanceCheckData004, TestSize.Level1)
2386 {
2387 /**
2388 * @tc.steps: step1. create parent and childframe node
2389 */
2390 auto parentId = ElementRegister::GetInstance()->MakeUniqueId();
2391 auto childId = ElementRegister::GetInstance()->MakeUniqueId();
2392 auto childIdId2 = ElementRegister::GetInstance()->MakeUniqueId();
2393 auto parent = FrameNode::CreateFrameNode("parent", parentId, AceType::MakeRefPtr<Pattern>(), true);
2394 auto child = FrameNode::CreateFrameNode("child", childId, AceType::MakeRefPtr<Pattern>(), true);
2395 auto child2 = FrameNode::CreateFrameNode("child2", childIdId2, AceType::MakeRefPtr<Pattern>(), true);
2396
2397 parent->tag_ = V2::JS_FOR_EACH_ETS_TAG;
2398 parent->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
2399 child->tag_ = V2::COMMON_VIEW_ETS_TAG;
2400 child->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
2401 parent->AddChild(child);
2402
2403 /**
2404 * @tc.steps: step2. construct parameter performanceCheckNodeMap and call GetPerformanceCheckData
2405 * @tc.expected: isBuildByJS_ is false
2406 */
2407 auto nodeId = ElementRegister::GetInstance()->MakeUniqueId();
2408 PerformanceCheckNodeMap nodeMap;
2409 PerformanceCheckNode performanceCheckNode = PerformanceCheckNode();
2410 nodeMap.emplace(nodeId, performanceCheckNode);
2411 child->UINode::GetPerformanceCheckData(nodeMap);
2412 child2->tag_ = V2::COMMON_VIEW_ETS_TAG;
2413 child2->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
2414 child->AddChild(child2, 1, false);
2415 auto childId4 = ElementRegister::GetInstance()->MakeUniqueId();
2416 auto child4 = FrameNode::CreateFrameNode("child4", childId4, AceType::MakeRefPtr<Pattern>(), true);
2417 child4->tag_ = V2::JS_FOR_EACH_ETS_TAG;
2418 child4->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
2419 child->AddChild(child4, 1, false);
2420 // grandChildren exist
2421 auto childIdId3 = ElementRegister::GetInstance()->MakeUniqueId();
2422 auto child3 = FrameNode::CreateFrameNode("child3", childIdId3, AceType::MakeRefPtr<Pattern>(), true);
2423 child3->nodeInfo_ = std::make_unique<PerformanceCheckNode>();
2424 child2->AddChild(child3);
2425 child->UINode::GetPerformanceCheckData(nodeMap);
2426
2427 /**
2428 * @tc.steps: step3. change child tag_ and call GetPerformanceCheckData
2429 * @tc.expected: isBuildByJS_ is false
2430 */
2431 child->tag_ = V2::JS_FOR_EACH_ETS_TAG;
2432 child->UINode::GetPerformanceCheckData(nodeMap);
2433 }
2434 } // namespace OHOS::Ace::NG
2435