• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2025 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 "gtest/gtest.h"
17 
18 #define private public
19 #define protected public
20 
21 #include "interfaces/inner_api/ace_kit/src/view/frame_node_impl.h"
22 #include "test/unittest/interfaces/ace_kit/mock/mock_ace_kit_pattern.h"
23 #include "test/unittest/interfaces/ace_kit/mock/mock_ace_kit_property.h"
24 #include "ui/base/geometry/ng/offset_t.h"
25 #include "ui/base/geometry/ng/size_t.h"
26 #include "ui/properties/dirty_flag.h"
27 #include "ui/view/frame_node.h"
28 #include "ui/view_factory/abstract_view_factory.h"
29 
30 #include "core/components_ng/base/frame_node.h"
31 #include "core/components_ng/pattern/pattern.h"
32 
33 using namespace testing;
34 using namespace testing::ext;
35 using namespace OHOS::Ace::Kit;
36 namespace OHOS::Ace {
37 class FrameNodeTest : public testing::Test {};
38 
39 class TestAICaller : public AICallerHelper {
40 public:
41     TestAICaller() = default;
42     ~TestAICaller() override = default;
onAIFunctionCaller(const std::string & funcName,const std::string & params)43     bool onAIFunctionCaller(const std::string& funcName, const std::string& params) override
44     {
45         if (funcName.compare("Success") == 0) {
46             return true;
47         }
48         return false;
49     }
50 };
51 
52 /**
53  * @tc.name: FrameNodeTestTest001
54  * @tc.desc:
55  * @tc.type: FUNC
56  */
57 HWTEST_F(FrameNodeTest, FrameNodeTestTest001, TestSize.Level1)
58 {
59     constexpr char tag[] = "TEST1";
60     const int32_t id = 1;
61     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
62     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
63     EXPECT_NE(frameNode, nullptr);
64 
65     EXPECT_EQ(frameNode->GetId(), id);
66     auto nodeTag = frameNode->GetTag();
67     EXPECT_EQ(tag, nodeTag);
68 }
69 
70 /**
71  * @tc.name: FrameNodeTestTest002
72  * @tc.desc:
73  * @tc.type: FUNC
74  */
75 HWTEST_F(FrameNodeTest, FrameNodeTestTest002, TestSize.Level1)
76 {
77     constexpr char tag[] = "TEST2";
78     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
79     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, 2, mockPattern);
80     EXPECT_NE(frameNode, nullptr);
81 
82     auto property = frameNode->GetProperty();
83     EXPECT_TRUE(property);
84 
85     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
86     ASSERT_TRUE(frameNodeImpl);
87 
88     auto* aceNodePtr = frameNodeImpl->GetAceNodePtr();
89     EXPECT_TRUE(aceNodePtr);
90     auto aceNode = frameNodeImpl->GetAceNode();
91     EXPECT_TRUE(aceNode);
92     auto pattern = frameNodeImpl->GetPattern();
93     EXPECT_TRUE(pattern);
94 
95     frameNode->Reset();
96     EXPECT_FALSE(frameNodeImpl->GetAceNodePtr());
97     EXPECT_FALSE(frameNodeImpl->GetAceNode());
98     EXPECT_FALSE(frameNodeImpl->GetPattern());
99 }
100 
101 /**
102  * @tc.name: FrameNodeTestTest003
103  * @tc.desc:
104  * @tc.type: FUNC
105  */
106 HWTEST_F(FrameNodeTest, FrameNodeTestTest003, TestSize.Level1)
107 {
108     constexpr char tag[] = "TEST3";
109     const int32_t id = 3;
110     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
111     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
112     EXPECT_NE(frameNode, nullptr);
113     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
114     ASSERT_TRUE(frameNodeImpl);
115 
116     auto aceNode =
__anon0eb596190102() 117         NG::FrameNode::GetOrCreateFrameNode("TEST_ACE_NODE", 3, []() { return AceType::MakeRefPtr<NG::Pattern>(); });
118     ASSERT_TRUE(aceNode);
119 
120     auto popAceNode = frameNodeImpl->MoveOwnershipAndGetAceNode();
121     EXPECT_EQ(popAceNode->GetTag(), tag);
122     EXPECT_EQ(popAceNode->GetId(), id);
123     EXPECT_NE(frameNodeImpl->GetAceNodePtr(), nullptr);
124 }
125 
126 /**
127  * @tc.name: FrameNodeTestTest004
128  * @tc.desc:
129  * @tc.type: FUNC
130  */
131 HWTEST_F(FrameNodeTest, FrameNodeTestTest004, TestSize.Level1)
132 {
133     constexpr char tag[] = "TEST4";
134     const int32_t id = 4;
135     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
136     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
137     EXPECT_NE(frameNode, nullptr);
138     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
139     ASSERT_TRUE(frameNodeImpl);
140 
141     frameNode->AddChild(nullptr);
142     EXPECT_EQ(frameNode->GetChildren().size(), 0);
143 
144     const std::string childTag = "TEST4_CHILD";
145     const int32_t childId = 4;
146     auto mockPatternChild = AceType::MakeRefPtr<MockAceKitPattern>();
147     auto frameNodeChild = AbstractViewFactory::CreateFrameNode(childTag, childId, mockPatternChild);
148     EXPECT_NE(frameNode, nullptr);
149     frameNode->AddChild(frameNodeChild);
150     EXPECT_EQ(frameNode->GetChildren().size(), 1);
151 
152     frameNode->RemoveChild(frameNodeChild);
153     EXPECT_EQ(frameNode->GetChildren().size(), 0);
154 }
155 
156 /**
157  * @tc.name: FrameNodeTestTest005
158  * @tc.desc:
159  * @tc.type: FUNC
160  */
161 HWTEST_F(FrameNodeTest, FrameNodeTestTest005, TestSize.Level1)
162 {
163     constexpr char tag[] = "TEST5";
164     const int32_t id = 5;
165     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
166     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
167     EXPECT_NE(frameNode, nullptr);
168     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
169     ASSERT_TRUE(frameNodeImpl);
170 
171     LayoutConstraintInfo constraint { .maxWidth = 100.0f, .maxHeight = 100.0f };
172     frameNode->Measure(constraint);
173     auto* aceNode = frameNodeImpl->GetAceNodePtr();
174     ASSERT_TRUE(aceNode);
175     EXPECT_TRUE(aceNode->IsActive());
176     auto geometryNode = aceNode->GetGeometryNode();
177     auto parentConstraint = geometryNode->GetParentLayoutConstraint();
178     EXPECT_TRUE(NearEqual(parentConstraint.value().maxSize.Width(), constraint.maxWidth));
179     EXPECT_TRUE(NearEqual(parentConstraint.value().maxSize.Height(), constraint.maxHeight));
180 
181     frameNode->Layout();
182     auto layoutProperty = aceNode->GetLayoutProperty();
183     auto layoutConstraint = layoutProperty->GetLayoutConstraint();
184     EXPECT_TRUE(NearEqual(layoutConstraint.value().maxSize.Width(), constraint.maxWidth));
185     EXPECT_TRUE(NearEqual(layoutConstraint.value().maxSize.Height(), constraint.maxHeight));
186 
187     auto propertyChangeFlag = layoutProperty->GetPropertyChangeFlag();
188     EXPECT_EQ(propertyChangeFlag, NG::PROPERTY_UPDATE_MEASURE | NG::PROPERTY_UPDATE_LAYOUT);
189     frameNode->MarkDirtyNode(NG::PROPERTY_UPDATE_MEASURE_SELF);
190     EXPECT_EQ(layoutProperty->GetPropertyChangeFlag(),
191         NG::PROPERTY_UPDATE_MEASURE | NG::PROPERTY_UPDATE_LAYOUT | NG::PROPERTY_UPDATE_MEASURE_SELF);
192 }
193 
194 /**
195  * @tc.name: FrameNodeTestTest005
196  * @tc.desc:
197  * @tc.type: FUNC
198  */
199 HWTEST_F(FrameNodeTest, FrameNodeTestTest006, TestSize.Level1)
200 {
201     constexpr char tag[] = "TEST6";
202     const int32_t id = 5;
203 
204     auto aceFrameNode =
__anon0eb596190202() 205         NG::FrameNode::GetOrCreateFrameNode(tag, id, []() { return AceType::MakeRefPtr<NG::Pattern>(); });
206     auto frameNode = Kit::FrameNode::GetFrameNode(reinterpret_cast<ArkUINodeHandle>(AceType::RawPtr(aceFrameNode)));
207     EXPECT_NE(frameNode, nullptr);
208 }
209 
210 /**
211  * @tc.name: FrameNodeTestTest007
212  * @tc.desc:
213  * @tc.type: FUNC
214  */
215 HWTEST_F(FrameNodeTest, FrameNodeTestTest007, TestSize.Level1)
216 {
217     constexpr char tag[] = "TEST7";
218     const int32_t id = 7;
219     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
220     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
221     EXPECT_NE(frameNode, nullptr);
222 
223     const std::string parentTag = "TEST7_PARENT";
224     const int32_t parentId = 8;
225     auto mockPatternParent = AceType::MakeRefPtr<MockAceKitPattern>();
226     auto frameNodeParent = AbstractViewFactory::CreateFrameNode(parentTag, parentId, mockPatternParent);
227     EXPECT_NE(frameNodeParent, nullptr);
228 
229     EXPECT_EQ(frameNode->GetParentHandle(), nullptr);
230     frameNodeParent->AddChild(frameNode);
231     EXPECT_NE(frameNode->GetParentHandle(), nullptr);
232 }
233 
234 /**
235  * @tc.name: FrameNodeTestTest008
236  * @tc.desc:
237  * @tc.type: FUNC
238  */
239 HWTEST_F(FrameNodeTest, FrameNodeTestTest008, TestSize.Level1)
240 {
241     constexpr char tag[] = "TEST8";
242     const int32_t id = 8;
243     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
244     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
245     EXPECT_NE(frameNode, nullptr);
246 
247     frameNode->ResetCompositingFilter();
248     SUCCEED();
249 }
250 
251 /**
252  * @tc.name: FrameNodeTestTest009
253  * @tc.desc:
254  * @tc.type: FUNC
255  */
256 HWTEST_F(FrameNodeTest, FrameNodeTestTest009, TestSize.Level1)
257 {
258     constexpr char tag[] = "TEST9";
259     const int32_t id = 9;
260     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
261     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
262     EXPECT_NE(frameNode, nullptr);
263 
264     frameNode->NeedAvoidContainerModal();
265     SUCCEED();
266 }
267 
268 /**
269  * @tc.name: FrameNodeTestTest100
270  * @tc.desc:
271  * @tc.type: FUNC
272  */
273 HWTEST_F(FrameNodeTest, FrameNodeTestTest100, TestSize.Level1)
274 {
275     /**
276      * @tc.steps1: initialize parameters.
277      */
278     constexpr char tag[] = "TEST100";
279     const int32_t id = 100;
280     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
281     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
282     EXPECT_NE(frameNode, nullptr);
283     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
284     ASSERT_TRUE(frameNodeImpl);
285 
286     /**
287      * @tc.steps2: set property value, validate result.
288      */
289     char value[7] = "value1";
290     frameNodeImpl->AddExtraCustomProperty("key", value);
291     bool result = frameNodeImpl->GetExtraCustomProperty("key");
292     EXPECT_EQ(result, true);
293 }
294 
295 /**
296  * @tc.name: FrameNodeTestTest101
297  * @tc.desc:
298  * @tc.type: FUNC
299  */
300 HWTEST_F(FrameNodeTest, FrameNodeTestTest101, TestSize.Level1)
301 {
302     /**
303      * @tc.steps1: initialize parameters.
304      */
305     constexpr char tag[] = "TEST101";
306     const int32_t id = 101;
307     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
308     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
309     EXPECT_NE(frameNode, nullptr);
310     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
311     ASSERT_TRUE(frameNodeImpl);
312 
313     /**
314      * @tc.steps2: set property value, verify error result.
315      */
316     char value[7] = "value1";
317     frameNodeImpl->AddExtraCustomProperty("key", value);
318     bool result = frameNodeImpl->GetExtraCustomProperty("key1");
319     EXPECT_EQ(result, false);
320 }
321 
322 /**
323  * @tc.name: FrameNodeTestTest102
324  * @tc.desc:
325  * @tc.type: FUNC
326  */
327 HWTEST_F(FrameNodeTest, FrameNodeTestTest102, TestSize.Level1)
328 {
329     /**
330      * @tc.steps1: initialize parameters.
331      */
332     constexpr char tag[] = "TEST102";
333     const int32_t id = 102;
334     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
335     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
336     EXPECT_NE(frameNode, nullptr);
337     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
338     ASSERT_TRUE(frameNodeImpl);
339 
340     /**
341      * @tc.steps2: set function callback, validate result.
342      */
__anon0eb596190302(RefPtr<FrameNode> node) 343     frameNodeImpl->SetMeasureCallback([](RefPtr<FrameNode> node) -> void {});
344     auto node = frameNodeImpl->PopAceNode();
345     EXPECT_NE(node->measureCallback_, nullptr);
346 }
347 
348 /**
349  * @tc.name: FrameNodeTestTest103
350  * @tc.desc:
351  * @tc.type: FUNC
352  */
353 HWTEST_F(FrameNodeTest, FrameNodeTestTest103, TestSize.Level1)
354 {
355     /**
356      * @tc.steps1: initialize parameters.
357      */
358     constexpr char tag[] = "TEST103";
359     const int32_t id = 103;
360     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
361     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
362     EXPECT_NE(frameNode, nullptr);
363     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
364     ASSERT_TRUE(frameNodeImpl);
365 
366     /**
367      * @tc.steps2: set function callback, validate result.
368      */
__anon0eb596190402(RefPtr<FrameNode> node) 369     frameNodeImpl->SetOnNodeDestroyCallback([](RefPtr<FrameNode> node) -> void {});
370     auto node = frameNodeImpl->PopAceNode();
371     EXPECT_NE(node->destroyCallback_, nullptr);
372 }
373 
374 /**
375  * @tc.name: FrameNodeTestTest104
376  * @tc.desc:
377  * @tc.type: FUNC
378  */
379 HWTEST_F(FrameNodeTest, FrameNodeTestTest104, TestSize.Level1)
380 {
381     /**
382      * @tc.steps1: initialize parameters.
383      */
384     constexpr char tag[] = "TEST104";
385     const int32_t id = 104;
386     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
387     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
388     EXPECT_NE(frameNode, nullptr);
389     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
390     ASSERT_TRUE(frameNodeImpl);
391 
392     /**
393      * @tc.steps2: set function callback, validate result.
394      */
__anon0eb596190502(const ConfigurationChange& configurationChange) 395     frameNodeImpl->SetConfigurationUpdateCallback([](const ConfigurationChange& configurationChange) -> void {});
396     auto node = frameNodeImpl->PopAceNode();
397     EXPECT_NE(node->configurationUpdateCallback_, nullptr);
398 }
399 
400 /**
401  * @tc.name: FrameNodeTestTest105
402  * @tc.desc:
403  * @tc.type: FUNC
404  */
405 HWTEST_F(FrameNodeTest, FrameNodeTestTest105, TestSize.Level1)
406 {
407     /**
408      * @tc.steps1: initialize parameters.
409      */
410     constexpr char tag[] = "TEST105";
411     const int32_t id = 105;
412     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
413     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
414     EXPECT_NE(frameNode, nullptr);
415     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
416     ASSERT_TRUE(frameNodeImpl);
417 
418     /**
419      * @tc.steps2: test attach to tree.
420      */
421     auto node = frameNodeImpl->PopAceNode();
422     node->AttachToMainTree();
423     node->GetRenderContext()->RequestNextFrame();
424     EXPECT_TRUE(node->IsOnMainTree());
425 }
426 
427 /**
428  * @tc.name: FrameNodeTestTest106
429  * @tc.desc:
430  * @tc.type: FUNC
431  */
432 HWTEST_F(FrameNodeTest, FrameNodeTestTest106, TestSize.Level1)
433 {
434     /**
435      * @tc.steps1: initialize parameters.
436      */
437     constexpr char tag[] = "TEST106";
438     const int32_t id = 106;
439     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
440     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
441     EXPECT_NE(frameNode, nullptr);
442     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
443     ASSERT_TRUE(frameNodeImpl);
444 
445     /**
446      * @tc.steps2: test node states.
447      */
448     auto node = frameNodeImpl->PopAceNode();
449     node->OnWindowShow();
450     node->OnWindowHide();
451     node->OnWindowFocused();
452     node->OnWindowUnfocused();
453 
454     NG::OnAreaChangedFunc callback = [](const NG::RectF& oldRect, const NG::OffsetF& oldOrigin, const NG::RectF& rect,
__anon0eb596190602(const NG::RectF& oldRect, const NG::OffsetF& oldOrigin, const NG::RectF& rect, const NG::OffsetF& origin) 455                                          const NG::OffsetF& origin) {};
456     node->SetOnAreaChangeCallback(std::move(callback));
457     EXPECT_NE(node->lastFrameRect_, nullptr);
458     EXPECT_NE(node->lastParentOffsetToWindow_, nullptr);
459 }
460 
461 /**
462  * @tc.name: FrameNodeTestTest107
463  * @tc.desc:
464  * @tc.type: FUNC
465  */
466 HWTEST_F(FrameNodeTest, FrameNodeTestTest107, TestSize.Level1)
467 {
468     /**
469      * @tc.steps1: initialize parameters.
470      */
471     constexpr char tag[] = "TEST107";
472     const int32_t id = 107;
473     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
474     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
475     EXPECT_NE(frameNode, nullptr);
476     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
477     ASSERT_TRUE(frameNodeImpl);
478 
479     /**
480      * @tc.steps2: build a object to SetOnAreaChangeCallback.
481      */
482     auto node = frameNodeImpl->PopAceNode();
483     NG::OnAreaChangedFunc callback = [](const NG::RectF& oldRect, const NG::OffsetF& oldOrigin, const NG::RectF& rect,
__anon0eb596190702(const NG::RectF& oldRect, const NG::OffsetF& oldOrigin, const NG::RectF& rect, const NG::OffsetF& origin) 484                                          const NG::OffsetF& origin) {};
485     node->lastFrameRect_ = std::make_unique<NG::RectF>();
486     node->SetOnAreaChangeCallback(std::move(callback));
487     EXPECT_NE(node->lastFrameRect_, nullptr);
488 }
489 
490 /**
491  * @tc.name: FrameNodeTestTest108
492  * @tc.desc:
493  * @tc.type: FUNC
494  */
495 HWTEST_F(FrameNodeTest, FrameNodeTestTest108, TestSize.Level1)
496 {
497     /**
498      * @tc.steps1: initialize parameters.
499      */
500     constexpr char tag[] = "TEST108";
501     const int32_t id = 108;
502     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
503     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
504     EXPECT_NE(frameNode, nullptr);
505     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
506     ASSERT_TRUE(frameNodeImpl);
507 
508     /**
509      * @tc.steps2: test while SetOnAreaChangeCallback is nullptr.
510      */
511     auto node = frameNodeImpl->PopAceNode();
512     node->lastParentOffsetToWindow_ = std::make_unique<NG::OffsetF>();
513     node->SetOnAreaChangeCallback(nullptr);
514     EXPECT_NE(node->lastParentOffsetToWindow_, nullptr);
515 }
516 
517 /**
518  * @tc.name: FrameNodeTestTest109
519  * @tc.desc:
520  * @tc.type: FUNC
521  */
522 HWTEST_F(FrameNodeTest, FrameNodeTestTest109, TestSize.Level1)
523 {
524     /**
525      * @tc.steps1: initialize parameters.
526      */
527     constexpr char tag[] = "TEST109";
528     const int32_t id = 109;
529     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
530     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
531     EXPECT_NE(frameNode, nullptr);
532     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
533     ASSERT_TRUE(frameNodeImpl);
534 
535     /**
536      * @tc.steps2: build a object to MarkModifyDone.
537      */
538     auto node = frameNodeImpl->PopAceNode();
539     node->MarkModifyDone();
540     EXPECT_TRUE(node->isRestoreInfoUsed_);
541     node->isRestoreInfoUsed_ = true;
542     node->MarkModifyDone();
543     EXPECT_TRUE(node->isRestoreInfoUsed_);
544 }
545 
546 /**
547  * @tc.name: FrameNodeTestTest110
548  * @tc.desc:
549  * @tc.type: FUNC
550  */
551 HWTEST_F(FrameNodeTest, FrameNodeTestTest110, TestSize.Level1)
552 {
553     /**
554      * @tc.steps1: initialize parameters.
555      */
556     constexpr char tag[] = "TEST110";
557     const int32_t id = 110;
558     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
559     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
560     EXPECT_NE(frameNode, nullptr);
561     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
562     ASSERT_TRUE(frameNodeImpl);
563 
564     /**
565      * @tc.steps2: callback MarkNeedRenderOnly.
566      */
567     auto node = frameNodeImpl->PopAceNode();
568     node->MarkNeedRenderOnly();
569     auto test = node->isRenderDirtyMarked_ = false;
570     auto test1 = node->isLayoutDirtyMarked_ = false;
571     node->MarkNeedRender(false);
572     node->MarkNeedRender(true);
573     EXPECT_FALSE(test);
574     EXPECT_FALSE(test1);
575 }
576 
577 /**
578  * @tc.name: FrameNodeTestTest111
579  * @tc.desc:
580  * @tc.type: FUNC
581  */
582 HWTEST_F(FrameNodeTest, FrameNodeTestTest111, TestSize.Level1)
583 {
584     /**
585      * @tc.steps1: initialize parameters.
586      */
587     constexpr char tag[] = "TEST111";
588     const int32_t id = 111;
589     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
590     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
591     EXPECT_NE(frameNode, nullptr);
592     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
593     ASSERT_TRUE(frameNodeImpl);
594 
595     /**
596      * @tc.steps2: callback IsNeedRequestParentMeasure.
597      */
598     auto node = frameNodeImpl->PopAceNode();
599     auto test = node->IsNeedRequestParentMeasure();
600     EXPECT_TRUE(test);
601 
602     node->layoutProperty_->propertyChangeFlag_ = NG::PROPERTY_UPDATE_BY_CHILD_REQUEST;
603     node->IsNeedRequestParentMeasure();
604 
605     node->layoutProperty_->propertyChangeFlag_ = NG::PROPERTY_UPDATE_BY_CHILD_REQUEST;
606     node->layoutProperty_->calcLayoutConstraint_ = std::make_unique<NG::MeasureProperty>();
607     auto test1 = node->IsNeedRequestParentMeasure();
608     EXPECT_TRUE(test1);
609 }
610 
611 /**
612  * @tc.name: FrameNodeTestTest112
613  * @tc.desc:
614  * @tc.type: FUNC
615  */
616 HWTEST_F(FrameNodeTest, FrameNodeTestTest112, TestSize.Level1)
617 {
618     /**
619      * @tc.steps1: initialize parameters.
620      */
621     constexpr char tag[] = "TEST112";
622     const int32_t id = 112;
623     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
624     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
625     EXPECT_NE(frameNode, nullptr);
626     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
627     ASSERT_TRUE(frameNodeImpl);
628 
629     /**
630      * @tc.steps2: callback IsOutOfTouchTestRegion.
631      */
632     auto node = frameNodeImpl->PopAceNode();
633     NG::PointF pointF;
634     std::vector<NG::RectF> rectF;
635     TouchEvent touchEvent;
636     auto test = node->IsOutOfTouchTestRegion(std::move(pointF), touchEvent);
637     EXPECT_TRUE(test);
638 
639     auto test1 = node->InResponseRegionList(pointF, rectF);
640     auto test2 = node->IsOutOfTouchTestRegion(std::move(pointF), touchEvent);
641     EXPECT_FALSE(test1);
642     EXPECT_TRUE(test2);
643 }
644 
645 /**
646  * @tc.name: FrameNodeTestTest113
647  * @tc.desc:
648  * @tc.type: FUNC
649  */
650 HWTEST_F(FrameNodeTest, FrameNodeTestTest113, TestSize.Level1)
651 {
652     /**
653      * @tc.steps1: initialize parameters.
654      */
655     constexpr char tag[] = "TEST113";
656     const int32_t id = 113;
657     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
658     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
659     EXPECT_NE(frameNode, nullptr);
660     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
661     ASSERT_TRUE(frameNodeImpl);
662 
663     /**
664      * @tc.steps2: test CalculateCurrentVisibleRatio.
665      */
666     auto node = frameNodeImpl->PopAceNode();
667     NG::RectF visibleRect;
668     NG::RectF renderRect;
669     node->CalculateCurrentVisibleRatio(visibleRect, renderRect);
670     EXPECT_EQ(visibleRect.Width(), 0);
671     EXPECT_EQ(renderRect.Width(), 0);
672 
673     /**
674      * @tc.steps3: set wrong value.
675      */
676     renderRect.SetWidth(-1);
677     EXPECT_EQ(node->CalculateCurrentVisibleRatio(visibleRect, renderRect), 0);
678     visibleRect.SetWidth(-1);
679     EXPECT_EQ(node->CalculateCurrentVisibleRatio(visibleRect, renderRect), 0);
680 }
681 
682 /**
683  * @tc.name: FrameNodeTestTest114
684  * @tc.desc:
685  * @tc.type: FUNC
686  */
687 HWTEST_F(FrameNodeTest, FrameNodeTestTest114, TestSize.Level1)
688 {
689     /**
690      * @tc.steps1: initialize parameters.
691      */
692     constexpr char tag[] = "TEST114";
693     const int32_t id = 114;
694     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
695     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
696     EXPECT_NE(frameNode, nullptr);
697     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
698     ASSERT_TRUE(frameNodeImpl);
699 
700     /**
701      * @tc.steps2: init a vector for preparing for args, then set a flag.
702      */
703     auto node = frameNodeImpl->PopAceNode();
704     std::vector<double> visibleAreaRatios { 0.2, 0.8, 0.21, 0.79, 0.5 };
705     int flag = 0;
__anon0eb596190802(bool input1, double input2) 706     auto defaultCallback = [&flag](bool input1, double input2) { flag += 1; };
707     VisibleCallbackInfo callbackInfo { defaultCallback, 1.0, false };
708 
709     /**
710      * @tc.steps2: call ProcessAllVisibleCallback with 0.5 from 0.
711      */
712     node->ProcessAllVisibleCallback(visibleAreaRatios, callbackInfo, 0.5, 0);
713     EXPECT_EQ(flag, 1);
714 
715     /**
716      * @tc.steps2: call ProcessAllVisibleCallback with 0 from 0.5.
717      */
718     node->ProcessAllVisibleCallback(visibleAreaRatios, callbackInfo, 0, 0.5);
719     EXPECT_EQ(flag, 2);
720 
721     /**
722      * @tc.steps2: call ProcessAllVisibleCallback with 0 from 0.
723      */
724     node->ProcessAllVisibleCallback(visibleAreaRatios, callbackInfo, 0, 0);
725     EXPECT_EQ(flag, 2);
726 
727     /**
728      * @tc.steps2: call ProcessAllVisibleCallback with 1 from 0.
729      */
730     node->ProcessAllVisibleCallback(visibleAreaRatios, callbackInfo, 1, 0);
731     EXPECT_EQ(flag, 3);
732 
733     /**
734      * @tc.steps2: call ProcessAllVisibleCallback with 1 from 1.
735      */
736     node->ProcessAllVisibleCallback(visibleAreaRatios, callbackInfo, 1, 1);
737     EXPECT_EQ(flag, 3);
738 }
739 
740 /**
741  * @tc.name: FrameNodeTestTest114
742  * @tc.desc:
743  * @tc.type: FUNC
744  */
745 HWTEST_F(FrameNodeTest, FrameNodeTestTest115, TestSize.Level1)
746 {
747     /**
748      * @tc.steps1: initialize parameters.
749      */
750     constexpr char tag[] = "TEST115";
751     const int32_t id = 115;
752     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
753     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
754     EXPECT_NE(frameNode, nullptr);
755     auto frameNodeImpl = AceType::DynamicCast<FrameNodeImpl>(frameNode);
756     ASSERT_TRUE(frameNodeImpl);
757 
758     /**
759      * @tc.steps2: create AI helper
760      */
761     auto myAICaller = std::make_shared<TestAICaller>();
762     /**
763      * @tc.steps3: call ai function without set
764      * @tc.excepted: step3 return 1 means AI helper not setted.
765      */
766     EXPECT_EQ(frameNodeImpl->frameNode_->CallAIFunction("Success", ""), 1);
767     /**
768      * @tc.steps4: set ai helper instance.
769      * @tc.excepted: step4 AI helper not null and setted success.
770      */
771     frameNodeImpl->SetAICallerHelper(myAICaller);
772     EXPECT_EQ(frameNodeImpl->frameNode_->aiCallerHelper_, myAICaller);
773     /**
774      * @tc.steps5: call ai function success after set.
775      * @tc.excepted: step5 ai function called success.
776      */
777     EXPECT_EQ(frameNodeImpl->frameNode_->CallAIFunction("Success", "params1: 1"), 0);
778     /**
779      * @tc.steps6: call invalid function after set.
780      * @tc.excepted: step6 ai function not found and return 2.
781      */
782     EXPECT_EQ(frameNodeImpl->frameNode_->CallAIFunction("OTHERFunction", "params1: 1"), 2);
783 }
784 
785 /**
786  * @tc.name: FrameNodeTestTest116
787  * @tc.desc: test GetParentGlobalOffsetDuringLayout
788  * @tc.type: FUNC
789  */
790 HWTEST_F(FrameNodeTest, FrameNodeTestTest116, TestSize.Level1)
791 {
792     /**
793      * @tc.steps1: initialize parameters.
794      */
795     constexpr char tag[] = "TEST116";
796     const int32_t id = 116;
797     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
798     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
799     EXPECT_NE(frameNode, nullptr);
800 
801     /**
802      * @tc.steps2: test GetParentGlobalOffsetDuringLayout.
803      */
804     auto offset = frameNode->GetParentGlobalOffsetDuringLayout();
805     EXPECT_TRUE(NearEqual(offset.GetX(), 0.0f));
806     EXPECT_TRUE(NearEqual(offset.GetY(), 0.0f));
807 }
808 
809 /**
810  * @tc.name: FrameNodeTestTest117
811  * @tc.desc: test ContainerModalTitleHeight
812  * @tc.type: FUNC
813  */
814 HWTEST_F(FrameNodeTest, FrameNodeTestTest117, TestSize.Level1)
815 {
816     /**
817      * @tc.steps1: initialize parameters.
818      */
819     constexpr char tag[] = "TEST117";
820     const int32_t id = 117;
821     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
822     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
823     EXPECT_NE(frameNode, nullptr);
824 
825     /**
826      * @tc.steps2: test GetContainerModalTitleHeight.
827      */
828     auto titleHeight = frameNode->GetContainerModalTitleHeight();
829     EXPECT_EQ(titleHeight, 0);
830 }
831 
832 /**
833  * @tc.name: FrameNodeTestTest118
834  * @tc.desc: test ContainerModalButtonsOffset
835  * @tc.type: FUNC
836  */
837 HWTEST_F(FrameNodeTest, FrameNodeTestTest118, TestSize.Level1)
838 {
839     /**
840      * @tc.steps1: initialize parameters.
841      */
842     constexpr char tag[] = "TEST118";
843     const int32_t id = 118;
844     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
845     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
846     EXPECT_NE(frameNode, nullptr);
847 
848     /**
849      * @tc.steps2: test ContainerModalButtonsOffset.
850      */
851     auto buttonsOffset = frameNode->GetContainerModalButtonsOffset();
852     EXPECT_TRUE(NearEqual(buttonsOffset.GetX(), 0.0f));
853     EXPECT_TRUE(NearEqual(buttonsOffset.GetY(), 0.0f));
854 }
855 
856 /**
857  * @tc.name: FrameNodeTestTest119
858  * @tc.desc: test ContainerModalButtonsSize
859  * @tc.type: FUNC
860  */
861 HWTEST_F(FrameNodeTest, FrameNodeTestTest119, TestSize.Level1)
862 {
863     /**
864      * @tc.steps1: initialize parameters.
865      */
866     constexpr char tag[] = "TEST119";
867     const int32_t id = 119;
868     auto mockPattern = AceType::MakeRefPtr<MockAceKitPattern>();
869     auto frameNode = AbstractViewFactory::CreateFrameNode(tag, id, mockPattern);
870     EXPECT_NE(frameNode, nullptr);
871 
872     /**
873      * @tc.steps2: test ContainerModalButtonsSize.
874      */
875     auto buttonsSize = frameNode->GetContainerModalButtonsSize();
876     EXPECT_TRUE(NearEqual(buttonsSize.Width(), 0.0f));
877     EXPECT_TRUE(NearEqual(buttonsSize.Height(), 0.0f));
878 }
879 } // namespace OHOS::Ace
880