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