1 /*
2  * Copyright (c) 2023 iSoftStone Information Technology (Group) 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 #include "test/unittest/core/base/view_abstract_test_ng.h"
16 
17 using namespace testing;
18 using namespace testing::ext;
19 
20 namespace OHOS::Ace::NG {
SetUpTestSuite()21 void ViewAbstractTestNg::SetUpTestSuite()
22 {
23     MockPipelineContext::SetUp();
24     MockContainer::SetUp();
25     MockContainer::Current()->pipelineContext_ = PipelineBase::GetCurrentContext();
26     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
27     PipelineBase::GetCurrentContext()->SetThemeManager(themeManager);
28     PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>());
29     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<PopupTheme>()));
30 }
31 
TearDownTestSuite()32 void ViewAbstractTestNg::TearDownTestSuite()
33 {
34     MockContainer::Current()->pipelineContext_ = nullptr;
35     MockPipelineContext::TearDown();
36 }
37 /**
38  * @tc.name: ViewAbstractTest001
39  * @tc.desc: SetWidth、SetHeight、SetMinWidth、SetMinHeight、SetMaxWidth、SetMaxHeight、ClearWidthOrHeight
40  * @tc.type: FUNC
41  */
42 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest001, TestSize.Level1)
43 {
44     /**
45      * @tc.steps: step1.Using static methods to set component properties
46      */
47     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
48     ASSERT_NE(frameNode, nullptr);
49     auto layoutProperty = frameNode->GetLayoutProperty();
50     ASSERT_NE(layoutProperty, nullptr);
51     ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
52     ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
53     ViewAbstract::SetMinWidth(NG::CalcLength(MIN_WIDTH));
54     ViewAbstract::SetMinHeight(NG::CalcLength(MIN_HEIGHT));
55     ViewAbstract::SetMaxWidth(NG::CalcLength(MIN_WIDTH));
56     ViewAbstract::SetMaxHeight(NG::CalcLength(MIN_HEIGHT));
57     ViewAbstract::ResetAspectRatio();
58     ViewAbstract::SetDrawModifier(nullptr);
59 
60     /**
61      * @tc.expected: Successfully set various properties of the top node on the stack
62      */
63     EXPECT_EQ(layoutProperty->calcLayoutConstraint_->selfIdealSize->Width(), NG::CalcLength(WIDTH));
64     EXPECT_EQ(layoutProperty->calcLayoutConstraint_->selfIdealSize->Height(), NG::CalcLength(HEIGHT));
65     EXPECT_EQ(layoutProperty->calcLayoutConstraint_->minSize->Width(), NG::CalcLength(MIN_WIDTH));
66     EXPECT_EQ(layoutProperty->calcLayoutConstraint_->minSize->Height(), NG::CalcLength(MIN_HEIGHT));
67     EXPECT_EQ(layoutProperty->calcLayoutConstraint_->maxSize->Width(), NG::CalcLength(MIN_WIDTH));
68     EXPECT_EQ(layoutProperty->calcLayoutConstraint_->maxSize->Height(), NG::CalcLength(MIN_HEIGHT));
69 
70     /**
71      * @tc.steps: step2.Static methods set properties for other nodes
72      */
__anon4809a5f10102() 73     auto newNode = FrameNode::GetOrCreateFrameNode("newframenode", 10, []() { return AceType::MakeRefPtr<Pattern>(); });
74     ViewAbstract::SetWidth(AceType::RawPtr(newNode), NG::CalcLength(WIDTH));
75     ViewAbstract::SetHeight(AceType::RawPtr(newNode), NG::CalcLength(HEIGHT));
76     ViewAbstract::SetMinWidth(AceType::RawPtr(newNode), NG::CalcLength(MIN_WIDTH));
77     ViewAbstract::SetMinHeight(AceType::RawPtr(newNode), NG::CalcLength(MIN_HEIGHT));
78     ViewAbstract::SetMaxWidth(AceType::RawPtr(newNode), NG::CalcLength(MIN_WIDTH));
79     ViewAbstract::SetMaxHeight(AceType::RawPtr(newNode), NG::CalcLength(MIN_HEIGHT));
80     auto newProperty = frameNode->GetLayoutProperty();
81 
82     /**
83      * @tc.expected: Successfully set various attributes of the new node
84      */
85     EXPECT_EQ(newProperty->calcLayoutConstraint_->selfIdealSize->Width(), NG::CalcLength(WIDTH));
86     EXPECT_EQ(newProperty->calcLayoutConstraint_->selfIdealSize->Height(), NG::CalcLength(HEIGHT));
87     EXPECT_EQ(newProperty->calcLayoutConstraint_->minSize->Width(), NG::CalcLength(MIN_WIDTH));
88     EXPECT_EQ(newProperty->calcLayoutConstraint_->minSize->Height(), NG::CalcLength(MIN_HEIGHT));
89     EXPECT_EQ(newProperty->calcLayoutConstraint_->maxSize->Width(), NG::CalcLength(MIN_WIDTH));
90     EXPECT_EQ(newProperty->calcLayoutConstraint_->maxSize->Height(), NG::CalcLength(MIN_HEIGHT));
91 
92     ViewAbstract::ClearWidthOrHeight(true);
93     ViewAbstract::ClearWidthOrHeight(AceType::RawPtr(newNode), true);
94     EXPECT_EQ(layoutProperty->calcLayoutConstraint_->selfIdealSize->Width(), std::nullopt);
95     EXPECT_EQ(newProperty->calcLayoutConstraint_->selfIdealSize->Width(), std::nullopt);
96 }
97 
98 /**
99  * @tc.name: ViewAbstractTest002
100  * @tc.desc: Test the operation of View_Abstract.
101  * @tc.type: FUNC
102  */
103 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest002, TestSize.Level1)
104 {
105     /**
106      * @tc.steps: step1.push FrameNode is not null, related function is called.
107      */
108     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
109     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
110 
111     ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
112     ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
113     ViewAbstract::SetMinWidth(NG::CalcLength(MIN_WIDTH));
114     ViewAbstract::SetMinHeight(NG::CalcLength(MIN_HEIGHT));
115     ViewAbstract::SetMaxWidth(NG::CalcLength(MIN_WIDTH));
116     ViewAbstract::SetMaxHeight(NG::CalcLength(MIN_HEIGHT));
117     ViewAbstract::ResetAspectRatio();
118     ViewAbstract::ClearWidthOrHeight(true);
119 
120     /**
121      * @tc.expected: Return expected results..
122      */
123     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
124     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
125     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
126     ASSERT_NE(frameNode, nullptr);
127     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
128     ASSERT_NE(Node, nullptr);
129     auto layoutProperty = Node->GetLayoutProperty();
130     ASSERT_NE(layoutProperty, nullptr);
131     ViewStackProcessor::GetInstance()->instance = nullptr;
132 }
133 
134 /**
135  * @tc.name: ViewAbstractTest003
136  * @tc.desc: Test the operation of View_Abstract
137  * @tc.type: FUNC
138  */
139 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest003, TestSize.Level1)
140 {
141     /**
142      * @tc.steps: step1.The FrameNode is null, related function is called.
143      */
144     ViewAbstract::SetAspectRatio(RATIO);
145     ViewAbstract::SetBackgroundColor(BLUE);
146     ViewAbstract::SetBackgroundColor(nullptr, BLUE);
147     ViewAbstract::SetBackgroundImage(imageSourceInfo);
148     ViewAbstract::SetBackgroundImage(nullptr, imageSourceInfo);
149     ViewAbstract::SetBackgroundImageSize(BACKGROUNDSIZE);
150     ViewAbstract::SetBackgroundImageSize(nullptr, BACKGROUNDSIZE);
151     ViewAbstract::SetBackgroundImagePosition(BACKGROUNDPOSITION);
152     ViewAbstract::SetBackgroundImagePosition(nullptr, BACKGROUNDPOSITION);
153     ViewAbstract::SetPixelRound(0);
154     ChainInfo chainInfo;
155     chainInfo.direction = LineDirection::HORIZONTAL;
156     chainInfo.style = ChainStyle::SPREAD;
157     ViewAbstract::SetChainStyle(chainInfo);
158     ViewAbstract::SetChainStyle(AceType::RawPtr(FRAME_NODE_REGISTER), chainInfo);
159     ViewAbstract::SetLayoutWeight(TEN);
160     ViewAbstract::SetLayoutWeight(AceType::RawPtr(FRAME_NODE_REGISTER), TEN);
161     ViewAbstract::SetBias(biasPair);
162     ViewAbstract::SetOuterBorderRadius(ZERO);
163     ViewAbstract::SetOuterBorderRadius(nullptr, ZERO);
164     NG::BorderRadiusProperty borderRadius;
165     ViewAbstract::SetOuterBorderRadius(borderRadius);
166     ViewAbstract::SetOuterBorderRadius(nullptr, borderRadius);
167     ViewAbstract::SetOuterBorderColor(BLUE);
168     ViewAbstract::SetOuterBorderColor(nullptr, BLUE);
169     NG::BorderColorProperty borderColor;
170     ViewAbstract::SetOuterBorderColor(borderColor);
171     ViewAbstract::SetOuterBorderColor(nullptr, borderColor);
172     ViewAbstract::SetOuterBorderWidth(ZERO);
173     ViewAbstract::SetOuterBorderWidth(nullptr, ZERO);
174     NG::BorderWidthProperty borderWidth;
175     ViewAbstract::SetOuterBorderWidth(borderWidth);
176     ViewAbstract::SetOuterBorderWidth(nullptr, borderWidth);
177     auto borderStyle = static_cast<BorderStyle>(INDEX);
178     ViewAbstract::SetOuterBorderStyle(borderStyle);
179     ViewAbstract::SetOuterBorderStyle(nullptr, borderStyle);
180     NG::BorderStyleProperty borderStyleProperty;
181     ViewAbstract::SetOuterBorderStyle(borderStyleProperty);
182     ViewAbstract::SetOuterBorderStyle(nullptr, borderStyleProperty);
183     BlendMode blendMode = BlendMode::NONE;
184     ViewAbstract::SetBlendMode(blendMode);
185     ViewAbstract::SetBlendMode(AceType::RawPtr(FRAME_NODE_REGISTER), blendMode);
186     BlendApplyType blendApplyType = BlendApplyType::FAST;
187     ViewAbstract::SetBlendApplyType(blendApplyType);
188     ViewAbstract::SetBlendApplyType(AceType::RawPtr(FRAME_NODE_REGISTER), blendApplyType);
189 
190     BlurStyleOption blurStyleOption;
191     blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
192     blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
193     blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
194     ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
195     ViewAbstract::SetBackgroundBlurStyle(AceType::RawPtr(FRAME_NODE_REGISTER), blurStyleOption);
196     CalcDimension dimensionRadius(0.0);
197     ViewAbstract::SetLightPosition(dimensionRadius, dimensionRadius, dimensionRadius);
198     ViewAbstract::SetLightIntensity(RATIO);
199     ViewAbstract::SetIlluminatedBorderWidth(ZERO);
200     ViewAbstract::SetBloom(RATIO);
201     std::map<AlignDirection, AlignRule> alignRules;
202     ViewAbstract::SetAlignRules(alignRules);
203     ViewAbstract::SetAlignRules(AceType::RawPtr(FRAME_NODE_REGISTER), alignRules);
204     auto repeat = static_cast<ImageRepeat>(INDEX);
205     ViewAbstract::SetBackgroundImageRepeat(repeat);
206     ViewAbstract::SetBackgroundImageRepeat(nullptr, repeat);
207     auto direction = static_cast<TextDirection>(INDEX);
208     ViewAbstract::SetLayoutDirection(direction);
209     ViewAbstract::SetLayoutDirection(AceType::RawPtr(FRAME_NODE_REGISTER), direction);
210     ViewAbstract::GetAlignRules(AceType::RawPtr(FRAME_NODE_REGISTER));
211 
212     /**
213      * @tc.expected: Return expected results..
214      */
215     EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
216 }
217 
218 /**
219  * @tc.name: ViewAbstractTest004
220  * @tc.desc: Test the operation of View_Abstract.
221  * @tc.type: FUNC
222  */
223 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest004, TestSize.Level1)
224 {
225     /**
226      * @tc.steps: step1.push FrameNode is not null, related function is called.
227      */
228     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
229     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
230 
231     ViewAbstract::SetAspectRatio(RATIO);
232     ViewAbstract::SetBackgroundColor(BLUE);
233     ViewAbstract::SetBackgroundColor(nullptr, BLUE);
234     ViewAbstract::SetBackgroundImage(imageSourceInfo);
235     ViewAbstract::SetBackgroundImage(nullptr, imageSourceInfo);
236     ViewAbstract::SetBackgroundImageSize(BACKGROUNDSIZE);
237     ViewAbstract::SetBackgroundImageSize(nullptr, BACKGROUNDSIZE);
238     ViewAbstract::SetBackgroundImagePosition(BACKGROUNDPOSITION);
239     ViewAbstract::SetBackgroundImagePosition(nullptr, BACKGROUNDPOSITION);
240     ViewAbstract::SetPixelRound(0);
241 
242     ChainInfo chainInfo;
243     chainInfo.direction = LineDirection::HORIZONTAL;
244     chainInfo.style = ChainStyle::SPREAD;
245     ViewAbstract::SetChainStyle(chainInfo);
246     ViewAbstract::SetChainStyle(AceType::RawPtr(FRAME_NODE_REGISTER), chainInfo);
247     ViewAbstract::SetBias(biasPair);
248     ViewAbstract::SetOuterBorderRadius(ZERO);
249     ViewAbstract::SetOuterBorderRadius(nullptr, ZERO);
250     NG::BorderRadiusProperty borderRadius;
251     ViewAbstract::SetOuterBorderRadius(borderRadius);
252     ViewAbstract::SetOuterBorderRadius(nullptr, borderRadius);
253     ViewAbstract::SetOuterBorderColor(BLUE);
254     ViewAbstract::SetOuterBorderColor(nullptr, BLUE);
255     NG::BorderColorProperty borderColor;
256     ViewAbstract::SetOuterBorderColor(borderColor);
257     ViewAbstract::SetOuterBorderColor(nullptr, borderColor);
258     ViewAbstract::SetOuterBorderWidth(ZERO);
259     ViewAbstract::SetOuterBorderWidth(nullptr, ZERO);
260     NG::BorderWidthProperty borderWidth;
261     ViewAbstract::SetOuterBorderWidth(borderWidth);
262     ViewAbstract::SetOuterBorderWidth(nullptr, borderWidth);
263     auto borderStyle = static_cast<BorderStyle>(INDEX);
264     ViewAbstract::SetOuterBorderStyle(borderStyle);
265     ViewAbstract::SetOuterBorderStyle(nullptr, borderStyle);
266     NG::BorderStyleProperty borderStyleProperty;
267     ViewAbstract::SetOuterBorderStyle(borderStyleProperty);
268     ViewAbstract::SetOuterBorderStyle(nullptr, borderStyleProperty);
269     ViewAbstract::SetLayoutWeight(TEN);
270     BlendMode blendMode = BlendMode::NONE;
271     ViewAbstract::SetBlendMode(blendMode);
272     BlendApplyType blendApplyType = BlendApplyType::FAST;
273     ViewAbstract::SetBlendApplyType(blendApplyType);
274 
275     BlurStyleOption blurStyleOption;
276     blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
277     blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
278     blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
279     ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
280 
281     std::map<AlignDirection, AlignRule> alignRules;
282     ViewAbstract::SetAlignRules(alignRules);
283     auto repeat = static_cast<ImageRepeat>(INDEX);
284     ViewAbstract::SetBackgroundImageRepeat(repeat);
285     ViewAbstract::SetBackgroundImageRepeat(nullptr, repeat);
286     auto direction = static_cast<TextDirection>(INDEX);
287     ViewAbstract::SetLayoutDirection(direction);
288     CalcDimension dimensionRadius(0.0);
289     ViewAbstract::SetLightPosition(dimensionRadius, dimensionRadius, dimensionRadius);
290     ViewAbstract::SetLightIntensity(RATIO);
291     ViewAbstract::SetIlluminatedBorderWidth(ZERO);
292     ViewAbstract::SetBloom(RATIO);
293 
294     /**
295      * @tc.expected: Return expected results.
296      */
297     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
298     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
299     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
300     ASSERT_NE(frameNode, nullptr);
301     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
302     ASSERT_NE(Node, nullptr);
303     auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
304     ASSERT_NE(layoutProperty, nullptr);
305     ViewStackProcessor::GetInstance()->instance = nullptr;
306 }
307 
308 /**
309  * @tc.name: ViewAbstractTest005
310  * @tc.desc: Test the operation of View_Abstract
311  * @tc.type: FUNC
312  */
313 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest005, TestSize.Level1)
314 {
315     /**
316      * @tc.steps: step1.The FrameNode is null, related function is called.
317      */
318     auto alignSelf = static_cast<FlexAlign>(INDEX);
319     ViewAbstract::SetAlignSelf(alignSelf);
320     ViewAbstract::SetFlexShrink(RATIO);
321     ViewAbstract::SetFlexGrow(RATIO);
322     ViewAbstract::SetFlexBasis(WIDTH);
323     ViewAbstract::SetDisplayIndex(INDEX);
324 
325     ViewAbstract::SetPadding(NG::CalcLength(WIDTH));
326     ViewAbstract::SetMargin(NG::CalcLength(WIDTH));
327     ViewAbstract::SetBorderRadius(WIDTH);
328     ViewAbstract::SetBorderColor(BLUE);
329     ViewAbstract::SetBorderWidth(WIDTH);
330     auto borderStyle = static_cast<BorderStyle>(INDEX);
331     ViewAbstract::SetBorderStyle(borderStyle);
332     ViewAbstract::SetBorderStyle(nullptr, borderStyle);
333     ViewAbstract::SetAutoEventParam(VALUE_X);
334 
335     /**
336      * @tc.expected: Return expected results..
337      */
338     EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
339 }
340 
341 /**
342  * @tc.name: ViewAbstractTest006
343  * @tc.desc: Test the operation of View_Abstract.
344  * @tc.type: FUNC
345  */
346 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest006, TestSize.Level1)
347 {
348     /**
349      * @tc.steps: step1.push FrameNode is not null, related function is called.
350      */
351     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
352     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
353 
354     auto alignSelf = static_cast<FlexAlign>(INDEX);
355     ViewAbstract::SetAlignSelf(alignSelf);
356     ViewAbstract::SetFlexShrink(RATIO);
357     ViewAbstract::SetFlexShrink(AceType::RawPtr(FRAME_NODE_REGISTER), RATIO);
358     ViewAbstract::SetFlexGrow(RATIO);
359     ViewAbstract::SetFlexGrow(AceType::RawPtr(FRAME_NODE_REGISTER), RATIO);
360     ViewAbstract::SetFlexBasis(WIDTH);
361     ViewAbstract::SetDisplayIndex(INDEX);
362 
363     ViewAbstract::SetPadding(NG::CalcLength(WIDTH));
364     ViewAbstract::SetMargin(NG::CalcLength(WIDTH));
365     ViewAbstract::SetBorderRadius(WIDTH);
366     ViewAbstract::SetBorderColor(BLUE);
367     ViewAbstract::SetBorderWidth(WIDTH);
368     auto borderStyle = static_cast<BorderStyle>(INDEX);
369     ViewAbstract::SetBorderStyle(borderStyle);
370     ViewAbstract::SetBorderStyle(nullptr, borderStyle);
371 
372     /**
373      * @tc.expected: Return expected results.
374      */
375     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
376     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
377     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
378     ASSERT_NE(frameNode, nullptr);
379     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
380     ASSERT_NE(Node, nullptr);
381     auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
382     ASSERT_NE(layoutProperty, nullptr);
383     ViewStackProcessor::GetInstance()->instance = nullptr;
384 }
385 
386 /**
387  * @tc.name: ViewAbstractTest007
388  * @tc.desc: Test the operation of View_Abstract
389  * @tc.type: FUNC
390  */
391 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest007, TestSize.Level1)
392 {
393     /**
394      * @tc.steps: step1.The FrameNode is null, related function is called.
395      */
396     NG::PaddingProperty paddings;
397     ViewAbstract::SetPadding(paddings);
398 
399     NG::MarginProperty margins;
400     ViewAbstract::SetMargin(margins);
401 
402     NG::BorderRadiusProperty borderRadius;
403     ViewAbstract::SetBorderRadius(borderRadius);
404     ViewAbstract::SetBorderRadius(nullptr, borderRadius);
405 
406     NG::BorderColorProperty borderColors;
407     ViewAbstract::SetBorderColor(borderColors);
408 
409     NG::BorderWidthProperty borderWidth;
410     ViewAbstract::SetBorderWidth(borderWidth);
411     ViewAbstract::SetBorderWidth(nullptr, borderWidth);
412 
413     NG::BorderStyleProperty borderStyles;
414     ViewAbstract::SetBorderStyle(borderStyles);
415     ViewAbstract::SetBorderStyle(nullptr, borderStyles);
416 
417     /**
418      * @tc.expected: Return expected results..
419      */
420     EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
421 }
422 
423 /**
424  * @tc.name: ViewAbstractTest008
425  * @tc.desc: Test the operation of View_Abstract.
426  * @tc.type: FUNC
427  */
428 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest008, TestSize.Level1)
429 {
430     /**
431      * @tc.steps: step1.push FrameNode is not null, related function is called.
432      */
433     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
434     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
435 
436     NG::PaddingProperty paddings;
437     ViewAbstract::SetPadding(paddings);
438 
439     NG::MarginProperty margins;
440     ViewAbstract::SetMargin(margins);
441 
442     NG::BorderRadiusProperty borderRadius;
443     ViewAbstract::SetBorderRadius(borderRadius);
444 
445     NG::BorderColorProperty borderColors;
446     ViewAbstract::SetBorderColor(borderColors);
447     ViewAbstract::SetBorderColor(nullptr, borderColors);
448 
449     NG::BorderWidthProperty borderWidth;
450     ViewAbstract::SetBorderWidth(borderWidth);
451 
452     NG::BorderStyleProperty borderStyles;
453     ViewAbstract::SetBorderStyle(borderStyles);
454     ViewAbstract::SetBorderStyle(nullptr, borderStyles);
455 
456     /**
457      * @tc.expected: Return expected results.
458      */
459     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
460     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
461     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
462     ASSERT_NE(frameNode, nullptr);
463     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
464     ASSERT_NE(Node, nullptr);
465     auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
466     ASSERT_NE(layoutProperty, nullptr);
467     ViewStackProcessor::GetInstance()->instance = nullptr;
468 }
469 
470 /**
471  * @tc.name: ViewAbstractTest009
472  * @tc.desc: Test the operation of View_Abstract
473  * @tc.type: FUNC
474  */
475 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest009, TestSize.Level1)
476 {
477     /**
478      * @tc.steps: step1.The FrameNode is null, related function is called.
479      */
480     GestureEventFunc tapEventFunc;
481     ViewAbstract::SetOnClick(std::move(tapEventFunc));
482     ViewAbstract::SetOnClick(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(tapEventFunc));
483     TouchEventFunc touchEventFunc;
484     ViewAbstract::SetOnTouch(std::move(touchEventFunc));
485     ViewAbstract::SetOnTouch(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(touchEventFunc));
486     OnMouseEventFunc onMouseEventFunc;
487     ViewAbstract::SetOnMouse(std::move(onMouseEventFunc));
488     OnHoverFunc onHoverEventFunc;
489     ViewAbstract::SetOnHover(std::move(onHoverEventFunc));
490     ViewAbstract::SetJSFrameNodeOnHover(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onHoverEventFunc));
491     ViewAbstract::ClearJSFrameNodeOnHover(AceType::RawPtr(FRAME_NODE_REGISTER));
492     OnKeyConsumeFunc onKeyCallback;
493     ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback));
494     DragPreviewOption dragPreviewOption;
495     ViewAbstract::SetDragPreviewOptions(dragPreviewOption);
496     ViewAbstract::SetDragPreviewOptions(AceType::RawPtr(FRAME_NODE_REGISTER), dragPreviewOption);
497     NG::DragDropInfo info;
498     ViewAbstract::SetDragPreview(info);
499 
500     auto hoverEffect = static_cast<HoverEffectType>(INDEX);
501     ViewAbstract::SetHoverEffect(hoverEffect);
502     ViewAbstract::SetHoverEffect(AceType::RawPtr(FRAME_NODE_REGISTER), hoverEffect);
503 
504     ViewAbstract::SetFocusable(false);
505     ViewAbstract::SetFocusable(AceType::RawPtr(FRAME_NODE_REGISTER), false);
506     ViewAbstract::SetEnabled(false);
507     ViewAbstract::SetEnabled(AceType::RawPtr(FRAME_NODE_REGISTER), false);
508     ViewAbstract::SetOnFocus(callback);
509     ViewAbstract::SetOnBlur(callback);
510 
511     /**
512      * @tc.expected: Return expected results.
513      */
514     EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
515 }
516 
517 /**
518  * @tc.name: ViewAbstractTest010
519  * @tc.desc: Test the operation of View_Abstract.
520  * @tc.type: FUNC
521  */
522 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest010, TestSize.Level1)
523 {
524     /**
525      * @tc.steps: step1.push FrameNode is not null, related function is called.
526      */
527     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
528     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
529 
530     GestureEventFunc tapEventFunc;
531     ViewAbstract::SetOnClick(std::move(tapEventFunc));
532     TouchEventFunc touchEventFunc;
533     ViewAbstract::SetOnTouch(std::move(touchEventFunc));
534     OnMouseEventFunc onMouseEventFunc;
535     ViewAbstract::SetOnMouse(std::move(onMouseEventFunc));
536     OnHoverFunc onHoverEventFunc;
537     ViewAbstract::SetOnHover(std::move(onHoverEventFunc));
538     OnKeyConsumeFunc onKeyCallback;
539     ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback));
540 
541     auto hoverEffect = static_cast<HoverEffectType>(INDEX);
542     ViewAbstract::SetHoverEffect(hoverEffect);
543 
544     ViewAbstract::SetFocusable(true);
545     ViewAbstract::SetOnFocus(callback);
546     ViewAbstract::SetOnBlur(callback);
547     ViewAbstract::SetFlexBasis(VALUE);
548 
549     auto eventHub = AceType::MakeRefPtr<EventHub>();
550     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
551     focusHub->focusable_ = true;
552     focusHub->parentFocusable_ = true;
553     ViewAbstract::SetVisibility(VisibleType::VISIBLE);
554     ViewAbstract::SetEnabled(true);
555 
556     /**
557      * @tc.expected: Return expected results.
558      */
559     EXPECT_FALSE(focusHub->IsFocusableScope());
560     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
561     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
562     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
563     ASSERT_NE(frameNode, nullptr);
564     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
565     ASSERT_NE(Node, nullptr);
566     auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
567     ASSERT_NE(layoutProperty, nullptr);
568     ViewStackProcessor::GetInstance()->instance = nullptr;
569 }
570 
571 /**
572  * @tc.name: ViewAbstractTest011
573  * @tc.desc: Test the operation of View_Abstract
574  * @tc.type: FUNC
575  */
576 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest011, TestSize.Level1)
577 {
578     /**
579      * @tc.steps: step1.The FrameNode is null, related function is called.
580      */
581     ViewAbstract::SetTabIndex(INDEX);
582     ViewAbstract::SetTabIndex(AceType::RawPtr(FRAME_NODE_REGISTER), INDEX);
583     ViewAbstract::SetFocusOnTouch(false);
584     ViewAbstract::SetFocusOnTouch(AceType::RawPtr(FRAME_NODE_REGISTER), false);
585     ViewAbstract::SetDefaultFocus(false);
586     ViewAbstract::SetGroupDefaultFocus(false);
587     ViewAbstract::SetGroupDefaultFocus(AceType::RawPtr(FRAME_NODE_REGISTER), false);
588     ViewAbstract::SetTouchable(false);
589     ViewAbstract::SetTouchable(AceType::RawPtr(FRAME_NODE_REGISTER), false);
590     ViewAbstract::SetOnAppear(callback);
591     ViewAbstract::SetOnAppear(AceType::RawPtr(FRAME_NODE_REGISTER), callback);
592     ViewAbstract::SetOnDisappear(callback);
593     ViewAbstract::SetOnDisappear(AceType::RawPtr(FRAME_NODE_REGISTER), callback);
594     ViewAbstract::GetFocusable(AceType::RawPtr(FRAME_NODE_REGISTER));
595     ViewAbstract::GetDefaultFocus(AceType::RawPtr(FRAME_NODE_REGISTER));
596     ViewAbstract::GetResponseRegion(AceType::RawPtr(FRAME_NODE_REGISTER));
597     ViewAbstract::GetOverlay(AceType::RawPtr(FRAME_NODE_REGISTER));
598     ViewAbstract::SetNeedFocus(AceType::RawPtr(FRAME_NODE_REGISTER), false);
599     ViewAbstract::GetNeedFocus(AceType::RawPtr(FRAME_NODE_REGISTER));
600     ViewAbstract::GetOpacity(AceType::RawPtr(FRAME_NODE_REGISTER));
601     ViewAbstract::GetBorderWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
602     ViewAbstract::GetLayoutBorderWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
603     ViewAbstract::GetBorderRadius(AceType::RawPtr(FRAME_NODE_REGISTER));
604     ViewAbstract::GetBorderColor(AceType::RawPtr(FRAME_NODE_REGISTER));
605     ViewAbstract::GetBorderStyle(AceType::RawPtr(FRAME_NODE_REGISTER));
606     ViewAbstract::GetZIndex(AceType::RawPtr(FRAME_NODE_REGISTER));
607 
608     auto hitTestMode = static_cast<HitTestMode>(INDEX);
609     ViewAbstract::SetHitTestMode(hitTestMode);
610     ViewAbstract::SetHitTestMode(AceType::RawPtr(FRAME_NODE_REGISTER), hitTestMode);
611 
612     std::vector<DimensionRect> responseRegion;
613     ViewAbstract::SetResponseRegion(std::move(responseRegion));
614     ViewAbstract::SetResponseRegion(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(responseRegion));
615     std::function<DragDropInfo(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragStart;
616     ViewAbstract::SetOnDragStart(std::move(onDragStart));
617     std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragEnter;
618     ViewAbstract::SetOnDragEnter(std::move(onDragEnter));
619     std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragLeave;
620     ViewAbstract::SetOnDragLeave(std::move(onDragLeave));
621     std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragMove;
622     ViewAbstract::SetOnDragMove(std::move(onDragMove));
623     std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDrop;
624     ViewAbstract::SetOnDrop(std::move(onDrop));
625     Alignment alignment;
626     ViewAbstract::SetAlign(std::move(alignment));
627     ViewAbstract::SetAlign(nullptr, std::move(alignment));
628 
629     /**
630      * @tc.expected: Return expected results.
631      */
632     EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
633 }
634 
635 /**
636  * @tc.name: ViewAbstractTest012
637  * @tc.desc: Test the operation of View_Abstract.
638  * @tc.type: FUNC
639  */
640 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest012, TestSize.Level1)
641 {
642     /**
643      * @tc.steps: step1.push FrameNode is not null, related function is called.
644      */
645     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
646     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
647 
648     ViewAbstract::SetTabIndex(INDEX);
649     ViewAbstract::SetFocusOnTouch(false);
650     ViewAbstract::SetDefaultFocus(false);
651     ViewAbstract::SetDefaultFocus(AceType::RawPtr(FRAME_NODE_REGISTER), false);
652     ViewAbstract::SetGroupDefaultFocus(false);
653     ViewAbstract::SetTouchable(false);
654     ViewAbstract::SetOnAppear(callback);
655     ViewAbstract::SetOnDisappear(callback);
656     auto hitTestMode = static_cast<HitTestMode>(INDEX);
657     ViewAbstract::SetHitTestMode(hitTestMode);
658 
659     std::vector<DimensionRect> responseRegion;
660     ViewAbstract::SetResponseRegion(std::move(responseRegion));
661     std::function<DragDropInfo(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragStart;
662     ViewAbstract::SetOnDragStart(std::move(onDragStart));
663     std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragEnter;
664     ViewAbstract::SetOnDragEnter(std::move(onDragEnter));
665     std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragLeave;
666     ViewAbstract::SetOnDragLeave(std::move(onDragLeave));
667     std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragMove;
668     ViewAbstract::SetOnDragMove(std::move(onDragMove));
669     std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDrop;
670     ViewAbstract::SetOnDrop(std::move(onDrop));
671     Alignment alignment;
672     ViewAbstract::SetAlign(std::move(alignment));
673 
674     /**
675      * @tc.expected: Return expected results.
676      */
677     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
678     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
679     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
680     ASSERT_NE(frameNode, nullptr);
681     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
682     ASSERT_NE(Node, nullptr);
683     auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
684     ASSERT_NE(layoutProperty, nullptr);
685     ViewStackProcessor::GetInstance()->instance = nullptr;
686 }
687 
688 /**
689  * @tc.name: ViewAbstractTest013
690  * @tc.desc: Test the operation of View_Abstract
691  * @tc.type: FUNC
692  */
693 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest013, TestSize.Level1)
694 {
695     /**
696      * @tc.steps: step1.The FrameNode is null, related function is called.
697      */
698     auto visible = static_cast<VisibleType>(INDEX);
699     ViewAbstract::SetVisibility(std::move(visible));
700     ViewAbstract::SetVisibility(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(visible));
701     ViewAbstract::SetGeometryTransition(srcimages);
702     ViewAbstract::SetGeometryTransition(AceType::RawPtr(FRAME_NODE_REGISTER), srcimages, false, true);
703     ViewAbstract::SetOpacity(OPACITYS);
704     ViewAbstract::SetOpacity(AceType::RawPtr(FRAME_NODE_REGISTER), OPACITYS);
705     ViewAbstract::SetZIndex(FOUF);
706 
707     OffsetT<Dimension> value = { WIDTH, HEIGHT };
708     ViewAbstract::SetPosition(value);
709     ViewAbstract::SetPosition(AceType::RawPtr(FRAME_NODE_REGISTER), value);
710     ViewAbstract::SetOffset(value);
711     ViewAbstract::SetOffset(AceType::RawPtr(FRAME_NODE_REGISTER), value);
712     ViewAbstract::MarkAnchor(value);
713     ViewAbstract::MarkAnchor(AceType::RawPtr(FRAME_NODE_REGISTER), value);
714     VectorF scale(1.0f, 1.0f);
715     ViewAbstract::SetScale(scale);
716     ViewAbstract::SetScale(AceType::RawPtr(FRAME_NODE_REGISTER), scale);
717     DimensionOffset valueOffset = { WIDTH, HEIGHT };
718     ViewAbstract::SetPivot(AceType::RawPtr(FRAME_NODE_REGISTER), valueOffset);
719     ViewAbstract::GetVisibility(AceType::RawPtr(FRAME_NODE_REGISTER));
720     ViewAbstract::GetClip(AceType::RawPtr(FRAME_NODE_REGISTER));
721     ViewAbstract::GetClipShape(AceType::RawPtr(FRAME_NODE_REGISTER));
722     ViewAbstract::GetTransform(AceType::RawPtr(FRAME_NODE_REGISTER));
723     ViewAbstract::GetHitTestBehavior(AceType::RawPtr(FRAME_NODE_REGISTER));
724     ViewAbstract::GetPosition(AceType::RawPtr(FRAME_NODE_REGISTER));
725     ViewAbstract::GetShadow(AceType::RawPtr(FRAME_NODE_REGISTER));
726     ViewAbstract::GetSweepGradient(AceType::RawPtr(FRAME_NODE_REGISTER));
727     ViewAbstract::GetRadialGradient(AceType::RawPtr(FRAME_NODE_REGISTER));
728     ViewAbstract::GetMask(AceType::RawPtr(FRAME_NODE_REGISTER));
729     ViewAbstract::GetMaskProgress(AceType::RawPtr(FRAME_NODE_REGISTER));
730     ViewAbstract::GetBlendMode(AceType::RawPtr(FRAME_NODE_REGISTER));
731     ViewAbstract::GetDirection(AceType::RawPtr(FRAME_NODE_REGISTER));
732     ViewAbstract::GetAlignSelf(AceType::RawPtr(FRAME_NODE_REGISTER));
733     ViewAbstract::GetFlexGrow(AceType::RawPtr(FRAME_NODE_REGISTER));
734     ViewAbstract::GetFlexShrink(AceType::RawPtr(FRAME_NODE_REGISTER));
735     ViewAbstract::GetFlexBasis(AceType::RawPtr(FRAME_NODE_REGISTER));
736     ViewAbstract::GetMinWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
737     ViewAbstract::GetMaxWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
738     ViewAbstract::GetMinHeight(AceType::RawPtr(FRAME_NODE_REGISTER));
739     ViewAbstract::GetMaxHeight(AceType::RawPtr(FRAME_NODE_REGISTER));
740     ViewAbstract::GetGrayScale(AceType::RawPtr(FRAME_NODE_REGISTER));
741     ViewAbstract::GetInvert(AceType::RawPtr(FRAME_NODE_REGISTER));
742     ViewAbstract::GetSepia(AceType::RawPtr(FRAME_NODE_REGISTER));
743     ViewAbstract::GetContrast(AceType::RawPtr(FRAME_NODE_REGISTER));
744     ViewAbstract::GetForegroundColor(AceType::RawPtr(FRAME_NODE_REGISTER));
745     ViewAbstract::GetScale(AceType::RawPtr(FRAME_NODE_REGISTER));
746     ViewAbstract::GetRotate(AceType::RawPtr(FRAME_NODE_REGISTER));
747     ViewAbstract::GetBrightness(AceType::RawPtr(FRAME_NODE_REGISTER));
748     ViewAbstract::GetSaturate(AceType::RawPtr(FRAME_NODE_REGISTER));
749     ViewAbstract::GetBackgroundImagePosition(AceType::RawPtr(FRAME_NODE_REGISTER));
750     ViewAbstract::GetLinearGradient(AceType::RawPtr(FRAME_NODE_REGISTER));
751     ViewAbstract::GetAlign(AceType::RawPtr(FRAME_NODE_REGISTER));
752     ViewAbstract::GetWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
753     ViewAbstract::GetHeight(AceType::RawPtr(FRAME_NODE_REGISTER));
754     ViewAbstract::GetBackgroundColor(AceType::RawPtr(FRAME_NODE_REGISTER));
755     ViewAbstract::GetBackgroundImageSrc(AceType::RawPtr(FRAME_NODE_REGISTER));
756     auto repeat = static_cast<ImageRepeat>(INDEX);
757     ViewAbstract::SetBackgroundImageRepeat(AceType::RawPtr(FRAME_NODE_REGISTER), repeat);
758     ViewAbstract::GetBackgroundImageRepeat(AceType::RawPtr(FRAME_NODE_REGISTER));
759     ViewAbstract::GetPadding(AceType::RawPtr(FRAME_NODE_REGISTER));
760     ViewAbstract::GetConfigSize(AceType::RawPtr(FRAME_NODE_REGISTER));
761     ViewAbstract::GetEnabled(AceType::RawPtr(FRAME_NODE_REGISTER));
762 
763     /**
764      * @tc.expected: Return expected results.
765      */
766     EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
767 }
768 
769 /**
770  * @tc.name: ViewAbstractTest014
771  * @tc.desc: Test the operation of View_Abstract.
772  * @tc.type: FUNC
773  */
774 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest014, TestSize.Level1)
775 {
776     /**
777      * @tc.steps: step1.push FrameNode is not null, related function is called.
778      */
779     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
780     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
781 
782     auto visible = static_cast<VisibleType>(INDEX);
783     ViewAbstract::SetVisibility(std::move(visible));
784     ViewAbstract::SetGeometryTransition(srcimages);
785     ViewAbstract::SetOpacity(OPACITYS);
786     ViewAbstract::SetZIndex(FOUF);
787     ViewAbstract::SetZIndex(nullptr, FOUF);
788 
789     OffsetT<Dimension> value = { WIDTH, HEIGHT };
790     ViewAbstract::SetPosition(value);
791     ViewAbstract::SetOffset(value);
792     ViewAbstract::MarkAnchor(value);
793     viewAbstractModelNG.SetScale(-1.0f, -1.0f, 0.0f);
794     ViewAbstract::GetMargin(AceType::RawPtr(FRAME_NODE_REGISTER));
795     ViewAbstract::GetTranslate(AceType::RawPtr(FRAME_NODE_REGISTER));
796     GestureEventFunc tapEventFunc;
797     ViewAbstract::SetJSFrameNodeOnClick(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(tapEventFunc));
798     ViewAbstract::ClearJSFrameNodeOnClick(AceType::RawPtr(FRAME_NODE_REGISTER));
799     TouchEventFunc touchEventFunc;
800     ViewAbstract::SetJSFrameNodeOnTouch(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(touchEventFunc));
801     ViewAbstract::ClearJSFrameNodeOnTouch(AceType::RawPtr(FRAME_NODE_REGISTER));
802     std::function<void()> buildFunc;
803     ViewAbstract::SetJSFrameNodeOnAppear(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(buildFunc));
804     ViewAbstract::ClearJSFrameNodeOnAppear(AceType::RawPtr(FRAME_NODE_REGISTER));
805     ViewAbstract::SetJSFrameNodeOnDisappear(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(buildFunc));
806     ViewAbstract::ClearJSFrameNodeOnDisappear(AceType::RawPtr(FRAME_NODE_REGISTER));
__anon4809a5f10202(KeyEventInfo& info) 807     OnKeyCallbackFunc onKeyCallback = [](KeyEventInfo& info) {};
808     ViewAbstract::SetJSFrameNodeOnKeyCallback(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onKeyCallback));
809     ViewAbstract::ClearJSFrameNodeOnKeyCallback(AceType::RawPtr(FRAME_NODE_REGISTER));
810 
811     std::function<void(bool, double)> onVisibleChange;
812     const std::vector<double> ratios;
813     constexpr uint32_t minInterval = 100; // 100ms
814     ViewAbstract::SetJSFrameNodeOnVisibleAreaApproximateChange(
815         AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onVisibleChange), ratios, minInterval);
816     ViewAbstract::ClearJSFrameNodeOnVisibleAreaApproximateChange(AceType::RawPtr(FRAME_NODE_REGISTER));
817 
818     /**
819      * @tc.expected: Return expected results.
820      */
821     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
822     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
823     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
824     ASSERT_NE(frameNode, nullptr);
825     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
826     ASSERT_NE(Node, nullptr);
827     auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
828     ASSERT_NE(layoutProperty, nullptr);
829     ViewStackProcessor::GetInstance()->instance = nullptr;
830 }
831 
832 /**
833  * @tc.name: ViewAbstractTest015
834  * @tc.desc: Test the operation of View_Abstract
835  * @tc.type: FUNC
836  */
837 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest015, TestSize.Level1)
838 {
839     /**
840      * @tc.steps: step1.The FrameNode is null, related function is called.
841      */
842     viewAbstractModelNG.SetPivot(WIDTH, HEIGHT, WIDTH);
843     NG::TranslateOptions pttions;
844     BlurOption blurOption;
845     ViewAbstract::SetTranslate(std::move(pttions));
846     ViewAbstract::SetTranslate(nullptr, std::move(pttions));
847     Matrix4 matrix;
848     ViewAbstract::SetTransformMatrix(std::move(matrix));
849     ViewAbstract::SetTransformMatrix(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(matrix));
850     ViewAbstract::SetBackdropBlur(RADIUS, blurOption);
851     ViewAbstract::SetBackdropBlur(nullptr, RADIUS, blurOption);
852     ViewAbstract::SetFrontBlur(RADIUS, blurOption);
853     ViewAbstract::SetFrontBlur(AceType::RawPtr(FRAME_NODE_REGISTER), RADIUS, blurOption);
854     ViewAbstract::SetInspectorId(srcimages);
855     ViewAbstract::SetInspectorId(AceType::RawPtr(FRAME_NODE_REGISTER), srcimages);
856 
857     Vector5F scale(1.0f, 1.0f, 2.0f, 2.0f, 0.0f);
858     ViewAbstract::SetRotate(scale);
859     ViewAbstract::SetRotate(nullptr, scale);
860     ShadowStyle style { 1 };
861     Shadow shadow { RATIO, OFFSET, BLUE, style };
862     ViewAbstract::SetBackShadow(shadow);
863     ViewAbstract::SetBackShadow(nullptr, shadow);
864 
865     NG::Gradient gradient;
866     ViewAbstract::SetLinearGradient(std::move(gradient));
867     ViewAbstract::SetLinearGradient(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(gradient));
868     ViewAbstract::SetSweepGradient(std::move(gradient));
869     ViewAbstract::SetSweepGradient(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(gradient));
870     ViewAbstract::SetRadialGradient(std::move(gradient));
871     ViewAbstract::SetRadialGradient(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(gradient));
872     ViewAbstract::SetSystemBarEffect(false);
873     ViewAbstract::SetFreeze(false);
874     ViewAbstract::SetUseShadowBatching(false);
875     ViewAbstract::SetUseShadowBatching(AceType::RawPtr(FRAME_NODE_REGISTER), false);
876 
877     /**
878      * @tc.expected: Return expected results.
879      */
880     EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
881 }
882 
883 /**
884  * @tc.name: ViewAbstractTest016
885  * @tc.desc: Test the operation of View_Abstract.
886  * @tc.type: FUNC
887  */
888 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest016, TestSize.Level1)
889 {
890     /**
891      * @tc.steps: step1.push FrameNode is not null, related function is called.
892      */
893     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
894     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
895 
896     viewAbstractModelNG.SetPivot(WIDTH, HEIGHT, ZERO);
897     NG::TranslateOptions pttions;
898     ViewAbstract::SetTranslate(std::move(pttions));
899     Matrix4 matrix;
900     BlurOption blurOption;
901     ViewAbstract::SetTransformMatrix(std::move(matrix));
902     ViewAbstract::SetBackdropBlur(RADIUS, blurOption);
903     ViewAbstract::SetFrontBlur(RADIUS, blurOption);
904     ViewAbstract::SetInspectorId(srcimages);
905     ViewAbstract::SetDebugLine(srcimages);
906 
907     Vector5F scale(1.0f, 1.0f, 2.0f, 2.0f, 0.0f);
908     ViewAbstract::SetRotate(scale);
909     ShadowStyle style { 1 };
910     Shadow shadow { RATIO, OFFSET, BLUE, style };
911     ViewAbstract::SetBackShadow(shadow);
912     NG::Gradient gradient;
913     ViewAbstract::SetLinearGradient(std::move(gradient));
914     ViewAbstract::SetSweepGradient(std::move(gradient));
915     ViewAbstract::SetRadialGradient(std::move(gradient));
916     ViewAbstract::SetSystemBarEffect(false);
917     ViewAbstract::SetFreeze(false);
918     ViewAbstract::SetUseShadowBatching(false);
919     /**
920      * @tc.expected: Return expected results.
921      */
922     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
923     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
924     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
925     ASSERT_NE(frameNode, nullptr);
926     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
927     ASSERT_NE(Node, nullptr);
928     auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
929     ASSERT_NE(layoutProperty, nullptr);
930     ViewStackProcessor::GetInstance()->instance = nullptr;
931 }
932 
933 /**
934  * @tc.name: ViewAbstractTest017
935  * @tc.desc: Test the operation of View_Abstract
936  * @tc.type: FUNC
937  */
938 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest017, TestSize.Level1)
939 {
940     /**
941      * @tc.steps: step1.The FrameNode is null, related function is called.
942      */
943     auto visible = static_cast<GridSizeType>(INDEX);
944     ViewAbstract::SetGrid(FOUF, FOUF, std::move(visible));
945     ViewAbstract::SetGrid(AceType::RawPtr(FRAME_NODE_REGISTER), FOUF, FOUF, std::move(visible));
946     TransitionOptions options;
947     ViewAbstract::SetTransition(std::move(options));
948     RefPtr<BasicShape> basicShape;
949     ViewAbstract::SetClipShape(std::move(basicShape));
950     ViewAbstract::SetClipShape(nullptr, std::move(basicShape));
951     ViewAbstract::SetMask(std::move(basicShape));
952     ViewAbstract::SetClipEdge(false);
953     ViewAbstract::SetGrayScale(RADIUS);
954     ViewAbstract::SetContrast(RADIUS);
955     ViewAbstract::SetSaturate(RADIUS);
956     ViewAbstract::SetSaturate(nullptr, RADIUS);
957     ViewAbstract::SetSepia(RADIUS);
958     ViewAbstract::SetSepia(nullptr, RADIUS);
959     ViewAbstract::SetInvert(invert);
960     ViewAbstract::SetInvert(nullptr, invert);
961     ViewAbstract::SetHueRotate(RATIO);
962     ViewAbstract::SetHueRotate(nullptr, RATIO);
963     ViewAbstract::SetBrightness(RADIUS);
964     ViewAbstract::SetColorBlend(BLUE);
965     ViewAbstract::SetBorderImageSource(srcimages);
966     ViewAbstract::SetBrightnessBlender(nullptr);
967 
968     /**
969      * @tc.expected: Return expected results.
970      */
971     EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
972 }
973 
974 /**
975  * @tc.name: ViewAbstractTest018
976  * @tc.desc: Test the operation of View_Abstract.
977  * @tc.type: FUNC
978  */
979 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest018, TestSize.Level1)
980 {
981     /**
982      * @tc.steps: step1.push FrameNode is not null, related function is called.
983      */
984     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
985     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
986 
987     auto visible = static_cast<GridSizeType>(INDEX);
988     ViewAbstract::SetGrid(FOUF, FOUF, std::move(visible));
989     TransitionOptions options;
990     ViewAbstract::SetTransition(std::move(options));
991     RefPtr<BasicShape> basicShape;
992     ViewAbstract::SetClipShape(std::move(basicShape));
993     ViewAbstract::SetMask(std::move(basicShape));
994     ViewAbstract::SetClipEdge(false);
995     ViewAbstract::SetClipEdge(nullptr, false);
996     ViewAbstract::SetGrayScale(RADIUS);
997     ViewAbstract::SetContrast(RADIUS);
998     ViewAbstract::SetSaturate(RADIUS);
999     ViewAbstract::SetSepia(RADIUS);
1000     ViewAbstract::SetInvert(invert);
1001     ViewAbstract::SetHueRotate(RATIO);
1002     ViewAbstract::SetBrightness(RADIUS);
1003     ViewAbstract::SetBrightness(nullptr, RADIUS);
1004     ViewAbstract::SetColorBlend(BLUE);
1005     ViewAbstract::SetColorBlend(nullptr, BLUE);
1006     ViewAbstract::SetBorderImageSource(srcimages);
1007     ViewAbstract::SetBrightnessBlender(nullptr);
1008 
1009     /**
1010      * @tc.expected: Return expected results.
1011      */
1012     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1013     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1014     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1015     ASSERT_NE(frameNode, nullptr);
1016     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1017     ASSERT_NE(Node, nullptr);
1018     auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1019     ASSERT_NE(layoutProperty, nullptr);
1020     ViewStackProcessor::GetInstance()->instance = nullptr;
1021 }
1022 
1023 /**
1024  * @tc.name: ViewAbstractTest019
1025  * @tc.desc: Test the operation of View_Abstract
1026  * @tc.type: FUNC
1027  */
1028 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest019, TestSize.Level1)
1029 {
1030     /**
1031      * @tc.steps: step1.The FrameNode is null, related function is called.
1032      */
1033     RefPtr<BorderImage> borderImage;
1034     ViewAbstract::SetBorderImage(std::move(borderImage));
1035     ViewAbstract::SetHasBorderImageSlice(true);
1036     ViewAbstract::SetHasBorderImageWidth(true);
1037     ViewAbstract::SetHasBorderImageOutset(true);
1038     ViewAbstract::SetHasBorderImageRepeat(true);
1039     ViewAbstract::SetHasBorderImageRepeat(nullptr, true);
1040     Gradient gradient;
1041     ViewAbstract::SetBorderImageGradient(std::move(gradient));
1042     ViewAbstract::SetBorderImageGradient(nullptr, std::move(gradient));
1043     OverlayOptions overlay;
1044     ViewAbstract::SetOverlay(std::move(overlay));
1045     ViewAbstract::SetOverlay(nullptr, std::move(overlay));
1046     MotionPathOption motionPath;
1047     ViewAbstract::SetMotionPath(std::move(motionPath));
1048     ViewAbstract::SetMotionPath(nullptr, std::move(motionPath));
1049     ViewAbstract::SetSharedTransition("", nullptr);
1050     ViewAbstract::SetSharedTransition(AceType::RawPtr(FRAME_NODE_REGISTER), "", nullptr);
1051     ViewAbstract::SetSphericalEffect(RATIO);
1052     ViewAbstract::SetLightUpEffect(RATIO);
1053     ViewAbstract::SetUseEffect(false, EffectType::DEFAULT);
1054     ViewAbstract::SetRenderGroup(false);
1055     ViewAbstract::SetRenderFit(RenderFit::BOTTOM);
1056     ViewAbstract::UpdateSafeAreaExpandOpts(safeAreaExpandOpts);
1057     ViewAbstract::UpdateSafeAreaExpandOpts(AceType::RawPtr(FRAME_NODE_REGISTER), safeAreaExpandOpts);
1058     ViewAbstract::SetObscured(reasonsVector);
1059     ViewAbstract::SetObscured(AceType::RawPtr(FRAME_NODE_REGISTER), reasonsVector);
1060 
1061     /**
1062      * @tc.expected: Return expected results.
1063      */
1064     EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
1065 }
1066 
1067 /**
1068  * @tc.name: ViewAbstractTest020
1069  * @tc.desc: Test the operation of View_Abstract.
1070  * @tc.type: FUNC
1071  */
1072 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest020, TestSize.Level1)
1073 {
1074     /**
1075      * @tc.steps: step1.push FrameNode is not null, related function is called.
1076      */
1077     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1078     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1079 
1080     RefPtr<BorderImage> borderImage;
1081     ViewAbstract::SetBorderImage(std::move(borderImage));
1082     ViewAbstract::SetBorderImage(nullptr, std::move(borderImage));
1083     ViewAbstract::SetHasBorderImageSlice(true);
1084     ViewAbstract::SetHasBorderImageWidth(true);
1085     ViewAbstract::SetHasBorderImageOutset(true);
1086     ViewAbstract::SetHasBorderImageRepeat(true);
1087     Gradient gradient;
1088     ViewAbstract::SetBorderImageGradient(std::move(gradient));
1089     OverlayOptions overlay;
1090     ViewAbstract::SetOverlay(std::move(overlay));
1091     MotionPathOption motionPath;
1092     ViewAbstract::SetMotionPath(std::move(motionPath));
1093     std::shared_ptr<SharedTransitionOption> option;
1094     ViewAbstract::SetSharedTransition(srcimages, std::move(option));
1095     ViewAbstract::SetSphericalEffect(RATIO);
1096     ViewAbstract::SetLightUpEffect(RATIO);
1097     ViewAbstract::SetDraggable(false);
1098     ViewAbstract::SetDraggable(AceType::RawPtr(FRAME_NODE_REGISTER), false);
1099     ViewAbstract::SetUseEffect(false, EffectType::DEFAULT);
1100     ViewAbstract::SetUseEffect(false, EffectType::WINDOW_EFFECT);
1101     ViewAbstract::SetUseEffect(true, EffectType::DEFAULT);
1102     ViewAbstract::SetUseEffect(true, EffectType::WINDOW_EFFECT);
1103     ViewAbstract::SetRenderGroup(false);
1104     ViewAbstract::SetRenderFit(RenderFit::BOTTOM);
1105     ViewAbstract::UpdateSafeAreaExpandOpts(safeAreaExpandOpts);
1106     ViewAbstract::SetObscured(reasonsVector);
1107 
1108     /**
1109      * @tc.expected: Return expected results.
1110      */
1111     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1112     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1113     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1114     ASSERT_NE(frameNode, nullptr);
1115     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1116     ASSERT_NE(Node, nullptr);
1117     auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1118     ASSERT_NE(layoutProperty, nullptr);
1119     ViewStackProcessor::GetInstance()->instance = nullptr;
1120 }
1121 
1122 /**
1123  * @tc.name: ViewAbstractTest021
1124  * @tc.desc: Test the operation of View_Abstract
1125  * @tc.type: FUNC
1126  */
1127 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest021, TestSize.Level1)
1128 {
1129     /**
1130      * @tc.steps: step1.The FrameNode is null, related function is called.
1131      */
1132     PixStretchEffectOption option;
1133     option.bottom = BOTTOM;
1134     option.left = LEFT;
1135     option.right = RIGHT;
1136     option.top = TOP;
1137     ViewAbstract::SetPixelStretchEffect(option);
1138     ViewAbstract::SetPixelStretchEffect(nullptr, option);
1139     RefPtr<NG::ChainedTransitionEffect> effect;
1140     ViewAbstract::SetChainedTransition(std::move(effect));
1141     RefPtr<ProgressMaskProperty> progress;
1142     ViewAbstract::SetProgressMask(std::move(progress));
1143 
1144     ViewAbstract::SetForegroundColor(BLUE);
1145     auto strategy = static_cast<ForegroundColorStrategy>(INDEX);
1146     ViewAbstract::SetForegroundColorStrategy(std::move(strategy));
1147     auto hoverEffect = static_cast<HoverEffectType>(INDEX);
1148     ViewAbstract::SetHoverEffectAuto(hoverEffect);
1149     ViewAbstract::SetDraggable(true);
1150 
1151     /**
1152      * @tc.expected: Return expected results.
1153      */
1154     EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
1155 }
1156 
1157 /**
1158  * @tc.name: ViewAbstractTest022
1159  * @tc.desc: Test the operation of View_Abstract.
1160  * @tc.type: FUNC
1161  */
1162 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest022, TestSize.Level1)
1163 {
1164     /**
1165      * @tc.steps: step1.push FrameNode is not null, related function is called.
1166      */
1167     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1168     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1169 
1170     PixStretchEffectOption option;
1171     option.bottom = BOTTOM;
1172     option.left = LEFT;
1173     option.right = RIGHT;
1174     option.top = TOP;
1175     ViewAbstract::SetPixelStretchEffect(option);
1176     RefPtr<NG::ChainedTransitionEffect> effect;
1177     ViewAbstract::SetChainedTransition(std::move(effect));
1178     RefPtr<ProgressMaskProperty> progress;
1179     ViewAbstract::SetProgressMask(std::move(progress));
1180     ViewAbstract::SetForegroundColor(BLUE);
1181     auto strategy = static_cast<ForegroundColorStrategy>(INDEX);
1182     ViewAbstract::SetForegroundColorStrategy(std::move(strategy));
1183     ViewAbstract::SetBorderWidth(VALUE);
1184     ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
1185     ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
1186     auto hoverEffect = static_cast<HoverEffectType>(INDEX);
1187     ViewAbstract::SetHoverEffectAuto(hoverEffect);
1188     ViewAbstract::SetDraggable(true);
1189 
1190     /**
1191      * @tc.expected: Return expected results.
1192      */
1193     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1194     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1195     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1196     ASSERT_NE(frameNode, nullptr);
1197     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1198     ASSERT_NE(Node, nullptr);
1199     auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1200     ASSERT_NE(layoutProperty, nullptr);
1201     ViewStackProcessor::GetInstance()->instance = nullptr;
1202 }
1203 
1204 /**
1205  * @tc.name: ViewAbstractTest023
1206  * @tc.desc: Test the operation of View_Abstract
1207  * @tc.type: FUNC
1208  */
1209 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest023, TestSize.Level1)
1210 {
1211     /**
1212      * @tc.steps: step1.The FrameNode is null, related function is called.
1213      */
1214     std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)>
1215         onAreaChanged;
1216     ViewAbstract::SetOnAreaChanged(std::move(onAreaChanged));
1217     ViewAbstract::SetOnAreaChanged(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onAreaChanged));
1218 
1219     std::function<void(const RectF& oldRect, const RectF& rect)> onSizeChanged;
1220     ViewAbstract::SetOnSizeChanged(std::move(onSizeChanged));
1221     std::function<void(bool, double)> onVisibleChange;
1222     const std::vector<double> ratios;
1223     ViewAbstract::SetOnVisibleChange(std::move(onVisibleChange), ratios);
1224 
1225     std::function<void(const RefPtr<OHOS::Ace::DragEvent>&)> onDragEnd;
1226     ViewAbstract::SetOnDragEnd(std::move(onDragEnd));
1227     std::set<std::string> allowDrop;
1228     ViewAbstract::SetAllowDrop(std::move(allowDrop));
1229     ViewAbstract::SetAllowDrop(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(allowDrop));
1230     ViewAbstract::CreateAnimatablePropertyFloat(srcimages, RATIO, nullptr);
1231     ViewAbstract::UpdateAnimatablePropertyFloat(srcimages, RATIO);
1232     ViewAbstract::SetRestoreId(TEN);
1233     ViewAbstract::SetRestoreId(AceType::RawPtr(FRAME_NODE_REGISTER), TEN);
1234 
1235     /**
1236      * @tc.expected: Return expected results.
1237      */
1238     EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
1239 }
1240 
1241 /**
1242  * @tc.name: ViewAbstractTest024
1243  * @tc.desc: Test the operation of View_Abstract.
1244  * @tc.type: FUNC
1245  */
1246 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest024, TestSize.Level1)
1247 {
1248     /**
1249      * @tc.steps: step1.push FrameNode is not null, related function is called.
1250      */
1251     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1252     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1253 
1254     std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)>
1255         onAreaChanged;
1256     ViewAbstract::SetOnAreaChanged(std::move(onAreaChanged));
1257     std::function<void(bool, double)> onVisibleChange;
1258     const std::vector<double> ratios;
1259     ViewAbstract::SetOnVisibleChange(std::move(onVisibleChange), ratios);
1260     std::function<void(const RefPtr<OHOS::Ace::DragEvent>&)> onDragEnd;
1261     ViewAbstract::SetOnDragEnd(std::move(onDragEnd));
1262     std::set<std::string> allowDrop;
1263     ViewAbstract::SetAllowDrop(std::move(allowDrop));
1264     ViewAbstract::CreateAnimatablePropertyFloat(srcimages, RATIO, nullptr);
1265     ViewAbstract::UpdateAnimatablePropertyFloat(srcimages, RATIO);
1266     ViewAbstract::SetRestoreId(TEN);
1267 
1268     /**
1269      * @tc.expected: Return expected results.
1270      */
1271     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1272     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1273     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1274     ASSERT_NE(frameNode, nullptr);
1275     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1276     ASSERT_NE(Node, nullptr);
1277     auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1278     ASSERT_NE(layoutProperty, nullptr);
1279     ViewStackProcessor::GetInstance()->instance = nullptr;
1280 }
1281 
1282 /**
1283  * @tc.name: ViewAbstractTest025
1284  * @tc.desc: Test the BindPopup of View_Abstract.
1285  * @tc.type: FUNC
1286  */
1287 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest025, TestSize.Level1)
1288 {
1289     /**
1290      * @tc.steps: step1. Create some FrameNode and params.
1291      */
1292     const RefPtr<FrameNode> customNode = FrameNode::CreateFrameNode("one", 1, AceType::MakeRefPtr<Pattern>(), true);
1293     const RefPtr<FrameNode> targetNode = FrameNode::CreateFrameNode("two", 2, AceType::MakeRefPtr<Pattern>());
1294     const RefPtr<FrameNode> targetNode2 = FrameNode::CreateFrameNode("three", 3, AceType::MakeRefPtr<Pattern>());
1295     auto param = AceType::MakeRefPtr<PopupParam>();
1296     auto param2 = AceType::MakeRefPtr<PopupParam>();
1297 
1298     /**
1299      * @tc.steps: step2. get popupInfo and change some params.
1300      */
1301     auto container = Container::Current();
1302     ASSERT_NE(container, nullptr);
1303     auto pipelineContext = container->GetPipelineContext();
1304     ASSERT_NE(pipelineContext, nullptr);
1305     auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext);
1306     ASSERT_NE(context, nullptr);
1307     auto overlayManager = context->GetOverlayManager();
1308     ASSERT_NE(overlayManager, nullptr);
1309     auto nodeId = targetNode->GetId();
1310     PopupInfo info = overlayManager->GetPopupInfo(nodeId);
1311     info.isCurrentOnShow = true;
1312     info.popupId = 1;
1313     auto popupNode1 = FrameNode::CreateFrameNode(
1314         V2::POPUP_ETS_TAG, info.popupId, AceType::MakeRefPtr<BubblePattern>(targetNode->GetId(), targetNode->GetTag()));
1315     info.popupNode = popupNode1;
1316     info.target = targetNode2;
1317     overlayManager->ShowPopup(targetNode->GetId(), info);
1318 
1319     /**
1320      * @tc.steps: step3. Call BindPopup many times.
1321      * @tc.expected: popupNode in overlayManager of targetNode not null
1322      */
1323     ViewAbstract::BindPopup(param, targetNode, customNode);
1324     ViewAbstract::BindPopup(param, targetNode, customNode);
1325     overlayManager->HidePopup(targetNode->GetId(), info);
1326     auto popupInfo = overlayManager->GetPopupInfo(targetNode->GetId());
1327     auto popupNode = popupInfo.popupNode;
1328     ASSERT_NE(popupNode, nullptr);
1329     popupNode->GetPattern<BubblePattern>()->transitionStatus_ = TransitionStatus::ENTERING;
1330     ViewAbstract::BindPopup(param, targetNode, customNode);
1331     param->SetIsShow(false);
1332     ViewAbstract::BindPopup(param, targetNode, customNode);
1333     param->SetShowInSubWindow(true);
1334     ViewAbstract::BindPopup(param, targetNode, customNode);
1335     EXPECT_NE(overlayManager->GetPopupInfo(targetNode->GetId()).popupNode, nullptr);
1336 
1337     /**
1338      * @tc.steps: step4. Call BindPopup with param use custom.
1339      * @tc.expected: popupNode in overlayManager of targetNode not null
1340      */
1341     param2->SetUseCustomComponent(true);
1342     ViewAbstract::BindPopup(param2, targetNode2, customNode);
1343     ViewAbstract::BindPopup(param2, targetNode2, customNode);
1344     param2->SetShowInSubWindow(true);
1345     ViewAbstract::BindPopup(param2, targetNode2, customNode);
1346     param2->SetIsShow(false);
1347     ViewAbstract::BindPopup(param2, targetNode2, customNode);
1348     EXPECT_NE(overlayManager->GetPopupInfo(targetNode->GetId()).popupNode, nullptr);
1349 }
1350 
1351 /**
1352  * @tc.name: ViewAbstractTest026
1353  * @tc.desc: Test the SetKeyboardShortcut of View_Abstract.
1354  * @tc.type: FUNC
1355  */
1356 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest026, TestSize.Level1)
1357 {
1358     /**
1359      * @tc.steps: step1. Create a FrameNode and get eventManager.
1360      */
1361     const RefPtr<FrameNode> targetNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true);
1362     ViewStackProcessor::GetInstance()->Push(targetNode);
1363     auto eventManager = PipelineContext::GetCurrentContext()->GetEventManager();
1364     /**
1365      * @tc.steps: step2. call SetKeyboardShortcut with ctrl + x.
1366      * @tc.expected: add fail
1367      */
1368     std::vector<ModifierKey> keys;
1369     keys.push_back(ModifierKey::CTRL);
1370     ViewAbstract::SetKeyboardShortcut(VALUE_X, std::move(keys), callback);
1371     ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_X, std::move(keys), callback);
1372     EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 0);
1373     keys.clear();
1374     /**
1375      * @tc.steps: step3. call SetKeyboardShortcut with other wrong type.
1376      * @tc.expected: add fail
1377      */
1378     ViewAbstract::SetKeyboardShortcut(VALUE_EMPTY, std::move(keys), callback);
1379     ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1380     ViewAbstract::SetKeyboardShortcut(VALUE_X, std::move(keys), callback);
1381     ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_EMPTY, std::move(keys), callback);
1382     ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_CX, std::move(keys), callback);
1383     ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_X, std::move(keys), callback);
1384 
1385     /**
1386      * @tc.steps: step4. and shift in keys and recall SetKeyboardShortcut .
1387      * @tc.expected: add success
1388      */
1389     keys.push_back(ModifierKey::ALT);
1390     ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1391     ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_CX, std::move(keys), callback);
1392     EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1393 
1394     /**
1395      * @tc.steps: step5. make other key and recall SetKeyboardShortcut .
1396      * @tc.expected: add fail
1397      */
1398     keys.push_back(ModifierKey::SHIFT);
1399     ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1400     ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_CX, std::move(keys), callback);
1401     EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1402     keys.push_back(ModifierKey::ALT);
1403     ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1404     ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_CX, std::move(keys), callback);
1405     EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1406 }
1407 
1408 /**
1409  * @tc.name: ViewAbstractTest027
1410  * @tc.desc: Test the operation of View_Abstract.
1411  * @tc.type: FUNC
1412  */
1413 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest027, TestSize.Level1)
1414 {
1415     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1416     /**
1417      * @tc.steps: step1. callback ShowMenu with two condition.
1418      */
1419     ContainerScope sontainerScope(1);
1420     /**
1421      * @tc.steps: step2. callback SetForegroundBlurStyle and ResetFlexShrink.
1422      */
1423     BlurStyleOption bgBlurStyle;
1424     ViewAbstract::SetForegroundBlurStyle(bgBlurStyle);
1425     ViewAbstract::SetForegroundBlurStyle(AceType::RawPtr(FRAME_NODE_REGISTER), bgBlurStyle);
1426     ViewAbstract::ResetFlexShrink();
1427     ViewAbstract::ResetFlexShrink(AceType::RawPtr(FRAME_NODE_REGISTER));
1428     /**
1429      * @tc.steps: step3. SetVisualState in ViewStackProcessor and recall the two function.
1430      * @tc.expected: the blur radius in render context meet expectations.
1431      */
1432     ViewStackProcessor::GetInstance()->SetVisualState(VisualState::FOCUSED);
1433     ViewAbstract::SetForegroundBlurStyle(bgBlurStyle);
1434     ViewAbstract::SetForegroundBlurStyle(AceType::RawPtr(FRAME_NODE_REGISTER), bgBlurStyle);
1435     ViewAbstract::ResetFlexShrink();
1436     ASSERT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr);
1437     EXPECT_FALSE(FRAME_NODE_ROOT->GetRenderContext()->GetFrontBlurRadius().has_value());
1438 }
1439 
1440 /**
1441  * @tc.name: ViewAbstractTest028
1442  * @tc.desc: Test the operation of View_Abstract.
1443  * @tc.type: FUNC
1444  */
1445 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest028, TestSize.Level1)
1446 {
1447     /**
1448      * @tc.steps: step1.push FrameNode is not null, callback Pop function.
1449      */
1450     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1451     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1452     ViewAbstract::Pop();
1453 
1454     /**
1455      * @tc.expected: Return expected results.
1456      */
1457     EXPECT_FALSE(ViewStackProcessor::GetInstance()->elementsStack_.empty());
1458     EXPECT_EQ(ViewStackProcessor::GetInstance()->elementsStack_.size(), INDEX);
1459 }
1460 
1461 /**
1462  * @tc.name: ViewAbstractTest029
1463  * @tc.desc: Test the operation of View_Abstract
1464  * @tc.type: FUNC
1465  */
1466 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest029, TestSize.Level1)
1467 {
1468     /**
1469      * @tc.steps: step1.ClearStack.
1470      */
1471     auto state = static_cast<VisualState>(INDEX);
1472     ViewStackProcessor::GetInstance()->SetVisualState(state);
1473     ViewStackProcessor::GetInstance()->ClearStack();
1474 
1475     /**
1476      * @tc.steps: step2. related function is called.
1477      */
1478     ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
1479     ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
1480     ViewAbstract::SetMinWidth(NG::CalcLength(MIN_WIDTH));
1481     ViewAbstract::SetMinHeight(NG::CalcLength(MIN_HEIGHT));
1482     ViewAbstract::SetMaxWidth(NG::CalcLength(MIN_WIDTH));
1483     ViewAbstract::SetMaxHeight(NG::CalcLength(MIN_HEIGHT));
1484     ViewAbstract::SetAspectRatio(RATIO);
1485     ViewAbstract::SetAspectRatio(AceType::RawPtr(FRAME_NODE_REGISTER), RATIO);
1486     ViewAbstract::SetBackgroundColor(BLUE);
1487     ViewAbstract::SetBackgroundColor(nullptr, BLUE);
1488     ViewAbstract::SetBackgroundImage(imageSourceInfo);
1489     ViewAbstract::SetBackgroundImage(nullptr, imageSourceInfo);
1490     ViewAbstract::SetBackgroundImageSize(BACKGROUNDSIZE);
1491     ViewAbstract::SetBackgroundImageSize(nullptr, BACKGROUNDSIZE);
1492     ViewAbstract::SetBackgroundImagePosition(BACKGROUNDPOSITION);
1493     ViewAbstract::SetBackgroundImagePosition(nullptr, BACKGROUNDPOSITION);
1494     ViewAbstract::SetPixelRound(0);
1495     ChainInfo chainInfo;
1496     chainInfo.direction = LineDirection::HORIZONTAL;
1497     chainInfo.style = ChainStyle::SPREAD;
1498     ViewAbstract::SetChainStyle(chainInfo);
1499     ViewAbstract::SetChainStyle(AceType::RawPtr(FRAME_NODE_REGISTER), chainInfo);
1500     ViewAbstract::SetBias(biasPair);
1501     ViewAbstract::SetOuterBorderRadius(ZERO);
1502     ViewAbstract::SetOuterBorderRadius(nullptr, ZERO);
1503     NG::BorderRadiusProperty borderRadius;
1504     ViewAbstract::SetOuterBorderRadius(borderRadius);
1505     ViewAbstract::SetOuterBorderRadius(nullptr, borderRadius);
1506     ViewAbstract::SetOuterBorderColor(BLUE);
1507     ViewAbstract::SetOuterBorderColor(nullptr, BLUE);
1508     NG::BorderColorProperty borderColor;
1509     ViewAbstract::SetOuterBorderColor(borderColor);
1510     ViewAbstract::SetOuterBorderColor(nullptr, borderColor);
1511     ViewAbstract::SetOuterBorderWidth(ZERO);
1512     ViewAbstract::SetOuterBorderWidth(nullptr, ZERO);
1513     NG::BorderWidthProperty borderWidth;
1514     ViewAbstract::SetOuterBorderWidth(borderWidth);
1515     ViewAbstract::SetOuterBorderWidth(nullptr, borderWidth);
1516     auto borderStyle = static_cast<BorderStyle>(INDEX);
1517     ViewAbstract::SetOuterBorderStyle(borderStyle);
1518     ViewAbstract::SetOuterBorderStyle(nullptr, borderStyle);
1519     NG::BorderStyleProperty borderStyleProperty;
1520     ViewAbstract::SetOuterBorderStyle(borderStyleProperty);
1521     ViewAbstract::SetOuterBorderStyle(nullptr, borderStyleProperty);
1522     ViewAbstract::ResetAspectRatio();
1523     ViewAbstract::ResetAspectRatio(AceType::RawPtr(FRAME_NODE_REGISTER));
1524 
1525     /**
1526      * @tc.expected: Return expected results.
1527      */
1528     bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1529     EXPECT_FALSE(result);
1530 }
1531 
1532 /**
1533  * @tc.name: ViewAbstractTest030
1534  * @tc.desc: Test the operation of View_Abstract
1535  * @tc.type: FUNC
1536  */
1537 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest030, TestSize.Level1)
1538 {
1539     /**
1540      * @tc.steps: step1.ClearStack.
1541      */
1542     auto state = static_cast<VisualState>(INDEX);
1543     ViewStackProcessor::GetInstance()->SetVisualState(state);
1544     ViewStackProcessor::GetInstance()->ClearStack();
1545 
1546     /**
1547      * @tc.steps: step2. related function is called.
1548      */
1549     MotionPathOption motionPath;
1550     ViewAbstract::SetMotionPath(std::move(motionPath));
1551     auto repeat = static_cast<ImageRepeat>(INDEX);
1552     ViewAbstract::SetBackgroundImageRepeat(repeat);
1553     GestureJudgeFunc tapEventFunc;
1554     ViewAbstract::SetOnGestureJudgeBegin(std::move(tapEventFunc));
1555 
1556     BlurStyleOption blurStyleOption;
1557     blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
1558     blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
1559     blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
1560     ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
1561 
1562     auto direction = static_cast<TextDirection>(INDEX);
1563     ViewAbstract::SetLayoutDirection(direction);
1564     std::map<AlignDirection, AlignRule> alignRules;
1565     ViewAbstract::SetAlignRules(alignRules);
1566     auto alignSelf = static_cast<FlexAlign>(INDEX);
1567     ViewAbstract::SetAlignSelf(alignSelf);
1568     ViewAbstract::SetAlignSelf(AceType::RawPtr(FRAME_NODE_REGISTER), alignSelf);
1569 
1570     /**
1571      * @tc.expected: Return expected results.
1572      */
1573     bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1574     EXPECT_FALSE(result);
1575 }
1576 } // namespace OHOS::Ace::NG