1 /*
2 * Copyright (c) 2023 iSoftStone Information Technology (Group) Co.,Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "test/unittest/core/base/view_abstract_test_ng.h"
16
17 #include "core/components/select/select_theme.h"
18 #include "core/components_ng/pattern/menu/menu_item/menu_item_model_ng.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS::Ace::NG {
SetUpTestSuite()24 void ViewAbstractTestNg::SetUpTestSuite()
25 {
26 MockPipelineContext::SetUp();
27 MockContainer::SetUp();
28 MockContainer::Current()->pipelineContext_ = PipelineBase::GetCurrentContext();
29 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
30 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager);
31 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>());
32 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<PopupTheme>()));
33 }
34
TearDownTestSuite()35 void ViewAbstractTestNg::TearDownTestSuite()
36 {
37 MockContainer::Current()->pipelineContext_ = nullptr;
38 MockPipelineContext::TearDown();
39 }
40 /**
41 * @tc.name: ViewAbstractTest001
42 * @tc.desc: SetWidth、SetHeight、SetMinWidth、SetMinHeight、SetMaxWidth、SetMaxHeight、ClearWidthOrHeight
43 * @tc.type: FUNC
44 */
45 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest001, TestSize.Level1)
46 {
47 /**
48 * @tc.steps: step1.Using static methods to set component properties
49 */
50 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
51 ASSERT_NE(frameNode, nullptr);
52 auto layoutProperty = frameNode->GetLayoutProperty();
53 ASSERT_NE(layoutProperty, nullptr);
54 ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
55 ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
56 ViewAbstract::SetMinWidth(NG::CalcLength(MIN_WIDTH));
57 ViewAbstract::SetMinHeight(NG::CalcLength(MIN_HEIGHT));
58 ViewAbstract::SetMaxWidth(NG::CalcLength(MIN_WIDTH));
59 ViewAbstract::SetMaxHeight(NG::CalcLength(MIN_HEIGHT));
60 ViewAbstract::ResetAspectRatio();
61 ViewAbstract::SetDrawModifier(nullptr);
62
63 /**
64 * @tc.expected: Successfully set various properties of the top node on the stack
65 */
66 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->selfIdealSize->Width(), NG::CalcLength(WIDTH));
67 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->selfIdealSize->Height(), NG::CalcLength(HEIGHT));
68 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->minSize->Width(), NG::CalcLength(MIN_WIDTH));
69 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->minSize->Height(), NG::CalcLength(MIN_HEIGHT));
70 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->maxSize->Width(), NG::CalcLength(MIN_WIDTH));
71 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->maxSize->Height(), NG::CalcLength(MIN_HEIGHT));
72
73 /**
74 * @tc.steps: step2.Static methods set properties for other nodes
75 */
__anoncde27ef90102() 76 auto newNode = FrameNode::GetOrCreateFrameNode("newframenode", 10, []() { return AceType::MakeRefPtr<Pattern>(); });
77 ViewAbstract::SetWidth(AceType::RawPtr(newNode), NG::CalcLength(WIDTH));
78 ViewAbstract::SetHeight(AceType::RawPtr(newNode), NG::CalcLength(HEIGHT));
79 ViewAbstract::SetMinWidth(AceType::RawPtr(newNode), NG::CalcLength(MIN_WIDTH));
80 ViewAbstract::SetMinHeight(AceType::RawPtr(newNode), NG::CalcLength(MIN_HEIGHT));
81 ViewAbstract::SetMaxWidth(AceType::RawPtr(newNode), NG::CalcLength(MIN_WIDTH));
82 ViewAbstract::SetMaxHeight(AceType::RawPtr(newNode), NG::CalcLength(MIN_HEIGHT));
83 auto newProperty = frameNode->GetLayoutProperty();
84
85 /**
86 * @tc.expected: Successfully set various attributes of the new node
87 */
88 EXPECT_EQ(newProperty->calcLayoutConstraint_->selfIdealSize->Width(), NG::CalcLength(WIDTH));
89 EXPECT_EQ(newProperty->calcLayoutConstraint_->selfIdealSize->Height(), NG::CalcLength(HEIGHT));
90 EXPECT_EQ(newProperty->calcLayoutConstraint_->minSize->Width(), NG::CalcLength(MIN_WIDTH));
91 EXPECT_EQ(newProperty->calcLayoutConstraint_->minSize->Height(), NG::CalcLength(MIN_HEIGHT));
92 EXPECT_EQ(newProperty->calcLayoutConstraint_->maxSize->Width(), NG::CalcLength(MIN_WIDTH));
93 EXPECT_EQ(newProperty->calcLayoutConstraint_->maxSize->Height(), NG::CalcLength(MIN_HEIGHT));
94
95 ViewAbstract::ClearWidthOrHeight(true);
96 ViewAbstract::ClearWidthOrHeight(AceType::RawPtr(newNode), true);
97 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->selfIdealSize->Width(), std::nullopt);
98 EXPECT_EQ(newProperty->calcLayoutConstraint_->selfIdealSize->Width(), std::nullopt);
99 }
100
101 /**
102 * @tc.name: ViewAbstractTest002
103 * @tc.desc: Test the operation of View_Abstract.
104 * @tc.type: FUNC
105 */
106 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest002, TestSize.Level1)
107 {
108 /**
109 * @tc.steps: step1.push FrameNode is not null, related function is called.
110 */
111 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
112 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
113
114 ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
115 ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
116 ViewAbstract::SetMinWidth(NG::CalcLength(MIN_WIDTH));
117 ViewAbstract::SetMinHeight(NG::CalcLength(MIN_HEIGHT));
118 ViewAbstract::SetMaxWidth(NG::CalcLength(MIN_WIDTH));
119 ViewAbstract::SetMaxHeight(NG::CalcLength(MIN_HEIGHT));
120 ViewAbstract::ResetAspectRatio();
121 ViewAbstract::ClearWidthOrHeight(true);
122
123 /**
124 * @tc.expected: Return expected results..
125 */
126 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
127 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
128 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
129 ASSERT_NE(frameNode, nullptr);
130 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
131 ASSERT_NE(Node, nullptr);
132 auto layoutProperty = Node->GetLayoutProperty();
133 ASSERT_NE(layoutProperty, nullptr);
134 ViewStackProcessor::GetInstance()->instance = nullptr;
135 }
136
137 /**
138 * @tc.name: ViewAbstractTest003
139 * @tc.desc: Test the operation of View_Abstract
140 * @tc.type: FUNC
141 */
142 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest003, TestSize.Level1)
143 {
144 /**
145 * @tc.steps: step1.The FrameNode is null, related function is called.
146 */
147 ViewAbstract::SetAspectRatio(RATIO);
148 ViewAbstract::SetBackgroundColor(BLUE);
149 ViewAbstract::SetBackgroundColor(nullptr, BLUE);
150 ViewAbstract::SetBackgroundImage(imageSourceInfo);
151 ViewAbstract::SetBackgroundImage(nullptr, imageSourceInfo);
152 ViewAbstract::SetBackgroundImageSize(BACKGROUNDSIZE);
153 ViewAbstract::SetBackgroundImageSize(nullptr, BACKGROUNDSIZE);
154 ViewAbstract::SetBackgroundImagePosition(BACKGROUNDPOSITION);
155 ViewAbstract::SetBackgroundImagePosition(nullptr, BACKGROUNDPOSITION);
156 ViewAbstract::SetPixelRound(0);
157 ChainInfo chainInfo;
158 chainInfo.direction = LineDirection::HORIZONTAL;
159 chainInfo.style = ChainStyle::SPREAD;
160 ViewAbstract::SetChainStyle(chainInfo);
161 ViewAbstract::SetChainStyle(AceType::RawPtr(FRAME_NODE_REGISTER), chainInfo);
162 ViewAbstract::SetLayoutWeight(TEN);
163 ViewAbstract::SetLayoutWeight(AceType::RawPtr(FRAME_NODE_REGISTER), TEN);
164 ViewAbstract::SetBias(biasPair);
165 ViewAbstract::SetBias(nullptr, biasPair);
166 ViewAbstract::SetOuterBorderRadius(ZERO);
167 ViewAbstract::SetOuterBorderRadius(nullptr, ZERO);
168 NG::BorderRadiusProperty borderRadius;
169 ViewAbstract::SetOuterBorderRadius(borderRadius);
170 ViewAbstract::SetOuterBorderRadius(nullptr, borderRadius);
171 ViewAbstract::SetOuterBorderColor(BLUE);
172 ViewAbstract::SetOuterBorderColor(nullptr, BLUE);
173 NG::BorderColorProperty borderColor;
174 ViewAbstract::SetOuterBorderColor(borderColor);
175 ViewAbstract::SetOuterBorderColor(nullptr, borderColor);
176 ViewAbstract::SetOuterBorderWidth(ZERO);
177 ViewAbstract::SetOuterBorderWidth(nullptr, ZERO);
178 NG::BorderWidthProperty borderWidth;
179 ViewAbstract::SetOuterBorderWidth(borderWidth);
180 ViewAbstract::SetOuterBorderWidth(nullptr, borderWidth);
181 auto borderStyle = static_cast<BorderStyle>(INDEX);
182 ViewAbstract::SetOuterBorderStyle(borderStyle);
183 ViewAbstract::SetOuterBorderStyle(nullptr, borderStyle);
184 NG::BorderStyleProperty borderStyleProperty;
185 ViewAbstract::SetOuterBorderStyle(borderStyleProperty);
186 ViewAbstract::SetOuterBorderStyle(nullptr, borderStyleProperty);
187 BlendMode blendMode = BlendMode::NONE;
188 ViewAbstract::SetBlendMode(blendMode);
189 ViewAbstract::SetBlendMode(AceType::RawPtr(FRAME_NODE_REGISTER), blendMode);
190 BlendApplyType blendApplyType = BlendApplyType::FAST;
191 ViewAbstract::SetBlendApplyType(blendApplyType);
192 ViewAbstract::SetBlendApplyType(AceType::RawPtr(FRAME_NODE_REGISTER), blendApplyType);
193
194 BlurStyleOption blurStyleOption;
195 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
196 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
197 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
198 ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
199 ViewAbstract::SetBackgroundBlurStyle(AceType::RawPtr(FRAME_NODE_REGISTER), blurStyleOption);
200 CalcDimension dimensionRadius(0.0);
201 ViewAbstract::SetLightPosition(dimensionRadius, dimensionRadius, dimensionRadius);
202 ViewAbstract::SetLightPosition(nullptr, dimensionRadius, dimensionRadius, dimensionRadius);
203 ViewAbstract::SetLightIntensity(RATIO);
204 ViewAbstract::SetLightIntensity(nullptr, RATIO);
205 ViewAbstract::SetIlluminatedBorderWidth(ZERO);
206 ViewAbstract::SetIlluminatedBorderWidth(nullptr, ZERO);
207 ViewAbstract::SetBloom(RATIO);
208 ViewAbstract::SetBloom(nullptr, RATIO);
209 std::map<AlignDirection, AlignRule> alignRules;
210 ViewAbstract::SetAlignRules(alignRules);
211 ViewAbstract::SetAlignRules(AceType::RawPtr(FRAME_NODE_REGISTER), alignRules);
212 auto repeat = static_cast<ImageRepeat>(INDEX);
213 ViewAbstract::SetBackgroundImageRepeat(repeat);
214 ViewAbstract::SetBackgroundImageRepeat(nullptr, repeat);
215 auto direction = static_cast<TextDirection>(INDEX);
216 ViewAbstract::SetLayoutDirection(direction);
217 ViewAbstract::SetLayoutDirection(AceType::RawPtr(FRAME_NODE_REGISTER), direction);
218 ViewAbstract::GetAlignRules(AceType::RawPtr(FRAME_NODE_REGISTER));
219 ViewAbstract::SetBackgroundImageSyncMode(true);
220
221 /**
222 * @tc.expected: Return expected results..
223 */
224 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
225 }
226
227 /**
228 * @tc.name: ViewAbstractTest004
229 * @tc.desc: Test the operation of View_Abstract.
230 * @tc.type: FUNC
231 */
232 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest004, TestSize.Level1)
233 {
234 /**
235 * @tc.steps: step1.push FrameNode is not null, related function is called.
236 */
237 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
238 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
239
240 ViewAbstract::SetAspectRatio(RATIO);
241 ViewAbstract::SetBackgroundColor(BLUE);
242 ViewAbstract::SetBackgroundColor(nullptr, BLUE);
243 ViewAbstract::SetBackgroundImage(imageSourceInfo);
244 ViewAbstract::SetBackgroundImage(nullptr, imageSourceInfo);
245 ViewAbstract::SetBackgroundImageSize(BACKGROUNDSIZE);
246 ViewAbstract::SetBackgroundImageSize(nullptr, BACKGROUNDSIZE);
247 ViewAbstract::SetBackgroundImagePosition(BACKGROUNDPOSITION);
248 ViewAbstract::SetBackgroundImagePosition(nullptr, BACKGROUNDPOSITION);
249 ViewAbstract::SetPixelRound(0);
250
251 ChainInfo chainInfo;
252 chainInfo.direction = LineDirection::HORIZONTAL;
253 chainInfo.style = ChainStyle::SPREAD;
254 ViewAbstract::SetChainStyle(chainInfo);
255 ViewAbstract::SetChainStyle(AceType::RawPtr(FRAME_NODE_REGISTER), chainInfo);
256 ViewAbstract::SetBias(biasPair);
257 ViewAbstract::SetBias(nullptr, biasPair);
258 ViewAbstract::SetOuterBorderRadius(ZERO);
259 ViewAbstract::SetOuterBorderRadius(nullptr, ZERO);
260 NG::BorderRadiusProperty borderRadius;
261 ViewAbstract::SetOuterBorderRadius(borderRadius);
262 ViewAbstract::SetOuterBorderRadius(nullptr, borderRadius);
263 ViewAbstract::SetOuterBorderColor(BLUE);
264 ViewAbstract::SetOuterBorderColor(nullptr, BLUE);
265 NG::BorderColorProperty borderColor;
266 ViewAbstract::SetOuterBorderColor(borderColor);
267 ViewAbstract::SetOuterBorderColor(nullptr, borderColor);
268 ViewAbstract::SetOuterBorderWidth(ZERO);
269 ViewAbstract::SetOuterBorderWidth(nullptr, ZERO);
270 NG::BorderWidthProperty borderWidth;
271 ViewAbstract::SetOuterBorderWidth(borderWidth);
272 ViewAbstract::SetOuterBorderWidth(nullptr, borderWidth);
273 auto borderStyle = static_cast<BorderStyle>(INDEX);
274 ViewAbstract::SetOuterBorderStyle(borderStyle);
275 ViewAbstract::SetOuterBorderStyle(nullptr, borderStyle);
276 NG::BorderStyleProperty borderStyleProperty;
277 ViewAbstract::SetOuterBorderStyle(borderStyleProperty);
278 ViewAbstract::SetOuterBorderStyle(nullptr, borderStyleProperty);
279 ViewAbstract::SetLayoutWeight(TEN);
280 BlendMode blendMode = BlendMode::NONE;
281 ViewAbstract::SetBlendMode(blendMode);
282 BlendApplyType blendApplyType = BlendApplyType::FAST;
283 ViewAbstract::SetBlendApplyType(blendApplyType);
284
285 BlurStyleOption blurStyleOption;
286 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
287 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
288 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
289 ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
290
291 std::map<AlignDirection, AlignRule> alignRules;
292 ViewAbstract::SetAlignRules(alignRules);
293 auto repeat = static_cast<ImageRepeat>(INDEX);
294 ViewAbstract::SetBackgroundImageRepeat(repeat);
295 ViewAbstract::SetBackgroundImageRepeat(nullptr, repeat);
296 auto direction = static_cast<TextDirection>(INDEX);
297 ViewAbstract::SetLayoutDirection(direction);
298 CalcDimension dimensionRadius(0.0);
299 ViewAbstract::SetLightPosition(dimensionRadius, dimensionRadius, dimensionRadius);
300 ViewAbstract::SetLightPosition(nullptr, dimensionRadius, dimensionRadius, dimensionRadius);
301 ViewAbstract::SetLightIntensity(RATIO);
302 ViewAbstract::SetLightIntensity(nullptr, RATIO);
303 Color color = Color::TRANSPARENT;
304 ViewAbstract::SetLightColor(color);
305 ViewAbstract::SetLightColor(nullptr, color);
306 ViewAbstract::SetIlluminatedBorderWidth(ZERO);
307 ViewAbstract::SetIlluminatedBorderWidth(nullptr, ZERO);
308 ViewAbstract::SetBloom(RATIO);
309 ViewAbstract::SetBloom(nullptr, RATIO);
310
311 /**
312 * @tc.expected: Return expected results.
313 */
314 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
315 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
316 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
317 ASSERT_NE(frameNode, nullptr);
318 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
319 ASSERT_NE(Node, nullptr);
320 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
321 ASSERT_NE(layoutProperty, nullptr);
322 ViewStackProcessor::GetInstance()->instance = nullptr;
323 }
324
325 /**
326 * @tc.name: ViewAbstractTest005
327 * @tc.desc: Test the operation of View_Abstract
328 * @tc.type: FUNC
329 */
330 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest005, TestSize.Level1)
331 {
332 /**
333 * @tc.steps: step1.The FrameNode is null, related function is called.
334 */
335 auto alignSelf = static_cast<FlexAlign>(INDEX);
336 ViewAbstract::SetAlignSelf(alignSelf);
337 ViewAbstract::SetFlexShrink(RATIO);
338 ViewAbstract::SetFlexGrow(RATIO);
339 ViewAbstract::SetFlexBasis(WIDTH);
340 ViewAbstract::SetDisplayIndex(INDEX);
341 ViewAbstract::SetDisplayIndex(nullptr, INDEX);
342
343 ViewAbstract::SetPadding(NG::CalcLength(WIDTH));
344 ViewAbstract::SetMargin(NG::CalcLength(WIDTH));
345 ViewAbstract::SetBorderRadius(WIDTH);
346 ViewAbstract::SetBorderColor(BLUE);
347 ViewAbstract::SetBorderWidth(WIDTH);
348 auto borderStyle = static_cast<BorderStyle>(INDEX);
349 ViewAbstract::SetBorderStyle(borderStyle);
350 ViewAbstract::SetBorderStyle(nullptr, borderStyle);
351 ViewAbstract::SetAutoEventParam(VALUE_X);
352
353 /**
354 * @tc.expected: Return expected results..
355 */
356 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
357 }
358
359 /**
360 * @tc.name: ViewAbstractTest006
361 * @tc.desc: Test the operation of View_Abstract.
362 * @tc.type: FUNC
363 */
364 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest006, TestSize.Level1)
365 {
366 /**
367 * @tc.steps: step1.push FrameNode is not null, related function is called.
368 */
369 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
370 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
371
372 auto alignSelf = static_cast<FlexAlign>(INDEX);
373 ViewAbstract::SetAlignSelf(alignSelf);
374 ViewAbstract::SetFlexShrink(RATIO);
375 ViewAbstract::SetFlexShrink(AceType::RawPtr(FRAME_NODE_REGISTER), RATIO);
376 ViewAbstract::SetFlexGrow(RATIO);
377 ViewAbstract::SetFlexGrow(AceType::RawPtr(FRAME_NODE_REGISTER), RATIO);
378 ViewAbstract::SetFlexBasis(WIDTH);
379 ViewAbstract::SetDisplayIndex(INDEX);
380 ViewAbstract::SetDisplayIndex(nullptr, INDEX);
381
382 ViewAbstract::SetPadding(NG::CalcLength(WIDTH));
383 ViewAbstract::SetMargin(NG::CalcLength(WIDTH));
384 ViewAbstract::SetBorderRadius(WIDTH);
385 ViewAbstract::SetBorderColor(BLUE);
386 ViewAbstract::SetBorderWidth(WIDTH);
387 auto borderStyle = static_cast<BorderStyle>(INDEX);
388 ViewAbstract::SetBorderStyle(borderStyle);
389 ViewAbstract::SetBorderStyle(nullptr, borderStyle);
390
391 /**
392 * @tc.expected: Return expected results.
393 */
394 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
395 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
396 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
397 ASSERT_NE(frameNode, nullptr);
398 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
399 ASSERT_NE(Node, nullptr);
400 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
401 ASSERT_NE(layoutProperty, nullptr);
402 ViewStackProcessor::GetInstance()->instance = nullptr;
403 }
404
405 /**
406 * @tc.name: ViewAbstractTest007
407 * @tc.desc: Test the operation of View_Abstract
408 * @tc.type: FUNC
409 */
410 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest007, TestSize.Level1)
411 {
412 /**
413 * @tc.steps: step1.The FrameNode is null, related function is called.
414 */
415 NG::PaddingProperty paddings;
416 ViewAbstract::SetPadding(paddings);
417
418 NG::MarginProperty margins;
419 ViewAbstract::SetMargin(margins);
420
421 NG::BorderRadiusProperty borderRadius;
422 ViewAbstract::SetBorderRadius(borderRadius);
423 ViewAbstract::SetBorderRadius(nullptr, borderRadius);
424
425 NG::BorderColorProperty borderColors;
426 ViewAbstract::SetBorderColor(borderColors);
427
428 NG::BorderWidthProperty borderWidth;
429 ViewAbstract::SetBorderWidth(borderWidth);
430 ViewAbstract::SetBorderWidth(nullptr, borderWidth);
431
432 NG::BorderStyleProperty borderStyles;
433 ViewAbstract::SetBorderStyle(borderStyles);
434 ViewAbstract::SetBorderStyle(nullptr, borderStyles);
435
436 /**
437 * @tc.expected: Return expected results..
438 */
439 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
440 }
441
442 /**
443 * @tc.name: ViewAbstractTest008
444 * @tc.desc: Test the operation of View_Abstract.
445 * @tc.type: FUNC
446 */
447 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest008, TestSize.Level1)
448 {
449 /**
450 * @tc.steps: step1.push FrameNode is not null, related function is called.
451 */
452 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
453 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
454
455 NG::PaddingProperty paddings;
456 ViewAbstract::SetPadding(paddings);
457
458 NG::MarginProperty margins;
459 ViewAbstract::SetMargin(margins);
460
461 NG::BorderRadiusProperty borderRadius;
462 ViewAbstract::SetBorderRadius(borderRadius);
463
464 NG::BorderColorProperty borderColors;
465 ViewAbstract::SetBorderColor(borderColors);
466 ViewAbstract::SetBorderColor(nullptr, borderColors);
467
468 NG::BorderWidthProperty borderWidth;
469 ViewAbstract::SetBorderWidth(borderWidth);
470
471 NG::BorderStyleProperty borderStyles;
472 ViewAbstract::SetBorderStyle(borderStyles);
473 ViewAbstract::SetBorderStyle(nullptr, borderStyles);
474
475 /**
476 * @tc.expected: Return expected results.
477 */
478 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
479 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
480 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
481 ASSERT_NE(frameNode, nullptr);
482 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
483 ASSERT_NE(Node, nullptr);
484 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
485 ASSERT_NE(layoutProperty, nullptr);
486 ViewStackProcessor::GetInstance()->instance = nullptr;
487 }
488
489 /**
490 * @tc.name: ViewAbstractTest009
491 * @tc.desc: Test the operation of View_Abstract
492 * @tc.type: FUNC
493 */
494 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest009, TestSize.Level1)
495 {
496 /**
497 * @tc.steps: step1.The FrameNode is null, related function is called.
498 */
499 GestureEventFunc tapEventFunc;
500 ViewAbstract::SetOnClick(std::move(tapEventFunc));
501 ViewAbstract::SetOnClick(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(tapEventFunc));
502 TouchEventFunc touchEventFunc;
503 ViewAbstract::SetOnTouch(std::move(touchEventFunc));
504 ViewAbstract::SetOnTouch(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(touchEventFunc));
505 OnMouseEventFunc onMouseEventFunc;
506 ViewAbstract::SetOnMouse(std::move(onMouseEventFunc));
507 OnHoverFunc onHoverEventFunc;
508 ViewAbstract::SetOnHover(std::move(onHoverEventFunc));
509 ViewAbstract::SetJSFrameNodeOnHover(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onHoverEventFunc));
510 ViewAbstract::ClearJSFrameNodeOnHover(AceType::RawPtr(FRAME_NODE_REGISTER));
511 OnKeyConsumeFunc onKeyCallback;
512 ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback));
513 DragPreviewOption dragPreviewOption;
514 ViewAbstract::SetDragPreviewOptions(dragPreviewOption);
515 ViewAbstract::SetDragPreviewOptions(AceType::RawPtr(FRAME_NODE_REGISTER), dragPreviewOption);
516 NG::DragDropInfo info;
517 ViewAbstract::SetDragPreview(info);
518
519 auto hoverEffect = static_cast<HoverEffectType>(INDEX);
520 ViewAbstract::SetHoverEffect(hoverEffect);
521 ViewAbstract::SetHoverEffect(AceType::RawPtr(FRAME_NODE_REGISTER), hoverEffect);
522
523 ViewAbstract::SetFocusable(false);
524 ViewAbstract::SetFocusable(AceType::RawPtr(FRAME_NODE_REGISTER), false);
525 ViewAbstract::SetEnabled(false);
526 ViewAbstract::SetEnabled(AceType::RawPtr(FRAME_NODE_REGISTER), false);
527 ViewAbstract::SetOnFocus(callback);
528 ViewAbstract::SetOnBlur(callback);
529
530 /**
531 * @tc.expected: Return expected results.
532 */
533 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
534 }
535
536 /**
537 * @tc.name: ViewAbstractTest010
538 * @tc.desc: Test the operation of View_Abstract.
539 * @tc.type: FUNC
540 */
541 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest010, TestSize.Level1)
542 {
543 /**
544 * @tc.steps: step1.push FrameNode is not null, related function is called.
545 */
546 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
547 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
548
549 GestureEventFunc tapEventFunc;
550 ViewAbstract::SetOnClick(std::move(tapEventFunc));
551 TouchEventFunc touchEventFunc;
552 ViewAbstract::SetOnTouch(std::move(touchEventFunc));
553 OnMouseEventFunc onMouseEventFunc;
554 ViewAbstract::SetOnMouse(std::move(onMouseEventFunc));
555 OnHoverFunc onHoverEventFunc;
556 ViewAbstract::SetOnHover(std::move(onHoverEventFunc));
557 OnKeyConsumeFunc onKeyCallback;
558 ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback));
559
560 auto hoverEffect = static_cast<HoverEffectType>(INDEX);
561 ViewAbstract::SetHoverEffect(hoverEffect);
562
563 ViewAbstract::SetFocusable(true);
564 ViewAbstract::SetOnFocus(callback);
565 ViewAbstract::SetOnBlur(callback);
566 ViewAbstract::SetFlexBasis(VALUE);
567
568 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>();
569 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
570 focusHub->focusable_ = true;
571 focusHub->parentFocusable_ = true;
572 ViewAbstract::SetVisibility(VisibleType::VISIBLE);
573 ViewAbstract::SetEnabled(true);
574
575 /**
576 * @tc.expected: Return expected results.
577 */
578 EXPECT_FALSE(focusHub->IsFocusableScope());
579 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
580 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
581 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
582 ASSERT_NE(frameNode, nullptr);
583 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
584 ASSERT_NE(Node, nullptr);
585 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
586 ASSERT_NE(layoutProperty, nullptr);
587 ViewStackProcessor::GetInstance()->instance = nullptr;
588 }
589
590 /**
591 * @tc.name: ViewAbstractTest011
592 * @tc.desc: Test the operation of View_Abstract
593 * @tc.type: FUNC
594 */
595 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest011, TestSize.Level1)
596 {
597 /**
598 * @tc.steps: step1.The FrameNode is null, related function is called.
599 */
600 ViewAbstract::SetTabIndex(INDEX);
601 ViewAbstract::SetTabIndex(AceType::RawPtr(FRAME_NODE_REGISTER), INDEX);
602 ViewAbstract::SetFocusOnTouch(false);
603 ViewAbstract::SetFocusOnTouch(AceType::RawPtr(FRAME_NODE_REGISTER), false);
604 ViewAbstract::SetDefaultFocus(false);
605 ViewAbstract::SetGroupDefaultFocus(false);
606 ViewAbstract::SetGroupDefaultFocus(AceType::RawPtr(FRAME_NODE_REGISTER), false);
607 ViewAbstract::SetTouchable(false);
608 ViewAbstract::SetTouchable(AceType::RawPtr(FRAME_NODE_REGISTER), false);
609 ViewAbstract::SetOnAppear(callback);
610 ViewAbstract::SetOnAppear(AceType::RawPtr(FRAME_NODE_REGISTER), callback);
611 ViewAbstract::SetOnDisappear(callback);
612 ViewAbstract::SetOnDisappear(AceType::RawPtr(FRAME_NODE_REGISTER), callback);
613 ViewAbstract::GetFocusable(AceType::RawPtr(FRAME_NODE_REGISTER));
614 ViewAbstract::GetDefaultFocus(AceType::RawPtr(FRAME_NODE_REGISTER));
615 ViewAbstract::GetResponseRegion(AceType::RawPtr(FRAME_NODE_REGISTER));
616 ViewAbstract::GetOverlay(AceType::RawPtr(FRAME_NODE_REGISTER));
617 ViewAbstract::SetNeedFocus(AceType::RawPtr(FRAME_NODE_REGISTER), false);
618 ViewAbstract::GetNeedFocus(AceType::RawPtr(FRAME_NODE_REGISTER));
619 ViewAbstract::GetOpacity(AceType::RawPtr(FRAME_NODE_REGISTER));
620 ViewAbstract::GetBorderWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
621 ViewAbstract::GetLayoutBorderWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
622 ViewAbstract::GetBorderRadius(AceType::RawPtr(FRAME_NODE_REGISTER));
623 ViewAbstract::GetBorderColor(AceType::RawPtr(FRAME_NODE_REGISTER));
624 ViewAbstract::GetBorderStyle(AceType::RawPtr(FRAME_NODE_REGISTER));
625 ViewAbstract::GetZIndex(AceType::RawPtr(FRAME_NODE_REGISTER));
626
627 auto hitTestMode = static_cast<HitTestMode>(INDEX);
628 ViewAbstract::SetHitTestMode(hitTestMode);
629 ViewAbstract::SetHitTestMode(AceType::RawPtr(FRAME_NODE_REGISTER), hitTestMode);
630
631 std::vector<DimensionRect> responseRegion;
632 ViewAbstract::SetResponseRegion(std::move(responseRegion));
633 ViewAbstract::SetResponseRegion(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(responseRegion));
634 std::function<DragDropInfo(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragStart;
635 ViewAbstract::SetOnDragStart(std::move(onDragStart));
636 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragEnter;
637 ViewAbstract::SetOnDragEnter(std::move(onDragEnter));
638 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragLeave;
639 ViewAbstract::SetOnDragLeave(std::move(onDragLeave));
640 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragMove;
641 ViewAbstract::SetOnDragMove(std::move(onDragMove));
642 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDrop;
643 ViewAbstract::SetOnDrop(std::move(onDrop));
644 Alignment alignment;
645 ViewAbstract::SetAlign(std::move(alignment));
646 ViewAbstract::SetAlign(nullptr, std::move(alignment));
647
648 /**
649 * @tc.expected: Return expected results.
650 */
651 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
652 }
653
654 /**
655 * @tc.name: ViewAbstractTest012
656 * @tc.desc: Test the operation of View_Abstract.
657 * @tc.type: FUNC
658 */
659 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest012, TestSize.Level1)
660 {
661 /**
662 * @tc.steps: step1.push FrameNode is not null, related function is called.
663 */
664 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
665 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
666
667 ViewAbstract::SetTabIndex(INDEX);
668 ViewAbstract::SetFocusOnTouch(false);
669 ViewAbstract::SetDefaultFocus(false);
670 ViewAbstract::SetDefaultFocus(AceType::RawPtr(FRAME_NODE_REGISTER), false);
671 ViewAbstract::SetGroupDefaultFocus(false);
672 ViewAbstract::SetTouchable(false);
673 ViewAbstract::SetOnAppear(callback);
674 ViewAbstract::SetOnDisappear(callback);
675 auto hitTestMode = static_cast<HitTestMode>(INDEX);
676 ViewAbstract::SetHitTestMode(hitTestMode);
677
678 std::vector<DimensionRect> responseRegion;
679 ViewAbstract::SetResponseRegion(std::move(responseRegion));
680 std::function<DragDropInfo(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragStart;
681 ViewAbstract::SetOnDragStart(std::move(onDragStart));
682 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragEnter;
683 ViewAbstract::SetOnDragEnter(std::move(onDragEnter));
684 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragLeave;
685 ViewAbstract::SetOnDragLeave(std::move(onDragLeave));
686 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragMove;
687 ViewAbstract::SetOnDragMove(std::move(onDragMove));
688 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDrop;
689 ViewAbstract::SetOnDrop(std::move(onDrop));
690 Alignment alignment;
691 ViewAbstract::SetAlign(std::move(alignment));
692
693 /**
694 * @tc.expected: Return expected results.
695 */
696 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
697 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
698 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
699 ASSERT_NE(frameNode, nullptr);
700 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
701 ASSERT_NE(Node, nullptr);
702 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
703 ASSERT_NE(layoutProperty, nullptr);
704 ViewStackProcessor::GetInstance()->instance = nullptr;
705 }
706
707 /**
708 * @tc.name: ViewAbstractTest013
709 * @tc.desc: Test the operation of View_Abstract
710 * @tc.type: FUNC
711 */
712 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest013, TestSize.Level1)
713 {
714 /**
715 * @tc.steps: step1.The FrameNode is null, related function is called.
716 */
717 auto visible = static_cast<VisibleType>(INDEX);
718 ViewAbstract::SetVisibility(std::move(visible));
719 ViewAbstract::SetVisibility(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(visible));
720 ViewAbstract::SetGeometryTransition(srcimages);
721 ViewAbstract::SetGeometryTransition(AceType::RawPtr(FRAME_NODE_REGISTER), srcimages, false, true);
722 ViewAbstract::SetOpacity(OPACITYS);
723 ViewAbstract::SetOpacity(AceType::RawPtr(FRAME_NODE_REGISTER), OPACITYS);
724 ViewAbstract::SetZIndex(FOUF);
725
726 OffsetT<Dimension> value = { WIDTH, HEIGHT };
727 ViewAbstract::SetPosition(value);
728 ViewAbstract::SetPosition(AceType::RawPtr(FRAME_NODE_REGISTER), value);
729 ViewAbstract::SetOffset(value);
730 ViewAbstract::SetOffset(AceType::RawPtr(FRAME_NODE_REGISTER), value);
731 ViewAbstract::MarkAnchor(value);
732 ViewAbstract::MarkAnchor(AceType::RawPtr(FRAME_NODE_REGISTER), value);
733 VectorF scale(1.0f, 1.0f);
734 ViewAbstract::SetScale(scale);
735 ViewAbstract::SetScale(AceType::RawPtr(FRAME_NODE_REGISTER), scale);
736 DimensionOffset valueOffset = { WIDTH, HEIGHT };
737 ViewAbstract::SetPivot(AceType::RawPtr(FRAME_NODE_REGISTER), valueOffset);
738 ViewAbstract::GetVisibility(AceType::RawPtr(FRAME_NODE_REGISTER));
739 ViewAbstract::GetClip(AceType::RawPtr(FRAME_NODE_REGISTER));
740 ViewAbstract::GetClipShape(AceType::RawPtr(FRAME_NODE_REGISTER));
741 ViewAbstract::GetTransform(AceType::RawPtr(FRAME_NODE_REGISTER));
742 ViewAbstract::GetHitTestBehavior(AceType::RawPtr(FRAME_NODE_REGISTER));
743 ViewAbstract::GetPosition(AceType::RawPtr(FRAME_NODE_REGISTER));
744 ViewAbstract::GetShadow(AceType::RawPtr(FRAME_NODE_REGISTER));
745 ViewAbstract::GetSweepGradient(AceType::RawPtr(FRAME_NODE_REGISTER));
746 ViewAbstract::GetRadialGradient(AceType::RawPtr(FRAME_NODE_REGISTER));
747 ViewAbstract::GetMask(AceType::RawPtr(FRAME_NODE_REGISTER));
748 ViewAbstract::GetMaskProgress(AceType::RawPtr(FRAME_NODE_REGISTER));
749 ViewAbstract::GetBlendMode(AceType::RawPtr(FRAME_NODE_REGISTER));
750 ViewAbstract::GetDirection(AceType::RawPtr(FRAME_NODE_REGISTER));
751 ViewAbstract::GetAlignSelf(AceType::RawPtr(FRAME_NODE_REGISTER));
752 ViewAbstract::GetFlexGrow(AceType::RawPtr(FRAME_NODE_REGISTER));
753 ViewAbstract::GetFlexShrink(AceType::RawPtr(FRAME_NODE_REGISTER));
754 ViewAbstract::GetFlexBasis(AceType::RawPtr(FRAME_NODE_REGISTER));
755 ViewAbstract::GetMinWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
756 ViewAbstract::GetMaxWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
757 ViewAbstract::GetMinHeight(AceType::RawPtr(FRAME_NODE_REGISTER));
758 ViewAbstract::GetMaxHeight(AceType::RawPtr(FRAME_NODE_REGISTER));
759 ViewAbstract::GetGrayScale(AceType::RawPtr(FRAME_NODE_REGISTER));
760 ViewAbstract::GetInvert(AceType::RawPtr(FRAME_NODE_REGISTER));
761 ViewAbstract::GetSepia(AceType::RawPtr(FRAME_NODE_REGISTER));
762 ViewAbstract::GetContrast(AceType::RawPtr(FRAME_NODE_REGISTER));
763 ViewAbstract::GetForegroundColor(AceType::RawPtr(FRAME_NODE_REGISTER));
764 ViewAbstract::GetScale(AceType::RawPtr(FRAME_NODE_REGISTER));
765 ViewAbstract::GetRotate(AceType::RawPtr(FRAME_NODE_REGISTER));
766 ViewAbstract::GetBrightness(AceType::RawPtr(FRAME_NODE_REGISTER));
767 ViewAbstract::GetSaturate(AceType::RawPtr(FRAME_NODE_REGISTER));
768 ViewAbstract::GetBackgroundImagePosition(AceType::RawPtr(FRAME_NODE_REGISTER));
769 ViewAbstract::GetLinearGradient(AceType::RawPtr(FRAME_NODE_REGISTER));
770 ViewAbstract::GetAlign(AceType::RawPtr(FRAME_NODE_REGISTER));
771 ViewAbstract::GetWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
772 ViewAbstract::GetHeight(AceType::RawPtr(FRAME_NODE_REGISTER));
773 ViewAbstract::GetBackgroundColor(AceType::RawPtr(FRAME_NODE_REGISTER));
774 ViewAbstract::GetBackgroundImageSrc(AceType::RawPtr(FRAME_NODE_REGISTER));
775 auto repeat = static_cast<ImageRepeat>(INDEX);
776 ViewAbstract::SetBackgroundImageRepeat(AceType::RawPtr(FRAME_NODE_REGISTER), repeat);
777 ViewAbstract::GetBackgroundImageRepeat(AceType::RawPtr(FRAME_NODE_REGISTER));
778 ViewAbstract::GetPadding(AceType::RawPtr(FRAME_NODE_REGISTER));
779 ViewAbstract::GetConfigSize(AceType::RawPtr(FRAME_NODE_REGISTER));
780 ViewAbstract::GetEnabled(AceType::RawPtr(FRAME_NODE_REGISTER));
781
782 /**
783 * @tc.expected: Return expected results.
784 */
785 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
786 }
787
788 /**
789 * @tc.name: ViewAbstractTest014
790 * @tc.desc: Test the operation of View_Abstract.
791 * @tc.type: FUNC
792 */
793 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest014, TestSize.Level1)
794 {
795 /**
796 * @tc.steps: step1.push FrameNode is not null, related function is called.
797 */
798 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
799 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
800
801 auto visible = static_cast<VisibleType>(INDEX);
802 ViewAbstract::SetVisibility(std::move(visible));
803 ViewAbstract::SetGeometryTransition(srcimages);
804 ViewAbstract::SetOpacity(OPACITYS);
805 ViewAbstract::SetZIndex(FOUF);
806 ViewAbstract::SetZIndex(nullptr, FOUF);
807
808 OffsetT<Dimension> value = { WIDTH, HEIGHT };
809 ViewAbstract::SetPosition(value);
810 ViewAbstract::SetOffset(value);
811 ViewAbstract::MarkAnchor(value);
812 viewAbstractModelNG.SetScale(-1.0f, -1.0f, 0.0f);
813 ViewAbstract::GetMargin(AceType::RawPtr(FRAME_NODE_REGISTER));
814 ViewAbstract::GetTranslate(AceType::RawPtr(FRAME_NODE_REGISTER));
815 GestureEventFunc tapEventFunc;
816 ViewAbstract::SetJSFrameNodeOnClick(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(tapEventFunc));
817 ViewAbstract::ClearJSFrameNodeOnClick(AceType::RawPtr(FRAME_NODE_REGISTER));
818 TouchEventFunc touchEventFunc;
819 ViewAbstract::SetJSFrameNodeOnTouch(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(touchEventFunc));
820 ViewAbstract::ClearJSFrameNodeOnTouch(AceType::RawPtr(FRAME_NODE_REGISTER));
821 std::function<void()> buildFunc;
822 ViewAbstract::SetJSFrameNodeOnAppear(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(buildFunc));
823 ViewAbstract::ClearJSFrameNodeOnAppear(AceType::RawPtr(FRAME_NODE_REGISTER));
824 ViewAbstract::SetJSFrameNodeOnDisappear(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(buildFunc));
825 ViewAbstract::ClearJSFrameNodeOnDisappear(AceType::RawPtr(FRAME_NODE_REGISTER));
__anoncde27ef90202(KeyEventInfo& info) 826 OnKeyCallbackFunc onKeyCallback = [](KeyEventInfo& info) {};
827 ViewAbstract::SetJSFrameNodeOnKeyCallback(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onKeyCallback));
828 ViewAbstract::ClearJSFrameNodeOnKeyCallback(AceType::RawPtr(FRAME_NODE_REGISTER));
829
830 std::function<void(bool, double)> onVisibleChange;
831 const std::vector<double> ratios;
832 constexpr uint32_t minInterval = 100; // 100ms
833 ViewAbstract::SetJSFrameNodeOnVisibleAreaApproximateChange(
834 AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onVisibleChange), ratios, minInterval);
835 ViewAbstract::ClearJSFrameNodeOnVisibleAreaApproximateChange(AceType::RawPtr(FRAME_NODE_REGISTER));
836
837 /**
838 * @tc.expected: Return expected results.
839 */
840 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
841 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
842 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
843 ASSERT_NE(frameNode, nullptr);
844 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
845 ASSERT_NE(Node, nullptr);
846 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
847 ASSERT_NE(layoutProperty, nullptr);
848 ViewStackProcessor::GetInstance()->instance = nullptr;
849 }
850
851 /**
852 * @tc.name: ViewAbstractTest015
853 * @tc.desc: Test the operation of View_Abstract
854 * @tc.type: FUNC
855 */
856 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest015, TestSize.Level1)
857 {
858 /**
859 * @tc.steps: step1.The FrameNode is null, related function is called.
860 */
861 viewAbstractModelNG.SetPivot(WIDTH, HEIGHT, WIDTH);
862 NG::TranslateOptions pttions;
863 BlurOption blurOption;
864 ViewAbstract::SetTranslate(std::move(pttions));
865 ViewAbstract::SetTranslate(nullptr, std::move(pttions));
866 Matrix4 matrix;
867 ViewAbstract::SetTransformMatrix(std::move(matrix));
868 ViewAbstract::SetTransformMatrix(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(matrix));
869 ViewAbstract::SetBackdropBlur(RADIUS, blurOption);
870 ViewAbstract::SetBackdropBlur(nullptr, RADIUS, blurOption);
871 ViewAbstract::SetFrontBlur(RADIUS, blurOption);
872 ViewAbstract::SetFrontBlur(AceType::RawPtr(FRAME_NODE_REGISTER), RADIUS, blurOption);
873 ViewAbstract::SetInspectorId(srcimages);
874 ViewAbstract::SetInspectorId(AceType::RawPtr(FRAME_NODE_REGISTER), srcimages);
875
876 Vector5F scale(1.0f, 1.0f, 2.0f, 2.0f, 0.0f);
877 ViewAbstract::SetRotate(scale);
878 ViewAbstract::SetRotate(nullptr, scale);
879 ShadowStyle style { 1 };
880 Shadow shadow { RATIO, OFFSET, BLUE, style };
881 ViewAbstract::SetBackShadow(shadow);
882 ViewAbstract::SetBackShadow(nullptr, shadow);
883
884 NG::Gradient gradient;
885 ViewAbstract::SetLinearGradient(std::move(gradient));
886 ViewAbstract::SetLinearGradient(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(gradient));
887 ViewAbstract::SetSweepGradient(std::move(gradient));
888 ViewAbstract::SetSweepGradient(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(gradient));
889 ViewAbstract::SetRadialGradient(std::move(gradient));
890 ViewAbstract::SetRadialGradient(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(gradient));
891 ViewAbstract::SetSystemBarEffect(false);
892 ViewAbstract::SetSystemBarEffect(nullptr, false);
893 ViewAbstract::SetFreeze(false);
894 ViewAbstract::SetUseShadowBatching(false);
895 ViewAbstract::SetUseShadowBatching(AceType::RawPtr(FRAME_NODE_REGISTER), false);
896
897 /**
898 * @tc.expected: Return expected results.
899 */
900 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
901 }
902
903 /**
904 * @tc.name: ViewAbstractTest016
905 * @tc.desc: Test the operation of View_Abstract.
906 * @tc.type: FUNC
907 */
908 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest016, TestSize.Level1)
909 {
910 /**
911 * @tc.steps: step1.push FrameNode is not null, related function is called.
912 */
913 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
914 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
915
916 viewAbstractModelNG.SetPivot(WIDTH, HEIGHT, ZERO);
917 NG::TranslateOptions pttions;
918 ViewAbstract::SetTranslate(std::move(pttions));
919 Matrix4 matrix;
920 BlurOption blurOption;
921 ViewAbstract::SetTransformMatrix(std::move(matrix));
922 ViewAbstract::SetBackdropBlur(RADIUS, blurOption);
923 ViewAbstract::SetFrontBlur(RADIUS, blurOption);
924 ViewAbstract::SetInspectorId(srcimages);
925 ViewAbstract::SetDebugLine(srcimages);
926
927 Vector5F scale(1.0f, 1.0f, 2.0f, 2.0f, 0.0f);
928 ViewAbstract::SetRotate(scale);
929 ShadowStyle style { 1 };
930 Shadow shadow { RATIO, OFFSET, BLUE, style };
931 ViewAbstract::SetBackShadow(shadow);
932 NG::Gradient gradient;
933 ViewAbstract::SetLinearGradient(std::move(gradient));
934 ViewAbstract::SetSweepGradient(std::move(gradient));
935 ViewAbstract::SetRadialGradient(std::move(gradient));
936 ViewAbstract::SetSystemBarEffect(false);
937 ViewAbstract::SetSystemBarEffect(nullptr, false);
938 ViewAbstract::SetFreeze(false);
939 ViewAbstract::SetUseShadowBatching(false);
940 ImageResizableSlice slice;
941 ViewAbstract::SetBackgroundImageResizableSlice(slice);
942 ViewAbstract::SetBackgroundImageResizableSlice(nullptr, slice);
943
944 /**
945 * @tc.expected: Return expected results.
946 */
947 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
948 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
949 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
950 ASSERT_NE(frameNode, nullptr);
951 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
952 ASSERT_NE(Node, nullptr);
953 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
954 ASSERT_NE(layoutProperty, nullptr);
955 ViewStackProcessor::GetInstance()->instance = nullptr;
956 }
957
958 /**
959 * @tc.name: ViewAbstractTest017
960 * @tc.desc: Test the operation of View_Abstract
961 * @tc.type: FUNC
962 */
963 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest017, TestSize.Level1)
964 {
965 /**
966 * @tc.steps: step1.The FrameNode is null, related function is called.
967 */
968 auto visible = static_cast<GridSizeType>(INDEX);
969 ViewAbstract::SetGrid(FOUF, FOUF, std::move(visible));
970 ViewAbstract::SetGrid(AceType::RawPtr(FRAME_NODE_REGISTER), FOUF, FOUF, std::move(visible));
971 TransitionOptions options;
972 ViewAbstract::SetTransition(std::move(options));
973 RefPtr<BasicShape> basicShape;
974 ViewAbstract::SetClipShape(std::move(basicShape));
975 ViewAbstract::SetClipShape(nullptr, std::move(basicShape));
976 ViewAbstract::SetMask(std::move(basicShape));
977 ViewAbstract::SetClipEdge(false);
978 ViewAbstract::SetGrayScale(RADIUS);
979 ViewAbstract::SetGrayScale(nullptr, RADIUS);
980 OHOS::Rosen::VisualEffect* visualEffect;
981 ViewAbstract::SetVisualEffect(visualEffect);
982 OHOS::Rosen::Filter* backgroundFilter;
983 ViewAbstract::SetBackgroundFilter(backgroundFilter);
984 OHOS::Rosen::Filter* foregroundFilter;
985 ViewAbstract::SetForegroundFilter(foregroundFilter);
986 OHOS::Rosen::Filter* compositingFilter;
987 ViewAbstract::SetCompositingFilter(compositingFilter);
988 ViewAbstract::SetDynamicDim(1.0f);
989 ViewAbstract::SetContrast(RADIUS);
990 ViewAbstract::SetSaturate(RADIUS);
991 ViewAbstract::SetSaturate(nullptr, RADIUS);
992 ViewAbstract::SetSepia(RADIUS);
993 ViewAbstract::SetSepia(nullptr, RADIUS);
994 ViewAbstract::SetInvert(invert);
995 ViewAbstract::SetInvert(nullptr, invert);
996 ViewAbstract::SetHueRotate(RATIO);
997 ViewAbstract::SetHueRotate(nullptr, RATIO);
998 ViewAbstract::SetBrightness(RADIUS);
999 ViewAbstract::SetColorBlend(BLUE);
1000 ViewAbstract::SetBorderImageSource(srcimages);
1001 ViewAbstract::SetBrightnessBlender(nullptr);
1002
1003 /**
1004 * @tc.expected: Return expected results.
1005 */
1006 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
1007 }
1008
1009 /**
1010 * @tc.name: ViewAbstractTest018
1011 * @tc.desc: Test the operation of View_Abstract.
1012 * @tc.type: FUNC
1013 */
1014 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest018, TestSize.Level1)
1015 {
1016 /**
1017 * @tc.steps: step1.push FrameNode is not null, related function is called.
1018 */
1019 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1020 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1021
1022 auto visible = static_cast<GridSizeType>(INDEX);
1023 ViewAbstract::SetGrid(FOUF, FOUF, std::move(visible));
1024 TransitionOptions options;
1025 ViewAbstract::SetTransition(std::move(options));
1026 RefPtr<BasicShape> basicShape;
1027 ViewAbstract::SetClipShape(std::move(basicShape));
1028 ViewAbstract::SetMask(std::move(basicShape));
1029 ViewAbstract::SetClipEdge(false);
1030 ViewAbstract::SetClipEdge(nullptr, false);
1031 ViewAbstract::SetGrayScale(RADIUS);
1032 ViewAbstract::SetGrayScale(nullptr, RADIUS);
1033 OHOS::Rosen::VisualEffect* visualEffect;
1034 ViewAbstract::SetVisualEffect(visualEffect);
1035 OHOS::Rosen::Filter* backgroundFilter;
1036 ViewAbstract::SetBackgroundFilter(backgroundFilter);
1037 OHOS::Rosen::Filter* foregroundFilter;
1038 ViewAbstract::SetForegroundFilter(foregroundFilter);
1039 OHOS::Rosen::Filter* compositingFilter;
1040 ViewAbstract::SetCompositingFilter(compositingFilter);
1041 ViewAbstract::SetContrast(RADIUS);
1042 ViewAbstract::SetSaturate(RADIUS);
1043 ViewAbstract::SetSepia(RADIUS);
1044 ViewAbstract::SetInvert(invert);
1045 ViewAbstract::SetHueRotate(RATIO);
1046 ViewAbstract::SetBrightness(RADIUS);
1047 ViewAbstract::SetBrightness(nullptr, RADIUS);
1048 ViewAbstract::SetColorBlend(BLUE);
1049 ViewAbstract::SetColorBlend(nullptr, BLUE);
1050 ViewAbstract::SetBorderImageSource(srcimages);
1051 ViewAbstract::SetBrightnessBlender(nullptr);
1052
1053 /**
1054 * @tc.expected: Return expected results.
1055 */
1056 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1057 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1058 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1059 ASSERT_NE(frameNode, nullptr);
1060 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1061 ASSERT_NE(Node, nullptr);
1062 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1063 ASSERT_NE(layoutProperty, nullptr);
1064 ViewStackProcessor::GetInstance()->instance = nullptr;
1065 }
1066
1067 /**
1068 * @tc.name: ViewAbstractTest019
1069 * @tc.desc: Test the operation of View_Abstract
1070 * @tc.type: FUNC
1071 */
1072 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest019, TestSize.Level1)
1073 {
1074 /**
1075 * @tc.steps: step1.The FrameNode is null, related function is called.
1076 */
1077 RefPtr<BorderImage> borderImage;
1078 ViewAbstract::SetBorderImage(std::move(borderImage));
1079 ViewAbstract::SetHasBorderImageSlice(true);
1080 ViewAbstract::SetHasBorderImageWidth(true);
1081 ViewAbstract::SetHasBorderImageOutset(true);
1082 ViewAbstract::SetHasBorderImageRepeat(true);
1083 ViewAbstract::SetHasBorderImageRepeat(nullptr, true);
1084 Gradient gradient;
1085 ViewAbstract::SetBorderImageGradient(std::move(gradient));
1086 ViewAbstract::SetBorderImageGradient(nullptr, std::move(gradient));
1087 OverlayOptions overlay;
1088 ViewAbstract::SetOverlay(std::move(overlay));
1089 ViewAbstract::SetOverlay(nullptr, std::move(overlay));
1090 MotionPathOption motionPath;
1091 ViewAbstract::SetMotionPath(std::move(motionPath));
1092 ViewAbstract::SetMotionPath(nullptr, std::move(motionPath));
1093 ViewAbstract::SetSharedTransition("", nullptr);
1094 ViewAbstract::SetSharedTransition(AceType::RawPtr(FRAME_NODE_REGISTER), "", nullptr);
1095 ViewAbstract::SetSphericalEffect(RATIO);
1096 ViewAbstract::SetLightUpEffect(RATIO);
1097 ViewAbstract::SetUseEffect(false, EffectType::DEFAULT);
1098 ViewAbstract::SetRenderGroup(false);
1099 ViewAbstract::SetRenderFit(RenderFit::BOTTOM);
1100 ViewAbstract::UpdateSafeAreaExpandOpts(safeAreaExpandOpts);
1101 ViewAbstract::UpdateSafeAreaExpandOpts(AceType::RawPtr(FRAME_NODE_REGISTER), safeAreaExpandOpts);
1102 ViewAbstract::SetObscured(reasonsVector);
1103 ViewAbstract::SetObscured(AceType::RawPtr(FRAME_NODE_REGISTER), reasonsVector);
1104
1105 /**
1106 * @tc.expected: Return expected results.
1107 */
1108 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
1109 }
1110
1111 /**
1112 * @tc.name: ViewAbstractTest020
1113 * @tc.desc: Test the operation of View_Abstract.
1114 * @tc.type: FUNC
1115 */
1116 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest020, TestSize.Level1)
1117 {
1118 /**
1119 * @tc.steps: step1.push FrameNode is not null, related function is called.
1120 */
1121 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1122 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1123
1124 RefPtr<BorderImage> borderImage;
1125 ViewAbstract::SetBorderImage(std::move(borderImage));
1126 ViewAbstract::SetBorderImage(nullptr, std::move(borderImage));
1127 ViewAbstract::SetHasBorderImageSlice(true);
1128 ViewAbstract::SetHasBorderImageWidth(true);
1129 ViewAbstract::SetHasBorderImageOutset(true);
1130 ViewAbstract::SetHasBorderImageRepeat(true);
1131 Gradient gradient;
1132 ViewAbstract::SetBorderImageGradient(std::move(gradient));
1133 OverlayOptions overlay;
1134 ViewAbstract::SetOverlay(std::move(overlay));
1135 MotionPathOption motionPath;
1136 ViewAbstract::SetMotionPath(std::move(motionPath));
1137 std::shared_ptr<SharedTransitionOption> option;
1138 ViewAbstract::SetSharedTransition(srcimages, std::move(option));
1139 ViewAbstract::SetSphericalEffect(RATIO);
1140 ViewAbstract::SetLightUpEffect(RATIO);
1141 ViewAbstract::SetDraggable(false);
1142 ViewAbstract::SetDraggable(AceType::RawPtr(FRAME_NODE_REGISTER), false);
1143 ViewAbstract::SetUseEffect(false, EffectType::DEFAULT);
1144 ViewAbstract::SetUseEffect(false, EffectType::WINDOW_EFFECT);
1145 ViewAbstract::SetUseEffect(true, EffectType::DEFAULT);
1146 ViewAbstract::SetUseEffect(true, EffectType::WINDOW_EFFECT);
1147 ViewAbstract::SetRenderGroup(false);
1148 ViewAbstract::SetRenderFit(RenderFit::BOTTOM);
1149 ViewAbstract::UpdateSafeAreaExpandOpts(safeAreaExpandOpts);
1150 ViewAbstract::SetObscured(reasonsVector);
1151
1152 /**
1153 * @tc.expected: Return expected results.
1154 */
1155 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1156 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1157 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1158 ASSERT_NE(frameNode, nullptr);
1159 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1160 ASSERT_NE(Node, nullptr);
1161 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1162 ASSERT_NE(layoutProperty, nullptr);
1163 ViewStackProcessor::GetInstance()->instance = nullptr;
1164 }
1165
1166 /**
1167 * @tc.name: ViewAbstractTest021
1168 * @tc.desc: Test the operation of View_Abstract
1169 * @tc.type: FUNC
1170 */
1171 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest021, TestSize.Level1)
1172 {
1173 /**
1174 * @tc.steps: step1.The FrameNode is null, related function is called.
1175 */
1176 PixStretchEffectOption option;
1177 option.bottom = BOTTOM;
1178 option.left = LEFT;
1179 option.right = RIGHT;
1180 option.top = TOP;
1181 ViewAbstract::SetPixelStretchEffect(option);
1182 ViewAbstract::SetPixelStretchEffect(nullptr, option);
1183 RefPtr<NG::ChainedTransitionEffect> effect;
1184 ViewAbstract::SetChainedTransition(std::move(effect));
1185 RefPtr<ProgressMaskProperty> progress;
1186 ViewAbstract::SetProgressMask(std::move(progress));
1187
1188 ViewAbstract::SetForegroundColor(BLUE);
1189 auto strategy = static_cast<ForegroundColorStrategy>(INDEX);
1190 ViewAbstract::SetForegroundColorStrategy(std::move(strategy));
1191 auto hoverEffect = static_cast<HoverEffectType>(INDEX);
1192 ViewAbstract::SetHoverEffectAuto(hoverEffect);
1193 ViewAbstract::SetDraggable(true);
1194
1195 /**
1196 * @tc.expected: Return expected results.
1197 */
1198 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
1199 }
1200
1201 /**
1202 * @tc.name: ViewAbstractTest022
1203 * @tc.desc: Test the operation of View_Abstract.
1204 * @tc.type: FUNC
1205 */
1206 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest022, TestSize.Level1)
1207 {
1208 /**
1209 * @tc.steps: step1.push FrameNode is not null, related function is called.
1210 */
1211 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1212 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1213
1214 PixStretchEffectOption option;
1215 option.bottom = BOTTOM;
1216 option.left = LEFT;
1217 option.right = RIGHT;
1218 option.top = TOP;
1219 ViewAbstract::SetPixelStretchEffect(option);
1220 RefPtr<NG::ChainedTransitionEffect> effect;
1221 ViewAbstract::SetChainedTransition(std::move(effect));
1222 RefPtr<ProgressMaskProperty> progress;
1223 ViewAbstract::SetProgressMask(std::move(progress));
1224 ViewAbstract::SetForegroundColor(BLUE);
1225 auto strategy = static_cast<ForegroundColorStrategy>(INDEX);
1226 ViewAbstract::SetForegroundColorStrategy(std::move(strategy));
1227 ViewAbstract::SetBorderWidth(VALUE);
1228 ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
1229 ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
1230 auto hoverEffect = static_cast<HoverEffectType>(INDEX);
1231 ViewAbstract::SetHoverEffectAuto(hoverEffect);
1232 ViewAbstract::SetDraggable(true);
1233
1234 /**
1235 * @tc.expected: Return expected results.
1236 */
1237 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1238 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1239 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1240 ASSERT_NE(frameNode, nullptr);
1241 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1242 ASSERT_NE(Node, nullptr);
1243 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1244 ASSERT_NE(layoutProperty, nullptr);
1245 ViewStackProcessor::GetInstance()->instance = nullptr;
1246 }
1247
1248 /**
1249 * @tc.name: ViewAbstractTest023
1250 * @tc.desc: Test the operation of View_Abstract
1251 * @tc.type: FUNC
1252 */
1253 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest023, TestSize.Level1)
1254 {
1255 /**
1256 * @tc.steps: step1.The FrameNode is null, related function is called.
1257 */
1258 std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)>
1259 onAreaChanged;
1260 ViewAbstract::SetOnAreaChanged(std::move(onAreaChanged));
1261 ViewAbstract::SetOnAreaChanged(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onAreaChanged));
1262
1263 std::function<void(const RectF& oldRect, const RectF& rect)> onSizeChanged;
1264 ViewAbstract::SetOnSizeChanged(std::move(onSizeChanged));
1265 std::function<void(bool, double)> onVisibleChange;
1266 const std::vector<double> ratios;
1267 ViewAbstract::SetOnVisibleChange(std::move(onVisibleChange), ratios);
1268
1269 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&)> onDragEnd;
1270 ViewAbstract::SetOnDragEnd(std::move(onDragEnd));
1271 std::set<std::string> allowDrop;
1272 ViewAbstract::SetAllowDrop(std::move(allowDrop));
1273 ViewAbstract::SetAllowDrop(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(allowDrop));
1274 ViewAbstract::CreateAnimatablePropertyFloat(srcimages, RATIO, nullptr);
1275 ViewAbstract::UpdateAnimatablePropertyFloat(srcimages, RATIO);
1276 ViewAbstract::SetRestoreId(TEN);
1277 ViewAbstract::SetRestoreId(AceType::RawPtr(FRAME_NODE_REGISTER), TEN);
1278
1279 /**
1280 * @tc.expected: Return expected results.
1281 */
1282 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
1283 }
1284
1285 /**
1286 * @tc.name: ViewAbstractTest024
1287 * @tc.desc: Test the operation of View_Abstract.
1288 * @tc.type: FUNC
1289 */
1290 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest024, TestSize.Level1)
1291 {
1292 /**
1293 * @tc.steps: step1.push FrameNode is not null, related function is called.
1294 */
1295 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1296 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1297
1298 std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)>
1299 onAreaChanged;
1300 ViewAbstract::SetOnAreaChanged(std::move(onAreaChanged));
1301 std::function<void(bool, double)> onVisibleChange;
1302 const std::vector<double> ratios;
1303 ViewAbstract::SetOnVisibleChange(std::move(onVisibleChange), ratios);
1304 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&)> onDragEnd;
1305 ViewAbstract::SetOnDragEnd(std::move(onDragEnd));
1306 std::set<std::string> allowDrop;
1307 ViewAbstract::SetAllowDrop(std::move(allowDrop));
1308 ViewAbstract::CreateAnimatablePropertyFloat(srcimages, RATIO, nullptr);
1309 ViewAbstract::UpdateAnimatablePropertyFloat(srcimages, RATIO);
1310 ViewAbstract::SetRestoreId(TEN);
1311
1312 /**
1313 * @tc.expected: Return expected results.
1314 */
1315 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1316 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1317 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1318 ASSERT_NE(frameNode, nullptr);
1319 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1320 ASSERT_NE(Node, nullptr);
1321 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1322 ASSERT_NE(layoutProperty, nullptr);
1323 ViewStackProcessor::GetInstance()->instance = nullptr;
1324 }
1325
1326 /**
1327 * @tc.name: ViewAbstractTest025
1328 * @tc.desc: Test the BindPopup of View_Abstract.
1329 * @tc.type: FUNC
1330 */
1331 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest025, TestSize.Level1)
1332 {
1333 /**
1334 * @tc.steps: step1. Create some FrameNode and params.
1335 */
1336 const RefPtr<FrameNode> customNode = FrameNode::CreateFrameNode("one", 1, AceType::MakeRefPtr<Pattern>(), true);
1337 const RefPtr<FrameNode> targetNode = FrameNode::CreateFrameNode("two", 2, AceType::MakeRefPtr<Pattern>());
1338 const RefPtr<FrameNode> targetNode2 = FrameNode::CreateFrameNode("three", 3, AceType::MakeRefPtr<Pattern>());
1339 auto param = AceType::MakeRefPtr<PopupParam>();
1340 auto param2 = AceType::MakeRefPtr<PopupParam>();
1341
1342 /**
1343 * @tc.steps: step2. get popupInfo and change some params.
1344 */
1345 auto container = Container::Current();
1346 ASSERT_NE(container, nullptr);
1347 auto pipelineContext = container->GetPipelineContext();
1348 ASSERT_NE(pipelineContext, nullptr);
1349 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext);
1350 ASSERT_NE(context, nullptr);
1351 auto overlayManager = context->GetOverlayManager();
1352 ASSERT_NE(overlayManager, nullptr);
1353 auto nodeId = targetNode->GetId();
1354 PopupInfo info = overlayManager->GetPopupInfo(nodeId);
1355 info.isCurrentOnShow = true;
1356 info.popupId = 1;
1357 auto popupNode1 = FrameNode::CreateFrameNode(
1358 V2::POPUP_ETS_TAG, info.popupId, AceType::MakeRefPtr<BubblePattern>(targetNode->GetId(), targetNode->GetTag()));
1359 info.popupNode = popupNode1;
1360 info.target = targetNode2;
1361 overlayManager->ShowPopup(targetNode->GetId(), info);
1362
1363 /**
1364 * @tc.steps: step3. Call BindPopup many times.
1365 * @tc.expected: popupNode in overlayManager of targetNode not null
1366 */
1367 ViewAbstract::BindPopup(param, targetNode, customNode);
1368 ViewAbstract::BindPopup(param, targetNode, customNode);
1369 overlayManager->HidePopup(targetNode->GetId(), info);
1370 auto popupInfo = overlayManager->GetPopupInfo(targetNode->GetId());
1371 auto popupNode = popupInfo.popupNode;
1372 ASSERT_NE(popupNode, nullptr);
1373 popupNode->GetPattern<BubblePattern>()->transitionStatus_ = TransitionStatus::ENTERING;
1374 ViewAbstract::BindPopup(param, targetNode, customNode);
1375 param->SetIsShow(false);
1376 ViewAbstract::BindPopup(param, targetNode, customNode);
1377 param->SetShowInSubWindow(true);
1378 ViewAbstract::BindPopup(param, targetNode, customNode);
1379 EXPECT_NE(overlayManager->GetPopupInfo(targetNode->GetId()).popupNode, nullptr);
1380
1381 /**
1382 * @tc.steps: step4. Call BindPopup with param use custom.
1383 * @tc.expected: popupNode in overlayManager of targetNode not null
1384 */
1385 param2->SetUseCustomComponent(true);
1386 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1387 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1388 param2->SetShowInSubWindow(true);
1389 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1390 param2->SetIsShow(false);
1391 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1392 EXPECT_NE(overlayManager->GetPopupInfo(targetNode->GetId()).popupNode, nullptr);
1393 }
1394
1395 /**
1396 * @tc.name: ViewAbstractTest026
1397 * @tc.desc: Test the SetKeyboardShortcut of View_Abstract.
1398 * @tc.type: FUNC
1399 */
1400 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest026, TestSize.Level1)
1401 {
1402 /**
1403 * @tc.steps: step1. Create a FrameNode and get eventManager.
1404 */
1405 const RefPtr<FrameNode> targetNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true);
1406 ViewStackProcessor::GetInstance()->Push(targetNode);
1407 auto eventManager = PipelineContext::GetCurrentContext()->GetEventManager();
1408 /**
1409 * @tc.steps: step2. call SetKeyboardShortcut with ctrl + x.
1410 * @tc.expected: add fail
1411 */
1412 std::vector<ModifierKey> keys;
1413 keys.push_back(ModifierKey::CTRL);
1414 ViewAbstract::SetKeyboardShortcut(VALUE_X, std::move(keys), callback);
1415 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_X, std::move(keys), callback);
1416 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1417 keys.clear();
1418 /**
1419 * @tc.steps: step3. call SetKeyboardShortcut with other wrong type.
1420 * @tc.expected: add fail
1421 */
1422 ViewAbstract::SetKeyboardShortcut(VALUE_EMPTY, std::move(keys), callback);
1423 ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1424 ViewAbstract::SetKeyboardShortcut(VALUE_X, std::move(keys), callback);
1425 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_EMPTY, std::move(keys), callback);
1426 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_CX, std::move(keys), callback);
1427 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_X, std::move(keys), callback);
1428
1429 /**
1430 * @tc.steps: step4. and shift in keys and recall SetKeyboardShortcut .
1431 * @tc.expected: add success
1432 */
1433 keys.push_back(ModifierKey::ALT);
1434 ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1435 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_CX, std::move(keys), callback);
1436 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1437
1438 /**
1439 * @tc.steps: step5. make other key and recall SetKeyboardShortcut .
1440 * @tc.expected: add fail
1441 */
1442 keys.push_back(ModifierKey::SHIFT);
1443 ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1444 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_CX, std::move(keys), callback);
1445 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1446 keys.push_back(ModifierKey::ALT);
1447 ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1448 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_CX, std::move(keys), callback);
1449 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1450 }
1451
1452 /**
1453 * @tc.name: ViewAbstractTest027
1454 * @tc.desc: Test the operation of View_Abstract.
1455 * @tc.type: FUNC
1456 */
1457 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest027, TestSize.Level1)
1458 {
1459 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1460 /**
1461 * @tc.steps: step1. callback ShowMenu with two condition.
1462 */
1463 ContainerScope sontainerScope(1);
1464 /**
1465 * @tc.steps: step2. callback SetForegroundBlurStyle and ResetFlexShrink.
1466 */
1467 BlurStyleOption bgBlurStyle;
1468 ViewAbstract::SetForegroundBlurStyle(bgBlurStyle);
1469 ViewAbstract::SetForegroundBlurStyle(AceType::RawPtr(FRAME_NODE_REGISTER), bgBlurStyle);
1470 ViewAbstract::ResetFlexShrink();
1471 ViewAbstract::ResetFlexShrink(AceType::RawPtr(FRAME_NODE_REGISTER));
1472 /**
1473 * @tc.steps: step3. SetVisualState in ViewStackProcessor and recall the two function.
1474 * @tc.expected: the blur radius in render context meet expectations.
1475 */
1476 ViewStackProcessor::GetInstance()->SetVisualState(VisualState::FOCUSED);
1477 ViewAbstract::SetForegroundBlurStyle(bgBlurStyle);
1478 ViewAbstract::SetForegroundBlurStyle(AceType::RawPtr(FRAME_NODE_REGISTER), bgBlurStyle);
1479 ViewAbstract::ResetFlexShrink();
1480 ASSERT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr);
1481 EXPECT_FALSE(FRAME_NODE_ROOT->GetRenderContext()->GetFrontBlurRadius().has_value());
1482 }
1483
1484 /**
1485 * @tc.name: ViewAbstractTest028
1486 * @tc.desc: Test the operation of View_Abstract.
1487 * @tc.type: FUNC
1488 */
1489 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest028, TestSize.Level1)
1490 {
1491 /**
1492 * @tc.steps: step1.push FrameNode is not null, callback Pop function.
1493 */
1494 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1495 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1496 ViewAbstract::Pop();
1497
1498 /**
1499 * @tc.expected: Return expected results.
1500 */
1501 EXPECT_FALSE(ViewStackProcessor::GetInstance()->elementsStack_.empty());
1502 EXPECT_EQ(ViewStackProcessor::GetInstance()->elementsStack_.size(), INDEX);
1503 }
1504
1505 /**
1506 * @tc.name: ViewAbstractTest029
1507 * @tc.desc: Test the operation of View_Abstract
1508 * @tc.type: FUNC
1509 */
1510 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest029, TestSize.Level1)
1511 {
1512 /**
1513 * @tc.steps: step1.ClearStack.
1514 */
1515 auto state = static_cast<VisualState>(INDEX);
1516 ViewStackProcessor::GetInstance()->SetVisualState(state);
1517 ViewStackProcessor::GetInstance()->ClearStack();
1518
1519 /**
1520 * @tc.steps: step2. related function is called.
1521 */
1522 ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
1523 ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
1524 ViewAbstract::SetMinWidth(NG::CalcLength(MIN_WIDTH));
1525 ViewAbstract::SetMinHeight(NG::CalcLength(MIN_HEIGHT));
1526 ViewAbstract::SetMaxWidth(NG::CalcLength(MIN_WIDTH));
1527 ViewAbstract::SetMaxHeight(NG::CalcLength(MIN_HEIGHT));
1528 ViewAbstract::SetAspectRatio(RATIO);
1529 ViewAbstract::SetAspectRatio(AceType::RawPtr(FRAME_NODE_REGISTER), RATIO);
1530 ViewAbstract::SetBackgroundColor(BLUE);
1531 ViewAbstract::SetBackgroundColor(nullptr, BLUE);
1532 ViewAbstract::SetBackgroundImage(imageSourceInfo);
1533 ViewAbstract::SetBackgroundImage(nullptr, imageSourceInfo);
1534 ViewAbstract::SetBackgroundImageSize(BACKGROUNDSIZE);
1535 ViewAbstract::SetBackgroundImageSize(nullptr, BACKGROUNDSIZE);
1536 ViewAbstract::SetBackgroundImagePosition(BACKGROUNDPOSITION);
1537 ViewAbstract::SetBackgroundImagePosition(nullptr, BACKGROUNDPOSITION);
1538 ViewAbstract::SetPixelRound(0);
1539 ChainInfo chainInfo;
1540 chainInfo.direction = LineDirection::HORIZONTAL;
1541 chainInfo.style = ChainStyle::SPREAD;
1542 ViewAbstract::SetChainStyle(chainInfo);
1543 ViewAbstract::SetChainStyle(AceType::RawPtr(FRAME_NODE_REGISTER), chainInfo);
1544 ViewAbstract::SetBias(biasPair);
1545 ViewAbstract::SetBias(nullptr, biasPair);
1546 ViewAbstract::SetOuterBorderRadius(ZERO);
1547 ViewAbstract::SetOuterBorderRadius(nullptr, ZERO);
1548 NG::BorderRadiusProperty borderRadius;
1549 ViewAbstract::SetOuterBorderRadius(borderRadius);
1550 ViewAbstract::SetOuterBorderRadius(nullptr, borderRadius);
1551 ViewAbstract::SetOuterBorderColor(BLUE);
1552 ViewAbstract::SetOuterBorderColor(nullptr, BLUE);
1553 NG::BorderColorProperty borderColor;
1554 ViewAbstract::SetOuterBorderColor(borderColor);
1555 ViewAbstract::SetOuterBorderColor(nullptr, borderColor);
1556 ViewAbstract::SetOuterBorderWidth(ZERO);
1557 ViewAbstract::SetOuterBorderWidth(nullptr, ZERO);
1558 NG::BorderWidthProperty borderWidth;
1559 ViewAbstract::SetOuterBorderWidth(borderWidth);
1560 ViewAbstract::SetOuterBorderWidth(nullptr, borderWidth);
1561 auto borderStyle = static_cast<BorderStyle>(INDEX);
1562 ViewAbstract::SetOuterBorderStyle(borderStyle);
1563 ViewAbstract::SetOuterBorderStyle(nullptr, borderStyle);
1564 NG::BorderStyleProperty borderStyleProperty;
1565 ViewAbstract::SetOuterBorderStyle(borderStyleProperty);
1566 ViewAbstract::SetOuterBorderStyle(nullptr, borderStyleProperty);
1567 ViewAbstract::ResetAspectRatio();
1568 ViewAbstract::ResetAspectRatio(AceType::RawPtr(FRAME_NODE_REGISTER));
1569
1570 /**
1571 * @tc.expected: Return expected results.
1572 */
1573 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1574 EXPECT_FALSE(result);
1575 }
1576
1577 /**
1578 * @tc.name: ViewAbstractTest030
1579 * @tc.desc: Test the operation of View_Abstract
1580 * @tc.type: FUNC
1581 */
1582 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest030, TestSize.Level1)
1583 {
1584 /**
1585 * @tc.steps: step1.ClearStack.
1586 */
1587 auto state = static_cast<VisualState>(INDEX);
1588 ViewStackProcessor::GetInstance()->SetVisualState(state);
1589 ViewStackProcessor::GetInstance()->ClearStack();
1590
1591 /**
1592 * @tc.steps: step2. related function is called.
1593 */
1594 MotionPathOption motionPath;
1595 ViewAbstract::SetMotionPath(std::move(motionPath));
1596 auto repeat = static_cast<ImageRepeat>(INDEX);
1597 ViewAbstract::SetBackgroundImageRepeat(repeat);
1598 GestureJudgeFunc tapEventFunc;
1599 ViewAbstract::SetOnGestureJudgeBegin(std::move(tapEventFunc));
1600
1601 BlurStyleOption blurStyleOption;
1602 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
1603 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
1604 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
1605 ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
1606
1607 auto direction = static_cast<TextDirection>(INDEX);
1608 ViewAbstract::SetLayoutDirection(direction);
1609 std::map<AlignDirection, AlignRule> alignRules;
1610 ViewAbstract::SetAlignRules(alignRules);
1611 auto alignSelf = static_cast<FlexAlign>(INDEX);
1612 ViewAbstract::SetAlignSelf(alignSelf);
1613 ViewAbstract::SetAlignSelf(AceType::RawPtr(FRAME_NODE_REGISTER), alignSelf);
1614
1615 /**
1616 * @tc.expected: Return expected results.
1617 */
1618 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1619 EXPECT_FALSE(result);
1620 }
1621
1622 /**
1623 * @tc.name: OpenPopup
1624 * @tc.desc: Test OpenPopup of View_Abstract
1625 * @tc.type: FUNC
1626 */
1627 HWTEST_F(ViewAbstractTestNg, OpenPopup, TestSize.Level1)
1628 {
1629 /**
1630 * @tc.steps: step1. Create some FrameNode and params.
1631 */
1632 auto pipelineContext = PipelineContext::GetCurrentContext();
1633 auto param = AceType::MakeRefPtr<PopupParam>();
1634 RefPtr<PopupParam> param2 = nullptr;
1635 auto contentNode =
1636 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anoncde27ef90302() 1637 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1638 RefPtr<FrameNode> contentNode2 = nullptr;
1639 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef90402() 1640 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1641
1642 /**
1643 * @tc.steps: step2. Return expected results.
1644 */
1645 EXPECT_EQ(ViewAbstract::OpenPopup(param2, contentNode2), ERROR_CODE_INTERNAL_ERROR);
1646 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode2), ERROR_CODE_DIALOG_CONTENT_ERROR);
1647 int32_t targetId = -1;
1648 param->SetTargetId(std::to_string(targetId));
1649 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_TARGET_INFO_NOT_EXIST);
1650 targetId = 10000;
1651 param->SetTargetId(std::to_string(targetId));
1652 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_TARGET_INFO_NOT_EXIST);
1653 param->SetTargetId(std::to_string(targetNode->GetId()));
1654 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_TARGET_NOT_ON_COMPONENT_TREE);
1655 param->SetIsShow(true);
1656 param->SetUseCustomComponent(true);
1657 ViewStackProcessor::GetInstance()->Push(targetNode);
1658 targetNode->onMainTree_ = true;
1659 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1660 auto stageNode = FrameNode::CreateFrameNode(
1661 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1662 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1663 stageNode->MountToParent(rootNode);
1664 targetNode->MountToParent(stageNode);
1665 rootNode->MarkDirtyNode();
1666 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_NO_ERROR);
1667 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_DIALOG_CONTENT_ALREADY_EXIST);
1668 }
1669
1670 /**
1671 * @tc.name: UpdatePopup
1672 * @tc.desc: Test UpdatePopup of View_Abstract
1673 * @tc.type: FUNC
1674 */
1675 HWTEST_F(ViewAbstractTestNg, UpdatePopup, TestSize.Level1)
1676 {
1677 /**
1678 * @tc.steps: step1. Create some FrameNode and params.
1679 */
1680 auto pipelineContext = PipelineContext::GetCurrentContext();
1681 auto param = AceType::MakeRefPtr<PopupParam>();
1682 auto contentNode =
1683 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anoncde27ef90502() 1684 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1685 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef90602() 1686 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1687 ViewStackProcessor::GetInstance()->Push(targetNode);
1688 targetNode->onMainTree_ = true;
1689 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1690 auto stageNode = FrameNode::CreateFrameNode(
1691 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1692 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1693 stageNode->MountToParent(rootNode);
1694 targetNode->MountToParent(stageNode);
1695 rootNode->MarkDirtyNode();
1696 param->SetIsShow(true);
1697 param->SetUseCustomComponent(true);
1698 param->SetShowInSubWindow(false);
1699 param->SetTargetId(std::to_string(targetNode->GetId()));
1700
1701 /**
1702 * @tc.expected: Return expected results.
1703 */
1704 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_NO_ERROR);
1705 auto context = contentNode->GetContextWithCheck();
1706 ASSERT_NE(context, nullptr);
1707 auto overlayManager = context->GetOverlayManager();
1708 ASSERT_NE(overlayManager, nullptr);
1709 overlayManager->popupMap_[targetNode->GetId()].isCurrentOnShow = true;
1710 param->SetIsPartialUpdate(true);
1711 EXPECT_EQ(ViewAbstract::UpdatePopup(param, contentNode), ERROR_CODE_NO_ERROR);
1712 }
1713
1714 /**
1715 * @tc.name: ClosePopup
1716 * @tc.desc: Test ClosePopup of View_Abstract
1717 * @tc.type: FUNC
1718 */
1719 HWTEST_F(ViewAbstractTestNg, ClosePopup, TestSize.Level1)
1720 {
1721 /**
1722 * @tc.steps: step1. Create some FrameNode and params.
1723 */
1724 auto pipelineContext = PipelineContext::GetCurrentContext();
1725 auto param = AceType::MakeRefPtr<PopupParam>();
1726 auto contentNode =
1727 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anoncde27ef90702() 1728 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1729
1730 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef90802() 1731 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1732 ViewStackProcessor::GetInstance()->Push(targetNode);
1733 targetNode->onMainTree_ = true;
1734 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1735 auto stageNode = FrameNode::CreateFrameNode(
1736 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1737 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1738 stageNode->MountToParent(rootNode);
1739 targetNode->MountToParent(stageNode);
1740 rootNode->MarkDirtyNode();
1741 param->SetIsShow(true);
1742 param->SetUseCustomComponent(true);
1743 param->SetTargetId(std::to_string(targetNode->GetId()));
1744
1745 /**
1746 * @tc.expected: Return expected results.
1747 */
1748 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_NO_ERROR);
1749 auto context = contentNode->GetContextWithCheck();
1750 ASSERT_NE(context, nullptr);
1751 auto overlayManager = context->GetOverlayManager();
1752 ASSERT_NE(overlayManager, nullptr);
1753 overlayManager->popupMap_[targetNode->GetId()].isCurrentOnShow = true;
1754 EXPECT_EQ(ViewAbstract::ClosePopup(contentNode), ERROR_CODE_NO_ERROR);
1755 EXPECT_EQ(ViewAbstract::ClosePopup(contentNode), ERROR_CODE_DIALOG_CONTENT_NOT_FOUND);
1756 }
1757
1758 /**
1759 * @tc.name: OpenMenu001
1760 * @tc.desc: Test OpenMenu of View_Abstract
1761 * @tc.type: FUNC
1762 */
1763 HWTEST_F(ViewAbstractTestNg, OpenMenu001, TestSize.Level1)
1764 {
1765 /**
1766 * @tc.steps: step1. Create some FrameNode and menuParam.
1767 */
1768 auto pipelineContext = PipelineContext::GetCurrentContext();
1769 MenuParam menuParam;
1770 menuParam.previewMode = MenuPreviewMode::IMAGE;
1771 auto contentNode =
1772 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anoncde27ef90902() 1773 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1774 RefPtr<FrameNode> contentNode2 = nullptr;
1775 auto contentNode3 =
1776 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anoncde27ef90a02() 1777 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1778 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef90b02() 1779 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1780 int32_t targetId = targetNode->GetId();
1781 /**
1782 * @tc.steps: step2. Return expected results.
1783 */
1784 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode2, targetId), ERROR_CODE_DIALOG_CONTENT_ERROR);
1785 targetId = -1;
1786 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_TARGET_INFO_NOT_EXIST);
1787 targetId = 10000;
1788 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_TARGET_INFO_NOT_EXIST);
1789 targetId = targetNode->GetId();
1790 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_TARGET_NOT_ON_COMPONENT_TREE);
1791 ViewStackProcessor::GetInstance()->Push(targetNode);
1792 targetNode->onMainTree_ = true;
1793 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1794 auto stageNode = FrameNode::CreateFrameNode(
1795 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1796 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1797 stageNode->MountToParent(rootNode);
1798 targetNode->MountToParent(stageNode);
1799 rootNode->MarkDirtyNode();
1800 targetId = targetNode->GetId();
1801 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
1802 ASSERT_NE(targetNodePipelineContext, nullptr);
1803 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1804 targetNodePipelineContext->SetThemeManager(themeManager);
1805 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
1806 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1807
1808 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
1809 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_DIALOG_CONTENT_ALREADY_EXIST);
1810 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode3, targetId), ERROR_CODE_NO_ERROR);
1811 }
1812
1813 /**
1814 * @tc.name: UpdateMenu001
1815 * @tc.desc: Test UpdateMenu of View_Abstract
1816 * @tc.type: FUNC
1817 */
1818 HWTEST_F(ViewAbstractTestNg, UpdateMenu001, TestSize.Level1)
1819 {
1820 /**
1821 * @tc.steps: step1. Create some FrameNode and menuParam.
1822 */
1823 auto pipelineContext = PipelineContext::GetCurrentContext();
1824 MenuParam menuParam;
1825 auto contentNode =
1826 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anoncde27ef90c02() 1827 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1828 RefPtr<FrameNode> contentNode2 = nullptr;
1829 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef90d02() 1830 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1831 ViewStackProcessor::GetInstance()->Push(targetNode);
1832 targetNode->onMainTree_ = true;
1833 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1834 auto stageNode = FrameNode::CreateFrameNode(
1835 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1836 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1837 stageNode->MountToParent(rootNode);
1838 targetNode->MountToParent(stageNode);
1839 rootNode->MarkDirtyNode();
1840 auto targetId = targetNode->GetId();
1841 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
1842 ASSERT_NE(targetNodePipelineContext, nullptr);
1843 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1844 targetNodePipelineContext->SetThemeManager(themeManager);
1845 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
1846 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1847
1848 /**
1849 * @tc.expected: Return expected results.
1850 */
1851 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
1852 auto overlayManager = ViewAbstract::GetCurOverlayManager(contentNode);
1853 ASSERT_NE(overlayManager, nullptr);
1854 overlayManager->menuMap_[targetId];
1855 EXPECT_EQ(ViewAbstract::UpdateMenu(menuParam, contentNode), ERROR_CODE_NO_ERROR);
1856 EXPECT_EQ(ViewAbstract::UpdateMenu(menuParam, contentNode2), ERROR_CODE_DIALOG_CONTENT_ERROR);
1857 overlayManager->menuMap_.clear();
1858 EXPECT_EQ(ViewAbstract::UpdateMenu(menuParam, contentNode), ERROR_CODE_DIALOG_CONTENT_NOT_FOUND);
1859 }
1860
1861 /**
1862 * @tc.name: UpdateMenu002
1863 * @tc.desc: Test UpdateMenu of View_Abstract
1864 * @tc.type: FUNC
1865 */
1866 HWTEST_F(ViewAbstractTestNg, UpdateMenu002, TestSize.Level1)
1867 {
1868 /**
1869 * @tc.steps: step1. Create some FrameNode and menuParam.
1870 */
1871 auto pipelineContext = PipelineContext::GetCurrentContext();
1872 MenuParam menuParam;
1873 auto contentNode =
1874 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anoncde27ef90e02() 1875 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1876 RefPtr<FrameNode> contentNode2 = nullptr;
1877 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef90f02() 1878 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1879 ViewStackProcessor::GetInstance()->Push(targetNode);
1880 targetNode->onMainTree_ = true;
1881 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1882 auto stageNode = FrameNode::CreateFrameNode(
1883 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1884 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1885 stageNode->MountToParent(rootNode);
1886 targetNode->MountToParent(stageNode);
1887 rootNode->MarkDirtyNode();
1888 auto targetId = targetNode->GetId();
1889 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
1890 ASSERT_NE(targetNodePipelineContext, nullptr);
1891 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1892 targetNodePipelineContext->SetThemeManager(themeManager);
1893 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
1894 auto selectTheme = AceType::MakeRefPtr<SelectTheme>();
1895 selectTheme->expandDisplay_ = true;
1896 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(selectTheme));
1897 EXPECT_CALL(*themeManager, GetTheme(_, _)).WillRepeatedly(Return(selectTheme));
1898
1899 /**
1900 * @tc.expected: Return expected results.
1901 */
1902 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
1903 auto overlayManager = ViewAbstract::GetCurOverlayManager(contentNode);
1904 ASSERT_NE(overlayManager, nullptr);
1905 overlayManager->menuMap_[targetId];
1906 auto contentNodePipelineContext = contentNode->GetContextWithCheck();
1907 contentNodePipelineContext->overlayManager_ = nullptr;
1908 EXPECT_EQ(ViewAbstract::UpdateMenu(menuParam, contentNode), ERROR_CODE_INTERNAL_ERROR);
1909 contentNodePipelineContext->overlayManager_ = overlayManager;
1910 }
1911
1912 /**
1913 * @tc.name: UpdateMenu003
1914 * @tc.desc: Test UpdateMenu of View_Abstract
1915 * @tc.type: FUNC
1916 */
1917 HWTEST_F(ViewAbstractTestNg, UpdateMenu003, TestSize.Level1)
1918 {
1919 /**
1920 * @tc.steps: step1. Create some FrameNode and menuParam.
1921 */
1922 auto pipelineContext = PipelineContext::GetCurrentContext();
1923 MenuParam menuParam;
1924 auto contentNode =
1925 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anoncde27ef91002() 1926 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1927 RefPtr<FrameNode> contentNode2 = nullptr;
1928 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef91102() 1929 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1930 ViewStackProcessor::GetInstance()->Push(targetNode);
1931 targetNode->onMainTree_ = true;
1932 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1933 auto stageNode = FrameNode::CreateFrameNode(
1934 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1935 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1936 stageNode->MountToParent(rootNode);
1937 targetNode->MountToParent(stageNode);
1938 rootNode->MarkDirtyNode();
1939 auto targetId = targetNode->GetId();
1940 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
1941 ASSERT_NE(targetNodePipelineContext, nullptr);
1942 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1943 targetNodePipelineContext->SetThemeManager(themeManager);
1944 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
1945 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1946 EXPECT_CALL(*themeManager, GetTheme(_, _)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1947
1948 /**
1949 * @tc.expected: Return expected results.
1950 */
1951 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
1952 auto overlayManager = ViewAbstract::GetCurOverlayManager(contentNode);
1953 ASSERT_NE(overlayManager, nullptr);
1954 overlayManager->menuMap_[targetId];
1955 auto menuWrapperNode = overlayManager->GetMenuNodeWithExistContent(contentNode);
1956 ASSERT_NE(menuWrapperNode, nullptr);
1957 auto wrapperPattern = AceType::DynamicCast<MenuWrapperPattern>(menuWrapperNode->GetPattern());
1958 ASSERT_NE(wrapperPattern, nullptr);
1959 auto menu = wrapperPattern->GetMenu();
1960 ASSERT_NE(menu, nullptr);
1961 auto menuPattern = AceType::DynamicCast<MenuPattern>(menu->GetPattern());
1962 ASSERT_NE(menuPattern, nullptr);
1963 auto menuItem = FrameNode::GetOrCreateFrameNode(V2::MENU_ITEM_ETS_TAG,
__anoncde27ef91202() 1964 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<MenuItemPattern>(); });
1965 menuItem->MountToParent(menu);
1966
1967 auto subMenu = FrameNode::CreateFrameNode(
1968 V2::MENU_ETS_TAG, 3, AceType::MakeRefPtr<MenuPattern>(1, V2::MENU_TAG, MenuType::SUB_MENU));
1969 subMenu->MountToParent(menuWrapperNode);
1970 menuPattern->SetShowedSubMenu(subMenu);
1971 auto menuItemPattern = menuItem->GetPattern<MenuItemPattern>();
1972 menuItemPattern->expandingMode_ = SubMenuExpandingMode::EMBEDDED;
1973 menuPattern->AddEmbeddedMenuItem(menuItem);
1974
1975 EXPECT_EQ(ViewAbstract::UpdateMenu(menuParam, contentNode), ERROR_CODE_NO_ERROR);
1976 }
1977
1978 /**
1979 * @tc.name: UpdateMenu004
1980 * @tc.desc: Test UpdateMenu of View_Abstract
1981 * @tc.type: FUNC
1982 */
1983 HWTEST_F(ViewAbstractTestNg, UpdateMenu004, TestSize.Level1)
1984 {
1985 /**
1986 * @tc.steps: step1. Create some FrameNode and menuParam.
1987 */
1988 auto pipelineContext = PipelineContext::GetCurrentContext();
1989 MenuParam menuParam;
1990 auto contentNode =
1991 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anoncde27ef91302() 1992 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1993 RefPtr<FrameNode> contentNode2 = nullptr;
1994 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef91402() 1995 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1996 ViewStackProcessor::GetInstance()->Push(targetNode);
1997 targetNode->onMainTree_ = true;
1998 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1999 auto stageNode = FrameNode::CreateFrameNode(
2000 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
2001 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
2002 stageNode->MountToParent(rootNode);
2003 targetNode->MountToParent(stageNode);
2004 rootNode->MarkDirtyNode();
2005 auto targetId = targetNode->GetId();
2006 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
2007 ASSERT_NE(targetNodePipelineContext, nullptr);
2008 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2009 targetNodePipelineContext->SetThemeManager(themeManager);
2010 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
2011 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2012 EXPECT_CALL(*themeManager, GetTheme(_, _)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2013
2014 /**
2015 * @tc.expected: Return expected results.
2016 */
2017 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
2018 auto overlayManager = ViewAbstract::GetCurOverlayManager(contentNode);
2019 ASSERT_NE(overlayManager, nullptr);
2020 overlayManager->menuMap_[targetId];
2021 auto menuWrapperNode = overlayManager->GetMenuNodeWithExistContent(contentNode);
2022 ASSERT_NE(menuWrapperNode, nullptr);
2023 auto wrapperPattern = AceType::DynamicCast<MenuWrapperPattern>(menuWrapperNode->GetPattern());
2024 ASSERT_NE(wrapperPattern, nullptr);
2025 auto menu = wrapperPattern->GetMenu();
2026 ASSERT_NE(menu, nullptr);
2027 auto menuPattern = AceType::DynamicCast<MenuPattern>(menu->GetPattern());
2028 ASSERT_NE(menuPattern, nullptr);
2029 auto menuItem = FrameNode::GetOrCreateFrameNode(V2::MENU_ITEM_ETS_TAG,
__anoncde27ef91502() 2030 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<MenuItemPattern>(); });
2031 menuItem->MountToParent(menu);
2032 auto subMenu = FrameNode::CreateFrameNode(
2033 V2::MENU_ETS_TAG, 3, AceType::MakeRefPtr<MenuPattern>(1, V2::MENU_ETS_TAG, MenuType::SUB_MENU));
2034 subMenu->MountToParent(menuWrapperNode);
2035 menuPattern->SetShowedSubMenu(subMenu);
2036 auto menuItemPattern = menuItem->GetPattern<MenuItemPattern>();
2037 menuItemPattern->expandingMode_ = SubMenuExpandingMode::STACK;
2038 EXPECT_EQ(ViewAbstract::UpdateMenu(menuParam, contentNode), ERROR_CODE_NO_ERROR);
2039 }
2040
2041 /**
2042 * @tc.name: CloseMenu001
2043 * @tc.desc: Test CloseMenu of View_Abstract
2044 * @tc.type: FUNC
2045 */
2046 HWTEST_F(ViewAbstractTestNg, CloseMenu001, TestSize.Level1)
2047 {
2048 /**
2049 * @tc.steps: step1. Create some FrameNode and menuParam.
2050 */
2051 auto pipelineContext = PipelineContext::GetCurrentContext();
2052 MenuParam menuParam;
2053 auto contentNode =
2054 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anoncde27ef91602() 2055 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
2056 RefPtr<FrameNode> contentNode2 = nullptr;
2057
2058 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef91702() 2059 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
2060 ViewStackProcessor::GetInstance()->Push(targetNode);
2061 targetNode->onMainTree_ = true;
2062 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
2063 auto stageNode = FrameNode::CreateFrameNode(
2064 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
2065 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
2066 stageNode->MountToParent(rootNode);
2067 targetNode->MountToParent(stageNode);
2068 rootNode->MarkDirtyNode();
2069 auto targetId = targetNode->GetId();
2070 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
2071 ASSERT_NE(targetNodePipelineContext, nullptr);
2072 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2073 targetNodePipelineContext->SetThemeManager(themeManager);
2074 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
2075 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2076
2077 /**
2078 * @tc.expected: Return expected results.
2079 */
2080 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
2081 auto overlayManager = ViewAbstract::GetCurOverlayManager(contentNode);
2082 ASSERT_NE(overlayManager, nullptr);
2083 overlayManager->menuMap_[targetId];
2084 EXPECT_EQ(ViewAbstract::CloseMenu(contentNode), ERROR_CODE_NO_ERROR);
2085 EXPECT_EQ(ViewAbstract::CloseMenu(contentNode2), ERROR_CODE_DIALOG_CONTENT_ERROR);
2086 overlayManager->menuMap_.clear();
2087 EXPECT_EQ(ViewAbstract::CloseMenu(contentNode), ERROR_CODE_DIALOG_CONTENT_NOT_FOUND);
2088 }
2089
2090 /**
2091 * @tc.name: CloseMenu002
2092 * @tc.desc: Test CloseMenu of View_Abstract
2093 * @tc.type: FUNC
2094 */
2095 HWTEST_F(ViewAbstractTestNg, CloseMenu002, TestSize.Level1)
2096 {
2097 /**
2098 * @tc.steps: step1. Create some FrameNode and menuParam.
2099 */
2100 auto pipelineContext = PipelineContext::GetCurrentContext();
2101 MenuParam menuParam;
2102 auto contentNode =
2103 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anoncde27ef91802() 2104 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
2105 RefPtr<FrameNode> contentNode2 = nullptr;
2106
2107 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef91902() 2108 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
2109 ViewStackProcessor::GetInstance()->Push(targetNode);
2110 targetNode->onMainTree_ = true;
2111 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
2112 auto stageNode = FrameNode::CreateFrameNode(
2113 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
2114 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
2115 stageNode->MountToParent(rootNode);
2116 targetNode->MountToParent(stageNode);
2117 rootNode->MarkDirtyNode();
2118 auto targetId = targetNode->GetId();
2119 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
2120 ASSERT_NE(targetNodePipelineContext, nullptr);
2121 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2122 targetNodePipelineContext->SetThemeManager(themeManager);
2123 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
2124 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2125 EXPECT_CALL(*themeManager, GetTheme(_, _)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2126
2127 /**
2128 * @tc.expected: Return expected results.
2129 */
2130 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
2131 auto overlayManager = ViewAbstract::GetCurOverlayManager(contentNode);
2132 ASSERT_NE(overlayManager, nullptr);
2133 overlayManager->menuMap_[targetId];
2134 auto contentNodePipelineContext = contentNode->GetContextWithCheck();
2135 contentNodePipelineContext->overlayManager_ = nullptr;
2136 EXPECT_EQ(ViewAbstract::CloseMenu(contentNode), ERROR_CODE_INTERNAL_ERROR);
2137 contentNodePipelineContext->overlayManager_ = overlayManager;
2138 }
2139
2140 /**
2141 * @tc.name: FreezeUINodeById
2142 * @tc.desc: Test FreezeUINodeById of View_Abstract
2143 * @tc.type: FUNC
2144 */
2145 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0037, TestSize.Level1)
2146 {
2147 /**
2148 * @tc.steps: Create some FrameNode.
2149 */
2150 const std::string& id = "test_id";
2151 auto targetNode =
2152 FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef91a02() 2153 ElementRegister::GetInstance()->MakeUniqueId(), []() {
2154 return AceType::MakeRefPtr<ButtonPattern>();
2155 }
2156 );
2157 /**
2158 * @tc.steps: connect the FrameNode and id.
2159 */
2160 targetNode->UpdateInspectorId(id);
2161
2162 /**
2163 * @tc.expected: call the function to freeze the node.
2164 */
2165 bool isFreeze = true;
2166 ViewAbstract::FreezeUINodeById(id, isFreeze);
2167
2168 /**
2169 * @tc.expected: verify the pipeline's property is set.
2170 */
2171 auto pipeline = targetNode->GetContext();
2172 bool isOpenInvisibleFreeze = pipeline->IsOpenInvisibleFreeze();
2173
2174 EXPECT_EQ(isOpenInvisibleFreeze, true);
2175 /**
2176 * @tc.expected: verify the node's freeze state.
2177 */
2178 bool res = targetNode->IsFreeze();
2179 EXPECT_EQ(res, isFreeze);
2180 }
2181
2182 /**
2183 * @tc.name: FreezeUINodeById
2184 * @tc.desc: Test FreezeUINodeById of View_Abstract
2185 * @tc.type: FUNC
2186 */
2187 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0038, TestSize.Level1)
2188 {
2189 /**
2190 * @tc.steps: Create some FrameNode.
2191 */
2192 const std::string& id = "test_id";
2193 auto targetNode =
2194 FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef91b02() 2195 ElementRegister::GetInstance()->MakeUniqueId(), []() {
2196 return AceType::MakeRefPtr<ButtonPattern>();
2197 }
2198 );
2199 /**
2200 * @tc.steps: connect the FrameNode and id.
2201 */
2202 targetNode->UpdateInspectorId(id);
2203 /**
2204 * @tc.steps: set the FrameNode's pipeline to null.
2205 */
2206 targetNode->context_ = nullptr;
2207
2208 /**
2209 * @tc.expected: call the function to unfreeze the node.
2210 */
2211 bool isFreeze = false;
2212 ViewAbstract::FreezeUINodeById(id, isFreeze);
2213
2214 /**
2215 * @tc.expected: verify the pipeline's property is set.
2216 */
2217 auto pipeline = targetNode->GetContext();
2218 bool isOpenInvisibleFreeze = pipeline->IsOpenInvisibleFreeze();
2219 EXPECT_EQ(isOpenInvisibleFreeze, true);
2220
2221 /**
2222 * @tc.expected: verify the node's freeze state.
2223 */
2224 bool res = targetNode->IsFreeze();
2225 EXPECT_EQ(res, isFreeze);
2226 }
2227
2228 /**
2229 * @tc.name: FreezeUINodeById
2230 * @tc.desc: Test FreezeUINodeById of View_Abstract
2231 * @tc.type: FUNC
2232 */
2233 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0039, TestSize.Level1)
2234 {
2235 /**
2236 * @tc.expected: use a non_existing node id.
2237 */
2238 const std::string& non_existing_id = "non_existing_id";
2239 /**
2240 * @tc.expected: call the function with the non_existing_id.
2241 */
2242 bool isFreeze = true;
2243 ViewAbstract::FreezeUINodeById(non_existing_id, isFreeze);
2244
2245 auto node = ElementRegister::GetInstance()->GetAttachedFrameNodeById(non_existing_id, true);
2246 EXPECT_EQ(node, nullptr);
2247 }
2248
2249 /**
2250 * @tc.name: FreezeUINodeByUniqueId
2251 * @tc.desc: Test FreezeUINodeByUniqueId of View_Abstract
2252 * @tc.type: FUNC
2253 */
2254 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0040, TestSize.Level1)
2255 {
2256 /**
2257 * @tc.steps: Create some FrameNode.
2258 */
2259 const int32_t& uniqueId = 1111;
2260 auto targetNode =
2261 FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef91c02() 2262 uniqueId, []() {
2263 return AceType::MakeRefPtr<ButtonPattern>();
2264 }
2265 );
2266
2267 /**
2268 * @tc.expected: call the function to freeze the node.
2269 */
2270 bool isFreeze = true;
2271 ViewAbstract::FreezeUINodeByUniqueId(uniqueId, isFreeze);
2272
2273 /**
2274 * @tc.expected: verify the pipeline's property is set.
2275 */
2276 auto pipeline = targetNode->GetContext();
2277 bool isOpenInvisibleFreeze = pipeline->IsOpenInvisibleFreeze();
2278
2279 EXPECT_EQ(isOpenInvisibleFreeze, true);
2280 /**
2281 * @tc.expected: verify the node's freeze state.
2282 */
2283 bool res = targetNode->IsFreeze();
2284 EXPECT_EQ(res, isFreeze);
2285 }
2286
2287 /**
2288 * @tc.name: FreezeUINodeByUniqueId
2289 * @tc.desc: Test FreezeUINodeByUniqueId of View_Abstract
2290 * @tc.type: FUNC
2291 */
2292 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0041, TestSize.Level1)
2293 {
2294 /**
2295 * @tc.steps: Create some FrameNode.
2296 */
2297 const int32_t& uniqueId = 222;
2298 auto targetNode =
2299 FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anoncde27ef91d02() 2300 uniqueId, []() {
2301 return AceType::MakeRefPtr<ButtonPattern>();
2302 }
2303 );
2304
2305 /**
2306 * @tc.steps: set the FrameNode's pipeline to null.
2307 */
2308 targetNode->context_ = nullptr;
2309
2310 /**
2311 * @tc.expected: call the function to freeze the node.
2312 */
2313 bool isFreeze = false;
2314 ViewAbstract::FreezeUINodeByUniqueId(uniqueId, isFreeze);
2315
2316 /**
2317 * @tc.expected: verify the pipeline's property is set.
2318 */
2319 auto pipeline = targetNode->GetContext();
2320 bool isOpenInvisibleFreeze = pipeline->IsOpenInvisibleFreeze();
2321
2322 EXPECT_EQ(isOpenInvisibleFreeze, true);
2323 /**
2324 * @tc.expected: verify the node's freeze state.
2325 */
2326 bool res = targetNode->IsFreeze();
2327 EXPECT_EQ(res, isFreeze);
2328 }
2329
2330 /**
2331 * @tc.name: FreezeUINodeByUniqueId
2332 * @tc.desc: Test FreezeUINodeByUniqueId of View_Abstract
2333 * @tc.type: FUNC
2334 */
2335 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0042, TestSize.Level1)
2336 {
2337 /**
2338 * @tc.expected: use a non_existing node uniqueId.
2339 */
2340 const int32_t& non_existing_unique_id = 333;
2341 /**
2342 * @tc.expected: call the function with the non_existing_unique_id.
2343 */
2344 bool isFreeze = true;
2345 ViewAbstract::FreezeUINodeByUniqueId(non_existing_unique_id, isFreeze);
2346
2347 auto node = ElementRegister::GetInstance()->GetNodeById(non_existing_unique_id);
2348 EXPECT_EQ(node, nullptr);
2349 }
2350
2351 /**
2352 * @tc.name: SetPositionLocalizedEdges
2353 * @tc.desc: Test SetPositionLocalizedEdges of View_Abstract
2354 * @tc.type: FUNC
2355 */
2356 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0043, TestSize.Level1)
2357 {
2358 auto targetNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2359 /**
2360 * @tc.expected: call the function to Update the layout property.
2361 */
2362 bool needLocalized = true;
2363 ViewAbstract::SetPositionLocalizedEdges(needLocalized);
2364
2365 auto layoutProperty = targetNode->GetLayoutProperty();
2366
2367 /**
2368 * @tc.expected: verify layout property is updated.
2369 */
2370 auto positionLocalizedEdges = layoutProperty->IsPositionLocalizedEdges();
2371 EXPECT_EQ(positionLocalizedEdges, needLocalized);
2372 }
2373
2374 /**
2375 * @tc.name: SetPositionLocalizedEdges
2376 * @tc.desc: Test SetPositionLocalizedEdges of View_Abstract
2377 * @tc.type: FUNC
2378 */
2379 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0044, TestSize.Level1)
2380 {
2381 auto targetNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2382 /**
2383 * @tc.expected: call the function to Update the layout property.
2384 */
2385 bool needLocalized = false;
2386 ViewAbstract::SetPositionLocalizedEdges(needLocalized);
2387
2388 auto layoutProperty = targetNode->GetLayoutProperty();
2389
2390 /**
2391 * @tc.expected: verify layout property is updated.
2392 */
2393 auto positionLocalizedEdges = layoutProperty->IsPositionLocalizedEdges();
2394 EXPECT_EQ(positionLocalizedEdges, needLocalized);
2395 }
2396
2397 } // namespace OHOS::Ace::NG