1 /*
2  * Copyright (c) 2024 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 "test/unittest/core/base/view_abstract_test_ng.h"
17 
18 using namespace testing;
19 using namespace testing::ext;
20 
21 namespace OHOS::Ace::NG {
22 /**
23  * @tc.name: ViewAbstractTest031
24  * @tc.desc: Test the operation of View_Abstract
25  * @tc.type: FUNC
26  */
27 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest031, TestSize.Level1)
28 {
29     /**
30      * @tc.steps: step1.ClearStack.
31      */
32     auto state = static_cast<VisualState>(INDEX);
33     ViewStackProcessor::GetInstance()->SetVisualState(state);
34     ViewStackProcessor::GetInstance()->ClearStack();
35 
36     /**
37      * @tc.steps: step2. related function is called.
38      */
39     ViewAbstract::SetFlexShrink(RATIO);
40     ViewAbstract::SetFlexGrow(RATIO);
41     ViewAbstract::SetFlexBasis(WIDTH);
42     ViewAbstract::SetFlexBasis(AceType::RawPtr(FRAME_NODE_REGISTER), WIDTH);
43     ViewAbstract::SetDisplayIndex(TEN);
44     ViewAbstract::SetZIndex(FOUF);
45 
46     Alignment alignment;
47     ViewAbstract::SetAlign(std::move(alignment));
48     auto visible = static_cast<VisibleType>(INDEX);
49     ViewAbstract::SetVisibility(std::move(visible));
50     ViewAbstract::SetOpacity(OPACITYS);
51 
52     /**
53      * @tc.expected: Return expected results.
54      */
55     bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
56     EXPECT_FALSE(result);
57 }
58 
59 /**
60  * @tc.name: ViewAbstractTest032
61  * @tc.desc: Test the operation of View_Abstract
62  * @tc.type: FUNC
63  */
64 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest032, TestSize.Level1)
65 {
66     /**
67      * @tc.steps: step1.ClearStack.
68      */
69     auto state = static_cast<VisualState>(INDEX);
70     ViewStackProcessor::GetInstance()->SetVisualState(state);
71     ViewStackProcessor::GetInstance()->ClearStack();
72 
73     /**
74      * @tc.steps: step2. related function is called.
75      */
76     OffsetT<Dimension> values = { WIDTH, HEIGHT };
77     ViewAbstract::SetPosition(values);
78     ViewAbstract::SetOffset(values);
79     ViewAbstract::MarkAnchor(values);
80 
81     ViewAbstract::SetPadding(NG::CalcLength(WIDTH));
82     ViewAbstract::SetPadding(AceType::RawPtr(FRAME_NODE_REGISTER), NG::CalcLength(WIDTH));
83     ViewAbstract::SetMargin(NG::CalcLength(WIDTH));
84     ViewAbstract::SetMargin(AceType::RawPtr(FRAME_NODE_REGISTER), NG::CalcLength(WIDTH));
85     ViewAbstract::SetBorderRadius(WIDTH);
86     ViewAbstract::SetBorderRadius(nullptr, WIDTH);
87     ViewAbstract::SetBorderColor(BLUE);
88     ViewAbstract::SetBorderColor(nullptr, BLUE);
89     ViewAbstract::SetBorderWidth(WIDTH);
90     ViewAbstract::SetBorderWidth(nullptr, WIDTH);
91 
92     auto borderStyle = static_cast<BorderStyle>(INDEX);
93     ViewAbstract::SetBorderStyle(borderStyle);
94     ViewAbstract::SetBorderStyle(nullptr, borderStyle);
95 
96     /**
97      * @tc.expected: Return expected results.
98      */
99     bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
100     EXPECT_FALSE(result);
101 }
102 
103 /**
104  * @tc.name: ViewAbstractTest033
105  * @tc.desc: Test the operation of View_Abstract
106  * @tc.type: FUNC
107  */
108 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest033, TestSize.Level1)
109 {
110     /**
111      * @tc.steps: step1.ClearStack.
112      */
113     auto state = static_cast<VisualState>(INDEX);
114     ViewStackProcessor::GetInstance()->SetVisualState(state);
115     ViewStackProcessor::GetInstance()->ClearStack();
116 
117     /**
118      * @tc.steps: step2. related function is called.
119      */
120     OffsetT<Dimension> values = { WIDTH, HEIGHT };
121     ViewAbstract::SetPosition(values);
122     ViewAbstract::SetOffset(values);
123     ViewAbstract::MarkAnchor(values);
124 
125     NG::PaddingProperty paddings;
126     ViewAbstract::SetPadding(paddings);
127     ViewAbstract::SetPadding(AceType::RawPtr(FRAME_NODE_REGISTER), paddings);
128 
129     NG::MarginProperty margins;
130     ViewAbstract::SetMargin(margins);
131     ViewAbstract::SetMargin(AceType::RawPtr(FRAME_NODE_REGISTER), margins);
132 
133     NG::BorderRadiusProperty borderRadius;
134     ViewAbstract::SetBorderRadius(borderRadius);
135 
136     NG::BorderColorProperty borderColors;
137     ViewAbstract::SetBorderColor(borderColors);
138 
139     NG::BorderWidthProperty borderWidth;
140     ViewAbstract::SetBorderWidth(borderWidth);
141 
142     NG::BorderStyleProperty borderStyles;
143     ViewAbstract::SetBorderStyle(borderStyles);
144     ViewAbstract::SetBorderStyle(nullptr, borderStyles);
145 
146     /**
147      * @tc.expected: Return expected results.
148      */
149     bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
150     EXPECT_FALSE(result);
151 }
152 
153 /**
154  * @tc.name: ViewAbstractTest034
155  * @tc.desc: Test the operation of View_Abstract
156  * @tc.type: FUNC
157  */
158 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest034, TestSize.Level1)
159 {
160     /**
161      * @tc.steps: step1.ClearStack.
162      */
163     auto state = static_cast<VisualState>(INDEX);
164     ViewStackProcessor::GetInstance()->SetVisualState(state);
165     ViewStackProcessor::GetInstance()->ClearStack();
166 
167     /**
168      * @tc.steps: step2. related function is called.
169      */
170     BlurOption blurOption;
171     ViewAbstract::SetBrightness(RADIUS);
172     ViewAbstract::SetGrayScale(RADIUS);
173     ViewAbstract::SetContrast(RADIUS);
174     ViewAbstract::SetContrast(nullptr, RADIUS);
175     ViewAbstract::SetSaturate(RADIUS);
176     ViewAbstract::SetSepia(RADIUS);
177     ViewAbstract::SetInvert(invert);
178     ViewAbstract::SetHueRotate(RATIO);
179     ViewAbstract::SetColorBlend(BLUE);
180     ViewAbstract::SetBackdropBlur(RADIUS, blurOption);
181     ViewAbstract::SetFrontBlur(RADIUS, blurOption);
182     ViewAbstract::SetClipEdge(false);
183 
184     /**
185      * @tc.expected: Return expected results.
186      */
187     bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
188     EXPECT_FALSE(result);
189 }
190 
191 /**
192  * @tc.name: ViewAbstractTest035
193  * @tc.desc: Test the operation of View_Abstract
194  * @tc.type: FUNC
195  */
196 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest035, TestSize.Level1)
197 {
198     /**
199      * @tc.steps: step1.ClearStack.
200      */
201     auto state = static_cast<VisualState>(INDEX);
202     ViewStackProcessor::GetInstance()->SetVisualState(state);
203     ViewStackProcessor::GetInstance()->ClearStack();
204 
205     /**
206      * @tc.steps: step2. related function is called.
207      */
208     viewAbstractModelNG.SetScale(1.0f, 1.0f, 0.0f);
209     DimensionOffset value = { WIDTH, HEIGHT };
210     viewAbstractModelNG.SetPivot(WIDTH, HEIGHT, ZERO);
211     NG::TranslateOptions values;
212     ViewAbstract::SetTranslate(std::move(values));
213     Vector5F scales(1.0f, 1.0f, 2.0f, 2.0f, 0.0f);
214     ViewAbstract::SetRotate(scales);
215     Matrix4 matrix;
216     ViewAbstract::SetTransformMatrix(std::move(matrix));
217 
218     ShadowStyle style { 1 };
219     Shadow shadow { RATIO, OFFSET, BLUE, style };
220     ViewAbstract::SetBackShadow(shadow);
221     NG::Gradient gradient;
222     ViewAbstract::SetLinearGradient(std::move(gradient));
223     ViewAbstract::SetSweepGradient(std::move(gradient));
224     ViewAbstract::SetRadialGradient(std::move(gradient));
225     TransitionOptions options;
226     ViewAbstract::SetTransition(std::move(options));
227     ViewAbstract::SetTransition(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(options));
228     RefPtr<BasicShape> basicShape;
229     ViewAbstract::SetClipShape(std::move(basicShape));
230     ViewAbstract::SetMask(std::move(basicShape));
231     ViewAbstract::SetMask(nullptr, std::move(basicShape));
232 
233     /**
234      * @tc.expected: Return expected results.
235      */
236     bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
237     EXPECT_FALSE(result);
238 }
239 
240 /**
241  * @tc.name: ViewAbstractTest036
242  * @tc.desc: Test the operation of View_Abstract
243  * @tc.type: FUNC
244  */
245 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest036, TestSize.Level1)
246 {
247     /**
248      * @tc.steps: step1.ClearStack.
249      */
250     auto state = static_cast<VisualState>(INDEX);
251     ViewStackProcessor::GetInstance()->SetVisualState(state);
252     ViewStackProcessor::GetInstance()->ClearStack();
253 
254     /**
255      * @tc.steps: step2. related function is called.
256      */
257     ViewAbstract::SetBorderImageSource(srcimages);
258     ViewAbstract::SetBorderImageSource(nullptr, srcimages);
259     ViewAbstract::SetHasBorderImageSlice(false);
260     ViewAbstract::SetHasBorderImageSlice(nullptr, false);
261     ViewAbstract::SetHasBorderImageWidth(false);
262     ViewAbstract::SetHasBorderImageWidth(nullptr, false);
263     ViewAbstract::SetHasBorderImageOutset(false);
264     ViewAbstract::SetHasBorderImageOutset(nullptr, false);
265     ViewAbstract::SetHasBorderImageRepeat(false);
266     ViewAbstract::SetSphericalEffect(RATIO);
267     ViewAbstract::SetSphericalEffect(nullptr, RATIO);
268     ViewAbstract::SetLightUpEffect(RATIO);
269     ViewAbstract::SetLightUpEffect(nullptr, RATIO);
270     ViewAbstract::SetForegroundColor(BLUE);
271     ViewAbstract::SetForegroundColor(AceType::RawPtr(FRAME_NODE_REGISTER), BLUE);
272     ViewAbstract::ClearWidthOrHeight(true);
273     ViewAbstract::SetRenderGroup(false);
274     ViewAbstract::SetRenderGroup(nullptr, false);
275     ViewAbstract::SetRenderFit(RenderFit::BOTTOM);
276     ViewAbstract::SetRenderFit(nullptr, RenderFit::BOTTOM);
277     ViewAbstract::UpdateSafeAreaExpandOpts(safeAreaExpandOpts);
278     ViewAbstract::SetObscured(reasonsVector);
279 
280     PixStretchEffectOption option;
281     option.bottom = BOTTOM;
282     option.left = LEFT;
283     option.right = RIGHT;
284     option.top = TOP;
285     ViewAbstract::SetPixelStretchEffect(option);
286 
287     /**
288      * @tc.expected: Return expected results.
289      */
290     bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
291     EXPECT_FALSE(result);
292 }
293 
294 /**
295  * @tc.name: ViewAbstractTest037
296  * @tc.desc: Test the operation of View_Abstract
297  * @tc.type: FUNC
298  */
299 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest037, TestSize.Level1)
300 {
301     /**
302      * @tc.steps: step1.ClearStack.
303      */
304     auto state = static_cast<VisualState>(INDEX);
305     ViewStackProcessor::GetInstance()->SetVisualState(state);
306     ViewStackProcessor::GetInstance()->ClearStack();
307 
308     /**
309      * @tc.steps: step2. related function is called.
310      */
311     RefPtr<BorderImage> borderImage;
312     ViewAbstract::SetBorderImage(std::move(borderImage));
313     Gradient gradient;
314     ViewAbstract::SetBorderImageGradient(std::move(gradient));
315     RefPtr<NG::ChainedTransitionEffect> effect;
316     ViewAbstract::SetChainedTransition(std::move(effect));
317     ViewAbstract::SetChainedTransition(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(effect));
318     RefPtr<ProgressMaskProperty> progress;
319     ViewAbstract::SetProgressMask(std::move(progress));
320     ViewAbstract::SetProgressMask(nullptr, std::move(progress));
321     auto strategy = static_cast<ForegroundColorStrategy>(INDEX);
322     ViewAbstract::SetForegroundColorStrategy(std::move(strategy));
323     ViewAbstract::SetForegroundColorStrategy(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(strategy));
324     OverlayOptions overlay;
325     ViewAbstract::SetOverlay(std::move(overlay));
326 
327     /**
328      * @tc.expected: Return expected results.
329      */
330     bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
331     EXPECT_FALSE(result);
332 }
333 
334 /**
335  * @tc.name: ViewAbstractTest038
336  * @tc.desc: Test the operation of View_Abstract.
337  * @tc.type: FUNC
338  */
339 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest038, TestSize.Level1)
340 {
341     /**
342      * @tc.steps: step1. Build a object viewAbstract.
343      */
344     ViewStackProcessor viewStackProcessor;
345     ViewAbstract viewAbstract;
346     constexpr char TAG_ROOT[] = "root";
347     constexpr char TAG_CHILD[] = "child";
348     const auto MOCK_PATTERN_ROOT = AceType::MakeRefPtr<Pattern>();
349     const auto FRAME_NODE_ROOT = FrameNode::CreateFrameNode(TAG_ROOT, 1, MOCK_PATTERN_ROOT, true);
350     const auto FRAME_NODE_CHILD = FrameNode::CreateFrameNode(TAG_CHILD, 2, MOCK_PATTERN_ROOT, false);
351     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
352     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
353     /**
354      * @tc.steps: step2. callback SetClickEffectLevel.push FrameNode is not null.
355      */
356     viewAbstract.SetClickEffectLevel(ClickEffectLevel::LIGHT, 1.0f);
357     viewAbstract.SetClickEffectLevel(AceType::RawPtr(FRAME_NODE_REGISTER), ClickEffectLevel::LIGHT, 1.0f);
358     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
359     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
360     auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
361     ASSERT_NE(frameNode, nullptr);
362     /**
363      * @tc.expected: step3. Return expected results..
364      */
365     auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
366     ASSERT_NE(Node, nullptr);
367     auto layoutProperty = Node->GetLayoutProperty();
368     ASSERT_NE(layoutProperty, nullptr);
369     viewStackProcessor.instance = nullptr;
370 }
371 
372 /**
373  * @tc.name: ViewAbstractTest039
374  * @tc.desc: Test the operation of View_Abstract
375  * @tc.type: FUNC
376  */
377 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest039, TestSize.Level1)
378 {
379     /**
380      * @tc.steps: step1. Build a object viewAbstract.
381      */
382     ViewStackProcessor viewStackProcessor;
383     ViewAbstract viewAbstract;
384     int32_t index = 1;
385     auto state = static_cast<VisualState>(index);
386     viewStackProcessor.GetInstance()->SetVisualState(state);
387     /**
388      * @tc.steps: step2.ClearStack and callback SetScale.
389      */
390     viewStackProcessor.GetInstance()->ClearStack();
391     /**
392      * @tc.expected: step2. Return expected results..
393      */
394     bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
395     viewAbstract.SetClickEffectLevel(ClickEffectLevel::LIGHT, 1.0f);
396     ViewAbstract::ResetMinSize(true);
397     EXPECT_FALSE(result);
398     /**
399      * @tc.steps: step3. visualState_ is null.
400      * @tc.expected: result is true.
401      */
402     ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
403     result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
404     viewAbstract.SetClickEffectLevel(ClickEffectLevel::LIGHT, 1.0f);
405     ViewAbstract::ResetMinSize(true);
406     EXPECT_TRUE(result);
407 }
408 
409 /**
410  * @tc.name: ViewAbstractTest040
411  * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG
412  * @tc.type: FUNC
413  */
414 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest040, TestSize.Level1)
415 {
416     /**
417      * @tc.steps: step1. create and put mainNode, then build some necessary params.
418      */
419     const RefPtr<FrameNode> mainNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true);
420     ViewStackProcessor::GetInstance()->Push(mainNode);
421 
422     auto container = Container::Current();
423     ASSERT_NE(container, nullptr);
424     auto pipelineContext = container->GetPipelineContext();
425     ASSERT_NE(pipelineContext, nullptr);
426     auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext);
427     ASSERT_NE(context, nullptr);
428     auto overlayManager = context->GetOverlayManager();
429     ASSERT_NE(overlayManager, nullptr);
430 
431     ASSERT_NE(SubwindowManager::GetInstance(), nullptr);
__anon4da86bda0102() 432     std::function<void()> flagFunc = []() { flag++; };
433     std::vector<NG::OptionParam> params = {};
434     std::function<void()> buildFunc;
435     MenuParam menuParam;
436     std::function<void()> previewBuildFunc = nullptr;
437     /**
438      * @tc.steps: step2. call Bind and BindContextMenu multiple times with unless parameters
439      * @tc.expected: The show or hide method will not call flagFunc.
440      */
441     viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam);
__anon4da86bda0202() 442     buildFunc = []() {};
443     viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam);
444     params.push_back(OptionParam());
445     viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam);
446     menuParam.type = MenuType::CONTEXT_MENU;
447     viewAbstractModelNG.BindContextMenu(ResponseType::LONG_PRESS, buildFunc, menuParam, previewBuildFunc);
448     EXPECT_EQ(flag, 0);
449     /**
450      * @tc.steps: step3. set appear and disappear and recall BindMenu and BindContextMenu;
451      * @tc.expected: The flagFunc call times meet expectations.
452      */
453     menuParam.onAppear = flagFunc;
454     menuParam.onDisappear = flagFunc;
455     menuParam.type = MenuType::MENU;
456     viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam);
457     menuParam.type = MenuType::CONTEXT_MENU;
458     viewAbstractModelNG.BindContextMenu(ResponseType::RIGHT_CLICK, buildFunc, menuParam, previewBuildFunc);
459     menuParam.contextMenuRegisterType = ContextMenuRegisterType::CUSTOM_TYPE;
460     menuParam.isShow = true;
461     viewAbstractModelNG.BindContextMenu(ResponseType::LONG_PRESS, buildFunc, menuParam, previewBuildFunc);
462     EXPECT_EQ(flag, 0);
463     auto subwindow = SubwindowManager::GetInstance()->GetSubwindow(container);
464     EXPECT_EQ(subwindow, nullptr);
465 
466     /**
467      * @tc.steps: step4. create mouseInfo, set some useless params and call onMouseCallback_;
468      * @tc.expected: StopPropagation in mouseInfo is false.
469      */
470     auto inputHub = mainNode->GetOrCreateInputEventHub();
471     ASSERT_NE(inputHub, nullptr);
__anon4da86bda0302(MouseInfo& info)472     auto mouseCallback = [](MouseInfo& info){};
473     inputHub->showMenu_ = AceType::MakeRefPtr<InputEvent>(mouseCallback);
474     ASSERT_NE(inputHub->showMenu_, nullptr);
475     MouseInfo mouseInfo;
476     mouseInfo.SetButton(MouseButton::LEFT_BUTTON);
477     mouseInfo.SetAction(MouseAction::NONE);
478     inputHub->showMenu_->onMouseCallback_(mouseInfo);
479     mouseInfo.SetButton(MouseButton::RIGHT_BUTTON);
480     mouseInfo.SetAction(MouseAction::NONE);
481     inputHub->showMenu_->onMouseCallback_(mouseInfo);
482     EXPECT_FALSE(mouseInfo.IsStopPropagation());
483     /**
484      * @tc.steps: step4. create mouseInfo, set right param and call onMouseCallback_;
485      * @tc.expected: StopPropagation in mouseInfo is false.
486      */
487     mouseInfo.SetButton(MouseButton::RIGHT_BUTTON);
488     mouseInfo.SetAction(MouseAction::RELEASE);
489     inputHub->showMenu_->onMouseCallback_(mouseInfo);
490     EXPECT_FALSE(mouseInfo.IsStopPropagation());
491 
492     /**
493      * @tc.steps: step5. create mouseInfo, set right param and call BindMenuWithCustomNode;
494      * @tc.expected: StopPropagation in mouseInfo is true.
495      */
496     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
497     PipelineBase::GetCurrentContext()->SetThemeManager(themeManager);
498     PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>());
499     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
500     int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId();
501     const RefPtr<FrameNode> targetNode =
502         FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true);
503     std::vector<OptionParam> param;
504     ViewAbstract::BindMenuWithItems(std::move(param), targetNode, OFFSETF, menuParam);
505     menuParam.type = MenuType::MULTI_MENU;
506     ViewAbstract::BindMenuWithCustomNode(std::move(buildFunc), targetNode, OFFSETF, menuParam,
507         std::move(previewBuildFunc));
508     EXPECT_FALSE(mouseInfo.IsStopPropagation());
509     param.push_back(OptionParam());
510     ViewAbstract::BindMenuWithItems(std::move(param), targetNode, OFFSETF, menuParam);
511     menuParam.type = MenuType::CONTEXT_MENU;
512     ViewAbstract::BindMenuWithCustomNode(std::move(buildFunc), targetNode, OFFSETF, menuParam,
513         std::move(previewBuildFunc));
514     EXPECT_FALSE(mouseInfo.IsStopPropagation());
515 }
516 
517 /**
518  * @tc.name: ViewAbstractTest041
519  * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG
520  * @tc.type: FUNC
521  */
522 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest041, TestSize.Level1)
523 {
524     /**
525      * @tc.steps: step1. creat frameNode and other creat.
526      */
527     int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId();
528     const RefPtr<FrameNode> frameNode =
529         FrameNode::CreateFrameNode("frameNode", nodeId, AceType::MakeRefPtr<Pattern>(), true);
530 
531     auto layoutProperty = frameNode->GetLayoutProperty();
532     CalcSize idealSize = { CalcLength(ZERO), CalcLength(ZERO) };
533     layoutProperty->calcLayoutConstraint_ = std::make_unique<MeasureProperty>();
534     layoutProperty->calcLayoutConstraint_->minSize = idealSize;
535     layoutProperty->calcLayoutConstraint_->maxSize = idealSize;
536     EffectOption option;
537     Color color = Color::TRANSPARENT;
538     option.color = color;
539 
540     std::vector<std::pair<float, float>> fractionStops;
541     fractionStops.push_back(std::pair<float, float>(0.0f, 1.0f));
542     CalcDimension dimensionRadius(0.0);
543     LinearGradientBlurPara blurPara(dimensionRadius, fractionStops, GradientDirection::LEFT);
544     /**
545      * @tc.steps: step2. ResetMinSize test, IsCurrentVisualStateProcess() == false
546      * @tc.expected:call ResetMinSize(),calcLayoutConstraint_ not change
547      */
548     ViewStackProcessor::GetInstance()->SetVisualState(VisualState::DISABLED);
549     ViewAbstract::ResetMinSize(true);
550     ViewAbstract::ResetMinSize(AceType::RawPtr(FRAME_NODE_REGISTER), true);
551     ViewAbstract::ResetMaxSize(true);
552     ViewAbstract::ResetMaxSize(AceType::RawPtr(FRAME_NODE_REGISTER), true);
553     ViewAbstract::SetBackgroundAlign(Alignment::TOP_LEFT);
554     ViewAbstract::SetBackgroundEffect(option);
555     ViewAbstract::SetBackgroundEffect(AceType::RawPtr(FRAME_NODE_REGISTER), option);
556     ViewAbstract::SetDynamicLightUp(0, 0);
557     ViewAbstract::SetDynamicLightUp(AceType::RawPtr(FRAME_NODE_REGISTER), 0, 0);
558     ViewAbstract::SetLinearGradientBlur(blurPara);
559     ViewAbstract::SetLinearGradientBlur(nullptr, blurPara);
560     EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->minSize.has_value());
561     EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->maxSize.has_value());
562 
563     /**
564      * @tc.steps: step3. ResetMinSize test, IsCurrentVisualStateProcess() == true
565      * @tc.expected:call ResetMinSize(),calcLayoutConstraint_->minSize.Width not change
566      */
567     ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
568     ViewAbstract::ResetMinSize(true);
569     ViewAbstract::ResetMaxSize(true);
570     ViewAbstract::SetBackgroundAlign(Alignment::BOTTOM_RIGHT);
571     ViewAbstract::SetBackgroundEffect(option);
572     ViewAbstract::SetDynamicLightUp(0, 0);
573     ViewAbstract::SetLinearGradientBlur(blurPara);
574     ViewAbstract::DisableOnAppear();
575     ViewAbstract::DisableOnAreaChange();
576     ViewAbstract::DisableOnDisAppear();
577     std::vector<DimensionRect> responseRegion;
578     DimensionRect responseRect(Dimension(0), Dimension(0), DimensionOffset(OFFSETF));
579     responseRegion.emplace_back(responseRect);
580     ViewAbstract::SetMouseResponseRegion(responseRegion);
581     ViewAbstract::SetMouseResponseRegion(AceType::RawPtr(FRAME_NODE_REGISTER), responseRegion);
582     EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->minSize.value().Width().has_value());
583     EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->maxSize.value().Width().has_value());
584 }
585 
586 /**
587  * @tc.name: ViewAbstractTest042
588  * @tc.desc: Test the SetKeyboardShortcut of View_Abstract for tab/Up arrow/Down arrow/Left arrow/Right arrow key.
589  * @tc.type: FUNC
590  */
591 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest042, TestSize.Level1)
592 {
593     /**
594      * @tc.steps: step1. Create a FrameNode and get eventManager.
595      */
596     const RefPtr<FrameNode> targetNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true);
597     ViewStackProcessor::GetInstance()->Push(targetNode);
598     auto eventManager = PipelineContext::GetCurrentContext()->GetEventManager();
599     /**
600      * @tc.steps: step2. call SetKeyboardShortcut with tab and ModifierKey.
601      * @tc.expected: add fail
602      */
603     std::vector<ModifierKey> keys;
604     keys.push_back(ModifierKey::SHIFT);
605     ViewAbstract::SetKeyboardShortcut(VALUE_TAB, std::move(keys), callback);
606     EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
607     keys.clear();
608 
609     /**
610      * @tc.steps: step3. call SetKeyboardShortcut with up arrow.
611      * @tc.expected: add success
612      */
613     ViewAbstract::SetKeyboardShortcut(VALUE_DPAD_UP, std::move(keys), callback);
614     EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
615     keys.clear();
616 
617     /**
618      * @tc.steps: step4. call SetKeyboardShortcut with up arrow and ModifierKey.
619      * @tc.expected: add success
620      */
621     keys.push_back(ModifierKey::ALT);
622     ViewAbstract::SetKeyboardShortcut(VALUE_DPAD_UP, std::move(keys), callback);
623     EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
624     keys.clear();
625 
626     /**
627      * @tc.steps: step5. call SetKeyboardShortcut with tab.
628      * @tc.expected: add success
629      */
630 
631     ViewAbstract::SetKeyboardShortcut(VALUE_TAB, std::move(keys), callback);
632     EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
633 }
634 
635 /**
636  * @tc.name: ViewAbstractOffsetEdges001
637  * @tc.desc: test offset attribute, use Edges type.
638  * @tc.type: FUNC
639  */
640 HWTEST_F(ViewAbstractTestNg, ViewAbstractOffset001, TestSize.Level1)
641 {
642     /**
643      * @tc.steps: step1. create and put mainNode, then build some necessary params.
644      */
645     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
646 
647     /**
648      * @tc.steps: step2. get node in ViewStackProcessor.
649      * @tc.expected: node is not null.
650      */
651     auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
652     EXPECT_NE(rootFrameNode, nullptr);
653 
654     /**
655      * @tc.steps: step3. use ViewAbstract::SetOffsetEdges.
656      * @tc.expected: success set render property offsetEdges value.
657      */
658     EdgesParam edges;
659     CalcDimension top(30, DimensionUnit::VP);
660     CalcDimension left(20, DimensionUnit::VP);
661     edges.SetTop(top);
662     edges.SetLeft(left);
663     ViewAbstract::SetOffsetEdges(edges);
664 
665     EXPECT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr);
666     EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext()
667                   ->GetOffsetEdgesValue(EdgesParam {}).top.value_or(Dimension {}).ConvertToVp(), 30.0f);
668     EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext()
669                   ->GetOffsetEdgesValue(EdgesParam {}).left.value_or(Dimension {}).ConvertToVp(), 20.0f);
670 
671     /**
672      * @tc.steps: step5. finish view stack.
673      */
674     ViewStackProcessor::GetInstance()->Finish();
675 }
676 
677 /**
678  * @tc.name: ViewAbstractPositionEdges001
679  * @tc.desc: test position attribute, use Edges type.
680  * @tc.type: FUNC
681  */
682 HWTEST_F(ViewAbstractTestNg, ViewAbstractPositionEdges001, TestSize.Level1)
683 {
684     /**
685      * @tc.steps: step1. create and put mainNode, then build some necessary params.
686      */
687     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
688 
689     /**
690      * @tc.steps: step2. get node in ViewStackProcessor.
691      * @tc.expected: node is not null.
692      */
693     auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
694     EXPECT_NE(rootFrameNode, nullptr);
695 
696     /**
697      * @tc.steps: step3. use ViewAbstract::SetPositionEdges.
698      * @tc.expected: success set render property PositionEdges value.
699      */
700     EdgesParam edges;
701     CalcDimension bottom(30, DimensionUnit::VP);
702     CalcDimension right(20, DimensionUnit::VP);
703     edges.SetBottom(bottom);
704     edges.SetRight(right);
705     ViewAbstract::SetPositionEdges(edges);
706 
707     EXPECT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr);
708     EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext()
709                   ->GetPositionEdgesValue(EdgesParam {}).bottom.value_or(Dimension {}).ConvertToVp(), 30.0f);
710     EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext()
711                   ->GetPositionEdgesValue(EdgesParam {}).right.value_or(Dimension {}).ConvertToVp(), 20.0f);
712 
713     /**
714      * @tc.steps: step5. finish view stack.
715      */
716     ViewStackProcessor::GetInstance()->Finish();
717 }
718 
719 /**
720  * @tc.name: ViewAbstractDisableClickTest
721  * @tc.desc: Test the operation of View_Abstract.
722  * @tc.type: FUNC
723  */
724 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableClickTest, TestSize.Level1)
725 {
726     /**
727      * @tc.steps: step1. create framenode and check callback;
728      * @tc.expected: callback is not null.
729      */
730     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
731     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
732     GestureEventFunc tapEventFunc;
733     ViewAbstract::SetOnClick(std::move(tapEventFunc));
734 
735     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
736     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
737     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
738     ASSERT_NE(frameNode, nullptr);
739     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
740     ASSERT_NE(node, nullptr);
741     auto gestureHub = node->GetOrCreateGestureEventHub();
742     auto& callback = gestureHub->clickEventActuator_->userCallback_;
743     EXPECT_NE(callback, nullptr);
744 
745     /**
746      * @tc.steps: step2. Disable callback.
747      * @tc.expected: callback is null.
748      */
749     ViewAbstract::DisableOnClick();
750     EXPECT_EQ(callback, nullptr);
751 
752     /**
753      * @tc.steps: step3. Add callback again.
754      * @tc.expected: callback is not null.
755      */
756     GestureEventFunc tapEventFunc2;
757     ViewAbstract::SetOnClick(std::move(tapEventFunc2));
758     EXPECT_NE(callback, nullptr);
759     ViewStackProcessor::GetInstance()->instance = nullptr;
760 }
761 
762 /**
763  * @tc.name: ViewAbstractDisableTouchTest
764  * @tc.desc: Test the operation of View_Abstract.
765  * @tc.type: FUNC
766  */
767 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableTouchTest, TestSize.Level1)
768 {
769     /**
770      * @tc.steps: step1. create framenode and check callback;
771      * @tc.expected: callback is not null.
772      */
773     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
774     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
775     TouchEventFunc touchEventFunc;
776     ViewAbstract::SetOnTouch(std::move(touchEventFunc));
777 
778     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
779     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
780     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
781     ASSERT_NE(frameNode, nullptr);
782     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
783     ASSERT_NE(node, nullptr);
784     auto gestureHub = node->GetOrCreateGestureEventHub();
785     auto& callback = gestureHub->touchEventActuator_->userCallback_;
786     EXPECT_NE(callback, nullptr);
787 
788     /**
789      * @tc.steps: step2. Disable callback.
790      * @tc.expected: callback is null.
791      */
792     ViewAbstract::DisableOnTouch();
793     EXPECT_EQ(callback, nullptr);
794 
795     /**
796      * @tc.steps: step3. Add callback again.
797      * @tc.expected: callback is not null.
798      */
799     TouchEventFunc touchEventFunc2;
800     ViewAbstract::SetOnTouch(std::move(touchEventFunc2));
801     EXPECT_NE(callback, nullptr);
802     ViewStackProcessor::GetInstance()->instance = nullptr;
803 }
804 
805 /**
806  * @tc.name: ViewAbstractDisableMouseTest
807  * @tc.desc: Test the operation of View_Abstract.
808  * @tc.type: FUNC
809  */
810 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableMouseTest, TestSize.Level1)
811 {
812     /**
813      * @tc.steps: step1. create framenode and check callback;
814      * @tc.expected: callback is not null.
815      */
816     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
817     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
818     OnMouseEventFunc onMouseEventFunc;
819     ViewAbstract::SetOnMouse(std::move(onMouseEventFunc));
820 
821     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
822     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
823     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
824     ASSERT_NE(frameNode, nullptr);
825     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
826     ASSERT_NE(node, nullptr);
827     auto eventHub = node->GetOrCreateInputEventHub();
828     auto& callback = eventHub->mouseEventActuator_->userCallback_;
829     EXPECT_NE(callback, nullptr);
830 
831     /**
832      * @tc.steps: step2. Disable callback.
833      * @tc.expected: callback is null.
834      */
835     ViewAbstract::DisableOnMouse();
836     EXPECT_EQ(callback, nullptr);
837 
838     /**
839      * @tc.steps: step3. Add callback again.
840      * @tc.expected: callback is not null.
841      */
842     OnMouseEventFunc onMouseEventFunc2;
843     ViewAbstract::SetOnMouse(std::move(onMouseEventFunc2));
844     ViewAbstract::SetJSFrameNodeOnMouse(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onMouseEventFunc2));
845     ViewAbstract::ClearJSFrameNodeOnMouse(AceType::RawPtr(FRAME_NODE_REGISTER));
846     EXPECT_NE(callback, nullptr);
847     ViewStackProcessor::GetInstance()->instance = nullptr;
848 }
849 
850 /**
851  * @tc.name: ViewAbstractDisableHoverTest
852  * @tc.desc: Test the operation of View_Abstract.
853  * @tc.type: FUNC
854  */
855 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableHoverTest, TestSize.Level1)
856 {
857     /**
858      * @tc.steps: step1. create framenode and check callback;
859      * @tc.expected: callback is not null.
860      */
861     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
862     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
863     OnHoverFunc onHoverEventFunc;
864     ViewAbstract::SetOnHover(std::move(onHoverEventFunc));
865 
866     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
867     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
868     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
869     ASSERT_NE(frameNode, nullptr);
870     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
871     ASSERT_NE(node, nullptr);
872     auto eventHub = node->GetOrCreateInputEventHub();
873     auto& callback = eventHub->hoverEventActuator_->userCallback_;
874     EXPECT_NE(callback, nullptr);
875 
876     /**
877      * @tc.steps: step2. Disable callback.
878      * @tc.expected: callback is null.
879      */
880     ViewAbstract::DisableOnHover();
881     EXPECT_EQ(callback, nullptr);
882 
883     /**
884      * @tc.steps: step3. Add callback again.
885      * @tc.expected: callback is not null.
886      */
887     OnHoverFunc onHoverEventFunc2;
888     ViewAbstract::SetOnHover(std::move(onHoverEventFunc2));
889     EXPECT_NE(callback, nullptr);
890     ViewStackProcessor::GetInstance()->instance = nullptr;
891 }
892 
893 /**
894  * @tc.name: ViewAbstractDisableKeyTest
895  * @tc.desc: Test the operation of View_Abstract.
896  * @tc.type: FUNC
897  */
898 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableKeyTest, TestSize.Level1)
899 {
900     /**
901      * @tc.steps: step1. create framenode and check callback;
902      * @tc.expected: callback is not null.
903      */
904     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
905     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
__anon4da86bda0402(KeyEventInfo& info) 906     OnKeyConsumeFunc onKeyCallback = [](KeyEventInfo& info) -> bool { return false; };
907     ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback));
908 
909     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
910     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
911     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
912     ASSERT_NE(frameNode, nullptr);
913     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
914     ASSERT_NE(node, nullptr);
915     auto focusHub = node->GetOrCreateFocusHub();
916     auto& callback = focusHub->focusCallbackEvents_->onKeyEventCallback_;
917     EXPECT_TRUE(callback);
918 
919     /**
920      * @tc.steps: step2. Disable callback.
921      * @tc.expected: callback is null.
922      */
923     ViewAbstract::DisableOnKeyEvent();
924     EXPECT_FALSE(callback);
925 
926     /**
927      * @tc.steps: step3. Add callback again.
928      * @tc.expected: callback is not null.
929      */
__anon4da86bda0502(KeyEventInfo& info) 930     OnKeyConsumeFunc onKeyCallback2 = [](KeyEventInfo& info) -> bool { return false; };
931     ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback2));
932     EXPECT_TRUE(callback);
933     ViewStackProcessor::GetInstance()->instance = nullptr;
934 }
935 
936 /**
937  * @tc.name: ViewAbstractDisableFocusTest
938  * @tc.desc: Test the operation of View_Abstract.
939  * @tc.type: FUNC
940  */
941 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableFocusTest, TestSize.Level1)
942 {
943     /**
944      * @tc.steps: step1. create framenode and check callback;
945      * @tc.expected: callback is not null.
946      */
947     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
948     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
__anon4da86bda0602() 949     OnFocusFunc onFocusCallback = []() {};
950     ViewAbstract::SetOnFocus(std::move(onFocusCallback));
951     ViewAbstract::SetOnFocus(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onFocusCallback));
952     ViewAbstract::SetJSFrameNodeOnFocusCallback(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onFocusCallback));
953     ViewAbstract::ClearJSFrameNodeOnFocusCallback(AceType::RawPtr(FRAME_NODE_REGISTER));
954 
955     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
956     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
957     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
958     ASSERT_NE(frameNode, nullptr);
959     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
960     ASSERT_NE(node, nullptr);
961     auto focusHub = node->GetOrCreateFocusHub();
962     auto& callback = focusHub->focusCallbackEvents_->onFocusCallback_;
963     EXPECT_NE(callback, nullptr);
964 
965     /**
966      * @tc.steps: step2. Disable callback.
967      * @tc.expected: callback is null.
968      */
969     ViewAbstract::DisableOnFocus();
970     EXPECT_EQ(callback, nullptr);
971 
972     /**
973      * @tc.steps: step3. Add callback again.
974      * @tc.expected: callback is not null.
975      */
__anon4da86bda0702() 976     OnFocusFunc onFocusCallback2 = []() {};
977     ViewAbstract::SetOnFocus(std::move(onFocusCallback2));
978     EXPECT_NE(callback, nullptr);
979     ViewStackProcessor::GetInstance()->instance = nullptr;
980 }
981 
982 /**
983  * @tc.name: ViewAbstractDisableBlurTest
984  * @tc.desc: Test the operation of View_Abstract.
985  * @tc.type: FUNC
986  */
987 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableBlurTest, TestSize.Level1)
988 {
989     /**
990      * @tc.steps: step1. create framenode and check callback;
991      * @tc.expected: callback is not null.
992      */
993     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
994     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
__anon4da86bda0802() 995     OnBlurFunc onBlurCallback = []() {};
996     ViewAbstract::SetOnFocus(std::move(onBlurCallback));
997     ViewAbstract::SetJSFrameNodeOnBlurCallback(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onBlurCallback));
998     ViewAbstract::ClearJSFrameNodeOnBlurCallback(AceType::RawPtr(FRAME_NODE_REGISTER));
999 
1000     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1001     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1002     auto frameNodeOne = static_cast<FrameNode*>(ViewAbstract::GetFrameNode());
1003     EXPECT_EQ(strcmp(frameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1004     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1005     ASSERT_NE(frameNode, nullptr);
1006     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1007     ASSERT_NE(node, nullptr);
1008     auto focusHub = node->GetOrCreateFocusHub();
1009     auto& callback = focusHub->focusCallbackEvents_->onBlurCallback_;
1010     EXPECT_FALSE(callback);
1011 
1012     /**
1013      * @tc.steps: step2. Disable callback.
1014      * @tc.expected: callback is null.
1015      */
1016     ViewAbstract::DisableOnBlur();
1017     EXPECT_FALSE(callback);
1018 
1019     /**
1020      * @tc.steps: step3. Add callback again.
1021      * @tc.expected: callback is not null.
1022      */
__anon4da86bda0902() 1023     OnBlurFunc onBlurCallback2 = []() {};
1024     ViewAbstract::SetOnBlur(std::move(onBlurCallback2));
1025     ViewAbstract::SetOnBlur(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onBlurCallback2));
1026     EXPECT_TRUE(callback);
1027     ViewStackProcessor::GetInstance()->instance = nullptr;
1028 }
1029 
1030 /**
1031  * @tc.name: ViewAbstractMonopolizeEvent001
1032  * @tc.desc: View_Abstract set MonopolizeEvent true test
1033  * @tc.type: FUNC
1034  */
1035 HWTEST_F(ViewAbstractTestNg, ViewAbstractMonopolizeEvent001, TestSize.Level1)
1036 {
1037     /**
1038      * @tc.steps: step1. create and put mainNode, then build some necessary params.
1039      */
1040     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1041 
1042     /**
1043      * @tc.steps: step2. set monopolize
1044      */
1045     ViewAbstract::SetMonopolizeEvents(true);
1046     ViewAbstract::SetMonopolizeEvents(AceType::RawPtr(FRAME_NODE_REGISTER), true);
1047 
1048     /**
1049      * @tc.steps: step3. get node in ViewStackProcessor.
1050      * @tc.expected: node is not null.
1051      */
1052     auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1053     EXPECT_NE(rootFrameNode, nullptr);
1054 
1055     /**
1056      * @tc.steps: step4. get monopolizeEvents value of the node.
1057      * @tc.expected: value is equal to true.
1058      */
1059     EXPECT_EQ(rootFrameNode->GetMonopolizeEvents(), true);
1060 
1061     /**
1062      * @tc.steps: step5. finish view stack.
1063      */
1064     ViewStackProcessor::GetInstance()->Finish();
1065 }
1066 
1067 /**
1068  * @tc.name: ViewAbstractMonopolizeEvent002
1069  * @tc.desc: View_Abstract set MonopolizeEvent false test
1070  * @tc.type: FUNC
1071  */
1072 HWTEST_F(ViewAbstractTestNg, ViewAbstractMonopolizeEvent002, TestSize.Level1)
1073 {
1074     /**
1075      * @tc.steps: step1. create and put mainNode, then build some necessary params.
1076      */
1077     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1078 
1079     /**
1080      * @tc.steps: step2. set monopolize
1081      */
1082     ViewAbstract::SetMonopolizeEvents(false);
1083 
1084     /**
1085      * @tc.steps: step3. get node in ViewStackProcessor.
1086      * @tc.expected: node is not null.
1087      */
1088     auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1089     EXPECT_NE(rootFrameNode, nullptr);
1090 
1091     /**
1092      * @tc.steps: step4. get monopolizeEvents value of the node.
1093      * @tc.expected: value is equal to true.
1094      */
1095     EXPECT_EQ(rootFrameNode->GetMonopolizeEvents(), false);
1096 
1097     /**
1098      * @tc.steps: step5. finish view stack.
1099      */
1100     ViewStackProcessor::GetInstance()->Finish();
1101 }
1102 
1103 /**
1104  * @tc.name: ViewAbstractMonopolizeEvent003
1105  * @tc.desc: View_Abstract not set MonopolizeEvent test (use default)
1106  * @tc.type: FUNC
1107  */
1108 HWTEST_F(ViewAbstractTestNg, ViewAbstractMonopolizeEvent003, TestSize.Level1)
1109 {
1110     /**
1111      * @tc.steps: step1. create and put mainNode, then build some necessary params.
1112      */
1113     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1114 
1115     /**
1116      * @tc.steps: step2. get node in ViewStackProcessor.
1117      * @tc.expected: node is not null.
1118      */
1119     auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1120     EXPECT_NE(rootFrameNode, nullptr);
1121 
1122     /**
1123      * @tc.steps: step3. get monopolizeEvents value of the node.
1124      * @tc.expected: value is equal to true.
1125      */
1126     EXPECT_EQ(rootFrameNode->GetMonopolizeEvents(), false);
1127 
1128     /**
1129      * @tc.steps: step5. finish view stack.
1130      */
1131     ViewStackProcessor::GetInstance()->Finish();
1132 }
1133 
1134 /**
1135  * @tc.name: ViewAbstractMenuTransition001
1136  * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG (use dafault)
1137  * @tc.type: FUNC
1138  */
1139 HWTEST_F(ViewAbstractTestNg, ViewAbstractMenuTransition001, TestSize.Level1)
1140 {
1141     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1142     PipelineBase::GetCurrentContext()->SetThemeManager(themeManager);
1143     PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>());
1144     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1145     int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId();
1146     const RefPtr<FrameNode> mainNode =
1147         FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true);
1148     ViewStackProcessor::GetInstance()->Push(mainNode);
1149     auto container = Container::Current();
1150     ASSERT_NE(container, nullptr);
1151     auto pipelineContext = container->GetPipelineContext();
1152     ASSERT_NE(pipelineContext, nullptr);
1153     auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext);
1154     ASSERT_NE(context, nullptr);
1155     auto overlayManager = context->GetOverlayManager();
1156     ASSERT_NE(overlayManager, nullptr);
1157 
1158     ASSERT_NE(SubwindowManager::GetInstance(), nullptr);
__anon4da86bda0a02() 1159     std::function<void()> flagFunc = []() { flag++; };
1160     std::vector<NG::OptionParam> params = {};
1161     std::function<void()> buildFunc;
1162     MenuParam menuParam;
1163     std::function<void()> previewBuildFunc = nullptr;
1164 
1165     menuParam.type = MenuType::MENU;
1166     menuParam.isShow = true;
1167 
1168     auto targetNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode();
1169     ASSERT_NE(targetNode, nullptr);
__anon4da86bda0b02null1170     std::function<void()> action = [] {};
1171     params.emplace_back("MenuItem1", "", action);
1172     params.emplace_back("MenuItem2", "", action);
1173     viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam);
1174     auto targetId = targetNode->GetId();
1175 
1176     auto menuNode = overlayManager->GetMenuNode(targetId);
1177     ASSERT_NE(menuNode, nullptr);
1178     auto wrapperPattern = menuNode->GetPattern<MenuWrapperPattern>();
1179     ASSERT_NE(wrapperPattern, nullptr);
1180     EXPECT_EQ(wrapperPattern->HasTransitionEffect(), false);
1181     EXPECT_EQ(wrapperPattern->HasPreviewTransitionEffect(), false);
1182 }
1183 
1184 /**
1185  * @tc.name: ViewAbstractMenuTransition002
1186  * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG (use true)
1187  * @tc.type: FUNC
1188  */
1189 HWTEST_F(ViewAbstractTestNg, ViewAbstractMenuTransition002, TestSize.Level1)
1190 {
1191     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1192     PipelineBase::GetCurrentContext()->SetThemeManager(themeManager);
1193     PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>());
1194     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1195     int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId();
1196     const RefPtr<FrameNode> mainNode =
1197         FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true);
1198     ViewStackProcessor::GetInstance()->Push(mainNode);
1199     auto container = Container::Current();
1200     ASSERT_NE(container, nullptr);
1201     auto pipelineContext = container->GetPipelineContext();
1202     ASSERT_NE(pipelineContext, nullptr);
1203     auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext);
1204     ASSERT_NE(context, nullptr);
1205     auto overlayManager = context->GetOverlayManager();
1206     ASSERT_NE(overlayManager, nullptr);
1207 
1208     ASSERT_NE(SubwindowManager::GetInstance(), nullptr);
__anon4da86bda0c02() 1209     std::function<void()> flagFunc = []() { flag++; };
1210     std::vector<NG::OptionParam> params = {};
1211     std::function<void()> buildFunc;
1212     MenuParam menuParam;
1213     std::function<void()> previewBuildFunc = nullptr;
1214 
1215     NG::RotateOptions rotate(0.0f, 0.0f, 0.0f, 0.0f, 0.5_pct, 0.5_pct);
1216 
1217     menuParam.hasTransitionEffect = true;
1218     menuParam.hasPreviewTransitionEffect = true;
1219     menuParam.transition = AceType::MakeRefPtr<NG::ChainedRotateEffect>(rotate);
1220     menuParam.previewTransition = AceType::MakeRefPtr<NG::ChainedRotateEffect>(rotate);
1221     menuParam.type = MenuType::MENU;
1222     menuParam.isShow = true;
1223 
1224     auto targetNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode();
1225     ASSERT_NE(targetNode, nullptr);
__anon4da86bda0d02null1226     std::function<void()> action = [] {};
1227     params.emplace_back("MenuItem1", "", action);
1228     params.emplace_back("MenuItem2", "", action);
1229     viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam);
1230     auto targetId = targetNode->GetId();
1231 
1232     auto menuNode = overlayManager->GetMenuNode(targetId);
1233     ASSERT_NE(menuNode, nullptr);
1234     auto wrapperPattern = menuNode->GetPattern<MenuWrapperPattern>();
1235     ASSERT_NE(wrapperPattern, nullptr);
1236     EXPECT_EQ(wrapperPattern->HasTransitionEffect(), true);
1237     EXPECT_EQ(wrapperPattern->HasPreviewTransitionEffect(), true);
1238 }
1239 
1240 /**
1241  * @tc.name: ViewAbstractMenuBorderRadius001
1242  * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG (use true)
1243  * @tc.type: FUNC
1244  */
1245 HWTEST_F(ViewAbstractTestNg, ViewAbstractMenuBorderRadius001, TestSize.Level1)
1246 {
1247     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1248     PipelineBase::GetCurrentContext()->SetThemeManager(themeManager);
1249     PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>());
1250     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1251     int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId();
1252     const RefPtr<FrameNode> mainNode =
1253         FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true);
1254     ViewStackProcessor::GetInstance()->Push(mainNode);
1255     auto container = Container::Current();
1256     ASSERT_NE(container, nullptr);
1257     auto pipelineContext = container->GetPipelineContext();
1258     ASSERT_NE(pipelineContext, nullptr);
1259     auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext);
1260     ASSERT_NE(context, nullptr);
1261     auto overlayManager = context->GetOverlayManager();
1262     ASSERT_NE(overlayManager, nullptr);
1263     ASSERT_NE(SubwindowManager::GetInstance(), nullptr);
1264     std::vector<NG::OptionParam> params = {};
1265     std::function<void()> buildFunc;
1266     MenuParam menuParam;
1267 
1268     menuParam.type = MenuType::MENU;
1269     menuParam.isShow = true;
1270     BorderRadiusProperty borderRadius;
1271     borderRadius.SetRadius(Dimension(16));
1272     menuParam.borderRadius = borderRadius;
1273 
1274     auto targetNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode();
1275     ASSERT_NE(targetNode, nullptr);
__anon4da86bda0e02null1276     std::function<void()> action = [] {};
1277     params.emplace_back("MenuItem1", "", action);
1278     params.emplace_back("MenuItem2", "", action);
1279     viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam);
1280     auto targetId = targetNode->GetId();
1281 
1282     auto menuNode = overlayManager->GetMenuNode(targetId);
1283     ASSERT_NE(menuNode, nullptr);
1284     auto wrapperPattern = menuNode->GetPattern<MenuWrapperPattern>();
1285     ASSERT_NE(wrapperPattern, nullptr);
1286     EXPECT_EQ(wrapperPattern->GetHasCustomRadius(), true);
1287 }
1288 
1289 /**
1290  * @tc.name: ViewAbstractDisableClickByFrameNodeTest
1291  * @tc.desc: Test the operation of View_Abstract.
1292  * @tc.type: FUNC
1293  */
1294 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableClickByFrameNodeTest, TestSize.Level1)
1295 {
1296     /**
1297      * @tc.steps: step1. create framenode and check callback;
1298      * @tc.expected: callback is not null.
1299      */
1300     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1301     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1302 
1303     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1304     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1305     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1306     ASSERT_NE(frameNode, nullptr);
1307     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1308     ASSERT_NE(node, nullptr);
1309     GestureEventFunc tapEventFunc;
1310     ViewAbstract::SetOnClick(AceType::RawPtr(node), std::move(tapEventFunc));
1311     auto gestureHub = node->GetOrCreateGestureEventHub();
1312     auto& callback = gestureHub->clickEventActuator_->userCallback_;
1313     EXPECT_NE(callback, nullptr);
1314 
1315     /**
1316      * @tc.steps: step2. Disable callback.
1317      * @tc.expected: callback is null.
1318      */
1319     ViewAbstract::DisableOnClick(AceType::RawPtr(node));
1320     EXPECT_EQ(callback, nullptr);
1321 }
1322 
1323 /**
1324  * @tc.name: ViewAbstractDisableTouchByFrameNodeTest
1325  * @tc.desc: Test the operation of View_Abstract.
1326  * @tc.type: FUNC
1327  */
1328 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableTouchByFrameNodeTest, TestSize.Level1)
1329 {
1330     /**
1331      * @tc.steps: step1. create framenode and check callback;
1332      * @tc.expected: callback is not null.
1333      */
1334     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1335     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1336 
1337     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1338     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1339     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1340     ASSERT_NE(frameNode, nullptr);
1341     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1342     ASSERT_NE(node, nullptr);
1343     TouchEventFunc touchEventFunc;
1344     ViewAbstract::SetOnTouch(AceType::RawPtr(node), std::move(touchEventFunc));
1345     auto gestureHub = node->GetOrCreateGestureEventHub();
1346     auto& callback = gestureHub->touchEventActuator_->userCallback_;
1347     EXPECT_NE(callback, nullptr);
1348 
1349     /**
1350      * @tc.steps: step2. Disable callback.
1351      * @tc.expected: callback is null.
1352      */
1353     ViewAbstract::DisableOnTouch(AceType::RawPtr(node));
1354     EXPECT_EQ(callback, nullptr);
1355 }
1356 
1357 /**
1358  * @tc.name: ViewAbstractDisableMouseByFrameNodeTest
1359  * @tc.desc: Test the operation of View_Abstract.
1360  * @tc.type: FUNC
1361  */
1362 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableMouseByFrameNodeTest, TestSize.Level1)
1363 {
1364     /**
1365      * @tc.steps: step1. create framenode and check callback;
1366      * @tc.expected: callback is not null.
1367      */
1368     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1369     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1370 
1371     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1372     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1373     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1374     ASSERT_NE(frameNode, nullptr);
1375     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1376     ASSERT_NE(node, nullptr);
1377     OnMouseEventFunc onMouseEventFunc;
1378     ViewAbstract::SetOnMouse(AceType::RawPtr(node), std::move(onMouseEventFunc));
1379     auto eventHub = node->GetOrCreateInputEventHub();
1380     auto& callback = eventHub->mouseEventActuator_->userCallback_;
1381     EXPECT_NE(callback, nullptr);
1382 
1383     /**
1384      * @tc.steps: step2. Disable callback.
1385      * @tc.expected: callback is null.
1386      */
1387     ViewAbstract::DisableOnMouse(AceType::RawPtr(node));
1388     EXPECT_EQ(callback, nullptr);
1389 }
1390 
1391 /**
1392  * @tc.name: ViewAbstractDisableHoverByFrameNodeTest
1393  * @tc.desc: Test the operation of View_Abstract.
1394  * @tc.type: FUNC
1395  */
1396 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableHoverByFrameNodeTest, TestSize.Level1)
1397 {
1398     /**
1399      * @tc.steps: step1. create framenode and check callback;
1400      * @tc.expected: callback is not null.
1401      */
1402     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1403     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1404 
1405     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1406     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1407     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1408     ASSERT_NE(frameNode, nullptr);
1409     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1410     ASSERT_NE(node, nullptr);
1411     OnHoverFunc onHoverEventFunc;
1412     ViewAbstract::SetOnHover(AceType::RawPtr(node), std::move(onHoverEventFunc));
1413     auto eventHub = node->GetOrCreateInputEventHub();
1414     auto& callback = eventHub->hoverEventActuator_->userCallback_;
1415     EXPECT_NE(callback, nullptr);
1416 
1417     /**
1418      * @tc.steps: step2. Disable callback.
1419      * @tc.expected: callback is null.
1420      */
1421     ViewAbstract::DisableOnHover(AceType::RawPtr(node));
1422     EXPECT_EQ(callback, nullptr);
1423 }
1424 
1425 /**
1426  * @tc.name: ViewAbstractDisableKeyByFrameNodeTest
1427  * @tc.desc: Test the operation of View_Abstract.
1428  * @tc.type: FUNC
1429  */
1430 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableKeyByFrameNodeTest, TestSize.Level1)
1431 {
1432     /**
1433      * @tc.steps: step1. create framenode and check callback;
1434      * @tc.expected: callback is not null.
1435      */
1436     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1437     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1438 
1439     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1440     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1441     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1442     ASSERT_NE(frameNode, nullptr);
1443     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1444     ASSERT_NE(node, nullptr);
__anon4da86bda0f02(KeyEventInfo& info) 1445     OnKeyConsumeFunc onKeyCallback = [](KeyEventInfo& info) -> bool { return false; };
1446     ViewAbstract::SetOnKeyEvent(AceType::RawPtr(node), std::move(onKeyCallback));
1447     auto focusHub = node->GetOrCreateFocusHub();
1448     auto& callback = focusHub->focusCallbackEvents_->onKeyEventCallback_;
1449     EXPECT_TRUE(callback);
1450 
1451     /**
1452      * @tc.steps: step2. Disable callback.
1453      * @tc.expected: callback is null.
1454      */
1455     ViewAbstract::DisableOnKeyEvent(AceType::RawPtr(node));
1456     EXPECT_FALSE(callback);
1457 }
1458 
1459 /**
1460  * @tc.name: ViewAbstractDisableFocusByFrameNodeTest
1461  * @tc.desc: Test the operation of View_Abstract.
1462  * @tc.type: FUNC
1463  */
1464 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableFocusByFrameNodeTest, TestSize.Level1)
1465 {
1466     /**
1467      * @tc.steps: step1. create framenode and check callback;
1468      * @tc.expected: callback is not null.
1469      */
1470     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1471     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1472 
1473     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1474     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1475     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1476     ASSERT_NE(frameNode, nullptr);
1477     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1478     ASSERT_NE(node, nullptr);
__anon4da86bda1002() 1479     OnFocusFunc onFocusCallback = []() {};
1480     ViewAbstract::SetOnFocus(AceType::RawPtr(node), std::move(onFocusCallback));
1481     auto focusHub = node->GetOrCreateFocusHub();
1482     auto& callback = focusHub->focusCallbackEvents_->onFocusCallback_;
1483     EXPECT_NE(callback, nullptr);
1484 
1485     /**
1486      * @tc.steps: step2. Disable callback.
1487      * @tc.expected: callback is null.
1488      */
1489     ViewAbstract::DisableOnFocus(AceType::RawPtr(node));
1490     EXPECT_EQ(callback, nullptr);
1491 }
1492 
1493 /**
1494  * @tc.name: ViewAbstractDisableBlurByFrameNodeTest
1495  * @tc.desc: Test the operation of View_Abstract.
1496  * @tc.type: FUNC
1497  */
1498 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableBlurByFrameNodeTest, TestSize.Level1)
1499 {
1500     /**
1501      * @tc.steps: step1. create framenode and check callback;
1502      * @tc.expected: callback is not null.
1503      */
1504     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1505     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1506 
1507     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1508     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1509     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1510     ASSERT_NE(frameNode, nullptr);
1511     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1512     ASSERT_NE(node, nullptr);
__anon4da86bda1102() 1513     OnBlurFunc onBlurCallback = []() {};
1514     ViewAbstract::SetOnBlur(AceType::RawPtr(node), std::move(onBlurCallback));
1515     auto focusHub = node->GetOrCreateFocusHub();
1516     auto& callback = focusHub->focusCallbackEvents_->onBlurCallback_;
1517     EXPECT_TRUE(callback);
1518 
1519     /**
1520      * @tc.steps: step2. Disable callback.
1521      * @tc.expected: callback is null.
1522      */
1523     ViewAbstract::DisableOnBlur(AceType::RawPtr(node));
1524     EXPECT_FALSE(callback);
1525 }
1526 
1527 /**
1528  * @tc.name: ViewAbstractDisableOnAppearByFrameNodeTest
1529  * @tc.desc: Test the operation of View_Abstract.
1530  * @tc.type: FUNC
1531  */
1532 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableOnAppearByFrameNodeTest, TestSize.Level1)
1533 {
1534     /**
1535      * @tc.steps: step1. create framenode and check callback;
1536      * @tc.expected: callback is not null.
1537      */
1538     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1539     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1540 
1541     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1542     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1543     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1544     ASSERT_NE(frameNode, nullptr);
1545     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1546     ASSERT_NE(node, nullptr);
__anon4da86bda1202() 1547     std::function<void()> onAppearCallback = []() {};
1548     ViewAbstract::SetOnAppear(AceType::RawPtr(node), std::move(onAppearCallback));
1549     auto eventHub = node->GetEventHub<EventHub>();
1550     auto& callback = eventHub->onAppear_;
1551     EXPECT_NE(callback, nullptr);
1552 
1553     /**
1554      * @tc.steps: step2. Disable callback.
1555      * @tc.expected: callback is null.
1556      */
1557     ViewAbstract::DisableOnAppear(AceType::RawPtr(node));
1558     EXPECT_EQ(callback, nullptr);
1559 }
1560 
1561 /**
1562  * @tc.name: ViewAbstractDisableOnDisAppearByFrameNodeTest
1563  * @tc.desc: Test the operation of View_Abstract.
1564  * @tc.type: FUNC
1565  */
1566 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableOnDisAppearByFrameNodeTest, TestSize.Level1)
1567 {
1568     /**
1569      * @tc.steps: step1. create framenode and check callback;
1570      * @tc.expected: callback is not null.
1571      */
1572     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1573     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1574 
1575     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1576     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1577     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1578     ASSERT_NE(frameNode, nullptr);
1579     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1580     ASSERT_NE(node, nullptr);
__anon4da86bda1302() 1581     std::function<void()> onDiaAppearCallback = []() {};
1582     ViewAbstract::SetOnDisappear(AceType::RawPtr(node), std::move(onDiaAppearCallback));
1583     auto eventHub = node->GetEventHub<EventHub>();
1584     auto& callback = eventHub->onDisappear_;
1585     EXPECT_NE(callback, nullptr);
1586 
1587     /**
1588      * @tc.steps: step2. Disable callback.
1589      * @tc.expected: callback is null.
1590      */
1591     ViewAbstract::DisableOnDisappear(AceType::RawPtr(node));
1592     EXPECT_EQ(callback, nullptr);
1593 }
1594 
1595 /**
1596  * @tc.name: ViewAbstractDisableOnAreaChangeByFrameNodeTest
1597  * @tc.desc: Test the operation of View_Abstract.
1598  * @tc.type: FUNC
1599  */
1600 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableOnAreaChangeByFrameNodeTest, TestSize.Level1)
1601 {
1602     /**
1603      * @tc.steps: step1. create framenode and check callback;
1604      * @tc.expected: callback is not null.
1605      */
1606     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1607     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1608 
1609     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1610     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1611     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1612     ASSERT_NE(frameNode, nullptr);
1613     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1614     ASSERT_NE(node, nullptr);
1615     std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)>
1616         onAreaChangeCallback =
__anon4da86bda1402(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 1617             [](const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) {};
1618     ViewAbstract::SetOnAreaChanged(AceType::RawPtr(node), std::move(onAreaChangeCallback));
1619     auto eventHub = node->GetEventHub<EventHub>();
1620     auto& callback = eventHub->onAreaChanged_;
1621     EXPECT_NE(callback, nullptr);
1622 
1623     /**
1624      * @tc.steps: step2. Disable callback.
1625      * @tc.expected: callback is null.
1626      */
1627     ViewAbstract::DisableOnAreaChange(AceType::RawPtr(node));
1628     EXPECT_EQ(callback, nullptr);
1629 }
1630 
1631 /**
1632  * @tc.name: ViewAbstractSetOnGestureJudgeBeiginByFrameNodeTest
1633  * @tc.desc: Test the operation of View_Abstract.
1634  * @tc.type: FUNC
1635  */
1636 HWTEST_F(ViewAbstractTestNg, ViewAbstractSetOnGestureJudgeBeiginByFrameNodeTest, TestSize.Level1)
1637 {
1638     /**
1639      * @tc.steps: step1. create framenode and check callback;
1640      * @tc.expected: callback is not null.
1641      */
1642     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1643     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1644 
1645     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1646     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1647     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1648     ASSERT_NE(frameNode, nullptr);
1649     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1650     ASSERT_NE(node, nullptr);
1651     GestureJudgeFunc onGestureJudgeCallback = [](const RefPtr<GestureInfo>& gestureInfo,
__anon4da86bda1502(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 1652                                                   const std::shared_ptr<BaseGestureEvent>& info) {
1653         return GestureJudgeResult::REJECT;
1654     };
1655     ViewAbstract::SetOnGestureJudgeBegin(AceType::RawPtr(node), std::move(onGestureJudgeCallback));
1656     auto gestureHub = node->GetOrCreateGestureEventHub();
1657     auto& callback = gestureHub->gestureJudgeFunc_;
1658     EXPECT_NE(callback, nullptr);
1659 }
1660 
1661 /**
1662  * @tc.name: ViewAbstractSetOnSizeChangeByFrameNodeTest
1663  * @tc.desc: Test the operation of View_Abstract.
1664  * @tc.type: FUNC
1665  */
1666 HWTEST_F(ViewAbstractTestNg, ViewAbstractSetOnSizeChangeByFrameNodeTest, TestSize.Level1)
1667 {
1668     /**
1669      * @tc.steps: step1. create framenode and check callback;
1670      * @tc.expected: callback is not null.
1671      */
1672     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1673     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1674 
1675     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1676     EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1677     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1678     ASSERT_NE(frameNode, nullptr);
1679     auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1680     ASSERT_NE(node, nullptr);
1681     std::function<void(const RectF& oldRect, const RectF& rect)> onSizeChangeCallback = [](const RectF& oldRect,
__anon4da86bda1602(const RectF& oldRect, const RectF& rect) 1682                                                                                             const RectF& rect) {};
1683     ViewAbstract::SetOnSizeChanged(AceType::RawPtr(node), std::move(onSizeChangeCallback));
1684     auto eventHub = node->GetEventHub<EventHub>();
1685     auto& callback = eventHub->onSizeChanged_;
1686     EXPECT_NE(callback, nullptr);
1687 }
1688 
1689 /**
1690  * @tc.name: MotionBlur001
1691  * @tc.desc: SetMotionBlur.
1692  * @tc.type: FUNC
1693  */
1694 HWTEST_F(ViewAbstractTestNg, MotionBlur001, TestSize.Level1)
1695 {
1696     /**
1697      * @tc.steps: step1. create and put mainNode, then build some necessary params.
1698      */
1699     ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1700 
1701     /**
1702      * @tc.steps: step2. get node in ViewStackProcessor.
1703      * @tc.expected: node is not null.
1704      */
1705     auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1706     EXPECT_NE(rootFrameNode, nullptr);
1707 
1708     /**
1709      * @tc.steps: step3. use ViewAbstract::SetMotionBlur.
1710      * @tc.expected: success set render property motionBlur value.
1711      */
1712     MotionBlurOption motionBlurOption;
1713     motionBlurOption.radius = 5;
1714     motionBlurOption.anchor.x = 0.5;
1715     motionBlurOption.anchor.y = 0.5;
1716     ViewAbstract::SetMotionBlur(motionBlurOption);
1717     /**
1718      * @tc.steps: step4. get propMotionBlur value of the node.
1719      * @tc.expected: anchor.x = 0.5, anchor.y = 0.5, radius = 5.
1720      */
1721     EXPECT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr);
1722     EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext()
1723                   ->GetOrCreateForeground()->propMotionBlur->anchor.x, 0.5);
1724     EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext()
1725                   ->GetOrCreateForeground()->propMotionBlur->anchor.y, 0.5);
1726     EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext()
1727                   ->GetOrCreateForeground()->propMotionBlur->radius, 5);
1728 
1729     /**
1730      * @tc.steps: step5. finish view stack.
1731      */
1732     ViewStackProcessor::GetInstance()->Finish();
1733 }
1734 
1735 /**
1736  * @tc.name: SetForegroundEffectTest
1737  * @tc.desc: Test the operation of setting foreground effect with different conditions.
1738  * @tc.type: FUNC
1739  */
1740 HWTEST_F(ViewAbstractTestNg, SetForegroundEffectTest, TestSize.Level1)
1741 {
1742     /**
1743      * @tc.steps: Build a object viewAbstract and set visual state.
1744      */
1745     ViewStackProcessor viewStackProcessor;
1746     int32_t index = 1;
1747     auto state = static_cast<VisualState>(index);
1748     viewStackProcessor.GetInstance()->SetVisualState(state);
1749     auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1750     auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1751     ASSERT_NE(frameNode, nullptr);
1752 
1753     /**
1754      * @tc.steps: Build a object viewAbstract and set visual state.
1755      * @tc.expected: The foreground effect is not changed.
1756      */
1757     auto originValue = frameNode->GetRenderContext()->GetForegroundEffect();
1758     ViewAbstract::SetForegroundEffect(1.1f);
1759     ASSERT_NE(frameNode->GetRenderContext()->GetForegroundEffect(), 1.1f);
1760     ASSERT_EQ(frameNode->GetRenderContext()->GetForegroundEffect(), originValue);
1761 
1762     /**
1763      * @tc.steps: Set visual state to null and check the current visual state process
1764      * @tc.expected: The foreground effect is changed as expected.
1765      */
1766     ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
1767     ViewAbstract::SetForegroundEffect(1.1f);
1768     ASSERT_EQ(frameNode->GetRenderContext()->GetForegroundEffect(), 1.1f);
1769 }
1770 } // namespace OHOS::Ace::NG