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
16 #include "gtest/gtest.h"
17 #define protected public
18 #define private public
19 #include "test/mock/core/common/mock_container.h"
20 #include "test/mock/core/common/mock_theme_manager.h"
21 #include "test/mock/core/pipeline/mock_pipeline_context.h"
22
23 #include "core/interfaces/native/node/api.h"
24 #include "core/components/common/properties/decoration.h"
25 #include "core/components/popup/popup_theme.h"
26 #include "core/components_ng/base/frame_node.h"
27 #include "core/components_ng/base/view_abstract.h"
28 #include "core/components_ng/base/view_abstract_model.h"
29 #include "core/components_ng/base/view_abstract_model_ng.h"
30 #include "core/components_ng/base/view_stack_model.h"
31 #include "core/components_ng/base/view_stack_model_ng.h"
32 #include "core/components_ng/layout/layout_property.h"
33 #include "core/components_ng/pattern/bubble/bubble_pattern.h"
34 #include "core/components_ng/pattern/menu/menu_pattern.h"
35 #include "core/components_ng/pattern/navigation/navigation_model_ng.h"
36 #include "core/components_ng/pattern/navigator/navigator_model_ng.h"
37 #include "core/components_ng/pattern/navrouter/navrouter_model_ng.h"
38 #include "core/components_ng/pattern/picker/datepicker_model_ng.h"
39 #include "core/components_ng/pattern/stepper/stepper_item_model_ng.h"
40 #include "core/components_ng/pattern/text/text_model_ng.h"
41 #include "core/components_ng/property/property.h"
42 #include "core/pipeline/base/element_register.h"
43 #include "frameworks/core/components_ng/pattern/checkboxgroup/checkboxgroup_model_ng.h"
44 #include "frameworks/core/components_ng/pattern/panel/sliding_panel_model_ng.h"
45 #include "frameworks/core/pipeline/base/element.h"
46
47 #undef private
48 #undef protected
49 using namespace testing;
50 using namespace testing::ext;
51
52 namespace OHOS::Ace::NG {
53 namespace {
54 const Dimension WIDTH { 50.0, DimensionUnit::PX };
55 const Dimension HEIGHT { 100.0, DimensionUnit::PX };
56 const Dimension MIN_WIDTH { 10.0, DimensionUnit::PX };
57 const Dimension MIN_HEIGHT { 20.0, DimensionUnit::PX };
58 const Dimension RADIUS { 10.0, DimensionUnit::PX };
59 const Dimension LEFT { 10.0, DimensionUnit::PX };
60 const Dimension TOP { 20.0, DimensionUnit::PX };
61 const Dimension RIGHT { 10.0, DimensionUnit::PX };
62 const Dimension BOTTOM { 20.0, DimensionUnit::PX };
63 const Dimension VALUE { -50.0, DimensionUnit::PX };
64 const Dimension ZERO { 0.0, DimensionUnit::PX };
65 const InvertVariant invert = 0.0f;
66 const OffsetF OFFSETF { 1.0, 1.0 };
67 const Offset OFFSET { 2.0, 2.0 };
68 const float RATIO = 1.0f;
69 const double OPACITYS = 10;
70 const int32_t TEN = 10;
71 const int32_t FOUF = 4;
72 const int32_t INDEX = 1;
73 const Color BLUE = Color(0xff0000ff);
74 const SafeAreaExpandOpts safeAreaExpandOpts = SafeAreaExpandOpts();
75 const std::vector<ObscuredReasons> reasonsVector = { ObscuredReasons::PLACEHOLDER };
76
77 const BackgroundImageSize BACKGROUNDSIZE { BackgroundImageSizeType::AUTO, 1.0 };
78 const BackgroundImagePosition BACKGROUNDPOSITION { BackgroundImagePositionType::PERCENT, -1.0,
79 BackgroundImagePositionType::PERCENT, 0.0 };
80
81 constexpr char TAG_ROOT[] = "root";
82 constexpr char TAG_CHILD[] = "child";
83 const auto MOCK_PATTERN_ROOT = AceType::MakeRefPtr<Pattern>();
84 const auto FRAME_NODE_ROOT = FrameNode::CreateFrameNode(TAG_ROOT, 1, MOCK_PATTERN_ROOT, true);
85 const auto FRAME_NODE_CHILD = FrameNode::CreateFrameNode(TAG_CHILD, 2, MOCK_PATTERN_ROOT, false);
86 const uint32_t REGISTER_ID = 1 << 20;
87 const auto FRAME_NODE_REGISTER = FrameNode::CreateFrameNode(TAG_ROOT, REGISTER_ID, MOCK_PATTERN_ROOT, false);
88
89 std::string srcimages = "common/images/mmm.jpg";
90 const std::string VALUE_EMPTY = "";
91 const std::string VALUE_X = "X";
92 const std::string VALUE_CX = "CX";
93 ViewAbstractModelNG viewAbstractModelNG;
__anonbfd7bfda0202() 94 auto callback = []() { srcimages = "test"; };
95 int32_t flag = 0;
96 const ImageSourceInfo imageSourceInfo = ImageSourceInfo("common/images/mmm.jpg", "abstract", "abstract");
97 }; // namespace
98 class ViewAbstractTestNg : public testing::Test {
99 public:
SetUpTestSuite()100 static void SetUpTestSuite()
101 {
102 MockPipelineContext::SetUp();
103 MockContainer::SetUp();
104 MockContainer::Current()->pipelineContext_ = PipelineBase::GetCurrentContext();
105 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
106 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager);
107 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>());
108 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<PopupTheme>()));
109 }
TearDownTestSuite()110 static void TearDownTestSuite()
111 {
112 MockContainer::Current()->pipelineContext_ = nullptr;
113 MockPipelineContext::TearDown();
114 }
115 };
116
117 /**
118 * @tc.name: ViewAbstractTest001
119 * @tc.desc: Test the operation of View_Abstract
120 * @tc.type: FUNC
121 */
122 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest001, TestSize.Level1)
123 {
124 /**
125 * @tc.steps: step1.The FrameNode is null, related function is called.
126 */
127 ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
128 ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
129 ViewAbstract::SetMinWidth(NG::CalcLength(MIN_WIDTH));
130 ViewAbstract::SetMinHeight(NG::CalcLength(MIN_HEIGHT));
131 ViewAbstract::SetMaxWidth(NG::CalcLength(MIN_WIDTH));
132 ViewAbstract::SetMaxHeight(NG::CalcLength(MIN_HEIGHT));
133 ViewAbstract::ResetAspectRatio();
134 ViewAbstract::ClearWidthOrHeight(true);
135
136 /**
137 * @tc.expected: Return expected results..
138 */
139 EXPECT_EQ(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
140 }
141
142 /**
143 * @tc.name: ViewAbstractTest002
144 * @tc.desc: Test the operation of View_Abstract.
145 * @tc.type: FUNC
146 */
147 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest002, TestSize.Level1)
148 {
149 /**
150 * @tc.steps: step1.push FrameNode is not null, related function is called.
151 */
152 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
153 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
154
155 ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
156 ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
157 ViewAbstract::SetMinWidth(NG::CalcLength(MIN_WIDTH));
158 ViewAbstract::SetMinHeight(NG::CalcLength(MIN_HEIGHT));
159 ViewAbstract::SetMaxWidth(NG::CalcLength(MIN_WIDTH));
160 ViewAbstract::SetMaxHeight(NG::CalcLength(MIN_HEIGHT));
161 ViewAbstract::ResetAspectRatio();
162 ViewAbstract::ClearWidthOrHeight(true);
163
164 /**
165 * @tc.expected: Return expected results..
166 */
167 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
168 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
169 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
170 ASSERT_NE(frameNode, nullptr);
171 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
172 ASSERT_NE(Node, nullptr);
173 auto layoutProperty = Node->GetLayoutProperty();
174 ASSERT_NE(layoutProperty, nullptr);
175 ViewStackProcessor::GetInstance()->instance = nullptr;
176 }
177
178 /**
179 * @tc.name: ViewAbstractTest003
180 * @tc.desc: Test the operation of View_Abstract
181 * @tc.type: FUNC
182 */
183 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest003, TestSize.Level1)
184 {
185 /**
186 * @tc.steps: step1.The FrameNode is null, related function is called.
187 */
188 ViewAbstract::SetAspectRatio(RATIO);
189 ViewAbstract::SetBackgroundColor(BLUE);
190 ViewAbstract::SetBackgroundImage(imageSourceInfo);
191 ViewAbstract::SetBackgroundImageSize(BACKGROUNDSIZE);
192 ViewAbstract::SetBackgroundImagePosition(BACKGROUNDPOSITION);
193 ViewAbstract::SetLayoutWeight(TEN);
194
195 BlurStyleOption blurStyleOption;
196 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
197 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
198 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
199 ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
200
201 std::map<AlignDirection, AlignRule> alignRules;
202 ViewAbstract::SetAlignRules(alignRules);
203 auto repeat = static_cast<ImageRepeat>(INDEX);
204 ViewAbstract::SetBackgroundImageRepeat(repeat);
205 auto direction = static_cast<TextDirection>(INDEX);
206 ViewAbstract::SetLayoutDirection(direction);
207
208 /**
209 * @tc.expected: Return expected results..
210 */
211 EXPECT_EQ(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
212 }
213
214 /**
215 * @tc.name: ViewAbstractTest004
216 * @tc.desc: Test the operation of View_Abstract.
217 * @tc.type: FUNC
218 */
219 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest004, TestSize.Level1)
220 {
221 /**
222 * @tc.steps: step1.push FrameNode is not null, related function is called.
223 */
224 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
225 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
226
227 ViewAbstract::SetAspectRatio(RATIO);
228 ViewAbstract::SetBackgroundColor(BLUE);
229 ViewAbstract::SetBackgroundImage(imageSourceInfo);
230 ViewAbstract::SetBackgroundImageSize(BACKGROUNDSIZE);
231 ViewAbstract::SetBackgroundImagePosition(BACKGROUNDPOSITION);
232 ViewAbstract::SetLayoutWeight(TEN);
233
234 BlurStyleOption blurStyleOption;
235 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
236 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
237 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
238 ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
239
240 std::map<AlignDirection, AlignRule> alignRules;
241 ViewAbstract::SetAlignRules(alignRules);
242 auto repeat = static_cast<ImageRepeat>(INDEX);
243 ViewAbstract::SetBackgroundImageRepeat(repeat);
244 auto direction = static_cast<TextDirection>(INDEX);
245 ViewAbstract::SetLayoutDirection(direction);
246
247 /**
248 * @tc.expected: Return expected results.
249 */
250 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
251 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
252 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
253 ASSERT_NE(frameNode, nullptr);
254 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
255 ASSERT_NE(Node, nullptr);
256 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
257 ASSERT_NE(layoutProperty, nullptr);
258 ViewStackProcessor::GetInstance()->instance = nullptr;
259 }
260
261 /**
262 * @tc.name: ViewAbstractTest005
263 * @tc.desc: Test the operation of View_Abstract
264 * @tc.type: FUNC
265 */
266 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest005, TestSize.Level1)
267 {
268 /**
269 * @tc.steps: step1.The FrameNode is null, related function is called.
270 */
271 auto alignSelf = static_cast<FlexAlign>(INDEX);
272 ViewAbstract::SetAlignSelf(alignSelf);
273 ViewAbstract::SetFlexShrink(RATIO);
274 ViewAbstract::SetFlexGrow(RATIO);
275 ViewAbstract::SetFlexBasis(WIDTH);
276 ViewAbstract::SetDisplayIndex(INDEX);
277
278 ViewAbstract::SetPadding(NG::CalcLength(WIDTH));
279 ViewAbstract::SetMargin(NG::CalcLength(WIDTH));
280 ViewAbstract::SetBorderRadius(WIDTH);
281 ViewAbstract::SetBorderColor(BLUE);
282 ViewAbstract::SetBorderWidth(WIDTH);
283 auto borderStyle = static_cast<BorderStyle>(INDEX);
284 ViewAbstract::SetBorderStyle(borderStyle);
285
286 /**
287 * @tc.expected: Return expected results..
288 */
289 EXPECT_EQ(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
290 }
291
292 /**
293 * @tc.name: ViewAbstractTest006
294 * @tc.desc: Test the operation of View_Abstract.
295 * @tc.type: FUNC
296 */
297 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest006, TestSize.Level1)
298 {
299 /**
300 * @tc.steps: step1.push FrameNode is not null, related function is called.
301 */
302 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
303 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
304
305 auto alignSelf = static_cast<FlexAlign>(INDEX);
306 ViewAbstract::SetAlignSelf(alignSelf);
307 ViewAbstract::SetFlexShrink(RATIO);
308 ViewAbstract::SetFlexGrow(RATIO);
309 ViewAbstract::SetFlexBasis(WIDTH);
310 ViewAbstract::SetDisplayIndex(INDEX);
311
312 ViewAbstract::SetPadding(NG::CalcLength(WIDTH));
313 ViewAbstract::SetMargin(NG::CalcLength(WIDTH));
314 ViewAbstract::SetBorderRadius(WIDTH);
315 ViewAbstract::SetBorderColor(BLUE);
316 ViewAbstract::SetBorderWidth(WIDTH);
317 auto borderStyle = static_cast<BorderStyle>(INDEX);
318 ViewAbstract::SetBorderStyle(borderStyle);
319
320 /**
321 * @tc.expected: Return expected results.
322 */
323 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
324 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
325 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
326 ASSERT_NE(frameNode, nullptr);
327 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
328 ASSERT_NE(Node, nullptr);
329 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
330 ASSERT_NE(layoutProperty, nullptr);
331 ViewStackProcessor::GetInstance()->instance = nullptr;
332 }
333
334 /**
335 * @tc.name: ViewAbstractTest007
336 * @tc.desc: Test the operation of View_Abstract
337 * @tc.type: FUNC
338 */
339 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest007, TestSize.Level1)
340 {
341 /**
342 * @tc.steps: step1.The FrameNode is null, related function is called.
343 */
344 NG::PaddingProperty paddings;
345 ViewAbstract::SetPadding(paddings);
346
347 NG::MarginProperty margins;
348 ViewAbstract::SetMargin(margins);
349
350 NG::BorderRadiusProperty borderRadius;
351 ViewAbstract::SetBorderRadius(borderRadius);
352
353 NG::BorderColorProperty borderColors;
354 ViewAbstract::SetBorderColor(borderColors);
355
356 NG::BorderWidthProperty borderWidth;
357 ViewAbstract::SetBorderWidth(borderWidth);
358
359 NG::BorderStyleProperty borderStyles;
360 ViewAbstract::SetBorderStyle(borderStyles);
361
362 /**
363 * @tc.expected: Return expected results..
364 */
365 EXPECT_EQ(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
366 }
367
368 /**
369 * @tc.name: ViewAbstractTest008
370 * @tc.desc: Test the operation of View_Abstract.
371 * @tc.type: FUNC
372 */
373 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest008, TestSize.Level1)
374 {
375 /**
376 * @tc.steps: step1.push FrameNode is not null, related function is called.
377 */
378 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
379 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
380
381 NG::PaddingProperty paddings;
382 ViewAbstract::SetPadding(paddings);
383
384 NG::MarginProperty margins;
385 ViewAbstract::SetMargin(margins);
386
387 NG::BorderRadiusProperty borderRadius;
388 ViewAbstract::SetBorderRadius(borderRadius);
389
390 NG::BorderColorProperty borderColors;
391 ViewAbstract::SetBorderColor(borderColors);
392
393 NG::BorderWidthProperty borderWidth;
394 ViewAbstract::SetBorderWidth(borderWidth);
395
396 NG::BorderStyleProperty borderStyles;
397 ViewAbstract::SetBorderStyle(borderStyles);
398
399 /**
400 * @tc.expected: Return expected results.
401 */
402 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
403 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
404 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
405 ASSERT_NE(frameNode, nullptr);
406 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
407 ASSERT_NE(Node, nullptr);
408 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
409 ASSERT_NE(layoutProperty, nullptr);
410 ViewStackProcessor::GetInstance()->instance = nullptr;
411 }
412
413 /**
414 * @tc.name: ViewAbstractTest009
415 * @tc.desc: Test the operation of View_Abstract
416 * @tc.type: FUNC
417 */
418 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest009, TestSize.Level1)
419 {
420 /**
421 * @tc.steps: step1.The FrameNode is null, related function is called.
422 */
423 GestureEventFunc tapEventFunc;
424 ViewAbstract::SetOnClick(std::move(tapEventFunc));
425 TouchEventFunc touchEventFunc;
426 ViewAbstract::SetOnTouch(std::move(touchEventFunc));
427 OnMouseEventFunc onMouseEventFunc;
428 ViewAbstract::SetOnMouse(std::move(onMouseEventFunc));
429 OnHoverFunc onHoverEventFunc;
430 ViewAbstract::SetOnHover(std::move(onHoverEventFunc));
431 OnKeyCallbackFunc onKeyCallback;
432 ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback));
433
434 auto hoverEffect = static_cast<HoverEffectType>(INDEX);
435 ViewAbstract::SetHoverEffect(hoverEffect);
436
437 ViewAbstract::SetFocusable(false);
438 ViewAbstract::SetEnabled(false);
439 ViewAbstract::SetOnFocus(callback);
440 ViewAbstract::SetOnBlur(callback);
441
442 /**
443 * @tc.expected: Return expected results.
444 */
445 EXPECT_EQ(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
446 }
447
448 /**
449 * @tc.name: ViewAbstractTest010
450 * @tc.desc: Test the operation of View_Abstract.
451 * @tc.type: FUNC
452 */
453 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest010, TestSize.Level1)
454 {
455 /**
456 * @tc.steps: step1.push FrameNode is not null, related function is called.
457 */
458 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
459 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
460
461 GestureEventFunc tapEventFunc;
462 ViewAbstract::SetOnClick(std::move(tapEventFunc));
463 TouchEventFunc touchEventFunc;
464 ViewAbstract::SetOnTouch(std::move(touchEventFunc));
465 OnMouseEventFunc onMouseEventFunc;
466 ViewAbstract::SetOnMouse(std::move(onMouseEventFunc));
467 OnHoverFunc onHoverEventFunc;
468 ViewAbstract::SetOnHover(std::move(onHoverEventFunc));
469 OnKeyCallbackFunc onKeyCallback;
470 ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback));
471
472 auto hoverEffect = static_cast<HoverEffectType>(INDEX);
473 ViewAbstract::SetHoverEffect(hoverEffect);
474
475 ViewAbstract::SetFocusable(true);
476 ViewAbstract::SetOnFocus(callback);
477 ViewAbstract::SetOnBlur(callback);
478 ViewAbstract::SetFlexBasis(VALUE);
479
480 auto eventHub = AceType::MakeRefPtr<EventHub>();
481 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
482 focusHub->focusable_ = true;
483 focusHub->parentFocusable_ = true;
484 ViewAbstract::SetVisibility(VisibleType::VISIBLE);
485 ViewAbstract::SetEnabled(true);
486
487 /**
488 * @tc.expected: Return expected results.
489 */
490 EXPECT_FALSE(focusHub->IsFocusableScope());
491 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
492 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
493 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
494 ASSERT_NE(frameNode, nullptr);
495 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
496 ASSERT_NE(Node, nullptr);
497 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
498 ASSERT_NE(layoutProperty, nullptr);
499 ViewStackProcessor::GetInstance()->instance = nullptr;
500 }
501
502 /**
503 * @tc.name: ViewAbstractTest011
504 * @tc.desc: Test the operation of View_Abstract
505 * @tc.type: FUNC
506 */
507 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest011, TestSize.Level1)
508 {
509 /**
510 * @tc.steps: step1.The FrameNode is null, related function is called.
511 */
512 ViewAbstract::SetTabIndex(INDEX);
513 ViewAbstract::SetFocusOnTouch(false);
514 ViewAbstract::SetDefaultFocus(false);
515 ViewAbstract::SetGroupDefaultFocus(false);
516 ViewAbstract::SetTouchable(false);
517 ViewAbstract::SetOnAppear(callback);
518 ViewAbstract::SetOnDisappear(callback);
519
520 auto hitTestMode = static_cast<HitTestMode>(INDEX);
521 ViewAbstract::SetHitTestMode(hitTestMode);
522
523 std::vector<DimensionRect> responseRegion;
524 ViewAbstract::SetResponseRegion(std::move(responseRegion));
525 std::function<DragDropInfo(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragStart;
526 ViewAbstract::SetOnDragStart(std::move(onDragStart));
527 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragEnter;
528 ViewAbstract::SetOnDragEnter(std::move(onDragEnter));
529 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragLeave;
530 ViewAbstract::SetOnDragLeave(std::move(onDragLeave));
531 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragMove;
532 ViewAbstract::SetOnDragMove(std::move(onDragMove));
533 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDrop;
534 ViewAbstract::SetOnDrop(std::move(onDrop));
535 Alignment alignment;
536 ViewAbstract::SetAlign(std::move(alignment));
537
538 /**
539 * @tc.expected: Return expected results.
540 */
541 EXPECT_EQ(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
542 }
543
544 /**
545 * @tc.name: ViewAbstractTest012
546 * @tc.desc: Test the operation of View_Abstract.
547 * @tc.type: FUNC
548 */
549 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest012, TestSize.Level1)
550 {
551 /**
552 * @tc.steps: step1.push FrameNode is not null, related function is called.
553 */
554 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
555 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
556
557 ViewAbstract::SetTabIndex(INDEX);
558 ViewAbstract::SetFocusOnTouch(false);
559 ViewAbstract::SetDefaultFocus(false);
560 ViewAbstract::SetGroupDefaultFocus(false);
561 ViewAbstract::SetTouchable(false);
562 ViewAbstract::SetOnAppear(callback);
563 ViewAbstract::SetOnDisappear(callback);
564 auto hitTestMode = static_cast<HitTestMode>(INDEX);
565 ViewAbstract::SetHitTestMode(hitTestMode);
566
567 std::vector<DimensionRect> responseRegion;
568 ViewAbstract::SetResponseRegion(std::move(responseRegion));
569 std::function<DragDropInfo(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragStart;
570 ViewAbstract::SetOnDragStart(std::move(onDragStart));
571 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragEnter;
572 ViewAbstract::SetOnDragEnter(std::move(onDragEnter));
573 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragLeave;
574 ViewAbstract::SetOnDragLeave(std::move(onDragLeave));
575 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragMove;
576 ViewAbstract::SetOnDragMove(std::move(onDragMove));
577 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDrop;
578 ViewAbstract::SetOnDrop(std::move(onDrop));
579 Alignment alignment;
580 ViewAbstract::SetAlign(std::move(alignment));
581
582 /**
583 * @tc.expected: Return expected results.
584 */
585 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
586 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
587 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
588 ASSERT_NE(frameNode, nullptr);
589 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
590 ASSERT_NE(Node, nullptr);
591 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
592 ASSERT_NE(layoutProperty, nullptr);
593 ViewStackProcessor::GetInstance()->instance = nullptr;
594 }
595
596 /**
597 * @tc.name: ViewAbstractTest013
598 * @tc.desc: Test the operation of View_Abstract
599 * @tc.type: FUNC
600 */
601 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest013, TestSize.Level1)
602 {
603 /**
604 * @tc.steps: step1.The FrameNode is null, related function is called.
605 */
606 auto visible = static_cast<VisibleType>(INDEX);
607 ViewAbstract::SetVisibility(std::move(visible));
608 ViewAbstract::SetGeometryTransition(srcimages);
609 ViewAbstract::SetOpacity(OPACITYS);
610 ViewAbstract::SetZIndex(FOUF);
611
612 OffsetT<Dimension> value = { WIDTH, HEIGHT };
613 ViewAbstract::SetPosition(value);
614 ViewAbstract::SetOffset(value);
615 ViewAbstract::MarkAnchor(value);
616 VectorF scale(1.0f, 1.0f);
617 ViewAbstract::SetScale(scale);
618
619 /**
620 * @tc.expected: Return expected results.
621 */
622 EXPECT_EQ(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
623 }
624
625 /**
626 * @tc.name: ViewAbstractTest014
627 * @tc.desc: Test the operation of View_Abstract.
628 * @tc.type: FUNC
629 */
630 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest014, TestSize.Level1)
631 {
632 /**
633 * @tc.steps: step1.push FrameNode is not null, related function is called.
634 */
635 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
636 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
637
638 auto visible = static_cast<VisibleType>(INDEX);
639 ViewAbstract::SetVisibility(std::move(visible));
640 ViewAbstract::SetGeometryTransition(srcimages);
641 ViewAbstract::SetOpacity(OPACITYS);
642 ViewAbstract::SetZIndex(FOUF);
643
644 OffsetT<Dimension> value = { WIDTH, HEIGHT };
645 ViewAbstract::SetPosition(value);
646 ViewAbstract::SetOffset(value);
647 ViewAbstract::MarkAnchor(value);
648 viewAbstractModelNG.SetScale(-1.0f, -1.0f, 0.0f);
649
650 /**
651 * @tc.expected: Return expected results.
652 */
653 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
654 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
655 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
656 ASSERT_NE(frameNode, nullptr);
657 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
658 ASSERT_NE(Node, nullptr);
659 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
660 ASSERT_NE(layoutProperty, nullptr);
661 ViewStackProcessor::GetInstance()->instance = nullptr;
662 }
663
664 /**
665 * @tc.name: ViewAbstractTest015
666 * @tc.desc: Test the operation of View_Abstract
667 * @tc.type: FUNC
668 */
669 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest015, TestSize.Level1)
670 {
671 /**
672 * @tc.steps: step1.The FrameNode is null, related function is called.
673 */
674 viewAbstractModelNG.SetPivot(WIDTH, HEIGHT, WIDTH);
675 NG::TranslateOptions pttions;
676 BlurOption blurOption;
677 ViewAbstract::SetTranslate(std::move(pttions));
678 Matrix4 matrix;
679 ViewAbstract::SetTransformMatrix(std::move(matrix));
680 ViewAbstract::SetBackdropBlur(RADIUS, blurOption);
681 ViewAbstract::SetFrontBlur(RADIUS, blurOption);
682 ViewAbstract::SetInspectorId(srcimages);
683
684 Vector5F scale(1.0f, 1.0f, 2.0f, 2.0f, 0.0f);
685 ViewAbstract::SetRotate(scale);
686 ShadowStyle style { 1 };
687 Shadow shadow { RATIO, OFFSET, BLUE, style };
688 ViewAbstract::SetBackShadow(shadow);
689
690 NG::Gradient gradient;
691 ViewAbstract::SetLinearGradient(std::move(gradient));
692 ViewAbstract::SetSweepGradient(std::move(gradient));
693 ViewAbstract::SetRadialGradient(std::move(gradient));
694
695 /**
696 * @tc.expected: Return expected results.
697 */
698 EXPECT_EQ(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
699 }
700
701 /**
702 * @tc.name: ViewAbstractTest016
703 * @tc.desc: Test the operation of View_Abstract.
704 * @tc.type: FUNC
705 */
706 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest016, TestSize.Level1)
707 {
708 /**
709 * @tc.steps: step1.push FrameNode is not null, related function is called.
710 */
711 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
712 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
713
714 viewAbstractModelNG.SetPivot(WIDTH, HEIGHT, ZERO);
715 NG::TranslateOptions pttions;
716 ViewAbstract::SetTranslate(std::move(pttions));
717 Matrix4 matrix;
718 BlurOption blurOption;
719 ViewAbstract::SetTransformMatrix(std::move(matrix));
720 ViewAbstract::SetBackdropBlur(RADIUS, blurOption);
721 ViewAbstract::SetFrontBlur(RADIUS, blurOption);
722 ViewAbstract::SetInspectorId(srcimages);
723 ViewAbstract::SetDebugLine(srcimages);
724
725 Vector5F scale(1.0f, 1.0f, 2.0f, 2.0f, 0.0f);
726 ViewAbstract::SetRotate(scale);
727 ShadowStyle style { 1 };
728 Shadow shadow { RATIO, OFFSET, BLUE, style };
729 ViewAbstract::SetBackShadow(shadow);
730 NG::Gradient gradient;
731 ViewAbstract::SetLinearGradient(std::move(gradient));
732 ViewAbstract::SetSweepGradient(std::move(gradient));
733 ViewAbstract::SetRadialGradient(std::move(gradient));
734
735 /**
736 * @tc.expected: Return expected results.
737 */
738 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
739 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
740 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
741 ASSERT_NE(frameNode, nullptr);
742 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
743 ASSERT_NE(Node, nullptr);
744 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
745 ASSERT_NE(layoutProperty, nullptr);
746 ViewStackProcessor::GetInstance()->instance = nullptr;
747 }
748
749 /**
750 * @tc.name: ViewAbstractTest017
751 * @tc.desc: Test the operation of View_Abstract
752 * @tc.type: FUNC
753 */
754 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest017, TestSize.Level1)
755 {
756 /**
757 * @tc.steps: step1.The FrameNode is null, related function is called.
758 */
759 auto visible = static_cast<GridSizeType>(INDEX);
760 ViewAbstract::SetGrid(FOUF, FOUF, std::move(visible));
761 TransitionOptions options;
762 ViewAbstract::SetTransition(std::move(options));
763 RefPtr<BasicShape> basicShape;
764 ViewAbstract::SetClipShape(std::move(basicShape));
765 ViewAbstract::SetMask(std::move(basicShape));
766 ViewAbstract::SetClipEdge(false);
767 ViewAbstract::SetGrayScale(RADIUS);
768 ViewAbstract::SetContrast(RADIUS);
769 ViewAbstract::SetSaturate(RADIUS);
770 ViewAbstract::SetSepia(RADIUS);
771 ViewAbstract::SetInvert(invert);
772 ViewAbstract::SetHueRotate(RATIO);
773 ViewAbstract::SetBrightness(RADIUS);
774 ViewAbstract::SetColorBlend(BLUE);
775 ViewAbstract::SetBorderImageSource(srcimages);
776
777 /**
778 * @tc.expected: Return expected results.
779 */
780 EXPECT_EQ(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
781 }
782
783 /**
784 * @tc.name: ViewAbstractTest018
785 * @tc.desc: Test the operation of View_Abstract.
786 * @tc.type: FUNC
787 */
788 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest018, TestSize.Level1)
789 {
790 /**
791 * @tc.steps: step1.push FrameNode is not null, related function is called.
792 */
793 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
794 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
795
796 auto visible = static_cast<GridSizeType>(INDEX);
797 ViewAbstract::SetGrid(FOUF, FOUF, std::move(visible));
798 TransitionOptions options;
799 ViewAbstract::SetTransition(std::move(options));
800 RefPtr<BasicShape> basicShape;
801 ViewAbstract::SetClipShape(std::move(basicShape));
802 ViewAbstract::SetMask(std::move(basicShape));
803 ViewAbstract::SetClipEdge(false);
804 ViewAbstract::SetGrayScale(RADIUS);
805 ViewAbstract::SetContrast(RADIUS);
806 ViewAbstract::SetSaturate(RADIUS);
807 ViewAbstract::SetSepia(RADIUS);
808 ViewAbstract::SetInvert(invert);
809 ViewAbstract::SetHueRotate(RATIO);
810 ViewAbstract::SetBrightness(RADIUS);
811 ViewAbstract::SetColorBlend(BLUE);
812 ViewAbstract::SetBorderImageSource(srcimages);
813
814 /**
815 * @tc.expected: Return expected results.
816 */
817 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
818 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
819 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
820 ASSERT_NE(frameNode, nullptr);
821 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
822 ASSERT_NE(Node, nullptr);
823 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
824 ASSERT_NE(layoutProperty, nullptr);
825 ViewStackProcessor::GetInstance()->instance = nullptr;
826 }
827
828 /**
829 * @tc.name: ViewAbstractTest019
830 * @tc.desc: Test the operation of View_Abstract
831 * @tc.type: FUNC
832 */
833 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest019, TestSize.Level1)
834 {
835 /**
836 * @tc.steps: step1.The FrameNode is null, related function is called.
837 */
838 RefPtr<BorderImage> borderImage;
839 ViewAbstract::SetBorderImage(std::move(borderImage));
840 ViewAbstract::SetHasBorderImageSlice(true);
841 ViewAbstract::SetHasBorderImageWidth(true);
842 ViewAbstract::SetHasBorderImageOutset(true);
843 ViewAbstract::SetHasBorderImageRepeat(true);
844 Gradient gradient;
845 ViewAbstract::SetBorderImageGradient(std::move(gradient));
846 OverlayOptions overlay;
847 ViewAbstract::SetOverlay(std::move(overlay));
848 MotionPathOption motionPath;
849 ViewAbstract::SetMotionPath(std::move(motionPath));
850 ViewAbstract::SetSharedTransition("", nullptr);
851 ViewAbstract::SetSphericalEffect(RATIO);
852 ViewAbstract::SetLightUpEffect(RATIO);
853 ViewAbstract::SetUseEffect(false);
854 ViewAbstract::SetRenderGroup(false);
855 ViewAbstract::SetRenderFit(RenderFit::BOTTOM);
856 ViewAbstract::UpdateSafeAreaExpandOpts(safeAreaExpandOpts);
857 ViewAbstract::SetObscured(reasonsVector);
858
859 /**
860 * @tc.expected: Return expected results.
861 */
862 EXPECT_EQ(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
863 }
864
865 /**
866 * @tc.name: ViewAbstractTest020
867 * @tc.desc: Test the operation of View_Abstract.
868 * @tc.type: FUNC
869 */
870 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest020, TestSize.Level1)
871 {
872 /**
873 * @tc.steps: step1.push FrameNode is not null, related function is called.
874 */
875 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
876 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
877
878 RefPtr<BorderImage> borderImage;
879 ViewAbstract::SetBorderImage(std::move(borderImage));
880 ViewAbstract::SetHasBorderImageSlice(true);
881 ViewAbstract::SetHasBorderImageWidth(true);
882 ViewAbstract::SetHasBorderImageOutset(true);
883 ViewAbstract::SetHasBorderImageRepeat(true);
884 Gradient gradient;
885 ViewAbstract::SetBorderImageGradient(std::move(gradient));
886 OverlayOptions overlay;
887 ViewAbstract::SetOverlay(std::move(overlay));
888 MotionPathOption motionPath;
889 ViewAbstract::SetMotionPath(std::move(motionPath));
890 std::shared_ptr<SharedTransitionOption> option;
891 ViewAbstract::SetSharedTransition(srcimages, std::move(option));
892 ViewAbstract::SetSphericalEffect(RATIO);
893 ViewAbstract::SetLightUpEffect(RATIO);
894 ViewAbstract::SetDraggable(false);
895 ViewAbstract::SetUseEffect(false);
896 ViewAbstract::SetRenderGroup(false);
897 ViewAbstract::SetRenderFit(RenderFit::BOTTOM);
898 ViewAbstract::UpdateSafeAreaExpandOpts(safeAreaExpandOpts);
899 ViewAbstract::SetObscured(reasonsVector);
900
901 /**
902 * @tc.expected: Return expected results.
903 */
904 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
905 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
906 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
907 ASSERT_NE(frameNode, nullptr);
908 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
909 ASSERT_NE(Node, nullptr);
910 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
911 ASSERT_NE(layoutProperty, nullptr);
912 ViewStackProcessor::GetInstance()->instance = nullptr;
913 }
914
915 /**
916 * @tc.name: ViewAbstractTest021
917 * @tc.desc: Test the operation of View_Abstract
918 * @tc.type: FUNC
919 */
920 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest021, TestSize.Level1)
921 {
922 /**
923 * @tc.steps: step1.The FrameNode is null, related function is called.
924 */
925 PixStretchEffectOption option;
926 option.bottom = BOTTOM;
927 option.left = LEFT;
928 option.right = RIGHT;
929 option.top = TOP;
930 ViewAbstract::SetPixelStretchEffect(option);
931 RefPtr<NG::ChainedTransitionEffect> effect;
932 ViewAbstract::SetChainedTransition(std::move(effect));
933 RefPtr<ProgressMaskProperty> progress;
934 ViewAbstract::SetProgressMask(std::move(progress));
935
936 ViewAbstract::SetForegroundColor(BLUE);
937 auto strategy = static_cast<ForegroundColorStrategy>(INDEX);
938 ViewAbstract::SetForegroundColorStrategy(std::move(strategy));
939 auto hoverEffect = static_cast<HoverEffectType>(INDEX);
940 ViewAbstract::SetHoverEffectAuto(hoverEffect);
941 ViewAbstract::SetDraggable(true);
942
943 /**
944 * @tc.expected: Return expected results.
945 */
946 EXPECT_EQ(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
947 }
948
949 /**
950 * @tc.name: ViewAbstractTest022
951 * @tc.desc: Test the operation of View_Abstract.
952 * @tc.type: FUNC
953 */
954 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest022, TestSize.Level1)
955 {
956 /**
957 * @tc.steps: step1.push FrameNode is not null, related function is called.
958 */
959 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
960 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
961
962 PixStretchEffectOption option;
963 option.bottom = BOTTOM;
964 option.left = LEFT;
965 option.right = RIGHT;
966 option.top = TOP;
967 ViewAbstract::SetPixelStretchEffect(option);
968 RefPtr<NG::ChainedTransitionEffect> effect;
969 ViewAbstract::SetChainedTransition(std::move(effect));
970 RefPtr<ProgressMaskProperty> progress;
971 ViewAbstract::SetProgressMask(std::move(progress));
972 ViewAbstract::SetForegroundColor(BLUE);
973 auto strategy = static_cast<ForegroundColorStrategy>(INDEX);
974 ViewAbstract::SetForegroundColorStrategy(std::move(strategy));
975 ViewAbstract::SetBorderWidth(VALUE);
976 ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
977 ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
978 auto hoverEffect = static_cast<HoverEffectType>(INDEX);
979 ViewAbstract::SetHoverEffectAuto(hoverEffect);
980 ViewAbstract::SetDraggable(true);
981
982 /**
983 * @tc.expected: Return expected results.
984 */
985 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
986 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
987 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
988 ASSERT_NE(frameNode, nullptr);
989 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
990 ASSERT_NE(Node, nullptr);
991 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
992 ASSERT_NE(layoutProperty, nullptr);
993 ViewStackProcessor::GetInstance()->instance = nullptr;
994 }
995
996 /**
997 * @tc.name: ViewAbstractTest023
998 * @tc.desc: Test the operation of View_Abstract
999 * @tc.type: FUNC
1000 */
1001 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest023, TestSize.Level1)
1002 {
1003 /**
1004 * @tc.steps: step1.The FrameNode is null, related function is called.
1005 */
1006 std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)>
1007 onAreaChanged;
1008 ViewAbstract::SetOnAreaChanged(std::move(onAreaChanged));
1009 std::function<void(bool, double)> onVisibleChange;
1010 const std::vector<double> ratios;
1011 ViewAbstract::SetOnVisibleChange(std::move(onVisibleChange), ratios);
1012
1013 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&)> onDragEnd;
1014 ViewAbstract::SetOnDragEnd(std::move(onDragEnd));
1015 std::set<std::string> allowDrop;
1016 ViewAbstract::SetAllowDrop(std::move(allowDrop));
1017 ViewAbstract::CreateAnimatablePropertyFloat(srcimages, RATIO, nullptr);
1018 ViewAbstract::UpdateAnimatablePropertyFloat(srcimages, RATIO);
1019 ViewAbstract::SetRestoreId(TEN);
1020
1021 /**
1022 * @tc.expected: Return expected results.
1023 */
1024 EXPECT_EQ(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
1025 }
1026
1027 /**
1028 * @tc.name: ViewAbstractTest024
1029 * @tc.desc: Test the operation of View_Abstract.
1030 * @tc.type: FUNC
1031 */
1032 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest024, TestSize.Level1)
1033 {
1034 /**
1035 * @tc.steps: step1.push FrameNode is not null, related function is called.
1036 */
1037 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1038 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1039
1040 std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)>
1041 onAreaChanged;
1042 ViewAbstract::SetOnAreaChanged(std::move(onAreaChanged));
1043 std::function<void(bool, double)> onVisibleChange;
1044 const std::vector<double> ratios;
1045 ViewAbstract::SetOnVisibleChange(std::move(onVisibleChange), ratios);
1046 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&)> onDragEnd;
1047 ViewAbstract::SetOnDragEnd(std::move(onDragEnd));
1048 std::set<std::string> allowDrop;
1049 ViewAbstract::SetAllowDrop(std::move(allowDrop));
1050 ViewAbstract::CreateAnimatablePropertyFloat(srcimages, RATIO, nullptr);
1051 ViewAbstract::UpdateAnimatablePropertyFloat(srcimages, RATIO);
1052 ViewAbstract::SetRestoreId(TEN);
1053
1054 /**
1055 * @tc.expected: Return expected results.
1056 */
1057 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1058 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1059 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1060 ASSERT_NE(frameNode, nullptr);
1061 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1062 ASSERT_NE(Node, nullptr);
1063 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1064 ASSERT_NE(layoutProperty, nullptr);
1065 ViewStackProcessor::GetInstance()->instance = nullptr;
1066 }
1067
1068 /**
1069 * @tc.name: ViewAbstractTest025
1070 * @tc.desc: Test the BindPopup of View_Abstract.
1071 * @tc.type: FUNC
1072 */
1073 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest025, TestSize.Level1)
1074 {
1075 /**
1076 * @tc.steps: step1. Create some FrameNode and params.
1077 */
1078 const RefPtr<FrameNode> customNode = FrameNode::CreateFrameNode("one", 1, AceType::MakeRefPtr<Pattern>(), true);
1079 const RefPtr<FrameNode> targetNode = FrameNode::CreateFrameNode("two", 2, AceType::MakeRefPtr<Pattern>());
1080 const RefPtr<FrameNode> targetNode2 = FrameNode::CreateFrameNode("three", 3, AceType::MakeRefPtr<Pattern>());
1081 auto param = AceType::MakeRefPtr<PopupParam>();
1082 auto param2 = AceType::MakeRefPtr<PopupParam>();
1083
1084 /**
1085 * @tc.steps: step2. get popupInfo and change some params.
1086 */
1087 auto container = Container::Current();
1088 ASSERT_NE(container, nullptr);
1089 auto pipelineContext = container->GetPipelineContext();
1090 ASSERT_NE(pipelineContext, nullptr);
1091 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext);
1092 ASSERT_NE(context, nullptr);
1093 auto overlayManager = context->GetOverlayManager();
1094 ASSERT_NE(overlayManager, nullptr);
1095 auto nodeId = targetNode->GetId();
1096 PopupInfo info = overlayManager->GetPopupInfo(nodeId);
1097 info.isCurrentOnShow = true;
1098 info.popupId = 1;
1099 auto popupNode1 = FrameNode::CreateFrameNode(
1100 V2::POPUP_ETS_TAG, info.popupId, AceType::MakeRefPtr<BubblePattern>(targetNode->GetId(), targetNode->GetTag()));
1101 info.popupNode = popupNode1;
1102 overlayManager->ShowPopup(targetNode->GetId(), info);
1103
1104 /**
1105 * @tc.steps: step3. Call BindPopup many times.
1106 * @tc.expected: popupNode in overlayManager of targetNode not null
1107 */
1108 ViewAbstract::BindPopup(param, targetNode, customNode);
1109 ViewAbstract::BindPopup(param, targetNode, customNode);
1110 auto popupInfo = overlayManager->GetPopupInfo(targetNode->GetId());
1111 auto popupNode = FrameNode::CreateFrameNode(
1112 V2::POPUP_ETS_TAG, popupInfo.popupId, AceType::MakeRefPtr<BubblePattern>(nodeId, targetNode->GetTag()));
1113 ASSERT_NE(popupNode, nullptr);
1114 popupNode->GetPattern<BubblePattern>()->transitionStatus_ = TransitionStatus::ENTERING;
1115 ViewAbstract::BindPopup(param, targetNode, customNode);
1116 param->SetIsShow(false);
1117 ViewAbstract::BindPopup(param, targetNode, customNode);
1118 param->SetShowInSubWindow(true);
1119 ViewAbstract::BindPopup(param, targetNode, customNode);
1120 EXPECT_FALSE(overlayManager->GetPopupInfo(targetNode->GetId()).isCurrentOnShow);
1121
1122 /**
1123 * @tc.steps: step4. Call BindPopup with param use custom.
1124 * @tc.expected: popupNode in overlayManager of targetNode not null
1125 */
1126 param2->SetUseCustomComponent(true);
1127 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1128 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1129 param2->SetShowInSubWindow(true);
1130 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1131 param2->SetIsShow(false);
1132 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1133 EXPECT_FALSE(overlayManager->GetPopupInfo(targetNode->GetId()).isCurrentOnShow);
1134 }
1135
1136 /**
1137 * @tc.name: ViewAbstractTest026
1138 * @tc.desc: Test the SetKeyboardShortcut of View_Abstract.
1139 * @tc.type: FUNC
1140 */
1141 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest026, TestSize.Level1)
1142 {
1143 /**
1144 * @tc.steps: step1. Create a FrameNode and get eventManager.
1145 */
1146 const RefPtr<FrameNode> targetNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true);
1147 ViewStackProcessor::GetInstance()->Push(targetNode);
1148 auto eventManager = PipelineContext::GetCurrentContext()->GetEventManager();
1149 /**
1150 * @tc.steps: step2. call SetKeyboardShortcut with ctrl + x.
1151 * @tc.expected: add fail
1152 */
1153 std::vector<ModifierKey> keys;
1154 keys.push_back(ModifierKey::CTRL);
1155 ViewAbstract::SetKeyboardShortcut(VALUE_X, std::move(keys), callback);
1156 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 0);
1157 keys.clear();
1158 /**
1159 * @tc.steps: step3. call SetKeyboardShortcut with other wrong type.
1160 * @tc.expected: add fail
1161 */
1162 ViewAbstract::SetKeyboardShortcut(VALUE_EMPTY, std::move(keys), callback);
1163 ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1164 ViewAbstract::SetKeyboardShortcut(VALUE_X, std::move(keys), callback);
1165
1166 /**
1167 * @tc.steps: step4. and shift in keys and recall SetKeyboardShortcut .
1168 * @tc.expected: add success
1169 */
1170 keys.push_back(ModifierKey::ALT);
1171 ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1172 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1173
1174 /**
1175 * @tc.steps: step5. make other key and recall SetKeyboardShortcut .
1176 * @tc.expected: add fail
1177 */
1178 keys.push_back(ModifierKey::SHIFT);
1179 ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1180 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1181 keys.push_back(ModifierKey::ALT);
1182 ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1183 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1184 }
1185
1186 /**
1187 * @tc.name: ViewAbstractTest027
1188 * @tc.desc: Test the operation of View_Abstract.
1189 * @tc.type: FUNC
1190 */
1191 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest027, TestSize.Level1)
1192 {
1193 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1194 /**
1195 * @tc.steps: step1. callback ShowMenu with two condition.
1196 */
1197 ContainerScope sontainerScope(1);
1198 ViewAbstract::ShowMenu(INDEX, OFFSETF, false);
1199 ViewAbstract::ShowMenu(INDEX, OFFSETF, true);
1200 /**
1201 * @tc.steps: step2. callback SetForegroundBlurStyle and ResetFlexShrink.
1202 */
1203 BlurStyleOption bgBlurStyle;
1204 ViewAbstract::SetForegroundBlurStyle(bgBlurStyle);
1205 ViewAbstract::ResetFlexShrink();
1206 /**
1207 * @tc.steps: step3. SetVisualState in ViewStackProcessor and recall the two function.
1208 * @tc.expected: the blur radius in render context meet expectations.
1209 */
1210 ViewStackProcessor::GetInstance()->SetVisualState(VisualState::FOCUSED);
1211 ViewAbstract::SetForegroundBlurStyle(bgBlurStyle);
1212 ViewAbstract::ResetFlexShrink();
1213 ASSERT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr);
1214 EXPECT_FALSE(FRAME_NODE_ROOT->GetRenderContext()->GetFrontBlurRadius().has_value());
1215 }
1216
1217 /**
1218 * @tc.name: ViewAbstractTest028
1219 * @tc.desc: Test the operation of View_Abstract.
1220 * @tc.type: FUNC
1221 */
1222 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest028, TestSize.Level1)
1223 {
1224 /**
1225 * @tc.steps: step1.push FrameNode is not null, callback Pop function.
1226 */
1227 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1228 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1229 ViewAbstract::Pop();
1230
1231 /**
1232 * @tc.expected: Return expected results.
1233 */
1234 EXPECT_FALSE(ViewStackProcessor::GetInstance()->elementsStack_.empty());
1235 EXPECT_EQ(ViewStackProcessor::GetInstance()->elementsStack_.size(), INDEX);
1236 }
1237
1238 /**
1239 * @tc.name: ViewAbstractTest029
1240 * @tc.desc: Test the operation of View_Abstract
1241 * @tc.type: FUNC
1242 */
1243 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest029, TestSize.Level1)
1244 {
1245 /**
1246 * @tc.steps: step1.ClearStack.
1247 */
1248 auto state = static_cast<VisualState>(INDEX);
1249 ViewStackProcessor::GetInstance()->SetVisualState(state);
1250 ViewStackProcessor::GetInstance()->ClearStack();
1251
1252 /**
1253 * @tc.steps: step2. related function is called.
1254 */
1255 ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
1256 ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
1257 ViewAbstract::SetMinWidth(NG::CalcLength(MIN_WIDTH));
1258 ViewAbstract::SetMinHeight(NG::CalcLength(MIN_HEIGHT));
1259 ViewAbstract::SetMaxWidth(NG::CalcLength(MIN_WIDTH));
1260 ViewAbstract::SetMaxHeight(NG::CalcLength(MIN_HEIGHT));
1261 ViewAbstract::SetAspectRatio(RATIO);
1262 ViewAbstract::SetBackgroundColor(BLUE);
1263 ViewAbstract::SetBackgroundImage(imageSourceInfo);
1264 ViewAbstract::SetBackgroundImageSize(BACKGROUNDSIZE);
1265 ViewAbstract::SetBackgroundImagePosition(BACKGROUNDPOSITION);
1266 ViewAbstract::ResetAspectRatio();
1267
1268 /**
1269 * @tc.expected: Return expected results.
1270 */
1271 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1272 EXPECT_FALSE(result);
1273 }
1274
1275 /**
1276 * @tc.name: ViewAbstractTest030
1277 * @tc.desc: Test the operation of View_Abstract
1278 * @tc.type: FUNC
1279 */
1280 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest030, TestSize.Level1)
1281 {
1282 /**
1283 * @tc.steps: step1.ClearStack.
1284 */
1285 auto state = static_cast<VisualState>(INDEX);
1286 ViewStackProcessor::GetInstance()->SetVisualState(state);
1287 ViewStackProcessor::GetInstance()->ClearStack();
1288
1289 /**
1290 * @tc.steps: step2. related function is called.
1291 */
1292 MotionPathOption motionPath;
1293 ViewAbstract::SetMotionPath(std::move(motionPath));
1294 auto repeat = static_cast<ImageRepeat>(INDEX);
1295 ViewAbstract::SetBackgroundImageRepeat(repeat);
1296
1297 BlurStyleOption blurStyleOption;
1298 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
1299 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
1300 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
1301 ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
1302
1303 auto direction = static_cast<TextDirection>(INDEX);
1304 ViewAbstract::SetLayoutDirection(direction);
1305 std::map<AlignDirection, AlignRule> alignRules;
1306 ViewAbstract::SetAlignRules(alignRules);
1307 auto alignSelf = static_cast<FlexAlign>(INDEX);
1308 ViewAbstract::SetAlignSelf(alignSelf);
1309
1310 /**
1311 * @tc.expected: Return expected results.
1312 */
1313 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1314 EXPECT_FALSE(result);
1315 }
1316
1317 /**
1318 * @tc.name: ViewAbstractTest031
1319 * @tc.desc: Test the operation of View_Abstract
1320 * @tc.type: FUNC
1321 */
1322 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest031, TestSize.Level1)
1323 {
1324 /**
1325 * @tc.steps: step1.ClearStack.
1326 */
1327 auto state = static_cast<VisualState>(INDEX);
1328 ViewStackProcessor::GetInstance()->SetVisualState(state);
1329 ViewStackProcessor::GetInstance()->ClearStack();
1330
1331 /**
1332 * @tc.steps: step2. related function is called.
1333 */
1334 ViewAbstract::SetFlexShrink(RATIO);
1335 ViewAbstract::SetFlexGrow(RATIO);
1336 ViewAbstract::SetFlexBasis(WIDTH);
1337 ViewAbstract::SetDisplayIndex(TEN);
1338 ViewAbstract::SetZIndex(FOUF);
1339
1340 Alignment alignment;
1341 ViewAbstract::SetAlign(std::move(alignment));
1342 auto visible = static_cast<VisibleType>(INDEX);
1343 ViewAbstract::SetVisibility(std::move(visible));
1344 ViewAbstract::SetOpacity(OPACITYS);
1345
1346 /**
1347 * @tc.expected: Return expected results.
1348 */
1349 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1350 EXPECT_FALSE(result);
1351 }
1352
1353 /**
1354 * @tc.name: ViewAbstractTest032
1355 * @tc.desc: Test the operation of View_Abstract
1356 * @tc.type: FUNC
1357 */
1358 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest032, TestSize.Level1)
1359 {
1360 /**
1361 * @tc.steps: step1.ClearStack.
1362 */
1363 auto state = static_cast<VisualState>(INDEX);
1364 ViewStackProcessor::GetInstance()->SetVisualState(state);
1365 ViewStackProcessor::GetInstance()->ClearStack();
1366
1367 /**
1368 * @tc.steps: step2. related function is called.
1369 */
1370 OffsetT<Dimension> values = { WIDTH, HEIGHT };
1371 ViewAbstract::SetPosition(values);
1372 ViewAbstract::SetOffset(values);
1373 ViewAbstract::MarkAnchor(values);
1374
1375 ViewAbstract::SetPadding(NG::CalcLength(WIDTH));
1376 ViewAbstract::SetMargin(NG::CalcLength(WIDTH));
1377 ViewAbstract::SetBorderRadius(WIDTH);
1378 ViewAbstract::SetBorderColor(BLUE);
1379 ViewAbstract::SetBorderWidth(WIDTH);
1380
1381 auto borderStyle = static_cast<BorderStyle>(INDEX);
1382 ViewAbstract::SetBorderStyle(borderStyle);
1383
1384 /**
1385 * @tc.expected: Return expected results.
1386 */
1387 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1388 EXPECT_FALSE(result);
1389 }
1390
1391 /**
1392 * @tc.name: ViewAbstractTest033
1393 * @tc.desc: Test the operation of View_Abstract
1394 * @tc.type: FUNC
1395 */
1396 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest033, TestSize.Level1)
1397 {
1398 /**
1399 * @tc.steps: step1.ClearStack.
1400 */
1401 auto state = static_cast<VisualState>(INDEX);
1402 ViewStackProcessor::GetInstance()->SetVisualState(state);
1403 ViewStackProcessor::GetInstance()->ClearStack();
1404
1405 /**
1406 * @tc.steps: step2. related function is called.
1407 */
1408 OffsetT<Dimension> values = { WIDTH, HEIGHT };
1409 ViewAbstract::SetPosition(values);
1410 ViewAbstract::SetOffset(values);
1411 ViewAbstract::MarkAnchor(values);
1412
1413 NG::PaddingProperty paddings;
1414 ViewAbstract::SetPadding(paddings);
1415
1416 NG::MarginProperty margins;
1417 ViewAbstract::SetMargin(margins);
1418
1419 NG::BorderRadiusProperty borderRadius;
1420 ViewAbstract::SetBorderRadius(borderRadius);
1421
1422 NG::BorderColorProperty borderColors;
1423 ViewAbstract::SetBorderColor(borderColors);
1424
1425 NG::BorderWidthProperty borderWidth;
1426 ViewAbstract::SetBorderWidth(borderWidth);
1427
1428 NG::BorderStyleProperty borderStyles;
1429 ViewAbstract::SetBorderStyle(borderStyles);
1430
1431 /**
1432 * @tc.expected: Return expected results.
1433 */
1434 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1435 EXPECT_FALSE(result);
1436 }
1437
1438 /**
1439 * @tc.name: ViewAbstractTest034
1440 * @tc.desc: Test the operation of View_Abstract
1441 * @tc.type: FUNC
1442 */
1443 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest034, TestSize.Level1)
1444 {
1445 /**
1446 * @tc.steps: step1.ClearStack.
1447 */
1448 auto state = static_cast<VisualState>(INDEX);
1449 ViewStackProcessor::GetInstance()->SetVisualState(state);
1450 ViewStackProcessor::GetInstance()->ClearStack();
1451
1452 /**
1453 * @tc.steps: step2. related function is called.
1454 */
1455 BlurOption blurOption;
1456 ViewAbstract::SetBrightness(RADIUS);
1457 ViewAbstract::SetGrayScale(RADIUS);
1458 ViewAbstract::SetContrast(RADIUS);
1459 ViewAbstract::SetSaturate(RADIUS);
1460 ViewAbstract::SetSepia(RADIUS);
1461 ViewAbstract::SetInvert(invert);
1462 ViewAbstract::SetHueRotate(RATIO);
1463 ViewAbstract::SetColorBlend(BLUE);
1464 ViewAbstract::SetBackdropBlur(RADIUS, blurOption);
1465 ViewAbstract::SetFrontBlur(RADIUS, blurOption);
1466 ViewAbstract::SetClipEdge(false);
1467
1468 /**
1469 * @tc.expected: Return expected results.
1470 */
1471 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1472 EXPECT_FALSE(result);
1473 }
1474
1475 /**
1476 * @tc.name: ViewAbstractTest035
1477 * @tc.desc: Test the operation of View_Abstract
1478 * @tc.type: FUNC
1479 */
1480 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest035, TestSize.Level1)
1481 {
1482 /**
1483 * @tc.steps: step1.ClearStack.
1484 */
1485 auto state = static_cast<VisualState>(INDEX);
1486 ViewStackProcessor::GetInstance()->SetVisualState(state);
1487 ViewStackProcessor::GetInstance()->ClearStack();
1488
1489 /**
1490 * @tc.steps: step2. related function is called.
1491 */
1492 viewAbstractModelNG.SetScale(1.0f, 1.0f, 0.0f);
1493 DimensionOffset value = { WIDTH, HEIGHT };
1494 viewAbstractModelNG.SetPivot(WIDTH, HEIGHT, ZERO);
1495 NG::TranslateOptions values;
1496 ViewAbstract::SetTranslate(std::move(values));
1497 Vector5F scales(1.0f, 1.0f, 2.0f, 2.0f, 0.0f);
1498 ViewAbstract::SetRotate(scales);
1499 Matrix4 matrix;
1500 ViewAbstract::SetTransformMatrix(std::move(matrix));
1501
1502 ShadowStyle style { 1 };
1503 Shadow shadow { RATIO, OFFSET, BLUE, style };
1504 ViewAbstract::SetBackShadow(shadow);
1505 NG::Gradient gradient;
1506 ViewAbstract::SetLinearGradient(std::move(gradient));
1507 ViewAbstract::SetSweepGradient(std::move(gradient));
1508 ViewAbstract::SetRadialGradient(std::move(gradient));
1509 TransitionOptions options;
1510 ViewAbstract::SetTransition(std::move(options));
1511 RefPtr<BasicShape> basicShape;
1512 ViewAbstract::SetClipShape(std::move(basicShape));
1513 ViewAbstract::SetMask(std::move(basicShape));
1514
1515 /**
1516 * @tc.expected: Return expected results.
1517 */
1518 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1519 EXPECT_FALSE(result);
1520 }
1521
1522 /**
1523 * @tc.name: ViewAbstractTest036
1524 * @tc.desc: Test the operation of View_Abstract
1525 * @tc.type: FUNC
1526 */
1527 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest036, TestSize.Level1)
1528 {
1529 /**
1530 * @tc.steps: step1.ClearStack.
1531 */
1532 auto state = static_cast<VisualState>(INDEX);
1533 ViewStackProcessor::GetInstance()->SetVisualState(state);
1534 ViewStackProcessor::GetInstance()->ClearStack();
1535
1536 /**
1537 * @tc.steps: step2. related function is called.
1538 */
1539 ViewAbstract::SetBorderImageSource(srcimages);
1540 ViewAbstract::SetHasBorderImageSlice(false);
1541 ViewAbstract::SetHasBorderImageWidth(false);
1542 ViewAbstract::SetHasBorderImageOutset(false);
1543 ViewAbstract::SetHasBorderImageRepeat(false);
1544 ViewAbstract::SetSphericalEffect(RATIO);
1545 ViewAbstract::SetLightUpEffect(RATIO);
1546 ViewAbstract::SetForegroundColor(BLUE);
1547 ViewAbstract::ClearWidthOrHeight(true);
1548 ViewAbstract::SetUseEffect(false);
1549 ViewAbstract::SetRenderGroup(false);
1550 ViewAbstract::SetRenderFit(RenderFit::BOTTOM);
1551 ViewAbstract::UpdateSafeAreaExpandOpts(safeAreaExpandOpts);
1552 ViewAbstract::SetObscured(reasonsVector);
1553
1554 PixStretchEffectOption option;
1555 option.bottom = BOTTOM;
1556 option.left = LEFT;
1557 option.right = RIGHT;
1558 option.top = TOP;
1559 ViewAbstract::SetPixelStretchEffect(option);
1560
1561 /**
1562 * @tc.expected: Return expected results.
1563 */
1564 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1565 EXPECT_FALSE(result);
1566 }
1567
1568 /**
1569 * @tc.name: ViewAbstractTest037
1570 * @tc.desc: Test the operation of View_Abstract
1571 * @tc.type: FUNC
1572 */
1573 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest037, TestSize.Level1)
1574 {
1575 /**
1576 * @tc.steps: step1.ClearStack.
1577 */
1578 auto state = static_cast<VisualState>(INDEX);
1579 ViewStackProcessor::GetInstance()->SetVisualState(state);
1580 ViewStackProcessor::GetInstance()->ClearStack();
1581
1582 /**
1583 * @tc.steps: step2. related function is called.
1584 */
1585 RefPtr<BorderImage> borderImage;
1586 ViewAbstract::SetBorderImage(std::move(borderImage));
1587 Gradient gradient;
1588 ViewAbstract::SetBorderImageGradient(std::move(gradient));
1589 RefPtr<NG::ChainedTransitionEffect> effect;
1590 ViewAbstract::SetChainedTransition(std::move(effect));
1591 RefPtr<ProgressMaskProperty> progress;
1592 ViewAbstract::SetProgressMask(std::move(progress));
1593 auto strategy = static_cast<ForegroundColorStrategy>(INDEX);
1594 ViewAbstract::SetForegroundColorStrategy(std::move(strategy));
1595 OverlayOptions overlay;
1596 ViewAbstract::SetOverlay(std::move(overlay));
1597
1598 /**
1599 * @tc.expected: Return expected results.
1600 */
1601 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1602 EXPECT_FALSE(result);
1603 }
1604
1605 /**
1606 * @tc.name: ViewAbstractTest038
1607 * @tc.desc: Test the operation of View_Abstract.
1608 * @tc.type: FUNC
1609 */
1610 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest038, TestSize.Level1)
1611 {
1612 /**
1613 * @tc.steps: step1. Build a object viewAbstract.
1614 */
1615 ViewStackProcessor viewStackProcessor;
1616 ViewAbstract viewAbstract;
1617 constexpr char TAG_ROOT[] = "root";
1618 constexpr char TAG_CHILD[] = "child";
1619 const auto MOCK_PATTERN_ROOT = AceType::MakeRefPtr<Pattern>();
1620 const auto FRAME_NODE_ROOT = FrameNode::CreateFrameNode(TAG_ROOT, 1, MOCK_PATTERN_ROOT, true);
1621 const auto FRAME_NODE_CHILD = FrameNode::CreateFrameNode(TAG_CHILD, 2, MOCK_PATTERN_ROOT, false);
1622 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1623 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1624 /**
1625 * @tc.steps: step2. callback SetClickEffectLevel.push FrameNode is not null.
1626 */
1627 viewAbstract.SetClickEffectLevel(ClickEffectLevel::LIGHT, 1.0f);
1628 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1629 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1630 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1631 ASSERT_NE(frameNode, nullptr);
1632 /**
1633 * @tc.expected: step3. Return expected results..
1634 */
1635 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1636 ASSERT_NE(Node, nullptr);
1637 auto layoutProperty = Node->GetLayoutProperty();
1638 ASSERT_NE(layoutProperty, nullptr);
1639 viewStackProcessor.instance = nullptr;
1640 }
1641
1642 /**
1643 * @tc.name: ViewAbstractTest039
1644 * @tc.desc: Test the operation of View_Abstract
1645 * @tc.type: FUNC
1646 */
1647 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest039, TestSize.Level1)
1648 {
1649 /**
1650 * @tc.steps: step1. Build a object viewAbstract.
1651 */
1652 ViewStackProcessor viewStackProcessor;
1653 ViewAbstract viewAbstract;
1654 int32_t index = 1;
1655 auto state = static_cast<VisualState>(index);
1656 viewStackProcessor.GetInstance()->SetVisualState(state);
1657 /**
1658 * @tc.steps: step2.ClearStack and callback SetScale.
1659 */
1660 viewStackProcessor.GetInstance()->ClearStack();
1661 /**
1662 * @tc.expected: step2. Return expected results..
1663 */
1664 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1665 viewAbstract.SetClickEffectLevel(ClickEffectLevel::LIGHT, 1.0f);
1666 ViewAbstract::ResetMinSize(true);
1667 EXPECT_FALSE(result);
1668 /**
1669 * @tc.steps: step3. visualState_ is null.
1670 * @tc.expected: result is true.
1671 */
1672 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
1673 result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1674 viewAbstract.SetClickEffectLevel(ClickEffectLevel::LIGHT, 1.0f);
1675 ViewAbstract::ResetMinSize(true);
1676 EXPECT_TRUE(result);
1677 }
1678
1679 /**
1680 * @tc.name: ViewAbstractTest040
1681 * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG
1682 * @tc.type: FUNC
1683 */
1684 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest040, TestSize.Level1)
1685 {
1686 /**
1687 * @tc.steps: step1. create and put mainNode, then build some necessary params.
1688 */
1689 const RefPtr<FrameNode> mainNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true);
1690 ViewStackProcessor::GetInstance()->Push(mainNode);
1691
1692 auto container = Container::Current();
1693 ASSERT_NE(container, nullptr);
1694 auto pipelineContext = container->GetPipelineContext();
1695 ASSERT_NE(pipelineContext, nullptr);
1696 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext);
1697 ASSERT_NE(context, nullptr);
1698 auto overlayManager = context->GetOverlayManager();
1699 ASSERT_NE(overlayManager, nullptr);
1700
1701 ASSERT_NE(SubwindowManager::GetInstance(), nullptr);
__anonbfd7bfda0302() 1702 std::function<void()> flagFunc = []() { flag++; };
1703 std::vector<NG::OptionParam> params = {};
1704 std::function<void()> buildFunc;
1705 MenuParam menuParam;
1706 std::function<void()> previewBuildFunc = nullptr;
1707 /**
1708 * @tc.steps: step2. call Bind and BindContextMenu multiple times with unless parameters
1709 * @tc.expected: The show or hide method will not call flagFunc.
1710 */
1711 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam);
__anonbfd7bfda0402() 1712 buildFunc = []() {};
1713 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam);
1714 params.push_back(OptionParam());
1715 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam);
1716 menuParam.type = MenuType::CONTEXT_MENU;
1717 viewAbstractModelNG.BindContextMenu(ResponseType::LONG_PRESS, buildFunc, menuParam, previewBuildFunc);
1718 EXPECT_EQ(flag, 0);
1719 /**
1720 * @tc.steps: step3. set appear and disappear and recall BindMenu and BindContextMenu;
1721 * @tc.expected: The flagFunc call times meet expectations.
1722 */
1723 menuParam.onAppear = flagFunc;
1724 menuParam.onDisappear = flagFunc;
1725 menuParam.type = MenuType::MENU;
1726 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam);
1727 menuParam.type = MenuType::CONTEXT_MENU;
1728 viewAbstractModelNG.BindContextMenu(ResponseType::RIGHT_CLICK, buildFunc, menuParam, previewBuildFunc);
1729 EXPECT_EQ(flag, 0);
1730 /**
1731 * @tc.steps: step4. create mouseInfo, set some useless params and call onMouseCallback_;
1732 * @tc.expected: StopPropagation in mouseInfo is false.
1733 */
1734 auto inputHub = mainNode->GetOrCreateInputEventHub();
1735 ASSERT_NE(inputHub, nullptr);
1736 MouseInfo mouseInfo;
1737 mouseInfo.SetButton(MouseButton::LEFT_BUTTON);
1738 mouseInfo.SetAction(MouseAction::NONE);
1739 inputHub->showMenu_->onMouseCallback_(mouseInfo);
1740 mouseInfo.SetButton(MouseButton::RIGHT_BUTTON);
1741 mouseInfo.SetAction(MouseAction::NONE);
1742 inputHub->showMenu_->onMouseCallback_(mouseInfo);
1743 EXPECT_FALSE(mouseInfo.IsStopPropagation());
1744 /**
1745 * @tc.steps: step4. create mouseInfo, set right param and call onMouseCallback_;
1746 * @tc.expected: StopPropagation in mouseInfo is false.
1747 */
1748 mouseInfo.SetButton(MouseButton::RIGHT_BUTTON);
1749 mouseInfo.SetAction(MouseAction::RELEASE);
1750 inputHub->showMenu_->onMouseCallback_(mouseInfo);
1751 EXPECT_FALSE(mouseInfo.IsStopPropagation());
1752
1753 /**
1754 * @tc.steps: step5. create mouseInfo, set right param and call BindMenuWithCustomNode;
1755 * @tc.expected: StopPropagation in mouseInfo is true.
1756 */
1757 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1758 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager);
1759 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>());
1760 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1761 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId();
1762 const RefPtr<FrameNode> targetNode =
1763 FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true);
1764 std::vector<OptionParam> param;
1765 ViewAbstract::BindMenuWithItems(std::move(param), targetNode, OFFSETF, menuParam);
1766 menuParam.type = MenuType::MULTI_MENU;
1767 ViewAbstract::BindMenuWithCustomNode(mainNode, targetNode, OFFSETF, menuParam);
1768 EXPECT_FALSE(mouseInfo.IsStopPropagation());
1769 param.push_back(OptionParam());
1770 ViewAbstract::BindMenuWithItems(std::move(param), targetNode, OFFSETF, menuParam);
1771 menuParam.type = MenuType::CONTEXT_MENU;
1772 ViewAbstract::BindMenuWithCustomNode(mainNode, targetNode, OFFSETF, menuParam);
1773 EXPECT_FALSE(mouseInfo.IsStopPropagation());
1774 }
1775
1776 /**
1777 * @tc.name: ViewAbstractTest041
1778 * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG
1779 * @tc.type: FUNC
1780 */
1781 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest041, TestSize.Level1)
1782 {
1783 /**
1784 * @tc.steps: step1. creat frameNode and other creat.
1785 */
1786 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId();
1787 const RefPtr<FrameNode> frameNode =
1788 FrameNode::CreateFrameNode("frameNode", nodeId, AceType::MakeRefPtr<Pattern>(), true);
1789
1790 auto layoutProperty = frameNode->GetLayoutProperty();
1791 CalcSize idealSize = { CalcLength(ZERO), CalcLength(ZERO) };
1792 layoutProperty->calcLayoutConstraint_ = std::make_unique<MeasureProperty>();
1793 layoutProperty->calcLayoutConstraint_->minSize = idealSize;
1794 layoutProperty->calcLayoutConstraint_->maxSize = idealSize;
1795 EffectOption option;
1796 Color color = Color::TRANSPARENT;
1797 option.color = color;
1798
1799 std::vector<std::pair<float, float>> fractionStops;
1800 fractionStops.push_back(std::pair<float, float>(0.0f, 1.0f));
1801 CalcDimension dimensionRadius(0.0);
1802 LinearGradientBlurPara blurPara(dimensionRadius, fractionStops, GradientDirection::LEFT);
1803 /**
1804 * @tc.steps: step2. ResetMinSize test, IsCurrentVisualStateProcess() == false
1805 * @tc.expected:call ResetMinSize(),calcLayoutConstraint_ not change
1806 */
1807 ViewStackProcessor::GetInstance()->SetVisualState(VisualState::DISABLED);
1808 ViewAbstract::ResetMinSize(true);
1809 ViewAbstract::ResetMaxSize(true);
1810 ViewAbstract::SetBackgroundAlign(Alignment::TOP_LEFT);
1811 ViewAbstract::SetBackgroundEffect(option);
1812 ViewAbstract::SetDynamicLightUp(0, 0);
1813 ViewAbstract::SetLinearGradientBlur(blurPara);
1814 EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->minSize.has_value());
1815 EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->maxSize.has_value());
1816
1817 /**
1818 * @tc.steps: step3. ResetMinSize test, IsCurrentVisualStateProcess() == true
1819 * @tc.expected:call ResetMinSize(),calcLayoutConstraint_->minSize.Width not change
1820 */
1821 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
1822 ViewAbstract::ResetMinSize(true);
1823 ViewAbstract::ResetMaxSize(true);
1824 ViewAbstract::SetBackgroundAlign(Alignment::BOTTOM_RIGHT);
1825 ViewAbstract::SetBackgroundEffect(option);
1826 ViewAbstract::SetDynamicLightUp(0, 0);
1827 ViewAbstract::SetLinearGradientBlur(blurPara);
1828 ViewAbstract::DisableOnAppear();
1829 ViewAbstract::DisableOnAreaChange();
1830 ViewAbstract::DisableOnDisAppear();
1831 std::vector<DimensionRect> responseRegion;
1832 DimensionRect responseRect(Dimension(0), Dimension(0), DimensionOffset(OFFSETF));
1833 responseRegion.emplace_back(responseRect);
1834 ViewAbstract::SetMouseResponseRegion(responseRegion);
1835 EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->minSize.value().Width().has_value());
1836 EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->maxSize.value().Width().has_value());
1837 }
1838
1839 /**
1840 * @tc.name: ViewAbstractDisableClickTest
1841 * @tc.desc: Test the operation of View_Abstract.
1842 * @tc.type: FUNC
1843 */
1844 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableClickTest, TestSize.Level1)
1845 {
1846 /**
1847 * @tc.steps: step1. create framenode and check callback;
1848 * @tc.expected: callback is not null.
1849 */
1850 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1851 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1852 GestureEventFunc tapEventFunc;
1853 ViewAbstract::SetOnClick(std::move(tapEventFunc));
1854
1855 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1856 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1857 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1858 ASSERT_NE(frameNode, nullptr);
1859 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1860 ASSERT_NE(node, nullptr);
1861 auto gestureHub = node->GetOrCreateGestureEventHub();
1862 auto& callback = gestureHub->clickEventActuator_->userCallback_;
1863 EXPECT_NE(callback, nullptr);
1864
1865 /**
1866 * @tc.steps: step2. Disable callback.
1867 * @tc.expected: callback is null.
1868 */
1869 ViewAbstract::DisableOnClick();
1870 EXPECT_EQ(callback, nullptr);
1871
1872 /**
1873 * @tc.steps: step3. Add callback again.
1874 * @tc.expected: callback is not null.
1875 */
1876 GestureEventFunc tapEventFunc2;
1877 ViewAbstract::SetOnClick(std::move(tapEventFunc2));
1878 EXPECT_NE(callback, nullptr);
1879 ViewStackProcessor::GetInstance()->instance = nullptr;
1880 }
1881
1882 /**
1883 * @tc.name: ViewAbstractDisableTouchTest
1884 * @tc.desc: Test the operation of View_Abstract.
1885 * @tc.type: FUNC
1886 */
1887 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableTouchTest, TestSize.Level1)
1888 {
1889 /**
1890 * @tc.steps: step1. create framenode and check callback;
1891 * @tc.expected: callback is not null.
1892 */
1893 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1894 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1895 TouchEventFunc touchEventFunc;
1896 ViewAbstract::SetOnTouch(std::move(touchEventFunc));
1897
1898 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1899 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1900 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1901 ASSERT_NE(frameNode, nullptr);
1902 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1903 ASSERT_NE(node, nullptr);
1904 auto gestureHub = node->GetOrCreateGestureEventHub();
1905 auto& callback = gestureHub->touchEventActuator_->userCallback_;
1906 EXPECT_NE(callback, nullptr);
1907
1908 /**
1909 * @tc.steps: step2. Disable callback.
1910 * @tc.expected: callback is null.
1911 */
1912 ViewAbstract::DisableOnTouch();
1913 EXPECT_EQ(callback, nullptr);
1914
1915 /**
1916 * @tc.steps: step3. Add callback again.
1917 * @tc.expected: callback is not null.
1918 */
1919 TouchEventFunc touchEventFunc2;
1920 ViewAbstract::SetOnTouch(std::move(touchEventFunc2));
1921 EXPECT_NE(callback, nullptr);
1922 ViewStackProcessor::GetInstance()->instance = nullptr;
1923 }
1924
1925 /**
1926 * @tc.name: ViewAbstractDisableMouseTest
1927 * @tc.desc: Test the operation of View_Abstract.
1928 * @tc.type: FUNC
1929 */
1930 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableMouseTest, TestSize.Level1)
1931 {
1932 /**
1933 * @tc.steps: step1. create framenode and check callback;
1934 * @tc.expected: callback is not null.
1935 */
1936 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1937 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1938 OnMouseEventFunc onMouseEventFunc;
1939 ViewAbstract::SetOnMouse(std::move(onMouseEventFunc));
1940
1941 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1942 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1943 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1944 ASSERT_NE(frameNode, nullptr);
1945 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1946 ASSERT_NE(node, nullptr);
1947 auto eventHub = node->GetOrCreateInputEventHub();
1948 auto& callback = eventHub->mouseEventActuator_->userCallback_;
1949 EXPECT_NE(callback, nullptr);
1950
1951 /**
1952 * @tc.steps: step2. Disable callback.
1953 * @tc.expected: callback is null.
1954 */
1955 ViewAbstract::DisableOnMouse();
1956 EXPECT_EQ(callback, nullptr);
1957
1958 /**
1959 * @tc.steps: step3. Add callback again.
1960 * @tc.expected: callback is not null.
1961 */
1962 OnMouseEventFunc onMouseEventFunc2;
1963 ViewAbstract::SetOnMouse(std::move(onMouseEventFunc2));
1964 EXPECT_NE(callback, nullptr);
1965 ViewStackProcessor::GetInstance()->instance = nullptr;
1966 }
1967
1968 /**
1969 * @tc.name: ViewAbstractDisableHoverTest
1970 * @tc.desc: Test the operation of View_Abstract.
1971 * @tc.type: FUNC
1972 */
1973 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableHoverTest, TestSize.Level1)
1974 {
1975 /**
1976 * @tc.steps: step1. create framenode and check callback;
1977 * @tc.expected: callback is not null.
1978 */
1979 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1980 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1981 OnHoverFunc onHoverEventFunc;
1982 ViewAbstract::SetOnHover(std::move(onHoverEventFunc));
1983
1984 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1985 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1986 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
1987 ASSERT_NE(frameNode, nullptr);
1988 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1989 ASSERT_NE(node, nullptr);
1990 auto eventHub = node->GetOrCreateInputEventHub();
1991 auto& callback = eventHub->hoverEventActuator_->userCallback_;
1992 EXPECT_NE(callback, nullptr);
1993
1994 /**
1995 * @tc.steps: step2. Disable callback.
1996 * @tc.expected: callback is null.
1997 */
1998 ViewAbstract::DisableOnHover();
1999 EXPECT_EQ(callback, nullptr);
2000
2001 /**
2002 * @tc.steps: step3. Add callback again.
2003 * @tc.expected: callback is not null.
2004 */
2005 OnHoverFunc onHoverEventFunc2;
2006 ViewAbstract::SetOnHover(std::move(onHoverEventFunc2));
2007 EXPECT_NE(callback, nullptr);
2008 ViewStackProcessor::GetInstance()->instance = nullptr;
2009 }
2010
2011 /**
2012 * @tc.name: ViewAbstractDisableKeyTest
2013 * @tc.desc: Test the operation of View_Abstract.
2014 * @tc.type: FUNC
2015 */
2016 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableKeyTest, TestSize.Level1)
2017 {
2018 /**
2019 * @tc.steps: step1. create framenode and check callback;
2020 * @tc.expected: callback is not null.
2021 */
2022 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
2023 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
__anonbfd7bfda0502(KeyEventInfo& info) 2024 OnKeyCallbackFunc onKeyCallback = [](KeyEventInfo& info) {};
2025 ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback));
2026
2027 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
2028 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
2029 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
2030 ASSERT_NE(frameNode, nullptr);
2031 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
2032 ASSERT_NE(node, nullptr);
2033 auto focusHub = node->GetOrCreateFocusHub();
2034 auto& callback = focusHub->focusCallbackEvents_->onKeyEventCallback_;
2035 EXPECT_TRUE(callback);
2036
2037 /**
2038 * @tc.steps: step2. Disable callback.
2039 * @tc.expected: callback is null.
2040 */
2041 ViewAbstract::DisableOnKeyEvent();
2042 EXPECT_FALSE(callback);
2043
2044 /**
2045 * @tc.steps: step3. Add callback again.
2046 * @tc.expected: callback is not null.
2047 */
__anonbfd7bfda0602(KeyEventInfo& info) 2048 OnKeyCallbackFunc onKeyCallback2 = [](KeyEventInfo& info) {};
2049 ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback2));
2050 EXPECT_TRUE(callback);
2051 ViewStackProcessor::GetInstance()->instance = nullptr;
2052 }
2053
2054 /**
2055 * @tc.name: ViewAbstractDisableFocusTest
2056 * @tc.desc: Test the operation of View_Abstract.
2057 * @tc.type: FUNC
2058 */
2059 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableFocusTest, TestSize.Level1)
2060 {
2061 /**
2062 * @tc.steps: step1. create framenode and check callback;
2063 * @tc.expected: callback is not null.
2064 */
2065 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
2066 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
__anonbfd7bfda0702() 2067 OnFocusFunc onFocusCallback = []() {};
2068 ViewAbstract::SetOnFocus(std::move(onFocusCallback));
2069
2070 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
2071 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
2072 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
2073 ASSERT_NE(frameNode, nullptr);
2074 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
2075 ASSERT_NE(node, nullptr);
2076 auto focusHub = node->GetOrCreateFocusHub();
2077 auto& callback = focusHub->focusCallbackEvents_->onFocusCallback_;
2078 EXPECT_NE(callback, nullptr);
2079
2080 /**
2081 * @tc.steps: step2. Disable callback.
2082 * @tc.expected: callback is null.
2083 */
2084 ViewAbstract::DisableOnFocus();
2085 EXPECT_EQ(callback, nullptr);
2086
2087 /**
2088 * @tc.steps: step3. Add callback again.
2089 * @tc.expected: callback is not null.
2090 */
__anonbfd7bfda0802() 2091 OnFocusFunc onFocusCallback2 = []() {};
2092 ViewAbstract::SetOnFocus(std::move(onFocusCallback2));
2093 EXPECT_NE(callback, nullptr);
2094 ViewStackProcessor::GetInstance()->instance = nullptr;
2095 }
2096
2097 /**
2098 * @tc.name: ViewAbstractDisableBlurTest
2099 * @tc.desc: Test the operation of View_Abstract.
2100 * @tc.type: FUNC
2101 */
2102 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableBlurTest, TestSize.Level1)
2103 {
2104 /**
2105 * @tc.steps: step1. create framenode and check callback;
2106 * @tc.expected: callback is not null.
2107 */
2108 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
2109 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
__anonbfd7bfda0902() 2110 OnBlurFunc onBlurCallback = []() {};
2111 ViewAbstract::SetOnFocus(std::move(onBlurCallback));
2112
2113 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
2114 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
2115 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
2116 ASSERT_NE(frameNode, nullptr);
2117 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
2118 ASSERT_NE(node, nullptr);
2119 auto focusHub = node->GetOrCreateFocusHub();
2120 auto& callback = focusHub->focusCallbackEvents_->onBlurCallback_;
2121 EXPECT_TRUE(callback);
2122
2123 /**
2124 * @tc.steps: step2. Disable callback.
2125 * @tc.expected: callback is null.
2126 */
2127 ViewAbstract::DisableOnBlur();
2128 EXPECT_FALSE(callback);
2129
2130 /**
2131 * @tc.steps: step3. Add callback again.
2132 * @tc.expected: callback is not null.
2133 */
__anonbfd7bfda0a02() 2134 OnBlurFunc onBlurCallback2 = []() {};
2135 ViewAbstract::SetOnBlur(std::move(onBlurCallback2));
2136 EXPECT_TRUE(callback);
2137 ViewStackProcessor::GetInstance()->instance = nullptr;
2138 }
2139
2140 /**
2141 * @tc.name: ViewAbstractMonopolizeEvent001
2142 * @tc.desc: View_Abstract set MonopolizeEvent true test
2143 * @tc.type: FUNC
2144 */
2145 HWTEST_F(ViewAbstractTestNg, ViewAbstractMonopolizeEvent001, TestSize.Level1)
2146 {
2147 /**
2148 * @tc.steps: step1. create and put mainNode, then build some necessary params.
2149 */
2150 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
2151
2152 /**
2153 * @tc.steps: step2. set monopolize
2154 */
2155 ViewAbstract::SetMonopolizeEvents(true);
2156
2157 /**
2158 * @tc.steps: step3. get node in ViewStackProcessor.
2159 * @tc.expected: node is not null.
2160 */
2161 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2162 EXPECT_NE(rootFrameNode, nullptr);
2163
2164 /**
2165 * @tc.steps: step4. get monopolizeEvents value of the node.
2166 * @tc.expected: value is equal to true.
2167 */
2168 EXPECT_EQ(rootFrameNode->GetMonopolizeEvents(), true);
2169
2170 /**
2171 * @tc.steps: step5. finish view stack.
2172 */
2173 ViewStackProcessor::GetInstance()->Finish();
2174 }
2175
2176 /**
2177 * @tc.name: ViewAbstractMonopolizeEvent002
2178 * @tc.desc: View_Abstract set MonopolizeEvent false test
2179 * @tc.type: FUNC
2180 */
2181 HWTEST_F(ViewAbstractTestNg, ViewAbstractMonopolizeEvent002, TestSize.Level1)
2182 {
2183 /**
2184 * @tc.steps: step1. create and put mainNode, then build some necessary params.
2185 */
2186 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
2187
2188 /**
2189 * @tc.steps: step2. set monopolize
2190 */
2191 ViewAbstract::SetMonopolizeEvents(false);
2192
2193 /**
2194 * @tc.steps: step3. get node in ViewStackProcessor.
2195 * @tc.expected: node is not null.
2196 */
2197 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2198 EXPECT_NE(rootFrameNode, nullptr);
2199
2200 /**
2201 * @tc.steps: step4. get monopolizeEvents value of the node.
2202 * @tc.expected: value is equal to true.
2203 */
2204 EXPECT_EQ(rootFrameNode->GetMonopolizeEvents(), false);
2205
2206 /**
2207 * @tc.steps: step5. finish view stack.
2208 */
2209 ViewStackProcessor::GetInstance()->Finish();
2210 }
2211
2212 /**
2213 * @tc.name: ViewAbstractMonopolizeEvent003
2214 * @tc.desc: View_Abstract not set MonopolizeEvent test (use default)
2215 * @tc.type: FUNC
2216 */
2217 HWTEST_F(ViewAbstractTestNg, ViewAbstractMonopolizeEvent003, TestSize.Level1)
2218 {
2219 /**
2220 * @tc.steps: step1. create and put mainNode, then build some necessary params.
2221 */
2222 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
2223
2224 /**
2225 * @tc.steps: step2. get node in ViewStackProcessor.
2226 * @tc.expected: node is not null.
2227 */
2228 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2229 EXPECT_NE(rootFrameNode, nullptr);
2230
2231 /**
2232 * @tc.steps: step3. get monopolizeEvents value of the node.
2233 * @tc.expected: value is equal to true.
2234 */
2235 EXPECT_EQ(rootFrameNode->GetMonopolizeEvents(), false);
2236
2237 /**
2238 * @tc.steps: step5. finish view stack.
2239 */
2240 ViewStackProcessor::GetInstance()->Finish();
2241 }
2242 } // namespace OHOS::Ace::NG
2243
