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