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/common/resource/resource_parse_utils.h"
18 #include "core/components/select/select_theme.h"
19 #include "core/components_ng/pattern/menu/menu_item/menu_item_model_ng.h"
20 #include "test/mock/base/mock_system_properties.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS::Ace::NG {
SetUpTestSuite()26 void ViewAbstractTestNg::SetUpTestSuite()
27 {
28 MockPipelineContext::SetUp();
29 MockContainer::SetUp();
30 MockContainer::Current()->pipelineContext_ = PipelineBase::GetCurrentContext();
31 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
32 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager);
33 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>());
34 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<PopupTheme>()));
35 }
36
TearDownTestSuite()37 void ViewAbstractTestNg::TearDownTestSuite()
38 {
39 MockContainer::Current()->pipelineContext_ = nullptr;
40 MockPipelineContext::TearDown();
41 }
42 /**
43 * @tc.name: ViewAbstractTest001
44 * @tc.desc: SetWidth、SetHeight、SetMinWidth、SetMinHeight、SetMaxWidth、SetMaxHeight、ClearWidthOrHeight
45 * @tc.type: FUNC
46 */
47 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest001, TestSize.Level1)
48 {
49 /**
50 * @tc.steps: step1.Using static methods to set component properties
51 */
52 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
53 ASSERT_NE(frameNode, nullptr);
54 auto layoutProperty = frameNode->GetLayoutProperty();
55 ASSERT_NE(layoutProperty, nullptr);
56 ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
57 ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
58 ViewAbstract::SetMinWidth(NG::CalcLength(MIN_WIDTH));
59 ViewAbstract::SetMinHeight(NG::CalcLength(MIN_HEIGHT));
60 ViewAbstract::SetMaxWidth(NG::CalcLength(MIN_WIDTH));
61 ViewAbstract::SetMaxHeight(NG::CalcLength(MIN_HEIGHT));
62 ViewAbstract::ResetAspectRatio();
63 ViewAbstract::SetDrawModifier(nullptr);
64
65 /**
66 * @tc.expected: Successfully set various properties of the top node on the stack
67 */
68 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->selfIdealSize->Width(), NG::CalcLength(WIDTH));
69 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->selfIdealSize->Height(), NG::CalcLength(HEIGHT));
70 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->minSize->Width(), NG::CalcLength(MIN_WIDTH));
71 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->minSize->Height(), NG::CalcLength(MIN_HEIGHT));
72 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->maxSize->Width(), NG::CalcLength(MIN_WIDTH));
73 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->maxSize->Height(), NG::CalcLength(MIN_HEIGHT));
74
75 /**
76 * @tc.steps: step2.Static methods set properties for other nodes
77 */
__anon34ec4f1b0102() 78 auto newNode = FrameNode::GetOrCreateFrameNode("newframenode", 10, []() { return AceType::MakeRefPtr<Pattern>(); });
79 ViewAbstract::SetWidth(AceType::RawPtr(newNode), NG::CalcLength(WIDTH));
80 ViewAbstract::SetHeight(AceType::RawPtr(newNode), NG::CalcLength(HEIGHT));
81 ViewAbstract::SetMinWidth(AceType::RawPtr(newNode), NG::CalcLength(MIN_WIDTH));
82 ViewAbstract::SetMinHeight(AceType::RawPtr(newNode), NG::CalcLength(MIN_HEIGHT));
83 ViewAbstract::SetMaxWidth(AceType::RawPtr(newNode), NG::CalcLength(MIN_WIDTH));
84 ViewAbstract::SetMaxHeight(AceType::RawPtr(newNode), NG::CalcLength(MIN_HEIGHT));
85 auto newProperty = frameNode->GetLayoutProperty();
86
87 /**
88 * @tc.expected: Successfully set various attributes of the new node
89 */
90 EXPECT_EQ(newProperty->calcLayoutConstraint_->selfIdealSize->Width(), NG::CalcLength(WIDTH));
91 EXPECT_EQ(newProperty->calcLayoutConstraint_->selfIdealSize->Height(), NG::CalcLength(HEIGHT));
92 EXPECT_EQ(newProperty->calcLayoutConstraint_->minSize->Width(), NG::CalcLength(MIN_WIDTH));
93 EXPECT_EQ(newProperty->calcLayoutConstraint_->minSize->Height(), NG::CalcLength(MIN_HEIGHT));
94 EXPECT_EQ(newProperty->calcLayoutConstraint_->maxSize->Width(), NG::CalcLength(MIN_WIDTH));
95 EXPECT_EQ(newProperty->calcLayoutConstraint_->maxSize->Height(), NG::CalcLength(MIN_HEIGHT));
96
97 ViewAbstract::ClearWidthOrHeight(true);
98 ViewAbstract::ClearWidthOrHeight(AceType::RawPtr(newNode), true);
99 EXPECT_EQ(layoutProperty->calcLayoutConstraint_->selfIdealSize->Width(), std::nullopt);
100 EXPECT_EQ(newProperty->calcLayoutConstraint_->selfIdealSize->Width(), std::nullopt);
101 }
102
103 /**
104 * @tc.name: ViewAbstractTest002
105 * @tc.desc: Test the operation of View_Abstract.
106 * @tc.type: FUNC
107 */
108 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest002, TestSize.Level1)
109 {
110 /**
111 * @tc.steps: step1.push FrameNode is not null, related function is called.
112 */
113 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
114 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
115
116 ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
117 ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
118 ViewAbstract::SetMinWidth(NG::CalcLength(MIN_WIDTH));
119 ViewAbstract::SetMinHeight(NG::CalcLength(MIN_HEIGHT));
120 ViewAbstract::SetMaxWidth(NG::CalcLength(MIN_WIDTH));
121 ViewAbstract::SetMaxHeight(NG::CalcLength(MIN_HEIGHT));
122 ViewAbstract::ResetAspectRatio();
123 ViewAbstract::ClearWidthOrHeight(true);
124
125 /**
126 * @tc.expected: Return expected results..
127 */
128 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
129 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
130 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
131 ASSERT_NE(frameNode, nullptr);
132 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
133 ASSERT_NE(Node, nullptr);
134 auto layoutProperty = Node->GetLayoutProperty();
135 ASSERT_NE(layoutProperty, nullptr);
136 ViewStackProcessor::GetInstance()->instance = nullptr;
137 }
138
139 /**
140 * @tc.name: ViewAbstractTest003
141 * @tc.desc: Test the operation of View_Abstract
142 * @tc.type: FUNC
143 */
144 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest003, TestSize.Level1)
145 {
146 /**
147 * @tc.steps: step1.The FrameNode is null, related function is called.
148 */
149 ViewAbstract::SetAspectRatio(RATIO);
150 ViewAbstract::SetBackgroundColor(BLUE);
151 ViewAbstract::SetBackgroundColor(nullptr, BLUE);
152 ViewAbstract::SetBackgroundImage(imageSourceInfo);
153 ViewAbstract::SetBackgroundImage(nullptr, imageSourceInfo);
154 ViewAbstract::SetBackgroundImageSize(BACKGROUNDSIZE);
155 ViewAbstract::SetBackgroundImageSize(nullptr, BACKGROUNDSIZE);
156 ViewAbstract::SetBackgroundImageSize(nullptr, BACKGROUNDSIZE, true);
157 ViewAbstract::SetBackgroundImagePosition(BACKGROUNDPOSITION);
158 ViewAbstract::SetBackgroundImagePosition(nullptr, BACKGROUNDPOSITION);
159 ViewAbstract::SetBackgroundImagePosition(nullptr, BACKGROUNDPOSITION, true);
160 ViewAbstract::SetPixelRound(0);
161 ChainInfo chainInfo;
162 chainInfo.direction = LineDirection::HORIZONTAL;
163 chainInfo.style = ChainStyle::SPREAD;
164 ViewAbstract::SetChainStyle(chainInfo);
165 ViewAbstract::SetChainStyle(AceType::RawPtr(FRAME_NODE_REGISTER), chainInfo);
166 ViewAbstract::SetLayoutWeight(TEN);
167 ViewAbstract::SetLayoutWeight(AceType::RawPtr(FRAME_NODE_REGISTER), TEN);
168 ViewAbstract::SetBias(biasPair);
169 ViewAbstract::SetBias(nullptr, biasPair);
170 ViewAbstract::SetOuterBorderRadius(ZERO);
171 ViewAbstract::SetOuterBorderRadius(nullptr, ZERO);
172 NG::BorderRadiusProperty borderRadius;
173 ViewAbstract::SetOuterBorderRadius(borderRadius);
174 ViewAbstract::SetOuterBorderRadius(nullptr, borderRadius);
175 ViewAbstract::SetOuterBorderColor(BLUE);
176 ViewAbstract::SetOuterBorderColor(nullptr, BLUE);
177 NG::BorderColorProperty borderColor;
178 ViewAbstract::SetOuterBorderColor(borderColor);
179 ViewAbstract::SetOuterBorderColor(nullptr, borderColor);
180 ViewAbstract::SetOuterBorderWidth(ZERO);
181 ViewAbstract::SetOuterBorderWidth(nullptr, ZERO);
182 NG::BorderWidthProperty borderWidth;
183 ViewAbstract::SetOuterBorderWidth(borderWidth);
184 ViewAbstract::SetOuterBorderWidth(nullptr, borderWidth);
185 auto borderStyle = static_cast<BorderStyle>(INDEX);
186 ViewAbstract::SetOuterBorderStyle(borderStyle);
187 ViewAbstract::SetOuterBorderStyle(nullptr, borderStyle);
188 NG::BorderStyleProperty borderStyleProperty;
189 ViewAbstract::SetOuterBorderStyle(borderStyleProperty);
190 ViewAbstract::SetOuterBorderStyle(nullptr, borderStyleProperty);
191 BlendMode blendMode = BlendMode::NONE;
192 ViewAbstract::SetBlendMode(blendMode);
193 ViewAbstract::SetBlendMode(AceType::RawPtr(FRAME_NODE_REGISTER), blendMode);
194 BlendApplyType blendApplyType = BlendApplyType::FAST;
195 ViewAbstract::SetBlendApplyType(blendApplyType);
196 ViewAbstract::SetBlendApplyType(AceType::RawPtr(FRAME_NODE_REGISTER), blendApplyType);
197
198 BlurStyleOption blurStyleOption;
199 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
200 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
201 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
202 ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
203 ViewAbstract::SetBackgroundBlurStyle(AceType::RawPtr(FRAME_NODE_REGISTER), blurStyleOption);
204 CalcDimension dimensionRadius(0.0);
205 ViewAbstract::SetLightPosition(dimensionRadius, dimensionRadius, dimensionRadius);
206 ViewAbstract::SetLightPosition(nullptr, dimensionRadius, dimensionRadius, dimensionRadius);
207 ViewAbstract::SetLightIntensity(RATIO);
208 ViewAbstract::SetLightIntensity(nullptr, RATIO);
209 ViewAbstract::SetIlluminatedBorderWidth(ZERO);
210 ViewAbstract::SetIlluminatedBorderWidth(nullptr, ZERO);
211 ViewAbstract::SetBloom(RATIO);
212 ViewAbstract::SetBloom(nullptr, RATIO);
213 std::map<AlignDirection, AlignRule> alignRules;
214 ViewAbstract::SetAlignRules(alignRules);
215 ViewAbstract::SetAlignRules(AceType::RawPtr(FRAME_NODE_REGISTER), alignRules);
216 auto repeat = static_cast<ImageRepeat>(INDEX);
217 ViewAbstract::SetBackgroundImageRepeat(repeat);
218 ViewAbstract::SetBackgroundImageRepeat(nullptr, repeat);
219 auto direction = static_cast<TextDirection>(INDEX);
220 ViewAbstract::SetLayoutDirection(direction);
221 ViewAbstract::SetLayoutDirection(AceType::RawPtr(FRAME_NODE_REGISTER), direction);
222 ViewAbstract::GetAlignRules(AceType::RawPtr(FRAME_NODE_REGISTER));
223 ViewAbstract::SetBackgroundImageSyncMode(true);
224
225 /**
226 * @tc.expected: Return expected results..
227 */
228 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
229 }
230
231 /**
232 * @tc.name: ViewAbstractTest004
233 * @tc.desc: Test the operation of View_Abstract.
234 * @tc.type: FUNC
235 */
236 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest004, TestSize.Level1)
237 {
238 /**
239 * @tc.steps: step1.push FrameNode is not null, related function is called.
240 */
241 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
242 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
243
244 ViewAbstract::SetAspectRatio(RATIO);
245 ViewAbstract::SetBackgroundColor(BLUE);
246 ViewAbstract::SetBackgroundColor(nullptr, BLUE);
247 ViewAbstract::SetBackgroundImage(imageSourceInfo);
248 ViewAbstract::SetBackgroundImage(nullptr, imageSourceInfo);
249 ViewAbstract::SetBackgroundImageSize(BACKGROUNDSIZE);
250 ViewAbstract::SetBackgroundImageSize(nullptr, BACKGROUNDSIZE);
251 ViewAbstract::SetBackgroundImageSize(nullptr, BACKGROUNDSIZE, true);
252 ViewAbstract::SetBackgroundImagePosition(BACKGROUNDPOSITION);
253 ViewAbstract::SetBackgroundImagePosition(nullptr, BACKGROUNDPOSITION);
254 ViewAbstract::SetBackgroundImagePosition(nullptr, BACKGROUNDPOSITION, true);
255 ViewAbstract::SetPixelRound(0);
256
257 ChainInfo chainInfo;
258 chainInfo.direction = LineDirection::HORIZONTAL;
259 chainInfo.style = ChainStyle::SPREAD;
260 ViewAbstract::SetChainStyle(chainInfo);
261 ViewAbstract::SetChainStyle(AceType::RawPtr(FRAME_NODE_REGISTER), chainInfo);
262 ViewAbstract::SetBias(biasPair);
263 ViewAbstract::SetBias(nullptr, biasPair);
264 ViewAbstract::SetOuterBorderRadius(ZERO);
265 ViewAbstract::SetOuterBorderRadius(nullptr, ZERO);
266 NG::BorderRadiusProperty borderRadius;
267 ViewAbstract::SetOuterBorderRadius(borderRadius);
268 ViewAbstract::SetOuterBorderRadius(nullptr, borderRadius);
269 ViewAbstract::SetOuterBorderColor(BLUE);
270 ViewAbstract::SetOuterBorderColor(nullptr, BLUE);
271 NG::BorderColorProperty borderColor;
272 ViewAbstract::SetOuterBorderColor(borderColor);
273 ViewAbstract::SetOuterBorderColor(nullptr, borderColor);
274 ViewAbstract::SetOuterBorderWidth(ZERO);
275 ViewAbstract::SetOuterBorderWidth(nullptr, ZERO);
276 NG::BorderWidthProperty borderWidth;
277 ViewAbstract::SetOuterBorderWidth(borderWidth);
278 ViewAbstract::SetOuterBorderWidth(nullptr, borderWidth);
279 auto borderStyle = static_cast<BorderStyle>(INDEX);
280 ViewAbstract::SetOuterBorderStyle(borderStyle);
281 ViewAbstract::SetOuterBorderStyle(nullptr, borderStyle);
282 NG::BorderStyleProperty borderStyleProperty;
283 ViewAbstract::SetOuterBorderStyle(borderStyleProperty);
284 ViewAbstract::SetOuterBorderStyle(nullptr, borderStyleProperty);
285 ViewAbstract::SetLayoutWeight(TEN);
286 BlendMode blendMode = BlendMode::NONE;
287 ViewAbstract::SetBlendMode(blendMode);
288 BlendApplyType blendApplyType = BlendApplyType::FAST;
289 ViewAbstract::SetBlendApplyType(blendApplyType);
290
291 BlurStyleOption blurStyleOption;
292 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
293 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
294 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
295 ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
296
297 std::map<AlignDirection, AlignRule> alignRules;
298 ViewAbstract::SetAlignRules(alignRules);
299 auto repeat = static_cast<ImageRepeat>(INDEX);
300 ViewAbstract::SetBackgroundImageRepeat(repeat);
301 ViewAbstract::SetBackgroundImageRepeat(nullptr, repeat);
302 auto direction = static_cast<TextDirection>(INDEX);
303 ViewAbstract::SetLayoutDirection(direction);
304 CalcDimension dimensionRadius(0.0);
305 ViewAbstract::SetLightPosition(dimensionRadius, dimensionRadius, dimensionRadius);
306 ViewAbstract::SetLightPosition(nullptr, dimensionRadius, dimensionRadius, dimensionRadius);
307 ViewAbstract::SetLightIntensity(RATIO);
308 ViewAbstract::SetLightIntensity(nullptr, RATIO);
309 Color color = Color::TRANSPARENT;
310 ViewAbstract::SetLightColor(color);
311 ViewAbstract::SetLightColor(nullptr, color);
312 ViewAbstract::SetIlluminatedBorderWidth(ZERO);
313 ViewAbstract::SetIlluminatedBorderWidth(nullptr, ZERO);
314 ViewAbstract::SetBloom(RATIO);
315 ViewAbstract::SetBloom(nullptr, RATIO);
316
317 /**
318 * @tc.expected: Return expected results.
319 */
320 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
321 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
322 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
323 ASSERT_NE(frameNode, nullptr);
324 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
325 ASSERT_NE(Node, nullptr);
326 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
327 ASSERT_NE(layoutProperty, nullptr);
328 ViewStackProcessor::GetInstance()->instance = nullptr;
329 }
330
331 /**
332 * @tc.name: ViewAbstractTest005
333 * @tc.desc: Test the operation of View_Abstract
334 * @tc.type: FUNC
335 */
336 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest005, TestSize.Level1)
337 {
338 /**
339 * @tc.steps: step1.The FrameNode is null, related function is called.
340 */
341 auto alignSelf = static_cast<FlexAlign>(INDEX);
342 ViewAbstract::SetAlignSelf(alignSelf);
343 ViewAbstract::SetFlexShrink(RATIO);
344 ViewAbstract::SetFlexGrow(RATIO);
345 ViewAbstract::SetFlexBasis(WIDTH);
346 ViewAbstract::SetDisplayIndex(INDEX);
347 ViewAbstract::SetDisplayIndex(nullptr, INDEX);
348
349 ViewAbstract::SetPadding(NG::CalcLength(WIDTH));
350 ViewAbstract::SetMargin(NG::CalcLength(WIDTH));
351 ViewAbstract::SetBorderRadius(WIDTH);
352 ViewAbstract::SetBorderColor(BLUE);
353 ViewAbstract::SetBorderWidth(WIDTH);
354 auto borderStyle = static_cast<BorderStyle>(INDEX);
355 ViewAbstract::SetBorderStyle(borderStyle);
356 ViewAbstract::SetBorderStyle(nullptr, borderStyle);
357 ViewAbstract::SetAutoEventParam(VALUE_X);
358
359 /**
360 * @tc.expected: Return expected results..
361 */
362 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
363 }
364
365 /**
366 * @tc.name: ViewAbstractTest006
367 * @tc.desc: Test the operation of View_Abstract.
368 * @tc.type: FUNC
369 */
370 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest006, TestSize.Level1)
371 {
372 /**
373 * @tc.steps: step1.push FrameNode is not null, related function is called.
374 */
375 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
376 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
377
378 auto alignSelf = static_cast<FlexAlign>(INDEX);
379 ViewAbstract::SetAlignSelf(alignSelf);
380 ViewAbstract::SetFlexShrink(RATIO);
381 ViewAbstract::SetFlexShrink(AceType::RawPtr(FRAME_NODE_REGISTER), RATIO);
382 ViewAbstract::SetFlexGrow(RATIO);
383 ViewAbstract::SetFlexGrow(AceType::RawPtr(FRAME_NODE_REGISTER), RATIO);
384 ViewAbstract::SetFlexBasis(WIDTH);
385 ViewAbstract::SetDisplayIndex(INDEX);
386 ViewAbstract::SetDisplayIndex(nullptr, INDEX);
387
388 ViewAbstract::SetPadding(NG::CalcLength(WIDTH));
389 ViewAbstract::SetMargin(NG::CalcLength(WIDTH));
390 ViewAbstract::SetBorderRadius(WIDTH);
391 ViewAbstract::SetBorderColor(BLUE);
392 ViewAbstract::SetBorderWidth(WIDTH);
393 auto borderStyle = static_cast<BorderStyle>(INDEX);
394 ViewAbstract::SetBorderStyle(borderStyle);
395 ViewAbstract::SetBorderStyle(nullptr, borderStyle);
396
397 /**
398 * @tc.expected: Return expected results.
399 */
400 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
401 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
402 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
403 ASSERT_NE(frameNode, nullptr);
404 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
405 ASSERT_NE(Node, nullptr);
406 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
407 ASSERT_NE(layoutProperty, nullptr);
408 ViewStackProcessor::GetInstance()->instance = nullptr;
409 }
410
411 /**
412 * @tc.name: ViewAbstractTest007
413 * @tc.desc: Test the operation of View_Abstract
414 * @tc.type: FUNC
415 */
416 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest007, TestSize.Level1)
417 {
418 /**
419 * @tc.steps: step1.The FrameNode is null, related function is called.
420 */
421 NG::PaddingProperty paddings;
422 ViewAbstract::SetPadding(paddings);
423
424 NG::MarginProperty margins;
425 ViewAbstract::SetMargin(margins);
426
427 NG::BorderRadiusProperty borderRadius;
428 ViewAbstract::SetBorderRadius(borderRadius);
429 ViewAbstract::SetBorderRadius(nullptr, borderRadius);
430
431 NG::BorderColorProperty borderColors;
432 ViewAbstract::SetBorderColor(borderColors);
433
434 NG::BorderWidthProperty borderWidth;
435 ViewAbstract::SetBorderWidth(borderWidth);
436 ViewAbstract::SetBorderWidth(nullptr, borderWidth);
437
438 NG::BorderStyleProperty borderStyles;
439 ViewAbstract::SetBorderStyle(borderStyles);
440 ViewAbstract::SetBorderStyle(nullptr, borderStyles);
441
442 /**
443 * @tc.expected: Return expected results..
444 */
445 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
446 }
447
448 /**
449 * @tc.name: ViewAbstractTest008
450 * @tc.desc: Test the operation of View_Abstract.
451 * @tc.type: FUNC
452 */
453 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest008, TestSize.Level1)
454 {
455 /**
456 * @tc.steps: step1.push FrameNode is not null, related function is called.
457 */
458 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
459 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
460
461 NG::PaddingProperty paddings;
462 ViewAbstract::SetPadding(paddings);
463
464 NG::MarginProperty margins;
465 ViewAbstract::SetMargin(margins);
466
467 NG::BorderRadiusProperty borderRadius;
468 ViewAbstract::SetBorderRadius(borderRadius);
469
470 NG::BorderColorProperty borderColors;
471 ViewAbstract::SetBorderColor(borderColors);
472 ViewAbstract::SetBorderColor(nullptr, borderColors);
473
474 NG::BorderWidthProperty borderWidth;
475 ViewAbstract::SetBorderWidth(borderWidth);
476
477 NG::BorderStyleProperty borderStyles;
478 ViewAbstract::SetBorderStyle(borderStyles);
479 ViewAbstract::SetBorderStyle(nullptr, borderStyles);
480
481 /**
482 * @tc.expected: Return expected results.
483 */
484 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
485 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
486 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
487 ASSERT_NE(frameNode, nullptr);
488 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
489 ASSERT_NE(Node, nullptr);
490 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
491 ASSERT_NE(layoutProperty, nullptr);
492 ViewStackProcessor::GetInstance()->instance = nullptr;
493 }
494
495 /**
496 * @tc.name: ViewAbstractTest009
497 * @tc.desc: Test the operation of View_Abstract
498 * @tc.type: FUNC
499 */
500 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest009, TestSize.Level1)
501 {
502 /**
503 * @tc.steps: step1.The FrameNode is null, related function is called.
504 */
505 GestureEventFunc tapEventFunc;
506 ViewAbstract::SetOnClick(std::move(tapEventFunc));
507 ViewAbstract::SetOnClick(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(tapEventFunc));
508 TouchEventFunc touchEventFunc;
509 ViewAbstract::SetOnTouch(std::move(touchEventFunc));
510 ViewAbstract::SetOnTouch(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(touchEventFunc));
511 OnMouseEventFunc onMouseEventFunc;
512 ViewAbstract::SetOnMouse(std::move(onMouseEventFunc));
513 OnHoverFunc onHoverEventFunc;
514 ViewAbstract::SetOnHover(std::move(onHoverEventFunc));
515 ViewAbstract::SetJSFrameNodeOnHover(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onHoverEventFunc));
516 ViewAbstract::ClearJSFrameNodeOnHover(AceType::RawPtr(FRAME_NODE_REGISTER));
517 OnKeyConsumeFunc onKeyCallback;
518 ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback));
519 DragPreviewOption dragPreviewOption;
520 ViewAbstract::SetDragPreviewOptions(dragPreviewOption);
521 ViewAbstract::SetDragPreviewOptions(AceType::RawPtr(FRAME_NODE_REGISTER), dragPreviewOption);
522 NG::DragDropInfo info;
523 ViewAbstract::SetDragPreview(info);
524
525 auto hoverEffect = static_cast<HoverEffectType>(INDEX);
526 ViewAbstract::SetHoverEffect(hoverEffect);
527 ViewAbstract::SetHoverEffect(AceType::RawPtr(FRAME_NODE_REGISTER), hoverEffect);
528
529 ViewAbstract::SetFocusable(false);
530 ViewAbstract::SetFocusable(AceType::RawPtr(FRAME_NODE_REGISTER), false);
531 ViewAbstract::SetEnabled(false);
532 ViewAbstract::SetEnabled(AceType::RawPtr(FRAME_NODE_REGISTER), false);
533 ViewAbstract::SetOnFocus(callback);
534 ViewAbstract::SetOnBlur(callback);
535
536 /**
537 * @tc.expected: Return expected results.
538 */
539 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
540 }
541
542 /**
543 * @tc.name: ViewAbstractTest010
544 * @tc.desc: Test the operation of View_Abstract.
545 * @tc.type: FUNC
546 */
547 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest010, TestSize.Level1)
548 {
549 /**
550 * @tc.steps: step1.push FrameNode is not null, related function is called.
551 */
552 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
553 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
554
555 GestureEventFunc tapEventFunc;
556 ViewAbstract::SetOnClick(std::move(tapEventFunc));
557 TouchEventFunc touchEventFunc;
558 ViewAbstract::SetOnTouch(std::move(touchEventFunc));
559 OnMouseEventFunc onMouseEventFunc;
560 ViewAbstract::SetOnMouse(std::move(onMouseEventFunc));
561 OnHoverFunc onHoverEventFunc;
562 ViewAbstract::SetOnHover(std::move(onHoverEventFunc));
563 OnKeyConsumeFunc onKeyCallback;
564 ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback));
565
566 auto hoverEffect = static_cast<HoverEffectType>(INDEX);
567 ViewAbstract::SetHoverEffect(hoverEffect);
568
569 ViewAbstract::SetFocusable(true);
570 ViewAbstract::SetOnFocus(callback);
571 ViewAbstract::SetOnBlur(callback);
572 ViewAbstract::SetFlexBasis(VALUE);
573
574 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>();
575 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
576 focusHub->focusable_ = true;
577 focusHub->parentFocusable_ = true;
578 ViewAbstract::SetVisibility(VisibleType::VISIBLE);
579 ViewAbstract::SetEnabled(true);
580
581 /**
582 * @tc.expected: Return expected results.
583 */
584 EXPECT_FALSE(focusHub->IsFocusableScope());
585 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
586 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
587 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
588 ASSERT_NE(frameNode, nullptr);
589 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
590 ASSERT_NE(Node, nullptr);
591 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
592 ASSERT_NE(layoutProperty, nullptr);
593 ViewStackProcessor::GetInstance()->instance = nullptr;
594 }
595
596 /**
597 * @tc.name: ViewAbstractTest011
598 * @tc.desc: Test the operation of View_Abstract
599 * @tc.type: FUNC
600 */
601 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest011, TestSize.Level1)
602 {
603 /**
604 * @tc.steps: step1.The FrameNode is null, related function is called.
605 */
606 ViewAbstract::SetTabIndex(INDEX);
607 ViewAbstract::SetTabIndex(AceType::RawPtr(FRAME_NODE_REGISTER), INDEX);
608 ViewAbstract::SetFocusOnTouch(false);
609 ViewAbstract::SetFocusOnTouch(AceType::RawPtr(FRAME_NODE_REGISTER), false);
610 ViewAbstract::SetDefaultFocus(false);
611 ViewAbstract::SetGroupDefaultFocus(false);
612 ViewAbstract::SetGroupDefaultFocus(AceType::RawPtr(FRAME_NODE_REGISTER), false);
613 ViewAbstract::SetTouchable(false);
614 ViewAbstract::SetTouchable(AceType::RawPtr(FRAME_NODE_REGISTER), false);
615 ViewAbstract::SetOnAppear(callback);
616 ViewAbstract::SetOnAppear(AceType::RawPtr(FRAME_NODE_REGISTER), callback);
617 ViewAbstract::SetOnDisappear(callback);
618 ViewAbstract::SetOnDisappear(AceType::RawPtr(FRAME_NODE_REGISTER), callback);
619 ViewAbstract::GetFocusable(AceType::RawPtr(FRAME_NODE_REGISTER));
620 ViewAbstract::GetDefaultFocus(AceType::RawPtr(FRAME_NODE_REGISTER));
621 ViewAbstract::GetResponseRegion(AceType::RawPtr(FRAME_NODE_REGISTER));
622 ViewAbstract::GetOverlay(AceType::RawPtr(FRAME_NODE_REGISTER));
623 ViewAbstract::SetNeedFocus(AceType::RawPtr(FRAME_NODE_REGISTER), false);
624 ViewAbstract::GetNeedFocus(AceType::RawPtr(FRAME_NODE_REGISTER));
625 ViewAbstract::GetOpacity(AceType::RawPtr(FRAME_NODE_REGISTER));
626 ViewAbstract::GetBorderWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
627 ViewAbstract::GetLayoutBorderWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
628 ViewAbstract::GetBorderRadius(AceType::RawPtr(FRAME_NODE_REGISTER));
629 ViewAbstract::GetBorderColor(AceType::RawPtr(FRAME_NODE_REGISTER));
630 ViewAbstract::GetBorderStyle(AceType::RawPtr(FRAME_NODE_REGISTER));
631 ViewAbstract::GetZIndex(AceType::RawPtr(FRAME_NODE_REGISTER));
632
633 auto hitTestMode = static_cast<HitTestMode>(INDEX);
634 ViewAbstract::SetHitTestMode(hitTestMode);
635 ViewAbstract::SetHitTestMode(AceType::RawPtr(FRAME_NODE_REGISTER), hitTestMode);
636
637 std::vector<DimensionRect> responseRegion;
638 ViewAbstract::SetResponseRegion(std::move(responseRegion));
639 ViewAbstract::SetResponseRegion(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(responseRegion));
640 std::function<DragDropInfo(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragStart;
641 ViewAbstract::SetOnDragStart(std::move(onDragStart));
642 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragEnter;
643 ViewAbstract::SetOnDragEnter(std::move(onDragEnter));
644 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragLeave;
645 ViewAbstract::SetOnDragLeave(std::move(onDragLeave));
646 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragMove;
647 ViewAbstract::SetOnDragMove(std::move(onDragMove));
648 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDrop;
649 ViewAbstract::SetOnDrop(std::move(onDrop));
650 Alignment alignment;
651 ViewAbstract::SetAlign(std::move(alignment));
652 ViewAbstract::SetAlign(nullptr, std::move(alignment));
653
654 /**
655 * @tc.expected: Return expected results.
656 */
657 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
658 }
659
660 /**
661 * @tc.name: ViewAbstractTest012
662 * @tc.desc: Test the operation of View_Abstract.
663 * @tc.type: FUNC
664 */
665 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest012, TestSize.Level1)
666 {
667 /**
668 * @tc.steps: step1.push FrameNode is not null, related function is called.
669 */
670 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
671 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
672
673 ViewAbstract::SetTabIndex(INDEX);
674 ViewAbstract::SetFocusOnTouch(false);
675 ViewAbstract::SetDefaultFocus(false);
676 ViewAbstract::SetDefaultFocus(AceType::RawPtr(FRAME_NODE_REGISTER), false);
677 ViewAbstract::SetGroupDefaultFocus(false);
678 ViewAbstract::SetTouchable(false);
679 ViewAbstract::SetOnAppear(callback);
680 ViewAbstract::SetOnDisappear(callback);
681 auto hitTestMode = static_cast<HitTestMode>(INDEX);
682 ViewAbstract::SetHitTestMode(hitTestMode);
683
684 std::vector<DimensionRect> responseRegion;
685 ViewAbstract::SetResponseRegion(std::move(responseRegion));
686 std::function<DragDropInfo(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragStart;
687 ViewAbstract::SetOnDragStart(std::move(onDragStart));
688 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragEnter;
689 ViewAbstract::SetOnDragEnter(std::move(onDragEnter));
690 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragLeave;
691 ViewAbstract::SetOnDragLeave(std::move(onDragLeave));
692 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDragMove;
693 ViewAbstract::SetOnDragMove(std::move(onDragMove));
694 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)> onDrop;
695 ViewAbstract::SetOnDrop(std::move(onDrop));
696 Alignment alignment;
697 ViewAbstract::SetAlign(std::move(alignment));
698
699 /**
700 * @tc.expected: Return expected results.
701 */
702 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
703 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
704 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
705 ASSERT_NE(frameNode, nullptr);
706 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
707 ASSERT_NE(Node, nullptr);
708 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
709 ASSERT_NE(layoutProperty, nullptr);
710 ViewStackProcessor::GetInstance()->instance = nullptr;
711 }
712
713 /**
714 * @tc.name: ViewAbstractTest013
715 * @tc.desc: Test the operation of View_Abstract
716 * @tc.type: FUNC
717 */
718 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest013, TestSize.Level1)
719 {
720 /**
721 * @tc.steps: step1.The FrameNode is null, related function is called.
722 */
723 auto visible = static_cast<VisibleType>(INDEX);
724 ViewAbstract::SetVisibility(std::move(visible));
725 ViewAbstract::SetVisibility(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(visible));
726 ViewAbstract::SetGeometryTransition(srcimages);
727 ViewAbstract::SetGeometryTransition(AceType::RawPtr(FRAME_NODE_REGISTER), srcimages, false, true);
728 ViewAbstract::SetOpacity(OPACITYS);
729 ViewAbstract::SetOpacity(AceType::RawPtr(FRAME_NODE_REGISTER), OPACITYS);
730 ViewAbstract::SetZIndex(FOUF);
731
732 OffsetT<Dimension> value = { WIDTH, HEIGHT };
733 ViewAbstract::SetPosition(value);
734 ViewAbstract::SetPosition(AceType::RawPtr(FRAME_NODE_REGISTER), value);
735 ViewAbstract::SetOffset(value);
736 ViewAbstract::SetOffset(AceType::RawPtr(FRAME_NODE_REGISTER), value);
737 ViewAbstract::MarkAnchor(value);
738 ViewAbstract::MarkAnchor(AceType::RawPtr(FRAME_NODE_REGISTER), value);
739 VectorF scale(1.0f, 1.0f);
740 ViewAbstract::SetScale(scale);
741 ViewAbstract::SetScale(AceType::RawPtr(FRAME_NODE_REGISTER), scale);
742 DimensionOffset valueOffset = { WIDTH, HEIGHT };
743 ViewAbstract::SetPivot(AceType::RawPtr(FRAME_NODE_REGISTER), valueOffset);
744 ViewAbstract::GetVisibility(AceType::RawPtr(FRAME_NODE_REGISTER));
745 ViewAbstract::GetClip(AceType::RawPtr(FRAME_NODE_REGISTER));
746 ViewAbstract::GetClipShape(AceType::RawPtr(FRAME_NODE_REGISTER));
747 ViewAbstract::GetTransform(AceType::RawPtr(FRAME_NODE_REGISTER));
748 ViewAbstract::GetHitTestBehavior(AceType::RawPtr(FRAME_NODE_REGISTER));
749 ViewAbstract::GetPosition(AceType::RawPtr(FRAME_NODE_REGISTER));
750 ViewAbstract::GetShadow(AceType::RawPtr(FRAME_NODE_REGISTER));
751 ViewAbstract::GetSweepGradient(AceType::RawPtr(FRAME_NODE_REGISTER));
752 ViewAbstract::GetRadialGradient(AceType::RawPtr(FRAME_NODE_REGISTER));
753 ViewAbstract::GetMask(AceType::RawPtr(FRAME_NODE_REGISTER));
754 ViewAbstract::GetMaskProgress(AceType::RawPtr(FRAME_NODE_REGISTER));
755 ViewAbstract::GetBlendMode(AceType::RawPtr(FRAME_NODE_REGISTER));
756 ViewAbstract::GetDirection(AceType::RawPtr(FRAME_NODE_REGISTER));
757 ViewAbstract::GetAlignSelf(AceType::RawPtr(FRAME_NODE_REGISTER));
758 ViewAbstract::GetFlexGrow(AceType::RawPtr(FRAME_NODE_REGISTER));
759 ViewAbstract::GetFlexShrink(AceType::RawPtr(FRAME_NODE_REGISTER));
760 ViewAbstract::GetFlexBasis(AceType::RawPtr(FRAME_NODE_REGISTER));
761 ViewAbstract::GetMinWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
762 ViewAbstract::GetMaxWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
763 ViewAbstract::GetMinHeight(AceType::RawPtr(FRAME_NODE_REGISTER));
764 ViewAbstract::GetMaxHeight(AceType::RawPtr(FRAME_NODE_REGISTER));
765 ViewAbstract::GetGrayScale(AceType::RawPtr(FRAME_NODE_REGISTER));
766 ViewAbstract::GetInvert(AceType::RawPtr(FRAME_NODE_REGISTER));
767 ViewAbstract::GetSepia(AceType::RawPtr(FRAME_NODE_REGISTER));
768 ViewAbstract::GetContrast(AceType::RawPtr(FRAME_NODE_REGISTER));
769 ViewAbstract::GetForegroundColor(AceType::RawPtr(FRAME_NODE_REGISTER));
770 ViewAbstract::GetScale(AceType::RawPtr(FRAME_NODE_REGISTER));
771 ViewAbstract::GetRotate(AceType::RawPtr(FRAME_NODE_REGISTER));
772 ViewAbstract::GetBrightness(AceType::RawPtr(FRAME_NODE_REGISTER));
773 ViewAbstract::GetSaturate(AceType::RawPtr(FRAME_NODE_REGISTER));
774 ViewAbstract::GetBackgroundImagePosition(AceType::RawPtr(FRAME_NODE_REGISTER));
775 ViewAbstract::GetLinearGradient(AceType::RawPtr(FRAME_NODE_REGISTER));
776 ViewAbstract::GetAlign(AceType::RawPtr(FRAME_NODE_REGISTER));
777 ViewAbstract::GetWidth(AceType::RawPtr(FRAME_NODE_REGISTER));
778 ViewAbstract::GetHeight(AceType::RawPtr(FRAME_NODE_REGISTER));
779 ViewAbstract::GetBackgroundColor(AceType::RawPtr(FRAME_NODE_REGISTER));
780 ViewAbstract::GetBackgroundImageSrc(AceType::RawPtr(FRAME_NODE_REGISTER));
781 auto repeat = static_cast<ImageRepeat>(INDEX);
782 ViewAbstract::SetBackgroundImageRepeat(AceType::RawPtr(FRAME_NODE_REGISTER), repeat);
783 ViewAbstract::GetBackgroundImageRepeat(AceType::RawPtr(FRAME_NODE_REGISTER));
784 ViewAbstract::GetPadding(AceType::RawPtr(FRAME_NODE_REGISTER));
785 ViewAbstract::GetConfigSize(AceType::RawPtr(FRAME_NODE_REGISTER));
786 ViewAbstract::GetEnabled(AceType::RawPtr(FRAME_NODE_REGISTER));
787
788 /**
789 * @tc.expected: Return expected results.
790 */
791 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
792 }
793
794 /**
795 * @tc.name: ViewAbstractTest014
796 * @tc.desc: Test the operation of View_Abstract.
797 * @tc.type: FUNC
798 */
799 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest014, TestSize.Level1)
800 {
801 /**
802 * @tc.steps: step1.push FrameNode is not null, related function is called.
803 */
804 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
805 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
806
807 auto visible = static_cast<VisibleType>(INDEX);
808 ViewAbstract::SetVisibility(std::move(visible));
809 ViewAbstract::SetGeometryTransition(srcimages);
810 ViewAbstract::SetOpacity(OPACITYS);
811 ViewAbstract::SetZIndex(FOUF);
812 ViewAbstract::SetZIndex(nullptr, FOUF);
813
814 OffsetT<Dimension> value = { WIDTH, HEIGHT };
815 ViewAbstract::SetPosition(value);
816 ViewAbstract::SetOffset(value);
817 ViewAbstract::MarkAnchor(value);
818 viewAbstractModelNG.SetScale(-1.0f, -1.0f, 0.0f);
819 ViewAbstract::GetMargin(AceType::RawPtr(FRAME_NODE_REGISTER));
820 ViewAbstract::GetTranslate(AceType::RawPtr(FRAME_NODE_REGISTER));
821 GestureEventFunc tapEventFunc;
822 ViewAbstract::SetJSFrameNodeOnClick(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(tapEventFunc));
823 ViewAbstract::ClearJSFrameNodeOnClick(AceType::RawPtr(FRAME_NODE_REGISTER));
824 TouchEventFunc touchEventFunc;
825 ViewAbstract::SetJSFrameNodeOnTouch(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(touchEventFunc));
826 ViewAbstract::ClearJSFrameNodeOnTouch(AceType::RawPtr(FRAME_NODE_REGISTER));
827 std::function<void()> buildFunc;
828 ViewAbstract::SetJSFrameNodeOnAppear(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(buildFunc));
829 ViewAbstract::ClearJSFrameNodeOnAppear(AceType::RawPtr(FRAME_NODE_REGISTER));
830 ViewAbstract::SetJSFrameNodeOnDisappear(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(buildFunc));
831 ViewAbstract::ClearJSFrameNodeOnDisappear(AceType::RawPtr(FRAME_NODE_REGISTER));
__anon34ec4f1b0202(KeyEventInfo& info) 832 OnKeyCallbackFunc onKeyCallback = [](KeyEventInfo& info) {};
833 ViewAbstract::SetJSFrameNodeOnKeyCallback(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onKeyCallback));
834 ViewAbstract::ClearJSFrameNodeOnKeyCallback(AceType::RawPtr(FRAME_NODE_REGISTER));
835
836 std::function<void(bool, double)> onVisibleChange;
837 const std::vector<double> ratios;
838 constexpr uint32_t minInterval = 100; // 100ms
839 ViewAbstract::SetJSFrameNodeOnVisibleAreaApproximateChange(
840 AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onVisibleChange), ratios, minInterval);
841 ViewAbstract::ClearJSFrameNodeOnVisibleAreaApproximateChange(AceType::RawPtr(FRAME_NODE_REGISTER));
842
843 /**
844 * @tc.expected: Return expected results.
845 */
846 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
847 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
848 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
849 ASSERT_NE(frameNode, nullptr);
850 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
851 ASSERT_NE(Node, nullptr);
852 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
853 ASSERT_NE(layoutProperty, nullptr);
854 ViewStackProcessor::GetInstance()->instance = nullptr;
855 }
856
857 /**
858 * @tc.name: ViewAbstractTest015
859 * @tc.desc: Test the operation of View_Abstract
860 * @tc.type: FUNC
861 */
862 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest015, TestSize.Level1)
863 {
864 /**
865 * @tc.steps: step1.The FrameNode is null, related function is called.
866 */
867 viewAbstractModelNG.SetPivot(WIDTH, HEIGHT, WIDTH);
868 NG::TranslateOptions pttions;
869 BlurOption blurOption;
870 ViewAbstract::SetTranslate(std::move(pttions));
871 ViewAbstract::SetTranslate(nullptr, std::move(pttions));
872 Matrix4 matrix;
873 ViewAbstract::SetTransformMatrix(std::move(matrix));
874 ViewAbstract::SetTransformMatrix(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(matrix));
875 ViewAbstract::SetBackdropBlur(RADIUS, blurOption);
876 ViewAbstract::SetBackdropBlur(nullptr, RADIUS, blurOption);
877 ViewAbstract::SetFrontBlur(RADIUS, blurOption);
878 ViewAbstract::SetFrontBlur(AceType::RawPtr(FRAME_NODE_REGISTER), RADIUS, blurOption);
879 ViewAbstract::SetInspectorId(srcimages);
880 ViewAbstract::SetInspectorId(AceType::RawPtr(FRAME_NODE_REGISTER), srcimages);
881
882 Vector5F scale(1.0f, 1.0f, 2.0f, 2.0f, 0.0f);
883 ViewAbstract::SetRotate(scale);
884 ViewAbstract::SetRotate(nullptr, scale);
885 ShadowStyle style { 1 };
886 Shadow shadow { RATIO, OFFSET, BLUE, style };
887 ViewAbstract::SetBackShadow(shadow);
888 ViewAbstract::SetBackShadow(nullptr, shadow);
889
890 NG::Gradient gradient;
891 ViewAbstract::SetLinearGradient(std::move(gradient));
892 ViewAbstract::SetLinearGradient(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(gradient));
893 ViewAbstract::SetSweepGradient(std::move(gradient));
894 ViewAbstract::SetSweepGradient(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(gradient));
895 ViewAbstract::SetRadialGradient(std::move(gradient));
896 ViewAbstract::SetRadialGradient(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(gradient));
897 ViewAbstract::SetSystemBarEffect(false);
898 ViewAbstract::SetSystemBarEffect(nullptr, false);
899 ViewAbstract::SetFreeze(false);
900 ViewAbstract::SetUseShadowBatching(false);
901 ViewAbstract::SetUseShadowBatching(AceType::RawPtr(FRAME_NODE_REGISTER), false);
902
903 /**
904 * @tc.expected: Return expected results.
905 */
906 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
907 }
908
909 /**
910 * @tc.name: ViewAbstractTest016
911 * @tc.desc: Test the operation of View_Abstract.
912 * @tc.type: FUNC
913 */
914 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest016, TestSize.Level1)
915 {
916 /**
917 * @tc.steps: step1.push FrameNode is not null, related function is called.
918 */
919 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
920 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
921
922 viewAbstractModelNG.SetPivot(WIDTH, HEIGHT, ZERO);
923 NG::TranslateOptions pttions;
924 ViewAbstract::SetTranslate(std::move(pttions));
925 Matrix4 matrix;
926 BlurOption blurOption;
927 ViewAbstract::SetTransformMatrix(std::move(matrix));
928 ViewAbstract::SetBackdropBlur(RADIUS, blurOption);
929 ViewAbstract::SetFrontBlur(RADIUS, blurOption);
930 ViewAbstract::SetInspectorId(srcimages);
931 ViewAbstract::SetDebugLine(srcimages);
932
933 Vector5F scale(1.0f, 1.0f, 2.0f, 2.0f, 0.0f);
934 ViewAbstract::SetRotate(scale);
935 ShadowStyle style { 1 };
936 Shadow shadow { RATIO, OFFSET, BLUE, style };
937 ViewAbstract::SetBackShadow(shadow);
938 NG::Gradient gradient;
939 ViewAbstract::SetLinearGradient(std::move(gradient));
940 ViewAbstract::SetSweepGradient(std::move(gradient));
941 ViewAbstract::SetRadialGradient(std::move(gradient));
942 ViewAbstract::SetSystemBarEffect(false);
943 ViewAbstract::SetSystemBarEffect(nullptr, false);
944 ViewAbstract::SetFreeze(false);
945 ViewAbstract::SetUseShadowBatching(false);
946 ImageResizableSlice slice;
947 ViewAbstract::SetBackgroundImageResizableSlice(slice);
948 ViewAbstract::SetBackgroundImageResizableSlice(nullptr, slice);
949 ViewAbstract::SetBackgroundImageResizableSlice(nullptr, slice, true);
950
951 /**
952 * @tc.expected: Return expected results.
953 */
954 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
955 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
956 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
957 ASSERT_NE(frameNode, nullptr);
958 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
959 ASSERT_NE(Node, nullptr);
960 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
961 ASSERT_NE(layoutProperty, nullptr);
962 ViewStackProcessor::GetInstance()->instance = nullptr;
963 }
964
965 /**
966 * @tc.name: ViewAbstractTest017
967 * @tc.desc: Test the operation of View_Abstract
968 * @tc.type: FUNC
969 */
970 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest017, TestSize.Level1)
971 {
972 /**
973 * @tc.steps: step1.The FrameNode is null, related function is called.
974 */
975 auto visible = static_cast<GridSizeType>(INDEX);
976 ViewAbstract::SetGrid(FOUF, FOUF, std::move(visible));
977 ViewAbstract::SetGrid(AceType::RawPtr(FRAME_NODE_REGISTER), FOUF, FOUF, std::move(visible));
978 TransitionOptions options;
979 ViewAbstract::SetTransition(std::move(options));
980 RefPtr<BasicShape> basicShape;
981 ViewAbstract::SetClipShape(std::move(basicShape));
982 ViewAbstract::SetClipShape(nullptr, std::move(basicShape));
983 ViewAbstract::SetMask(std::move(basicShape));
984 ViewAbstract::SetClipEdge(false);
985 ViewAbstract::SetGrayScale(RADIUS);
986 ViewAbstract::SetGrayScale(nullptr, RADIUS);
987 OHOS::Rosen::VisualEffect* visualEffect;
988 ViewAbstract::SetVisualEffect(visualEffect);
989 OHOS::Rosen::Filter* backgroundFilter;
990 ViewAbstract::SetBackgroundFilter(backgroundFilter);
991 OHOS::Rosen::Filter* foregroundFilter;
992 ViewAbstract::SetForegroundFilter(foregroundFilter);
993 OHOS::Rosen::Filter* compositingFilter;
994 ViewAbstract::SetCompositingFilter(compositingFilter);
995 ViewAbstract::SetDynamicDim(1.0f);
996 ViewAbstract::SetContrast(RADIUS);
997 ViewAbstract::SetSaturate(RADIUS);
998 ViewAbstract::SetSaturate(nullptr, RADIUS);
999 ViewAbstract::SetSepia(RADIUS);
1000 ViewAbstract::SetSepia(nullptr, RADIUS);
1001 ViewAbstract::SetInvert(invert);
1002 ViewAbstract::SetInvert(nullptr, invert);
1003 ViewAbstract::SetHueRotate(RATIO);
1004 ViewAbstract::SetHueRotate(nullptr, RATIO);
1005 ViewAbstract::SetBrightness(RADIUS);
1006 ViewAbstract::SetColorBlend(BLUE);
1007 ViewAbstract::SetBorderImageSource(srcimages);
1008 ViewAbstract::SetBlender(nullptr);
1009
1010 /**
1011 * @tc.expected: Return expected results.
1012 */
1013 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
1014 }
1015
1016 /**
1017 * @tc.name: ViewAbstractTest018
1018 * @tc.desc: Test the operation of View_Abstract.
1019 * @tc.type: FUNC
1020 */
1021 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest018, TestSize.Level1)
1022 {
1023 /**
1024 * @tc.steps: step1.push FrameNode is not null, related function is called.
1025 */
1026 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1027 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1028
1029 auto visible = static_cast<GridSizeType>(INDEX);
1030 ViewAbstract::SetGrid(FOUF, FOUF, std::move(visible));
1031 TransitionOptions options;
1032 ViewAbstract::SetTransition(std::move(options));
1033 RefPtr<BasicShape> basicShape;
1034 ViewAbstract::SetClipShape(std::move(basicShape));
1035 ViewAbstract::SetMask(std::move(basicShape));
1036 ViewAbstract::SetClipEdge(false);
1037 ViewAbstract::SetClipEdge(nullptr, false);
1038 ViewAbstract::SetGrayScale(RADIUS);
1039 ViewAbstract::SetGrayScale(nullptr, RADIUS);
1040 OHOS::Rosen::VisualEffect* visualEffect;
1041 ViewAbstract::SetVisualEffect(visualEffect);
1042 OHOS::Rosen::Filter* backgroundFilter;
1043 ViewAbstract::SetBackgroundFilter(backgroundFilter);
1044 OHOS::Rosen::Filter* foregroundFilter;
1045 ViewAbstract::SetForegroundFilter(foregroundFilter);
1046 OHOS::Rosen::Filter* compositingFilter;
1047 ViewAbstract::SetCompositingFilter(compositingFilter);
1048 ViewAbstract::SetContrast(RADIUS);
1049 ViewAbstract::SetSaturate(RADIUS);
1050 ViewAbstract::SetSepia(RADIUS);
1051 ViewAbstract::SetInvert(invert);
1052 ViewAbstract::SetHueRotate(RATIO);
1053 ViewAbstract::SetBrightness(RADIUS);
1054 ViewAbstract::SetBrightness(nullptr, RADIUS);
1055 ViewAbstract::SetColorBlend(BLUE);
1056 ViewAbstract::SetColorBlend(nullptr, BLUE);
1057 ViewAbstract::SetBorderImageSource(srcimages);
1058 ViewAbstract::SetBlender(nullptr);
1059
1060 /**
1061 * @tc.expected: Return expected results.
1062 */
1063 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1064 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1065 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1066 ASSERT_NE(frameNode, nullptr);
1067 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1068 ASSERT_NE(Node, nullptr);
1069 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1070 ASSERT_NE(layoutProperty, nullptr);
1071 ViewStackProcessor::GetInstance()->instance = nullptr;
1072 }
1073
1074 /**
1075 * @tc.name: ViewAbstractTest019
1076 * @tc.desc: Test the operation of View_Abstract
1077 * @tc.type: FUNC
1078 */
1079 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest019, TestSize.Level1)
1080 {
1081 /**
1082 * @tc.steps: step1.The FrameNode is null, related function is called.
1083 */
1084 RefPtr<BorderImage> borderImage;
1085 ViewAbstract::SetBorderImage(std::move(borderImage));
1086 ViewAbstract::SetHasBorderImageSlice(true);
1087 ViewAbstract::SetHasBorderImageWidth(true);
1088 ViewAbstract::SetHasBorderImageOutset(true);
1089 ViewAbstract::SetHasBorderImageRepeat(true);
1090 ViewAbstract::SetHasBorderImageRepeat(nullptr, true);
1091 Gradient gradient;
1092 ViewAbstract::SetBorderImageGradient(std::move(gradient));
1093 ViewAbstract::SetBorderImageGradient(nullptr, std::move(gradient));
1094 OverlayOptions overlay;
1095 ViewAbstract::SetOverlay(std::move(overlay));
1096 ViewAbstract::SetOverlay(nullptr, std::move(overlay));
1097 MotionPathOption motionPath;
1098 ViewAbstract::SetMotionPath(std::move(motionPath));
1099 ViewAbstract::SetMotionPath(nullptr, std::move(motionPath));
1100 ViewAbstract::SetSharedTransition("", nullptr);
1101 ViewAbstract::SetSharedTransition(AceType::RawPtr(FRAME_NODE_REGISTER), "", nullptr);
1102 ViewAbstract::SetSphericalEffect(RATIO);
1103 ViewAbstract::SetLightUpEffect(RATIO);
1104 ViewAbstract::SetUseEffect(false, EffectType::DEFAULT);
1105 ViewAbstract::SetRenderGroup(false);
1106 ViewAbstract::SetRenderFit(RenderFit::BOTTOM);
1107 ViewAbstract::UpdateSafeAreaExpandOpts(safeAreaExpandOpts);
1108 ViewAbstract::UpdateSafeAreaExpandOpts(AceType::RawPtr(FRAME_NODE_REGISTER), safeAreaExpandOpts);
1109 ViewAbstract::SetObscured(reasonsVector);
1110 ViewAbstract::SetObscured(AceType::RawPtr(FRAME_NODE_REGISTER), reasonsVector);
1111
1112 /**
1113 * @tc.expected: Return expected results.
1114 */
1115 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
1116 }
1117
1118 /**
1119 * @tc.name: ViewAbstractTest020
1120 * @tc.desc: Test the operation of View_Abstract.
1121 * @tc.type: FUNC
1122 */
1123 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest020, TestSize.Level1)
1124 {
1125 /**
1126 * @tc.steps: step1.push FrameNode is not null, related function is called.
1127 */
1128 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1129 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1130
1131 RefPtr<BorderImage> borderImage;
1132 ViewAbstract::SetBorderImage(std::move(borderImage));
1133 ViewAbstract::SetBorderImage(nullptr, std::move(borderImage));
1134 ViewAbstract::SetHasBorderImageSlice(true);
1135 ViewAbstract::SetHasBorderImageWidth(true);
1136 ViewAbstract::SetHasBorderImageOutset(true);
1137 ViewAbstract::SetHasBorderImageRepeat(true);
1138 Gradient gradient;
1139 ViewAbstract::SetBorderImageGradient(std::move(gradient));
1140 OverlayOptions overlay;
1141 ViewAbstract::SetOverlay(std::move(overlay));
1142 MotionPathOption motionPath;
1143 ViewAbstract::SetMotionPath(std::move(motionPath));
1144 std::shared_ptr<SharedTransitionOption> option;
1145 ViewAbstract::SetSharedTransition(srcimages, std::move(option));
1146 ViewAbstract::SetSphericalEffect(RATIO);
1147 ViewAbstract::SetLightUpEffect(RATIO);
1148 ViewAbstract::SetDraggable(false);
1149 ViewAbstract::SetDraggable(AceType::RawPtr(FRAME_NODE_REGISTER), false);
1150 ViewAbstract::SetUseEffect(false, EffectType::DEFAULT);
1151 ViewAbstract::SetUseEffect(false, EffectType::WINDOW_EFFECT);
1152 ViewAbstract::SetUseEffect(true, EffectType::DEFAULT);
1153 ViewAbstract::SetUseEffect(true, EffectType::WINDOW_EFFECT);
1154 ViewAbstract::SetRenderGroup(false);
1155 ViewAbstract::SetRenderFit(RenderFit::BOTTOM);
1156 ViewAbstract::UpdateSafeAreaExpandOpts(safeAreaExpandOpts);
1157 ViewAbstract::SetObscured(reasonsVector);
1158
1159 /**
1160 * @tc.expected: Return expected results.
1161 */
1162 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1163 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1164 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1165 ASSERT_NE(frameNode, nullptr);
1166 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1167 ASSERT_NE(Node, nullptr);
1168 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1169 ASSERT_NE(layoutProperty, nullptr);
1170 ViewStackProcessor::GetInstance()->instance = nullptr;
1171 }
1172
1173 /**
1174 * @tc.name: ViewAbstractTest021
1175 * @tc.desc: Test the operation of View_Abstract
1176 * @tc.type: FUNC
1177 */
1178 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest021, TestSize.Level1)
1179 {
1180 /**
1181 * @tc.steps: step1.The FrameNode is null, related function is called.
1182 */
1183 PixStretchEffectOption option;
1184 option.bottom = BOTTOM;
1185 option.left = LEFT;
1186 option.right = RIGHT;
1187 option.top = TOP;
1188 ViewAbstract::SetPixelStretchEffect(option);
1189 ViewAbstract::SetPixelStretchEffect(nullptr, option);
1190 RefPtr<NG::ChainedTransitionEffect> effect;
1191 ViewAbstract::SetChainedTransition(std::move(effect));
1192 RefPtr<ProgressMaskProperty> progress;
1193 ViewAbstract::SetProgressMask(std::move(progress));
1194
1195 ViewAbstract::SetForegroundColor(BLUE);
1196 auto strategy = static_cast<ForegroundColorStrategy>(INDEX);
1197 ViewAbstract::SetForegroundColorStrategy(std::move(strategy));
1198 auto hoverEffect = static_cast<HoverEffectType>(INDEX);
1199 ViewAbstract::SetHoverEffectAuto(hoverEffect);
1200 ViewAbstract::SetDraggable(true);
1201
1202 /**
1203 * @tc.expected: Return expected results.
1204 */
1205 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
1206 }
1207
1208 /**
1209 * @tc.name: ViewAbstractTest022
1210 * @tc.desc: Test the operation of View_Abstract.
1211 * @tc.type: FUNC
1212 */
1213 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest022, TestSize.Level1)
1214 {
1215 /**
1216 * @tc.steps: step1.push FrameNode is not null, related function is called.
1217 */
1218 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1219 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1220
1221 PixStretchEffectOption option;
1222 option.bottom = BOTTOM;
1223 option.left = LEFT;
1224 option.right = RIGHT;
1225 option.top = TOP;
1226 ViewAbstract::SetPixelStretchEffect(option);
1227 RefPtr<NG::ChainedTransitionEffect> effect;
1228 ViewAbstract::SetChainedTransition(std::move(effect));
1229 RefPtr<ProgressMaskProperty> progress;
1230 ViewAbstract::SetProgressMask(std::move(progress));
1231 ViewAbstract::SetForegroundColor(BLUE);
1232 auto strategy = static_cast<ForegroundColorStrategy>(INDEX);
1233 ViewAbstract::SetForegroundColorStrategy(std::move(strategy));
1234 ViewAbstract::SetBorderWidth(VALUE);
1235 ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
1236 ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
1237 auto hoverEffect = static_cast<HoverEffectType>(INDEX);
1238 ViewAbstract::SetHoverEffectAuto(hoverEffect);
1239 ViewAbstract::SetDraggable(true);
1240
1241 /**
1242 * @tc.expected: Return expected results.
1243 */
1244 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1245 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1246 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1247 ASSERT_NE(frameNode, nullptr);
1248 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1249 ASSERT_NE(Node, nullptr);
1250 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1251 ASSERT_NE(layoutProperty, nullptr);
1252 ViewStackProcessor::GetInstance()->instance = nullptr;
1253 }
1254
1255 /**
1256 * @tc.name: ViewAbstractTest023
1257 * @tc.desc: Test the operation of View_Abstract
1258 * @tc.type: FUNC
1259 */
1260 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest023, TestSize.Level1)
1261 {
1262 /**
1263 * @tc.steps: step1.The FrameNode is null, related function is called.
1264 */
1265 std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)>
1266 onAreaChanged;
1267 ViewAbstract::SetOnAreaChanged(std::move(onAreaChanged));
1268 ViewAbstract::SetOnAreaChanged(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onAreaChanged));
1269
1270 std::function<void(const RectF& oldRect, const RectF& rect)> onSizeChanged;
1271 ViewAbstract::SetOnSizeChanged(std::move(onSizeChanged));
1272 std::function<void(bool, double)> onVisibleChange;
1273 const std::vector<double> ratios;
1274 ViewAbstract::SetOnVisibleChange(std::move(onVisibleChange), ratios);
1275
1276 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&)> onDragEnd;
1277 ViewAbstract::SetOnDragEnd(std::move(onDragEnd));
1278 std::set<std::string> allowDrop;
1279 ViewAbstract::SetAllowDrop(std::move(allowDrop));
1280 ViewAbstract::SetAllowDrop(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(allowDrop));
1281 ViewAbstract::CreateAnimatablePropertyFloat(srcimages, RATIO, nullptr);
1282 ViewAbstract::UpdateAnimatablePropertyFloat(srcimages, RATIO);
1283 ViewAbstract::SetRestoreId(TEN);
1284 ViewAbstract::SetRestoreId(AceType::RawPtr(FRAME_NODE_REGISTER), TEN);
1285
1286 /**
1287 * @tc.expected: Return expected results.
1288 */
1289 EXPECT_NE(ViewStackProcessor::GetInstance()->GetMainElementNode(), nullptr);
1290 }
1291
1292 /**
1293 * @tc.name: ViewAbstractTest024
1294 * @tc.desc: Test the operation of View_Abstract.
1295 * @tc.type: FUNC
1296 */
1297 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest024, TestSize.Level1)
1298 {
1299 /**
1300 * @tc.steps: step1.push FrameNode is not null, related function is called.
1301 */
1302 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1303 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1304
1305 std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)>
1306 onAreaChanged;
1307 ViewAbstract::SetOnAreaChanged(std::move(onAreaChanged));
1308 std::function<void(bool, double)> onVisibleChange;
1309 const std::vector<double> ratios;
1310 ViewAbstract::SetOnVisibleChange(std::move(onVisibleChange), ratios);
1311 std::function<void(const RefPtr<OHOS::Ace::DragEvent>&)> onDragEnd;
1312 ViewAbstract::SetOnDragEnd(std::move(onDragEnd));
1313 std::set<std::string> allowDrop;
1314 ViewAbstract::SetAllowDrop(std::move(allowDrop));
1315 ViewAbstract::CreateAnimatablePropertyFloat(srcimages, RATIO, nullptr);
1316 ViewAbstract::UpdateAnimatablePropertyFloat(srcimages, RATIO);
1317 ViewAbstract::SetRestoreId(TEN);
1318
1319 /**
1320 * @tc.expected: Return expected results.
1321 */
1322 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
1323 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0);
1324 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1325 ASSERT_NE(frameNode, nullptr);
1326 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode);
1327 ASSERT_NE(Node, nullptr);
1328 auto layoutProperty = Node->GetLayoutProperty<LayoutProperty>();
1329 ASSERT_NE(layoutProperty, nullptr);
1330 ViewStackProcessor::GetInstance()->instance = nullptr;
1331 }
1332
1333 /**
1334 * @tc.name: ViewAbstractTest025
1335 * @tc.desc: Test the BindPopup of View_Abstract.
1336 * @tc.type: FUNC
1337 */
1338 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest025, TestSize.Level1)
1339 {
1340 /**
1341 * @tc.steps: step1. Create some FrameNode and params.
1342 */
1343 const RefPtr<FrameNode> customNode = FrameNode::CreateFrameNode("one", 1, AceType::MakeRefPtr<Pattern>(), true);
1344 const RefPtr<FrameNode> targetNode = FrameNode::CreateFrameNode("two", 2, AceType::MakeRefPtr<Pattern>());
1345 const RefPtr<FrameNode> targetNode2 = FrameNode::CreateFrameNode("three", 3, AceType::MakeRefPtr<Pattern>());
1346 auto param = AceType::MakeRefPtr<PopupParam>();
1347 auto param2 = AceType::MakeRefPtr<PopupParam>();
1348
1349 /**
1350 * @tc.steps: step2. get popupInfo and change some params.
1351 */
1352 auto container = Container::Current();
1353 ASSERT_NE(container, nullptr);
1354 auto pipelineContext = container->GetPipelineContext();
1355 ASSERT_NE(pipelineContext, nullptr);
1356 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext);
1357 ASSERT_NE(context, nullptr);
1358 auto overlayManager = context->GetOverlayManager();
1359 ASSERT_NE(overlayManager, nullptr);
1360 auto nodeId = targetNode->GetId();
1361 PopupInfo info = overlayManager->GetPopupInfo(nodeId);
1362 info.isCurrentOnShow = true;
1363 info.popupId = 1;
1364 auto popupNode1 = FrameNode::CreateFrameNode(
1365 V2::POPUP_ETS_TAG, info.popupId, AceType::MakeRefPtr<BubblePattern>(targetNode->GetId(), targetNode->GetTag()));
1366 info.popupNode = popupNode1;
1367 info.target = targetNode2;
1368 overlayManager->ShowPopup(targetNode->GetId(), info);
1369
1370 /**
1371 * @tc.steps: step3. Call BindPopup many times.
1372 * @tc.expected: popupNode in overlayManager of targetNode not null
1373 */
1374 ViewAbstract::BindPopup(param, targetNode, customNode);
1375 ViewAbstract::BindPopup(param, targetNode, customNode);
1376 overlayManager->HidePopup(targetNode->GetId(), info);
1377 auto popupInfo = overlayManager->GetPopupInfo(targetNode->GetId());
1378 auto popupNode = popupInfo.popupNode;
1379 ASSERT_NE(popupNode, nullptr);
1380 popupNode->GetPattern<BubblePattern>()->transitionStatus_ = TransitionStatus::ENTERING;
1381 ViewAbstract::BindPopup(param, targetNode, customNode);
1382 param->SetIsShow(false);
1383 ViewAbstract::BindPopup(param, targetNode, customNode);
1384 param->SetShowInSubWindow(true);
1385 ViewAbstract::BindPopup(param, targetNode, customNode);
1386 EXPECT_NE(overlayManager->GetPopupInfo(targetNode->GetId()).popupNode, nullptr);
1387
1388 /**
1389 * @tc.steps: step4. Call BindPopup with param use custom.
1390 * @tc.expected: popupNode in overlayManager of targetNode not null
1391 */
1392 param2->SetUseCustomComponent(true);
1393 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1394 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1395 param2->SetShowInSubWindow(true);
1396 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1397 param2->SetIsShow(false);
1398 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1399 param2->SetShowInSubWindow(true);
1400 ViewAbstract::BindPopup(param2, targetNode2, customNode);
1401 EXPECT_NE(overlayManager->GetPopupInfo(targetNode->GetId()).popupNode, nullptr);
1402 }
1403
1404 /**
1405 * @tc.name: ViewAbstractTest026
1406 * @tc.desc: Test the SetKeyboardShortcut of View_Abstract.
1407 * @tc.type: FUNC
1408 */
1409 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest026, TestSize.Level1)
1410 {
1411 /**
1412 * @tc.steps: step1. Create a FrameNode and get eventManager.
1413 */
1414 const RefPtr<FrameNode> targetNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true);
1415 ViewStackProcessor::GetInstance()->Push(targetNode);
1416 auto eventManager = PipelineContext::GetCurrentContext()->GetEventManager();
1417 /**
1418 * @tc.steps: step2. call SetKeyboardShortcut with ctrl + x.
1419 * @tc.expected: add fail
1420 */
1421 std::vector<ModifierKey> keys;
1422 keys.push_back(ModifierKey::CTRL);
1423 ViewAbstract::SetKeyboardShortcut(VALUE_X, std::move(keys), callback);
1424 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_X, std::move(keys), callback);
1425 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1426 keys.clear();
1427 /**
1428 * @tc.steps: step3. call SetKeyboardShortcut with other wrong type.
1429 * @tc.expected: add fail
1430 */
1431 ViewAbstract::SetKeyboardShortcut(VALUE_EMPTY, std::move(keys), callback);
1432 ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1433 ViewAbstract::SetKeyboardShortcut(VALUE_X, std::move(keys), callback);
1434 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_EMPTY, std::move(keys), callback);
1435 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_CX, std::move(keys), callback);
1436 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_X, std::move(keys), callback);
1437
1438 /**
1439 * @tc.steps: step4. and shift in keys and recall SetKeyboardShortcut .
1440 * @tc.expected: add success
1441 */
1442 keys.push_back(ModifierKey::ALT);
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
1447 /**
1448 * @tc.steps: step5. make other key and recall SetKeyboardShortcut .
1449 * @tc.expected: add fail
1450 */
1451 keys.push_back(ModifierKey::SHIFT);
1452 ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1453 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_CX, std::move(keys), callback);
1454 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1455 keys.push_back(ModifierKey::ALT);
1456 ViewAbstract::SetKeyboardShortcut(VALUE_CX, std::move(keys), callback);
1457 ViewAbstract::SetKeyboardShortcut(AceType::RawPtr(FRAME_NODE_REGISTER), VALUE_CX, std::move(keys), callback);
1458 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1459 }
1460
1461 /**
1462 * @tc.name: ViewAbstractTest027
1463 * @tc.desc: Test the operation of View_Abstract.
1464 * @tc.type: FUNC
1465 */
1466 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest027, TestSize.Level1)
1467 {
1468 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1469 /**
1470 * @tc.steps: step1. callback ShowMenu with two condition.
1471 */
1472 ContainerScope sontainerScope(1);
1473 /**
1474 * @tc.steps: step2. callback SetForegroundBlurStyle and ResetFlexShrink.
1475 */
1476 BlurStyleOption bgBlurStyle;
1477 ViewAbstract::SetForegroundBlurStyle(bgBlurStyle);
1478 ViewAbstract::SetForegroundBlurStyle(AceType::RawPtr(FRAME_NODE_REGISTER), bgBlurStyle);
1479 ViewAbstract::ResetFlexShrink();
1480 ViewAbstract::ResetFlexShrink(AceType::RawPtr(FRAME_NODE_REGISTER));
1481 /**
1482 * @tc.steps: step3. SetVisualState in ViewStackProcessor and recall the two function.
1483 * @tc.expected: the blur radius in render context meet expectations.
1484 */
1485 ViewStackProcessor::GetInstance()->SetVisualState(VisualState::FOCUSED);
1486 ViewAbstract::SetForegroundBlurStyle(bgBlurStyle);
1487 ViewAbstract::SetForegroundBlurStyle(AceType::RawPtr(FRAME_NODE_REGISTER), bgBlurStyle);
1488 ViewAbstract::ResetFlexShrink();
1489 ASSERT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr);
1490 EXPECT_FALSE(FRAME_NODE_ROOT->GetRenderContext()->GetFrontBlurRadius().has_value());
1491 }
1492
1493 /**
1494 * @tc.name: ViewAbstractTest028
1495 * @tc.desc: Test the operation of View_Abstract.
1496 * @tc.type: FUNC
1497 */
1498 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest028, TestSize.Level1)
1499 {
1500 /**
1501 * @tc.steps: step1.push FrameNode is not null, callback Pop function.
1502 */
1503 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT);
1504 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD);
1505 ViewAbstract::Pop();
1506
1507 /**
1508 * @tc.expected: Return expected results.
1509 */
1510 EXPECT_FALSE(ViewStackProcessor::GetInstance()->elementsStack_.empty());
1511 EXPECT_EQ(ViewStackProcessor::GetInstance()->elementsStack_.size(), INDEX);
1512 }
1513
1514 /**
1515 * @tc.name: ViewAbstractTest029
1516 * @tc.desc: Test the operation of View_Abstract
1517 * @tc.type: FUNC
1518 */
1519 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest029, TestSize.Level1)
1520 {
1521 /**
1522 * @tc.steps: step1.ClearStack.
1523 */
1524 auto state = static_cast<VisualState>(INDEX);
1525 ViewStackProcessor::GetInstance()->SetVisualState(state);
1526 ViewStackProcessor::GetInstance()->ClearStack();
1527
1528 /**
1529 * @tc.steps: step2. related function is called.
1530 */
1531 ViewAbstract::SetWidth(NG::CalcLength(WIDTH));
1532 ViewAbstract::SetHeight(NG::CalcLength(HEIGHT));
1533 ViewAbstract::SetMinWidth(NG::CalcLength(MIN_WIDTH));
1534 ViewAbstract::SetMinHeight(NG::CalcLength(MIN_HEIGHT));
1535 ViewAbstract::SetMaxWidth(NG::CalcLength(MIN_WIDTH));
1536 ViewAbstract::SetMaxHeight(NG::CalcLength(MIN_HEIGHT));
1537 ViewAbstract::SetAspectRatio(RATIO);
1538 ViewAbstract::SetAspectRatio(AceType::RawPtr(FRAME_NODE_REGISTER), RATIO);
1539 ViewAbstract::SetBackgroundColor(BLUE);
1540 ViewAbstract::SetBackgroundColor(nullptr, BLUE);
1541 ViewAbstract::SetBackgroundImage(imageSourceInfo);
1542 ViewAbstract::SetBackgroundImage(nullptr, imageSourceInfo);
1543 ViewAbstract::SetBackgroundImageSize(BACKGROUNDSIZE);
1544 ViewAbstract::SetBackgroundImageSize(nullptr, BACKGROUNDSIZE);
1545 ViewAbstract::SetBackgroundImageSize(nullptr, BACKGROUNDSIZE, true);
1546 ViewAbstract::SetBackgroundImagePosition(BACKGROUNDPOSITION);
1547 ViewAbstract::SetBackgroundImagePosition(nullptr, BACKGROUNDPOSITION);
1548 ViewAbstract::SetBackgroundImagePosition(nullptr, BACKGROUNDPOSITION, true);
1549 ViewAbstract::SetPixelRound(0);
1550 ChainInfo chainInfo;
1551 chainInfo.direction = LineDirection::HORIZONTAL;
1552 chainInfo.style = ChainStyle::SPREAD;
1553 ViewAbstract::SetChainStyle(chainInfo);
1554 ViewAbstract::SetChainStyle(AceType::RawPtr(FRAME_NODE_REGISTER), chainInfo);
1555 ViewAbstract::SetBias(biasPair);
1556 ViewAbstract::SetBias(nullptr, biasPair);
1557 ViewAbstract::SetOuterBorderRadius(ZERO);
1558 ViewAbstract::SetOuterBorderRadius(nullptr, ZERO);
1559 NG::BorderRadiusProperty borderRadius;
1560 ViewAbstract::SetOuterBorderRadius(borderRadius);
1561 ViewAbstract::SetOuterBorderRadius(nullptr, borderRadius);
1562 ViewAbstract::SetOuterBorderColor(BLUE);
1563 ViewAbstract::SetOuterBorderColor(nullptr, BLUE);
1564 NG::BorderColorProperty borderColor;
1565 ViewAbstract::SetOuterBorderColor(borderColor);
1566 ViewAbstract::SetOuterBorderColor(nullptr, borderColor);
1567 ViewAbstract::SetOuterBorderWidth(ZERO);
1568 ViewAbstract::SetOuterBorderWidth(nullptr, ZERO);
1569 NG::BorderWidthProperty borderWidth;
1570 ViewAbstract::SetOuterBorderWidth(borderWidth);
1571 ViewAbstract::SetOuterBorderWidth(nullptr, borderWidth);
1572 auto borderStyle = static_cast<BorderStyle>(INDEX);
1573 ViewAbstract::SetOuterBorderStyle(borderStyle);
1574 ViewAbstract::SetOuterBorderStyle(nullptr, borderStyle);
1575 NG::BorderStyleProperty borderStyleProperty;
1576 ViewAbstract::SetOuterBorderStyle(borderStyleProperty);
1577 ViewAbstract::SetOuterBorderStyle(nullptr, borderStyleProperty);
1578 ViewAbstract::ResetAspectRatio();
1579 ViewAbstract::ResetAspectRatio(AceType::RawPtr(FRAME_NODE_REGISTER));
1580
1581 /**
1582 * @tc.expected: Return expected results.
1583 */
1584 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1585 EXPECT_FALSE(result);
1586 }
1587
1588 /**
1589 * @tc.name: ViewAbstractTest030
1590 * @tc.desc: Test the operation of View_Abstract
1591 * @tc.type: FUNC
1592 */
1593 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest030, TestSize.Level1)
1594 {
1595 /**
1596 * @tc.steps: step1.ClearStack.
1597 */
1598 auto state = static_cast<VisualState>(INDEX);
1599 ViewStackProcessor::GetInstance()->SetVisualState(state);
1600 ViewStackProcessor::GetInstance()->ClearStack();
1601
1602 /**
1603 * @tc.steps: step2. related function is called.
1604 */
1605 MotionPathOption motionPath;
1606 ViewAbstract::SetMotionPath(std::move(motionPath));
1607 auto repeat = static_cast<ImageRepeat>(INDEX);
1608 ViewAbstract::SetBackgroundImageRepeat(repeat);
1609 GestureJudgeFunc tapEventFunc;
1610 ViewAbstract::SetOnGestureJudgeBegin(std::move(tapEventFunc));
1611
1612 BlurStyleOption blurStyleOption;
1613 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
1614 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
1615 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
1616 ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
1617
1618 auto direction = static_cast<TextDirection>(INDEX);
1619 ViewAbstract::SetLayoutDirection(direction);
1620 std::map<AlignDirection, AlignRule> alignRules;
1621 ViewAbstract::SetAlignRules(alignRules);
1622 auto alignSelf = static_cast<FlexAlign>(INDEX);
1623 ViewAbstract::SetAlignSelf(alignSelf);
1624 ViewAbstract::SetAlignSelf(AceType::RawPtr(FRAME_NODE_REGISTER), alignSelf);
1625
1626 /**
1627 * @tc.expected: Return expected results.
1628 */
1629 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
1630 EXPECT_FALSE(result);
1631 }
1632
1633 /**
1634 * @tc.name: OpenPopup
1635 * @tc.desc: Test OpenPopup of View_Abstract
1636 * @tc.type: FUNC
1637 */
1638 HWTEST_F(ViewAbstractTestNg, OpenPopup, TestSize.Level1)
1639 {
1640 /**
1641 * @tc.steps: step1. Create some FrameNode and params.
1642 */
1643 auto pipelineContext = PipelineContext::GetCurrentContext();
1644 auto param = AceType::MakeRefPtr<PopupParam>();
1645 RefPtr<PopupParam> param2 = nullptr;
1646 auto contentNode =
1647 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon34ec4f1b0302() 1648 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1649 RefPtr<FrameNode> contentNode2 = nullptr;
1650 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b0402() 1651 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1652
1653 /**
1654 * @tc.steps: step2. Return expected results.
1655 */
1656 EXPECT_EQ(ViewAbstract::OpenPopup(param2, contentNode2), ERROR_CODE_INTERNAL_ERROR);
1657 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode2), ERROR_CODE_DIALOG_CONTENT_ERROR);
1658 int32_t targetId = -1;
1659 param->SetTargetId(std::to_string(targetId));
1660 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_TARGET_INFO_NOT_EXIST);
1661 targetId = 10000;
1662 param->SetTargetId(std::to_string(targetId));
1663 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_TARGET_INFO_NOT_EXIST);
1664 param->SetTargetId(std::to_string(targetNode->GetId()));
1665 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_TARGET_NOT_ON_COMPONENT_TREE);
1666 param->SetIsShow(true);
1667 param->SetUseCustomComponent(true);
1668 ViewStackProcessor::GetInstance()->Push(targetNode);
1669 targetNode->onMainTree_ = true;
1670 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1671 auto stageNode = FrameNode::CreateFrameNode(
1672 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1673 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1674 stageNode->MountToParent(rootNode);
1675 targetNode->MountToParent(stageNode);
1676 rootNode->MarkDirtyNode();
1677 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_NO_ERROR);
1678 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_DIALOG_CONTENT_ALREADY_EXIST);
1679 }
1680
1681 /**
1682 * @tc.name: UpdatePopup
1683 * @tc.desc: Test UpdatePopup of View_Abstract
1684 * @tc.type: FUNC
1685 */
1686 HWTEST_F(ViewAbstractTestNg, UpdatePopup, TestSize.Level1)
1687 {
1688 /**
1689 * @tc.steps: step1. Create some FrameNode and params.
1690 */
1691 auto pipelineContext = PipelineContext::GetCurrentContext();
1692 auto param = AceType::MakeRefPtr<PopupParam>();
1693 auto contentNode =
1694 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon34ec4f1b0502() 1695 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1696 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b0602() 1697 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1698 ViewStackProcessor::GetInstance()->Push(targetNode);
1699 targetNode->onMainTree_ = true;
1700 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1701 auto stageNode = FrameNode::CreateFrameNode(
1702 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1703 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1704 stageNode->MountToParent(rootNode);
1705 targetNode->MountToParent(stageNode);
1706 rootNode->MarkDirtyNode();
1707 param->SetIsShow(true);
1708 param->SetUseCustomComponent(true);
1709 param->SetShowInSubWindow(false);
1710 param->SetTargetId(std::to_string(targetNode->GetId()));
1711
1712 /**
1713 * @tc.expected: Return expected results.
1714 */
1715 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_NO_ERROR);
1716 auto context = contentNode->GetContextWithCheck();
1717 ASSERT_NE(context, nullptr);
1718 auto overlayManager = context->GetOverlayManager();
1719 ASSERT_NE(overlayManager, nullptr);
1720 overlayManager->popupMap_[targetNode->GetId()].isCurrentOnShow = true;
1721 param->SetIsPartialUpdate(true);
1722 EXPECT_EQ(ViewAbstract::UpdatePopup(param, contentNode), ERROR_CODE_NO_ERROR);
1723 }
1724
1725 /**
1726 * @tc.name: ClosePopup
1727 * @tc.desc: Test ClosePopup of View_Abstract
1728 * @tc.type: FUNC
1729 */
1730 HWTEST_F(ViewAbstractTestNg, ClosePopup, TestSize.Level1)
1731 {
1732 /**
1733 * @tc.steps: step1. Create some FrameNode and params.
1734 */
1735 auto pipelineContext = PipelineContext::GetCurrentContext();
1736 auto param = AceType::MakeRefPtr<PopupParam>();
1737 auto contentNode =
1738 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon34ec4f1b0702() 1739 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1740
1741 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b0802() 1742 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1743 ViewStackProcessor::GetInstance()->Push(targetNode);
1744 targetNode->onMainTree_ = true;
1745 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1746 auto stageNode = FrameNode::CreateFrameNode(
1747 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1748 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1749 stageNode->MountToParent(rootNode);
1750 targetNode->MountToParent(stageNode);
1751 rootNode->MarkDirtyNode();
1752 param->SetIsShow(true);
1753 param->SetUseCustomComponent(true);
1754 param->SetTargetId(std::to_string(targetNode->GetId()));
1755
1756 /**
1757 * @tc.expected: Return expected results.
1758 */
1759 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_NO_ERROR);
1760 auto context = contentNode->GetContextWithCheck();
1761 ASSERT_NE(context, nullptr);
1762 auto overlayManager = context->GetOverlayManager();
1763 ASSERT_NE(overlayManager, nullptr);
1764 overlayManager->popupMap_[targetNode->GetId()].isCurrentOnShow = true;
1765 EXPECT_EQ(ViewAbstract::ClosePopup(contentNode), ERROR_CODE_NO_ERROR);
1766 EXPECT_EQ(ViewAbstract::ClosePopup(contentNode), ERROR_CODE_DIALOG_CONTENT_NOT_FOUND);
1767 }
1768
1769 /**
1770 * @tc.name: OpenMenu001
1771 * @tc.desc: Test OpenMenu of View_Abstract
1772 * @tc.type: FUNC
1773 */
1774 HWTEST_F(ViewAbstractTestNg, OpenMenu001, TestSize.Level1)
1775 {
1776 /**
1777 * @tc.steps: step1. Create some FrameNode and menuParam.
1778 */
1779 auto pipelineContext = PipelineContext::GetCurrentContext();
1780 MenuParam menuParam;
1781 menuParam.isShowInSubWindow = false;
1782 menuParam.previewMode = MenuPreviewMode::IMAGE;
1783 auto contentNode =
1784 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon34ec4f1b0902() 1785 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1786 RefPtr<FrameNode> contentNode2 = nullptr;
1787 auto contentNode3 =
1788 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon34ec4f1b0a02() 1789 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1790 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b0b02() 1791 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1792 int32_t targetId = targetNode->GetId();
1793 /**
1794 * @tc.steps: step2. Return expected results.
1795 */
1796 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode2, targetId), ERROR_CODE_DIALOG_CONTENT_ERROR);
1797 targetId = -1;
1798 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_TARGET_INFO_NOT_EXIST);
1799 targetId = 10000;
1800 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_TARGET_INFO_NOT_EXIST);
1801 targetId = targetNode->GetId();
1802 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_TARGET_NOT_ON_COMPONENT_TREE);
1803 ViewStackProcessor::GetInstance()->Push(targetNode);
1804 targetNode->onMainTree_ = true;
1805 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1806 auto stageNode = FrameNode::CreateFrameNode(
1807 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1808 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1809 stageNode->MountToParent(rootNode);
1810 targetNode->MountToParent(stageNode);
1811 rootNode->MarkDirtyNode();
1812 targetId = targetNode->GetId();
1813 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
1814 ASSERT_NE(targetNodePipelineContext, nullptr);
1815 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1816 targetNodePipelineContext->SetThemeManager(themeManager);
1817 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
1818 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1819
1820 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
1821 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_DIALOG_CONTENT_ALREADY_EXIST);
1822 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode3, targetId), ERROR_CODE_NO_ERROR);
1823 }
1824
1825 /**
1826 * @tc.name: UpdateMenu001
1827 * @tc.desc: Test UpdateMenu of View_Abstract
1828 * @tc.type: FUNC
1829 */
1830 HWTEST_F(ViewAbstractTestNg, UpdateMenu001, TestSize.Level1)
1831 {
1832 /**
1833 * @tc.steps: step1. Create some FrameNode and menuParam.
1834 */
1835 auto pipelineContext = PipelineContext::GetCurrentContext();
1836 MenuParam menuParam;
1837 menuParam.isShowInSubWindow = false;
1838 auto contentNode =
1839 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon34ec4f1b0c02() 1840 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1841 RefPtr<FrameNode> contentNode2 = nullptr;
1842 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b0d02() 1843 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1844 ViewStackProcessor::GetInstance()->Push(targetNode);
1845 targetNode->onMainTree_ = true;
1846 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1847 auto stageNode = FrameNode::CreateFrameNode(
1848 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1849 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1850 stageNode->MountToParent(rootNode);
1851 targetNode->MountToParent(stageNode);
1852 rootNode->MarkDirtyNode();
1853 auto targetId = targetNode->GetId();
1854 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
1855 ASSERT_NE(targetNodePipelineContext, nullptr);
1856 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1857 targetNodePipelineContext->SetThemeManager(themeManager);
1858 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
1859 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1860
1861 /**
1862 * @tc.expected: Return expected results.
1863 */
1864 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
1865 auto overlayManager = ViewAbstract::GetCurOverlayManager(contentNode);
1866 ASSERT_NE(overlayManager, nullptr);
1867 overlayManager->menuMap_[targetId];
1868 EXPECT_EQ(ViewAbstract::UpdateMenu(menuParam, contentNode), ERROR_CODE_NO_ERROR);
1869 EXPECT_EQ(ViewAbstract::UpdateMenu(menuParam, contentNode2), ERROR_CODE_DIALOG_CONTENT_ERROR);
1870 overlayManager->menuMap_.clear();
1871 EXPECT_EQ(ViewAbstract::UpdateMenu(menuParam, contentNode), ERROR_CODE_DIALOG_CONTENT_NOT_FOUND);
1872 }
1873
1874 /**
1875 * @tc.name: UpdateMenu002
1876 * @tc.desc: Test UpdateMenu of View_Abstract
1877 * @tc.type: FUNC
1878 */
1879 HWTEST_F(ViewAbstractTestNg, UpdateMenu002, TestSize.Level1)
1880 {
1881 /**
1882 * @tc.steps: step1. Create some FrameNode and menuParam.
1883 */
1884 auto pipelineContext = PipelineContext::GetCurrentContext();
1885 MenuParam menuParam;
1886 menuParam.isShowInSubWindow = false;
1887 auto contentNode =
1888 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon34ec4f1b0e02() 1889 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1890 RefPtr<FrameNode> contentNode2 = nullptr;
1891 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b0f02() 1892 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1893 ViewStackProcessor::GetInstance()->Push(targetNode);
1894 targetNode->onMainTree_ = true;
1895 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1896 auto stageNode = FrameNode::CreateFrameNode(
1897 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1898 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1899 stageNode->MountToParent(rootNode);
1900 targetNode->MountToParent(stageNode);
1901 rootNode->MarkDirtyNode();
1902 auto targetId = targetNode->GetId();
1903 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
1904 ASSERT_NE(targetNodePipelineContext, nullptr);
1905 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1906 targetNodePipelineContext->SetThemeManager(themeManager);
1907 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
1908 auto selectTheme = AceType::MakeRefPtr<SelectTheme>();
1909 selectTheme->expandDisplay_ = true;
1910 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(selectTheme));
1911 EXPECT_CALL(*themeManager, GetTheme(_, _)).WillRepeatedly(Return(selectTheme));
1912
1913 /**
1914 * @tc.expected: Return expected results.
1915 */
1916 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
1917 auto overlayManager = ViewAbstract::GetCurOverlayManager(contentNode);
1918 ASSERT_NE(overlayManager, nullptr);
1919 overlayManager->menuMap_[targetId];
1920 auto contentNodePipelineContext = contentNode->GetContextWithCheck();
1921 contentNodePipelineContext->overlayManager_ = nullptr;
1922 EXPECT_EQ(ViewAbstract::UpdateMenu(menuParam, contentNode), ERROR_CODE_INTERNAL_ERROR);
1923 contentNodePipelineContext->overlayManager_ = overlayManager;
1924 }
1925
1926 /**
1927 * @tc.name: UpdateMenu003
1928 * @tc.desc: Test UpdateMenu of View_Abstract
1929 * @tc.type: FUNC
1930 */
1931 HWTEST_F(ViewAbstractTestNg, UpdateMenu003, TestSize.Level1)
1932 {
1933 /**
1934 * @tc.steps: step1. Create some FrameNode and menuParam.
1935 */
1936 auto pipelineContext = PipelineContext::GetCurrentContext();
1937 MenuParam menuParam;
1938 menuParam.isShowInSubWindow = false;
1939 auto contentNode =
1940 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon34ec4f1b1002() 1941 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
1942 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b1102() 1943 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1944 ViewStackProcessor::GetInstance()->Push(targetNode);
1945 targetNode->onMainTree_ = true;
1946 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
1947 auto stageNode = FrameNode::CreateFrameNode(
1948 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1949 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
1950 stageNode->MountToParent(rootNode);
1951 targetNode->MountToParent(stageNode);
1952 rootNode->MarkDirtyNode();
1953 auto targetId = targetNode->GetId();
1954 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
1955 ASSERT_NE(targetNodePipelineContext, nullptr);
1956 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1957 targetNodePipelineContext->SetThemeManager(themeManager);
1958 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
1959 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1960 EXPECT_CALL(*themeManager, GetTheme(_, _)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
1961
1962 /**
1963 * @tc.expected: Return expected results.
1964 */
1965 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
1966 auto overlayManager = ViewAbstract::GetCurOverlayManager(contentNode);
1967 ASSERT_NE(overlayManager, nullptr);
1968 overlayManager->menuMap_[targetId];
1969 auto menuWrapperNode = overlayManager->GetMenuNodeWithExistContent(contentNode);
1970 ASSERT_NE(menuWrapperNode, nullptr);
1971 auto wrapperPattern = AceType::DynamicCast<MenuWrapperPattern>(menuWrapperNode->GetPattern());
1972 ASSERT_NE(wrapperPattern, nullptr);
1973 auto menu = wrapperPattern->GetMenu();
1974 ASSERT_NE(menu, nullptr);
1975 auto menuPattern = AceType::DynamicCast<MenuPattern>(menu->GetPattern());
1976 ASSERT_NE(menuPattern, nullptr);
1977 auto menuItem = FrameNode::GetOrCreateFrameNode(V2::MENU_ITEM_ETS_TAG,
__anon34ec4f1b1202() 1978 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<MenuItemPattern>(); });
1979 menuItem->MountToParent(menu);
1980
1981 auto subMenu = FrameNode::CreateFrameNode(
1982 V2::MENU_ETS_TAG, 3, AceType::MakeRefPtr<MenuPattern>(1, V2::MENU_TAG, MenuType::SUB_MENU));
1983 subMenu->MountToParent(menuWrapperNode);
1984 menuPattern->SetShowedSubMenu(subMenu);
1985 auto menuItemPattern = menuItem->GetPattern<MenuItemPattern>();
1986 menuItemPattern->expandingMode_ = SubMenuExpandingMode::EMBEDDED;
1987 menuPattern->AddEmbeddedMenuItem(menuItem);
1988
1989 EXPECT_EQ(ViewAbstract::UpdateMenu(menuParam, contentNode), ERROR_CODE_NO_ERROR);
1990 }
1991
1992 /**
1993 * @tc.name: UpdateMenu004
1994 * @tc.desc: Test UpdateMenu of View_Abstract
1995 * @tc.type: FUNC
1996 */
1997 HWTEST_F(ViewAbstractTestNg, UpdateMenu004, TestSize.Level1)
1998 {
1999 /**
2000 * @tc.steps: step1. Create some FrameNode and menuParam.
2001 */
2002 auto pipelineContext = PipelineContext::GetCurrentContext();
2003 MenuParam menuParam;
2004 menuParam.isShowInSubWindow = false;
2005 auto contentNode =
2006 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon34ec4f1b1302() 2007 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
2008 RefPtr<FrameNode> contentNode2 = nullptr;
2009 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b1402() 2010 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
2011 ViewStackProcessor::GetInstance()->Push(targetNode);
2012 targetNode->onMainTree_ = true;
2013 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
2014 auto stageNode = FrameNode::CreateFrameNode(
2015 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
2016 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
2017 stageNode->MountToParent(rootNode);
2018 targetNode->MountToParent(stageNode);
2019 rootNode->MarkDirtyNode();
2020 auto targetId = targetNode->GetId();
2021 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
2022 ASSERT_NE(targetNodePipelineContext, nullptr);
2023 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2024 targetNodePipelineContext->SetThemeManager(themeManager);
2025 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
2026 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2027 EXPECT_CALL(*themeManager, GetTheme(_, _)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2028
2029 /**
2030 * @tc.expected: Return expected results.
2031 */
2032 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
2033 auto overlayManager = ViewAbstract::GetCurOverlayManager(contentNode);
2034 ASSERT_NE(overlayManager, nullptr);
2035 overlayManager->menuMap_[targetId];
2036 auto menuWrapperNode = overlayManager->GetMenuNodeWithExistContent(contentNode);
2037 ASSERT_NE(menuWrapperNode, nullptr);
2038 auto wrapperPattern = AceType::DynamicCast<MenuWrapperPattern>(menuWrapperNode->GetPattern());
2039 ASSERT_NE(wrapperPattern, nullptr);
2040 auto menu = wrapperPattern->GetMenu();
2041 ASSERT_NE(menu, nullptr);
2042 auto menuPattern = AceType::DynamicCast<MenuPattern>(menu->GetPattern());
2043 ASSERT_NE(menuPattern, nullptr);
2044 auto menuItem = FrameNode::GetOrCreateFrameNode(V2::MENU_ITEM_ETS_TAG,
__anon34ec4f1b1502() 2045 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<MenuItemPattern>(); });
2046 menuItem->MountToParent(menu);
2047 auto subMenu = FrameNode::CreateFrameNode(
2048 V2::MENU_ETS_TAG, 3, AceType::MakeRefPtr<MenuPattern>(1, V2::MENU_ETS_TAG, MenuType::SUB_MENU));
2049 subMenu->MountToParent(menuWrapperNode);
2050 menuPattern->SetShowedSubMenu(subMenu);
2051 auto menuItemPattern = menuItem->GetPattern<MenuItemPattern>();
2052 menuItemPattern->expandingMode_ = SubMenuExpandingMode::STACK;
2053 EXPECT_EQ(ViewAbstract::UpdateMenu(menuParam, contentNode), ERROR_CODE_NO_ERROR);
2054 }
2055
2056 /**
2057 * @tc.name: CloseMenu001
2058 * @tc.desc: Test CloseMenu of View_Abstract
2059 * @tc.type: FUNC
2060 */
2061 HWTEST_F(ViewAbstractTestNg, CloseMenu001, TestSize.Level1)
2062 {
2063 /**
2064 * @tc.steps: step1. Create some FrameNode and menuParam.
2065 */
2066 auto pipelineContext = PipelineContext::GetCurrentContext();
2067 MenuParam menuParam;
2068 menuParam.isShowInSubWindow = false;
2069 auto contentNode =
2070 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon34ec4f1b1602() 2071 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
2072 RefPtr<FrameNode> contentNode2 = nullptr;
2073
2074 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b1702() 2075 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
2076 ViewStackProcessor::GetInstance()->Push(targetNode);
2077 targetNode->onMainTree_ = true;
2078 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
2079 auto stageNode = FrameNode::CreateFrameNode(
2080 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
2081 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
2082 stageNode->MountToParent(rootNode);
2083 targetNode->MountToParent(stageNode);
2084 rootNode->MarkDirtyNode();
2085 auto targetId = targetNode->GetId();
2086 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
2087 ASSERT_NE(targetNodePipelineContext, nullptr);
2088 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2089 targetNodePipelineContext->SetThemeManager(themeManager);
2090 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
2091 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2092
2093 /**
2094 * @tc.expected: Return expected results.
2095 */
2096 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
2097 auto overlayManager = ViewAbstract::GetCurOverlayManager(contentNode);
2098 ASSERT_NE(overlayManager, nullptr);
2099 overlayManager->menuMap_[targetId];
2100 EXPECT_EQ(ViewAbstract::CloseMenu(contentNode), ERROR_CODE_NO_ERROR);
2101 EXPECT_EQ(ViewAbstract::CloseMenu(contentNode2), ERROR_CODE_DIALOG_CONTENT_ERROR);
2102 overlayManager->menuMap_.clear();
2103 EXPECT_EQ(ViewAbstract::CloseMenu(contentNode), ERROR_CODE_DIALOG_CONTENT_NOT_FOUND);
2104 }
2105
2106 /**
2107 * @tc.name: CloseMenu002
2108 * @tc.desc: Test CloseMenu of View_Abstract
2109 * @tc.type: FUNC
2110 */
2111 HWTEST_F(ViewAbstractTestNg, CloseMenu002, TestSize.Level1)
2112 {
2113 /**
2114 * @tc.steps: step1. Create some FrameNode and menuParam.
2115 */
2116 auto pipelineContext = PipelineContext::GetCurrentContext();
2117 MenuParam menuParam;
2118 menuParam.isShowInSubWindow = false;
2119 auto contentNode =
2120 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon34ec4f1b1802() 2121 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
2122 RefPtr<FrameNode> contentNode2 = nullptr;
2123
2124 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b1902() 2125 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
2126 ViewStackProcessor::GetInstance()->Push(targetNode);
2127 targetNode->onMainTree_ = true;
2128 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
2129 auto stageNode = FrameNode::CreateFrameNode(
2130 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
2131 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
2132 stageNode->MountToParent(rootNode);
2133 targetNode->MountToParent(stageNode);
2134 rootNode->MarkDirtyNode();
2135 auto targetId = targetNode->GetId();
2136 auto targetNodePipelineContext = targetNode->GetContextWithCheck();
2137 ASSERT_NE(targetNodePipelineContext, nullptr);
2138 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2139 targetNodePipelineContext->SetThemeManager(themeManager);
2140 targetNodePipelineContext->SetEventManager(AceType::MakeRefPtr<EventManager>());
2141 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2142 EXPECT_CALL(*themeManager, GetTheme(_, _)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
2143
2144 /**
2145 * @tc.expected: Return expected results.
2146 */
2147 EXPECT_EQ(ViewAbstract::OpenMenu(menuParam, contentNode, targetId), ERROR_CODE_NO_ERROR);
2148 auto overlayManager = ViewAbstract::GetCurOverlayManager(contentNode);
2149 ASSERT_NE(overlayManager, nullptr);
2150 overlayManager->menuMap_[targetId];
2151 auto contentNodePipelineContext = contentNode->GetContextWithCheck();
2152 contentNodePipelineContext->overlayManager_ = nullptr;
2153 EXPECT_EQ(ViewAbstract::CloseMenu(contentNode), ERROR_CODE_INTERNAL_ERROR);
2154 contentNodePipelineContext->overlayManager_ = overlayManager;
2155 }
2156
2157 /**
2158 * @tc.name: FreezeUINodeById
2159 * @tc.desc: Test FreezeUINodeById of View_Abstract
2160 * @tc.type: FUNC
2161 */
2162 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0037, TestSize.Level1)
2163 {
2164 /**
2165 * @tc.steps: Create some FrameNode.
2166 */
2167 const std::string& id = "test_id";
2168 auto targetNode =
2169 FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b1a02() 2170 ElementRegister::GetInstance()->MakeUniqueId(), []() {
2171 return AceType::MakeRefPtr<ButtonPattern>();
2172 }
2173 );
2174 /**
2175 * @tc.steps: connect the FrameNode and id.
2176 */
2177 targetNode->UpdateInspectorId(id);
2178
2179 /**
2180 * @tc.expected: call the function to freeze the node.
2181 */
2182 bool isFreeze = true;
2183 ViewAbstract::FreezeUINodeById(id, isFreeze);
2184
2185 /**
2186 * @tc.expected: verify the pipeline's property is set.
2187 */
2188 auto pipeline = targetNode->GetContext();
2189 bool isOpenInvisibleFreeze = pipeline->IsOpenInvisibleFreeze();
2190
2191 EXPECT_EQ(isOpenInvisibleFreeze, true);
2192 /**
2193 * @tc.expected: verify the node's freeze state.
2194 */
2195 bool res = targetNode->IsFreeze();
2196 EXPECT_EQ(res, isFreeze);
2197 }
2198
2199 /**
2200 * @tc.name: FreezeUINodeById
2201 * @tc.desc: Test FreezeUINodeById of View_Abstract
2202 * @tc.type: FUNC
2203 */
2204 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0038, TestSize.Level1)
2205 {
2206 /**
2207 * @tc.steps: Create some FrameNode.
2208 */
2209 const std::string& id = "test_id";
2210 auto targetNode =
2211 FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b1b02() 2212 ElementRegister::GetInstance()->MakeUniqueId(), []() {
2213 return AceType::MakeRefPtr<ButtonPattern>();
2214 }
2215 );
2216 /**
2217 * @tc.steps: connect the FrameNode and id.
2218 */
2219 targetNode->UpdateInspectorId(id);
2220 /**
2221 * @tc.steps: set the FrameNode's pipeline to null.
2222 */
2223 targetNode->context_ = nullptr;
2224
2225 /**
2226 * @tc.expected: call the function to unfreeze the node.
2227 */
2228 bool isFreeze = false;
2229 ViewAbstract::FreezeUINodeById(id, isFreeze);
2230
2231 /**
2232 * @tc.expected: verify the pipeline's property is set.
2233 */
2234 auto pipeline = targetNode->GetContext();
2235 bool isOpenInvisibleFreeze = pipeline->IsOpenInvisibleFreeze();
2236 EXPECT_EQ(isOpenInvisibleFreeze, true);
2237
2238 /**
2239 * @tc.expected: verify the node's freeze state.
2240 */
2241 bool res = targetNode->IsFreeze();
2242 EXPECT_EQ(res, isFreeze);
2243 }
2244
2245 /**
2246 * @tc.name: FreezeUINodeById
2247 * @tc.desc: Test FreezeUINodeById of View_Abstract
2248 * @tc.type: FUNC
2249 */
2250 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0039, TestSize.Level1)
2251 {
2252 /**
2253 * @tc.expected: use a non_existing node id.
2254 */
2255 const std::string& non_existing_id = "non_existing_id";
2256 /**
2257 * @tc.expected: call the function with the non_existing_id.
2258 */
2259 bool isFreeze = true;
2260 ViewAbstract::FreezeUINodeById(non_existing_id, isFreeze);
2261
2262 auto node = ElementRegister::GetInstance()->GetAttachedFrameNodeById(non_existing_id, true);
2263 EXPECT_EQ(node, nullptr);
2264 }
2265
2266 /**
2267 * @tc.name: FreezeUINodeByUniqueId
2268 * @tc.desc: Test FreezeUINodeByUniqueId of View_Abstract
2269 * @tc.type: FUNC
2270 */
2271 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0040, TestSize.Level1)
2272 {
2273 /**
2274 * @tc.steps: Create some FrameNode.
2275 */
2276 const int32_t& uniqueId = 1111;
2277 auto targetNode =
2278 FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b1c02() 2279 uniqueId, []() {
2280 return AceType::MakeRefPtr<ButtonPattern>();
2281 }
2282 );
2283
2284 /**
2285 * @tc.expected: call the function to freeze the node.
2286 */
2287 bool isFreeze = true;
2288 ViewAbstract::FreezeUINodeByUniqueId(uniqueId, isFreeze);
2289
2290 /**
2291 * @tc.expected: verify the pipeline's property is set.
2292 */
2293 auto pipeline = targetNode->GetContext();
2294 bool isOpenInvisibleFreeze = pipeline->IsOpenInvisibleFreeze();
2295
2296 EXPECT_EQ(isOpenInvisibleFreeze, true);
2297 /**
2298 * @tc.expected: verify the node's freeze state.
2299 */
2300 bool res = targetNode->IsFreeze();
2301 EXPECT_EQ(res, isFreeze);
2302 }
2303
2304 /**
2305 * @tc.name: FreezeUINodeByUniqueId
2306 * @tc.desc: Test FreezeUINodeByUniqueId of View_Abstract
2307 * @tc.type: FUNC
2308 */
2309 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0041, TestSize.Level1)
2310 {
2311 /**
2312 * @tc.steps: Create some FrameNode.
2313 */
2314 const int32_t& uniqueId = 222;
2315 auto targetNode =
2316 FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon34ec4f1b1d02() 2317 uniqueId, []() {
2318 return AceType::MakeRefPtr<ButtonPattern>();
2319 }
2320 );
2321
2322 /**
2323 * @tc.steps: set the FrameNode's pipeline to null.
2324 */
2325 targetNode->context_ = nullptr;
2326
2327 /**
2328 * @tc.expected: call the function to freeze the node.
2329 */
2330 bool isFreeze = false;
2331 ViewAbstract::FreezeUINodeByUniqueId(uniqueId, isFreeze);
2332
2333 /**
2334 * @tc.expected: verify the pipeline's property is set.
2335 */
2336 auto pipeline = targetNode->GetContext();
2337 bool isOpenInvisibleFreeze = pipeline->IsOpenInvisibleFreeze();
2338
2339 EXPECT_EQ(isOpenInvisibleFreeze, true);
2340 /**
2341 * @tc.expected: verify the node's freeze state.
2342 */
2343 bool res = targetNode->IsFreeze();
2344 EXPECT_EQ(res, isFreeze);
2345 }
2346
2347 /**
2348 * @tc.name: FreezeUINodeByUniqueId
2349 * @tc.desc: Test FreezeUINodeByUniqueId of View_Abstract
2350 * @tc.type: FUNC
2351 */
2352 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0042, TestSize.Level1)
2353 {
2354 /**
2355 * @tc.expected: use a non_existing node uniqueId.
2356 */
2357 const int32_t& non_existing_unique_id = 333;
2358 /**
2359 * @tc.expected: call the function with the non_existing_unique_id.
2360 */
2361 bool isFreeze = true;
2362 ViewAbstract::FreezeUINodeByUniqueId(non_existing_unique_id, isFreeze);
2363
2364 auto node = ElementRegister::GetInstance()->GetNodeById(non_existing_unique_id);
2365 EXPECT_EQ(node, nullptr);
2366 }
2367
2368 /**
2369 * @tc.name: SetPositionLocalizedEdges
2370 * @tc.desc: Test SetPositionLocalizedEdges of View_Abstract
2371 * @tc.type: FUNC
2372 */
2373 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0043, TestSize.Level1)
2374 {
2375 auto targetNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2376 /**
2377 * @tc.expected: call the function to Update the layout property.
2378 */
2379 bool needLocalized = true;
2380 ViewAbstract::SetPositionLocalizedEdges(needLocalized);
2381
2382 auto layoutProperty = targetNode->GetLayoutProperty();
2383
2384 /**
2385 * @tc.expected: verify layout property is updated.
2386 */
2387 auto positionLocalizedEdges = layoutProperty->IsPositionLocalizedEdges();
2388 EXPECT_EQ(positionLocalizedEdges, needLocalized);
2389 }
2390
2391 /**
2392 * @tc.name: SetPositionLocalizedEdges
2393 * @tc.desc: Test SetPositionLocalizedEdges of View_Abstract
2394 * @tc.type: FUNC
2395 */
2396 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0044, TestSize.Level1)
2397 {
2398 auto targetNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2399 /**
2400 * @tc.expected: call the function to Update the layout property.
2401 */
2402 bool needLocalized = false;
2403 ViewAbstract::SetPositionLocalizedEdges(needLocalized);
2404
2405 auto layoutProperty = targetNode->GetLayoutProperty();
2406
2407 /**
2408 * @tc.expected: verify layout property is updated.
2409 */
2410 auto positionLocalizedEdges = layoutProperty->IsPositionLocalizedEdges();
2411 EXPECT_EQ(positionLocalizedEdges, needLocalized);
2412 }
2413
2414 /**
2415 * @tc.name: CreateWithForegroundColorResourceObj
2416 * @tc.desc: Test CreateWithForegroundColorResourceObj of View_Abstract
2417 * @tc.type: FUNC
2418 */
2419 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0045, TestSize.Level1)
2420 {
2421 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2422 CHECK_NULL_VOID(frameNode);
2423 auto pattern = frameNode->GetPattern<Pattern>();
2424 CHECK_NULL_VOID(pattern);
2425 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>("", "", -1);
__anon34ec4f1b1e02(const RefPtr<ResourceObject>& resObj) 2426 auto&& updateFunc = [weak = AceType::WeakClaim(frameNode)](const RefPtr<ResourceObject>& resObj) {};
2427 updateFunc(resObj);
2428 pattern->AddResObj("foregroundColor", resObj, std::move(updateFunc));
2429 std::string foregroundColor = pattern->GetResCacheMapByKey("foregroundColor");
2430 EXPECT_EQ(foregroundColor, "");
2431 }
2432
2433 /**
2434 * @tc.name: SetBackgroundColor
2435 * @tc.desc: Test SetBackgroundColor of View_Abstract
2436 * @tc.type: FUNC
2437 */
2438 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0046, TestSize.Level1)
2439 {
2440 Color p3Red;
2441 p3Red.SetValue(0xffff0000);
2442 p3Red.SetColorSpace(ColorSpace::DISPLAY_P3);
2443 ViewAbstract::SetBackgroundColor(AceType::RawPtr(FRAME_NODE_REGISTER), p3Red);
2444 Color result = ViewAbstract::GetBackgroundColor(AceType::RawPtr(FRAME_NODE_REGISTER));
2445 EXPECT_EQ(result.GetColorSpace(), p3Red.GetColorSpace());
2446 }
2447
2448 /**
2449 * @tc.name: SetSweepGradient
2450 * @tc.desc: Test SetSweepGradient of View_Abstract
2451 * @tc.type: FUNC
2452 */
2453 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0047, TestSize.Level1)
2454 {
2455 Color p3Red;
2456 p3Red.SetValue(0xffff0000);
2457 p3Red.SetColorSpace(ColorSpace::DISPLAY_P3);
2458 Color p3Green;
2459 p3Green.SetValue(0xff00ff00);
2460 p3Green.SetColorSpace(ColorSpace::DISPLAY_P3);
2461 Color p3Blue;
2462 p3Blue.SetValue(0xff0000ff);
2463 p3Blue.SetColorSpace(ColorSpace::DISPLAY_P3);
2464 GradientColor gradientColor;
2465 Gradient gradient;
2466 gradientColor.SetColor(p3Red);
2467 gradient.AddColor(gradientColor);
2468 gradientColor.SetColor(p3Green);
2469 gradient.AddColor(gradientColor);
2470 gradientColor.SetColor(p3Blue);
2471 gradient.AddColor(gradientColor);
2472 ViewAbstract::SetSweepGradient(AceType::RawPtr(FRAME_NODE_REGISTER), gradient);
2473 Gradient result = ViewAbstract::GetSweepGradient(AceType::RawPtr(FRAME_NODE_REGISTER));
2474 EXPECT_EQ(result.GetColors().front().GetColor().GetColorSpace(), p3Red.GetColorSpace());
2475 EXPECT_EQ(result.GetColors().back().GetColor().GetColorSpace(), p3Blue.GetColorSpace());
2476 }
2477
2478 /**
2479 * @tc.name: SetLinearGradient
2480 * @tc.desc: Test SetLinearGradient of View_Abstract
2481 * @tc.type: FUNC
2482 */
2483 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0048, TestSize.Level1)
2484 {
2485 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2486 ASSERT_NE(frameNode, nullptr);
2487 auto pattern = frameNode->GetPattern<Pattern>();
2488 ASSERT_NE(pattern, nullptr);
2489
2490 g_isConfigChangePerform = true;
2491 NG::Gradient gradient;
2492 ViewAbstract::SetLinearGradient(gradient);
2493 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2494 g_isConfigChangePerform = false;
2495 std::string gradientStr = pattern->GetResCacheMapByKey("LinearGradient.gradient");
2496 EXPECT_EQ(gradientStr, "");
2497 }
2498
2499 /**
2500 * @tc.name: CreateWithForegroundColorResourceObj
2501 * @tc.desc: Test CreateWithForegroundColorResourceObj of View_Abstract
2502 * @tc.type: FUNC
2503 */
2504 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0049, TestSize.Level1)
2505 {
2506 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2507 ASSERT_NE(frameNode, nullptr);
2508 auto pattern = frameNode->GetPattern<Pattern>();
2509 ASSERT_NE(pattern, nullptr);
2510 std::string foregroundColor = pattern->GetResCacheMapByKey("foregroundColor");
2511 EXPECT_EQ(foregroundColor, "");
2512 std::string bundleName = "com.example.test";
2513 std::string moduleName = "entry";
2514 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
2515 ViewAbstract::CreateWithForegroundColorResourceObj(resObj);
2516 Color result;
2517 ResourceParseUtils::ParseResColor(resObj, result);
2518 foregroundColor = pattern->GetResCacheMapByKey("foregroundColor");
2519 EXPECT_EQ(foregroundColor, result.ColorToString());
2520 }
2521
2522 /**
2523 * @tc.name: CreateWithOuterBorderColorResourceObj
2524 * @tc.desc: Test CreateWithOuterBorderColorResourceObj of View_Abstract
2525 * @tc.type: FUNC
2526 */
2527 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0050, TestSize.Level1)
2528 {
2529 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2530 ASSERT_NE(frameNode, nullptr);
2531 auto pattern = frameNode->GetPattern<Pattern>();
2532 ASSERT_NE(pattern, nullptr);
2533 std::string colorStr = pattern->GetResCacheMapByKey("outerBorderColorRes");
2534 EXPECT_EQ(colorStr, "");
2535 std::string bundleName = "com.example.test";
2536 std::string moduleName = "entry";
2537 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
2538 ViewAbstract::CreateWithOuterBorderColorResourceObj(resObj);
2539 Color result;
2540 ResourceParseUtils::ParseResColor(resObj, result);
2541 colorStr = pattern->GetResCacheMapByKey("outerBorderColorRes");
2542 EXPECT_EQ(colorStr, result.ColorToString());
2543 }
2544
2545 /**
2546 * @tc.name: CreateWithOuterBorderRadiusResourceObj
2547 * @tc.desc: Test CreateWithOuterBorderRadiusResourceObj of View_Abstract
2548 * @tc.type: FUNC
2549 */
2550 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0051, TestSize.Level1)
2551 {
2552 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2553 ASSERT_NE(frameNode, nullptr);
2554 auto pattern = frameNode->GetPattern<Pattern>();
2555 ASSERT_NE(pattern, nullptr);
2556 std::string radiusStr = pattern->GetResCacheMapByKey("outerBorderRadiusRes");
2557 EXPECT_EQ(radiusStr, "");
2558 std::string bundleName = "com.example.test";
2559 std::string moduleName = "entry";
2560 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
2561 ViewAbstract::CreateWithOuterBorderRadiusResourceObj(resObj);
2562 CalcDimension result;
2563 ResourceParseUtils::ParseResDimensionVp(resObj, result);
2564 radiusStr = pattern->GetResCacheMapByKey("outerBorderRadiusRes");
2565 EXPECT_EQ(radiusStr, result.ToString());
2566 }
2567
2568 /**
2569 * @tc.name: CreateWithLightColorResourceObj
2570 * @tc.desc: Test CreateWithLightColorResourceObj of View_Abstract
2571 * @tc.type: FUNC
2572 */
2573 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0052, TestSize.Level1)
2574 {
2575 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2576 ASSERT_NE(frameNode, nullptr);
2577 auto pattern = frameNode->GetPattern<Pattern>();
2578 ASSERT_NE(pattern, nullptr);
2579 std::string colorStr = pattern->GetResCacheMapByKey("LightColorRes");
2580 EXPECT_EQ(colorStr, "");
2581 std::string bundleName = "com.example.test";
2582 std::string moduleName = "entry";
2583 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
2584 ViewAbstract::CreateWithLightColorResourceObj(resObj);
2585 Color result;
2586 ResourceParseUtils::ParseResColor(resObj, result);
2587 colorStr = pattern->GetResCacheMapByKey("LightColorRes");
2588 EXPECT_EQ(colorStr, result.ColorToString());
2589 }
2590
2591 /**
2592 * @tc.name: CreateWithOuterBorderWidthResourceObj
2593 * @tc.desc: Test CreateWithOuterBorderWidthResourceObj of View_Abstract
2594 * @tc.type: FUNC
2595 */
2596 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0053, TestSize.Level1)
2597 {
2598 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2599 ASSERT_NE(frameNode, nullptr);
2600 auto pattern = frameNode->GetPattern<Pattern>();
2601 ASSERT_NE(pattern, nullptr);
2602 std::string widthStr = pattern->GetResCacheMapByKey("outerBorderWidthRes");
2603 EXPECT_EQ(widthStr, "");
2604 std::string bundleName = "com.example.test";
2605 std::string moduleName = "entry";
2606 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
2607 ViewAbstract::CreateWithOuterBorderWidthResourceObj(resObj);
2608 CalcDimension result;
2609 ResourceParseUtils::ParseResDimensionVp(resObj, result);
2610 widthStr = pattern->GetResCacheMapByKey("outerBorderWidthRes");
2611 EXPECT_EQ(widthStr, result.ToString());
2612 }
2613
2614 /**
2615 * @tc.name: CreateWithColorBlendResourceObj
2616 * @tc.desc: Test CreateWithColorBlendResourceObj of View_Abstract
2617 * @tc.type: FUNC
2618 */
2619 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0054, TestSize.Level1)
2620 {
2621 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2622 ASSERT_NE(frameNode, nullptr);
2623 auto pattern = frameNode->GetPattern<Pattern>();
2624 ASSERT_NE(pattern, nullptr);
2625 std::string colorStr = pattern->GetResCacheMapByKey("viewAbstract.colorBlend");
2626 EXPECT_EQ(colorStr, "");
2627 std::string bundleName = "com.example.test";
2628 std::string moduleName = "entry";
2629 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
2630 ViewAbstract::CreateWithColorBlendResourceObj(resObj);
2631 Color result;
2632 ResourceParseUtils::ParseResColor(resObj, result);
2633 colorStr = pattern->GetResCacheMapByKey("viewAbstract.colorBlend");
2634 EXPECT_EQ(colorStr, result.ToString());
2635 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2636 }
2637
2638 /**
2639 * @tc.name: CreateWithOpacityResourceObj
2640 * @tc.desc: Test CreateWithOpacityResourceObj of View_Abstract
2641 * @tc.type: FUNC
2642 */
2643 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0055, TestSize.Level1)
2644 {
2645 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2646 ASSERT_NE(frameNode, nullptr);
2647 auto pattern = frameNode->GetPattern<Pattern>();
2648 ASSERT_NE(pattern, nullptr);
2649 std::string opacityStr = pattern->GetResCacheMapByKey("viewAbstract.opacity");
2650 EXPECT_EQ(opacityStr, "");
2651 std::string bundleName = "app.float.test";
2652 std::string moduleName = "entry";
2653 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
2654
2655 g_isConfigChangePerform = true;
2656 ViewAbstract::CreateWithOpacityResourceObj(resObj);
2657 double result;
2658 ResourceParseUtils::ParseResDouble(resObj, result);
2659 opacityStr = pattern->GetResCacheMapByKey("viewAbstract.opacity");
2660 EXPECT_EQ(opacityStr, std::to_string(result));
2661 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2662 g_isConfigChangePerform = false;
2663 }
2664
2665 /**
2666 * @tc.name: SetSweepGradient
2667 * @tc.desc: Test SetSweepGradient of View_Abstract
2668 * @tc.type: FUNC
2669 */
2670 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0056, TestSize.Level1)
2671 {
2672 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2673 ASSERT_NE(frameNode, nullptr);
2674 auto pattern = frameNode->GetPattern<Pattern>();
2675 ASSERT_NE(pattern, nullptr);
2676
2677 g_isConfigChangePerform = true;
2678 NG::Gradient gradient;
2679 gradient.CreateGradientWithType(NG::GradientType::SWEEP);
2680 ViewAbstract::SetSweepGradient(gradient);
2681 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2682 g_isConfigChangePerform = false;
2683 std::string gradientStr = pattern->GetResCacheMapByKey("SweepGradient.gradient");
2684 EXPECT_EQ(gradientStr, "");
2685 }
2686
2687 /**
2688 * @tc.name: SetRadialGradient
2689 * @tc.desc: Test SetRadialGradient of View_Abstract
2690 * @tc.type: FUNC
2691 */
2692 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0057, TestSize.Level1)
2693 {
2694 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2695 ASSERT_NE(frameNode, nullptr);
2696 auto pattern = frameNode->GetPattern<Pattern>();
2697 ASSERT_NE(pattern, nullptr);
2698
2699 g_isConfigChangePerform = true;
2700 NG::Gradient gradient;
2701 gradient.CreateGradientWithType(NG::GradientType::RADIAL);
2702 ViewAbstract::SetRadialGradient(gradient);
2703 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2704 g_isConfigChangePerform = false;
2705 std::string gradientStr = pattern->GetResCacheMapByKey("RadialGradient.gradient");
2706 EXPECT_EQ(gradientStr, "");
2707 }
2708
2709 /**
2710 * @tc.name: SetClipShape
2711 * @tc.desc: Test SetClipShape of View_Abstract
2712 * @tc.type: FUNC
2713 */
2714 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0058, TestSize.Level1)
2715 {
2716 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2717 ASSERT_NE(frameNode, nullptr);
2718 auto pattern = frameNode->GetPattern<Pattern>();
2719 ASSERT_NE(pattern, nullptr);
2720 g_isConfigChangePerform = true;
2721 ViewAbstract::SetClipEdge(frameNode, true);
2722 auto basicShape = AceType::MakeRefPtr<BasicShape>(BasicShapeType::CIRCLE);
2723 ViewAbstract::SetClipShape(basicShape);
2724 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2725 g_isConfigChangePerform = false;
2726 std::string shapeStr = pattern->GetResCacheMapByKey("clipShape");
2727 EXPECT_EQ(shapeStr, "");
2728 }
2729
2730 /**
2731 * @tc.name: SetBackgroundBlurStyle
2732 * @tc.desc: Test SetBackgroundBlurStyle of View_Abstract
2733 * @tc.type: FUNC
2734 */
2735 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0059, TestSize.Level1)
2736 {
2737 BlurStyleOption blurStyleOption;
2738 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
2739 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
2740 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
2741 blurStyleOption.policy = BlurStyleActivePolicy::FOLLOWS_WINDOW_ACTIVE_STATE;
2742 g_isConfigChangePerform = true;
2743 ViewAbstract::SetBackgroundBlurStyle(blurStyleOption);
2744 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2745 ASSERT_NE(frameNode, nullptr);
2746 auto pattern = frameNode->GetPattern<Pattern>();
2747 ASSERT_NE(pattern, nullptr);
2748 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2749 g_isConfigChangePerform = false;
2750
2751 std::string blurStyleStr = pattern->GetResCacheMapByKey("backgroundBlurStyle.backgroundBlurStyleOptions");
2752 EXPECT_EQ(blurStyleStr, "");
2753 }
2754
2755 /**
2756 * @tc.name: SetBackgroundEffect
2757 * @tc.desc: Test SetBackgroundEffect of View_Abstract
2758 * @tc.type: FUNC
2759 */
2760 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0060, TestSize.Level1)
2761 {
2762 EffectOption option;
2763 Color color = Color::TRANSPARENT;
2764 option.color = color;
2765 option.policy = BlurStyleActivePolicy::FOLLOWS_WINDOW_ACTIVE_STATE;
2766 g_isConfigChangePerform = true;
2767 ViewAbstract::SetBackgroundEffect(option);
2768
2769 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2770 ASSERT_NE(frameNode, nullptr);
2771 auto pattern = frameNode->GetPattern<Pattern>();
2772 ASSERT_NE(pattern, nullptr);
2773 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2774 g_isConfigChangePerform = false;
2775 std::string effectStr = pattern->GetResCacheMapByKey("backgroundEffect");
2776 EXPECT_EQ(effectStr, "");
2777 }
2778
2779 /**
2780 * @tc.name: SetPixelStretchEffect
2781 * @tc.desc: Test SetPixelStretchEffect of View_Abstract
2782 * @tc.type: FUNC
2783 */
2784 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0061, TestSize.Level1)
2785 {
2786 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2787 ASSERT_NE(frameNode, nullptr);
2788 auto pattern = frameNode->GetPattern<Pattern>();
2789 ASSERT_NE(pattern, nullptr);
2790 g_isConfigChangePerform = true;
2791 PixStretchEffectOption option;
2792 option.ResetValue();
2793 ViewAbstract::SetPixelStretchEffect(option);
2794 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2795 g_isConfigChangePerform = false;
2796 std::string effectStr = pattern->GetResCacheMapByKey("pixelStretchEffect");
2797 EXPECT_EQ(effectStr, "");
2798 }
2799
2800 /**
2801 * @tc.name: SetOuterBorderRadius
2802 * @tc.desc: Test SetOuterBorderRadius of View_Abstract
2803 * @tc.type: FUNC
2804 */
2805 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0062, TestSize.Level1)
2806 {
2807 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2808 ASSERT_NE(frameNode, nullptr);
2809 auto pattern = frameNode->GetPattern<Pattern>();
2810 ASSERT_NE(pattern, nullptr);
2811 g_isConfigChangePerform = true;
2812 NG::BorderRadiusProperty borderRadius;
2813 borderRadius.multiValued = true;
2814 ViewAbstract::SetOuterBorderRadius(borderRadius);
2815 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2816 g_isConfigChangePerform = false;
2817 std::string borderRadiusStr = pattern->GetResCacheMapByKey("outerBorderRadius");
2818 EXPECT_EQ(borderRadiusStr, "");
2819 }
2820
2821 /**
2822 * @tc.name: SetOuterBorderColor
2823 * @tc.desc: Test SetOuterBorderColor of View_Abstract
2824 * @tc.type: FUNC
2825 */
2826 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0063, TestSize.Level1)
2827 {
2828 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2829 ASSERT_NE(frameNode, nullptr);
2830 auto pattern = frameNode->GetPattern<Pattern>();
2831 ASSERT_NE(pattern, nullptr);
2832 g_isConfigChangePerform = true;
2833 BorderColorProperty borderColor;
2834 ViewAbstract::SetOuterBorderColor(borderColor);
2835 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2836 g_isConfigChangePerform = false;
2837 std::string borderColorStr = pattern->GetResCacheMapByKey("outerBorderColor");
2838 EXPECT_EQ(borderColorStr, "");
2839 }
2840
2841 /**
2842 * @tc.name: SetOuterBorderWidth
2843 * @tc.desc: Test SetOuterBorderWidth of View_Abstract
2844 * @tc.type: FUNC
2845 */
2846 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0064, TestSize.Level1)
2847 {
2848 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2849 ASSERT_NE(frameNode, nullptr);
2850 auto pattern = frameNode->GetPattern<Pattern>();
2851 ASSERT_NE(pattern, nullptr);
2852 g_isConfigChangePerform = true;
2853 BorderWidthProperty borderWidth;
2854 ViewAbstract::SetOuterBorderWidth(borderWidth);
2855 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2856 g_isConfigChangePerform = false;
2857 std::string borderWidthStr = pattern->GetResCacheMapByKey("outerBorderWidth");
2858 EXPECT_EQ(borderWidthStr, "");
2859 }
2860
2861 /**
2862 * @tc.name: SetProgressMask
2863 * @tc.desc: Test SetProgressMask of View_Abstract
2864 * @tc.type: FUNC
2865 */
2866 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0065, TestSize.Level1)
2867 {
2868 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2869 ASSERT_NE(frameNode, nullptr);
2870 auto pattern = frameNode->GetPattern<Pattern>();
2871 ASSERT_NE(pattern, nullptr);
2872 g_isConfigChangePerform = true;
2873 RefPtr<BasicShape> basicShape = AceType::MakeRefPtr<BasicShape>(BasicShapeType::CIRCLE);
2874 RefPtr<NG::ProgressMaskProperty> progressMaskProperty = AceType::MakeRefPtr<NG::ProgressMaskProperty>();
2875 progressMaskProperty->SetMaxValue(200.0f);
2876 progressMaskProperty->SetColor(Color(0xffff0000));
2877 progressMaskProperty->SetValue(1.0f);
2878 auto target = frameNode->GetRenderContext();
2879 ASSERT_NE(target, nullptr);
2880 target->UpdateClipMask(basicShape);
2881 ViewAbstract::SetProgressMask(progressMaskProperty);
2882
2883 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2884 g_isConfigChangePerform = false;
2885 std::string maskShape = pattern->GetResCacheMapByKey("ProgressMask");
2886 EXPECT_EQ(maskShape, "");
2887 }
2888
2889 /**
2890 * @tc.name: SetLightPosition
2891 * @tc.desc: Test SetLightPosition of View_Abstract
2892 * @tc.type: FUNC
2893 */
2894 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0066, TestSize.Level1)
2895 {
2896 NG::TranslateOptions option;
2897 CalcDimension dimPositionX(30, DimensionUnit::VP);
2898 CalcDimension dimPositionY(20, DimensionUnit::VP);
2899 CalcDimension dimPositionZ(10, DimensionUnit::VP);
2900 option.x = dimPositionX;
2901 option.y = dimPositionY;
2902 option.z = dimPositionZ;
2903 g_isConfigChangePerform = true;
2904 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2905 CHECK_NULL_VOID(frameNode);
2906 auto pattern = frameNode->GetPattern<Pattern>();
2907 CHECK_NULL_VOID(pattern);
2908
2909 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
2910 ViewAbstract::SetLightPosition(option);
2911 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
2912 EXPECT_TRUE(result);
2913
2914 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2915 std::string lightSource = pattern->GetResCacheMapByKey("pointLight.LightSource");
2916 EXPECT_EQ(lightSource, "");
2917
2918 auto state = static_cast<VisualState>(INDEX);
2919 ViewStackProcessor::GetInstance()->SetVisualState(state);
2920 ViewStackProcessor::GetInstance()->ClearStack();
2921 ViewAbstract::SetLightPosition(option);
2922 g_isConfigChangePerform = false;
2923 result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
2924 EXPECT_FALSE(result);
2925 }
2926
2927 /**
2928 * @tc.name: SetBackShadow
2929 * @tc.desc: Test SetBackShadow of View_Abstract
2930 * @tc.type: FUNC
2931 */
2932 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0067, TestSize.Level1)
2933 {
2934 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2935 ASSERT_NE(frameNode, nullptr);
2936 auto pattern = frameNode->GetPattern<Pattern>();
2937 ASSERT_NE(pattern, nullptr);
2938 g_isConfigChangePerform = true;
2939 Shadow shadow;
2940 ViewAbstract::SetBackShadow(shadow);
2941 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2942 g_isConfigChangePerform = false;
2943 std::string shadowStr = pattern->GetResCacheMapByKey("shadow");
2944 EXPECT_EQ(shadowStr, "");
2945 }
2946
2947 /**
2948 * @tc.name: SetMask
2949 * @tc.desc: Test SetMask of View_Abstract
2950 * @tc.type: FUNC
2951 */
2952 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0068, TestSize.Level1)
2953 {
2954 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2955 ASSERT_NE(frameNode, nullptr);
2956 auto pattern = frameNode->GetPattern<Pattern>();
2957 ASSERT_NE(pattern, nullptr);
2958 RefPtr<BasicShape> basicShape = AceType::MakeRefPtr<BasicShape>(BasicShapeType::CIRCLE);
2959 RefPtr<NG::ProgressMaskProperty> progressMaskProperty = AceType::MakeRefPtr<NG::ProgressMaskProperty>();
2960 progressMaskProperty->SetMaxValue(200.0f);
2961 progressMaskProperty->SetColor(Color(0xffff0000));
2962 progressMaskProperty->SetValue(1.0f);
2963 auto target = frameNode->GetRenderContext();
2964 ASSERT_NE(target, nullptr);
2965 ViewAbstract::SetProgressMask(frameNode, progressMaskProperty);
2966 g_isConfigChangePerform = true;
2967
2968 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
2969 ViewAbstract::SetMask(basicShape);
2970 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
2971 EXPECT_TRUE(result);
2972
2973 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
2974 g_isConfigChangePerform = false;
2975 std::string maskShape = pattern->GetResCacheMapByKey("maskShape");
2976 EXPECT_EQ(maskShape, "");
2977 }
2978
2979 /**
2980 * @tc.name: ViewAbstractTest069
2981 * @tc.desc: Test the operation of View_Abstract.
2982 * @tc.type: FUNC
2983 */
2984 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest069, TestSize.Level1)
2985 {
2986 /**
2987 * @tc.steps: step1.Using static methods to set component properties
2988 */
2989 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
2990 ASSERT_NE(frameNode, nullptr);
2991 auto pattern = frameNode->GetPattern();
2992 ASSERT_NE(pattern, nullptr);
2993
2994 std::string bundleName = "com.example.test";
2995 std::string moduleName = "entry";
2996 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
2997 ViewAbstract::SetWidth(resObj);
2998 ViewAbstract::SetHeight(resObj);
2999 ViewAbstract::SetMinWidth(resObj);
3000 ViewAbstract::SetMinHeight(resObj);
3001 ViewAbstract::SetMaxWidth(resObj);
3002 ViewAbstract::SetMaxHeight(resObj);
3003 pattern->OnColorModeChange(1);
3004 ViewAbstract::ResetAspectRatio();
3005 ViewAbstract::SetDrawModifier(nullptr);
3006
3007 /**
3008 * @tc.expected: Successfully set various properties of the top node on the stack
3009 */
3010 CalcDimension result;
3011 ResourceParseUtils::ParseResDimensionVpNG(resObj, result);
3012 EXPECT_EQ(pattern->GetResCacheMapByKey("width"), result.ToString());
3013 EXPECT_EQ(pattern->GetResCacheMapByKey("height"), result.ToString());
3014 EXPECT_EQ(pattern->GetResCacheMapByKey("constraintSize.minWidth"), result.ToString());
3015 EXPECT_EQ(pattern->GetResCacheMapByKey("constraintSize.minHeight"), result.ToString());
3016 EXPECT_EQ(pattern->GetResCacheMapByKey("constraintSize.maxWidth"), result.ToString());
3017 EXPECT_EQ(pattern->GetResCacheMapByKey("constraintSize.maxHeight"), result.ToString());
3018 pattern->RemoveResObj("width");
3019 pattern->RemoveResObj("height");
3020 pattern->RemoveResObj("constraintSize.minWidth");
3021 pattern->RemoveResObj("constraintSize.minHeight");
3022 pattern->RemoveResObj("constraintSize.maxWidth");
3023 pattern->RemoveResObj("constraintSize.maxHeight");
3024 }
3025
3026 /**
3027 * @tc.name: ViewAbstractTest070
3028 * @tc.desc: Test the operation of View_Abstract
3029 * @tc.type: FUNC
3030 */
3031 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest070, TestSize.Level1)
3032 {
3033 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3034 ASSERT_NE(frameNode, nullptr);
3035 auto pattern = frameNode->GetPattern();
3036 ASSERT_NE(pattern, nullptr);
3037 std::string bundleName = "com.example.test";
3038 std::string moduleName = "entry";
3039 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3040 ViewAbstract::SetPadding(resObj);
3041 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3042 EXPECT_EQ(pattern->GetResCacheMapByKey("padding"), "0.00px");
3043 pattern->RemoveResObj("padding");
3044 NG::PaddingProperty paddings;
__anon34ec4f1b1f02(const RefPtr<ResourceObject>& resObj, NG::PaddingProperty& paddings) 3045 auto updateFunc = [](const RefPtr<ResourceObject>& resObj, NG::PaddingProperty& paddings) {
3046 paddings.bottom = NG::CalcLength(BOTTOM);
3047 };
3048 paddings.AddResource("bottom", resObj, std::move(updateFunc));
3049 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3050 g_isConfigChangePerform = true;
3051 ViewAbstract::SetPadding(paddings);
3052 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3053 g_isConfigChangePerform = false;
3054 pattern->RemoveResObj("padding");
3055 auto layoutProperty = frameNode->GetLayoutProperty<LayoutProperty>();
3056 ASSERT_NE(layoutProperty, nullptr);
3057 auto& padding = layoutProperty->GetPaddingProperty();
3058 ASSERT_NE(padding, nullptr);
3059 EXPECT_EQ(padding->bottom, NG::CalcLength(BOTTOM));
3060 }
3061
3062 /**
3063 * @tc.name: ViewAbstractTest071
3064 * @tc.desc: Test the operation of View_Abstract
3065 * @tc.type: FUNC
3066 */
3067 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest071, TestSize.Level1)
3068 {
3069 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3070 ASSERT_NE(frameNode, nullptr);
3071 auto pattern = frameNode->GetPattern();
3072 ASSERT_NE(pattern, nullptr);
3073 std::string bundleName = "com.example.test";
3074 std::string moduleName = "entry";
3075 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3076 ViewAbstract::SetMargin(resObj);
3077 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3078 EXPECT_EQ(pattern->GetResCacheMapByKey("margin"), "0.00px");
3079 pattern->RemoveResObj("margin");
3080 NG::MarginProperty margins;
__anon34ec4f1b2002(const RefPtr<ResourceObject>& resObj, NG::MarginProperty& margins) 3081 auto updateFunc = [](const RefPtr<ResourceObject>& resObj, NG::MarginProperty& margins) {
3082 margins.bottom = NG::CalcLength(BOTTOM);
3083 };
3084 margins.AddResource("margin.bottom", resObj, std::move(updateFunc));
3085 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3086 g_isConfigChangePerform = true;
3087 ViewAbstract::SetMargin(margins);
3088 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3089 g_isConfigChangePerform = false;
3090 pattern->RemoveResObj("margin");
3091 auto layoutProperty = frameNode->GetLayoutProperty<LayoutProperty>();
3092 ASSERT_NE(layoutProperty, nullptr);
3093 auto& margin = layoutProperty->GetMarginProperty();
3094 ASSERT_NE(margin, nullptr);
3095 EXPECT_EQ(margin->bottom, NG::CalcLength(BOTTOM));
3096 }
3097
3098 /**
3099 * @tc.name: ViewAbstractTest072
3100 * @tc.desc: Test the operation of View_Abstract
3101 * @tc.type: FUNC
3102 */
3103 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest072, TestSize.Level1)
3104 {
3105 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3106 ASSERT_NE(frameNode, nullptr);
3107 auto pattern = frameNode->GetPattern();
3108 ASSERT_NE(pattern, nullptr);
3109 std::string bundleName = "com.example.test";
3110 std::string moduleName = "entry";
3111 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3112 ViewAbstract::SetBorderRadius(resObj);
3113 pattern->OnColorModeChange(1);
3114 EXPECT_EQ(pattern->GetResCacheMapByKey("borderRadius"), "0.00px");
3115 pattern->RemoveResObj("borderRadius");
3116 NG::BorderRadiusProperty borderRadius;
__anon34ec4f1b2102(const RefPtr<ResourceObject>& resObj, NG::BorderRadiusProperty& borderRadius) 3117 auto updateFunc = [](const RefPtr<ResourceObject>& resObj, NG::BorderRadiusProperty& borderRadius) {
3118 borderRadius.radiusBottomLeft = BOTTOM;
3119 };
3120 borderRadius.AddResource("borderRadius.radiusBottomLeft", resObj, std::move(updateFunc));
3121 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3122 g_isConfigChangePerform = true;
3123 ViewAbstract::SetBorderRadius(borderRadius);
3124 pattern->OnColorModeChange(1);
3125 g_isConfigChangePerform = false;
3126 pattern->RemoveResObj("borderRadius");
3127 auto context = frameNode->GetRenderContext();
3128 ASSERT_NE(context, nullptr);
3129 Dimension defaultDimension(0);
3130 BorderRadiusProperty defaultBorderRadius = { defaultDimension, defaultDimension, defaultDimension,
3131 defaultDimension };
3132 auto borderRadiusValue = context->GetBorderRadiusValue(defaultBorderRadius);
3133 EXPECT_EQ(borderRadiusValue.radiusBottomLeft, BOTTOM);
3134 }
3135
3136
3137 /**
3138 * @tc.name: ViewAbstractTest073
3139 * @tc.desc: Test the operation of View_Abstract
3140 * @tc.type: FUNC
3141 */
3142 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest073, TestSize.Level1)
3143 {
3144 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3145 ASSERT_NE(frameNode, nullptr);
3146 auto pattern = frameNode->GetPattern();
3147 ASSERT_NE(pattern, nullptr);
3148 std::string bundleName = "com.example.test";
3149 std::string moduleName = "entry";
3150 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3151 ViewAbstract::SetBorderColor(resObj);
3152 pattern->OnColorModeChange(1);
3153 EXPECT_EQ(pattern->GetResCacheMapByKey("borderColor"), "#FF000000");
3154 pattern->RemoveResObj("borderColor");
3155 NG::BorderColorProperty borderColor;
__anon34ec4f1b2202(const RefPtr<ResourceObject>& resObj, NG::BorderColorProperty& borderColor) 3156 auto updateFunc = [](const RefPtr<ResourceObject>& resObj, NG::BorderColorProperty& borderColor) {
3157 borderColor.bottomColor = BLUE;
3158 };
3159 borderColor.AddResource("borderColor.bottomColor", resObj, std::move(updateFunc));
3160 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3161 g_isConfigChangePerform = true;
3162 ViewAbstract::SetBorderColor(borderColor);
3163 pattern->OnColorModeChange(1);
3164 g_isConfigChangePerform = false;
3165 pattern->RemoveResObj("borderColor");
3166 auto context = frameNode->GetRenderContext();
3167 ASSERT_NE(context, nullptr);
3168 Color defaultColor(0xff000000);
3169 BorderColorProperty defaultBorderColor = { defaultColor, defaultColor, defaultColor, defaultColor, std::nullopt,
3170 std::nullopt };
3171 auto borderColorValue = context->GetBorderColorValue(defaultBorderColor);
3172 EXPECT_EQ(borderColorValue.bottomColor, BLUE);
3173 }
3174
3175 /**
3176 * @tc.name: ViewAbstractTest074
3177 * @tc.desc: Test the operation of View_Abstract
3178 * @tc.type: FUNC
3179 */
3180 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest074, TestSize.Level1)
3181 {
3182 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3183 ASSERT_NE(frameNode, nullptr);
3184 auto pattern = frameNode->GetPattern();
3185 ASSERT_NE(pattern, nullptr);
3186 std::string bundleName = "com.example.test";
3187 std::string moduleName = "entry";
3188 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3189 ViewAbstract::SetBorderWidth(resObj);
3190 pattern->OnColorModeChange(1);
3191 EXPECT_EQ(pattern->GetResCacheMapByKey("borderWidth"), "0.00px");
3192 pattern->RemoveResObj("borderWidth");
3193 NG::BorderWidthProperty borderWidth;
__anon34ec4f1b2302(const RefPtr<ResourceObject>& resObj, NG::BorderWidthProperty& borderWidth) 3194 auto updateFunc = [](const RefPtr<ResourceObject>& resObj, NG::BorderWidthProperty& borderWidth) {
3195 borderWidth.bottomDimen = BOTTOM;
3196 };
3197 borderWidth.AddResource("borderWidth.bottomDimen", resObj, std::move(updateFunc));
3198 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3199 g_isConfigChangePerform = true;
3200 ViewAbstract::SetBorderWidth(borderWidth);
3201 pattern->OnColorModeChange(1);
3202 g_isConfigChangePerform = false;
3203 pattern->RemoveResObj("borderWidth");
3204
3205 auto layoutProperty = frameNode->GetLayoutProperty<LayoutProperty>();
3206 ASSERT_NE(layoutProperty, nullptr);
3207 auto& layoutBorderWidth = layoutProperty->GetBorderWidthProperty();
3208 ASSERT_NE(layoutBorderWidth, nullptr);
3209 EXPECT_EQ(layoutBorderWidth->bottomDimen, BOTTOM);
3210
3211 auto context = frameNode->GetRenderContext();
3212 ASSERT_NE(context, nullptr);
3213 Dimension defaultDimension(0);
3214 BorderWidthProperty defaultBorderWidth = { defaultDimension, defaultDimension, defaultDimension, defaultDimension };
3215 auto contextBorderWidth = context->GetBorderWidthValue(defaultBorderWidth);
3216 EXPECT_EQ(contextBorderWidth.bottomDimen, BOTTOM);
3217 }
3218
3219 /**
3220 * @tc.name: ViewAbstractTest075
3221 * @tc.desc: Test the operation of View_Abstract
3222 * @tc.type: FUNC
3223 */
3224 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest075, TestSize.Level1)
3225 {
3226 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3227 ASSERT_NE(frameNode, nullptr);
3228 auto pattern = frameNode->GetPattern();
3229 ASSERT_NE(pattern, nullptr);
3230 std::string bundleName = "com.example.test";
3231 std::string moduleName = "entry";
3232 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3233 NG::BorderWidthProperty borderWidth;
__anon34ec4f1b2402(const RefPtr<ResourceObject>& resObj, NG::BorderWidthProperty& borderWidth) 3234 auto updateFunc = [](const RefPtr<ResourceObject>& resObj, NG::BorderWidthProperty& borderWidth) {
3235 borderWidth.bottomDimen = BOTTOM;
3236 };
3237 borderWidth.AddResource("borderWidth.bottomDimen", resObj, std::move(updateFunc));
3238 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3239 g_isConfigChangePerform = true;
3240 ViewAbstract::SetDashGap(borderWidth);
3241 pattern->OnColorModeChange(1);
3242 g_isConfigChangePerform = false;
3243 pattern->RemoveResObj("borderWidth");
3244
3245 auto context = frameNode->GetRenderContext();
3246 ASSERT_NE(context, nullptr);
3247 Dimension defaultDimension(0);
3248 BorderWidthProperty defaultBorderWidth = { defaultDimension, defaultDimension, defaultDimension, defaultDimension };
3249 auto contextBorderWidth = context->GetDashGapValue(defaultBorderWidth);
3250 EXPECT_EQ(contextBorderWidth.bottomDimen, BOTTOM);
3251 }
3252
3253 /**
3254 * @tc.name: ViewAbstractTest076
3255 * @tc.desc: Test the operation of View_Abstract
3256 * @tc.type: FUNC
3257 */
3258 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest076, TestSize.Level1)
3259 {
3260 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3261 ASSERT_NE(frameNode, nullptr);
3262 auto pattern = frameNode->GetPattern();
3263 ASSERT_NE(pattern, nullptr);
3264 std::string bundleName = "com.example.test";
3265 std::string moduleName = "entry";
3266 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3267 NG::BorderWidthProperty borderWidth;
3268 borderWidth.bottomDimen = BOTTOM;
3269 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3270 g_isConfigChangePerform = true;
3271 ViewAbstract::SetDashWidth(borderWidth);
3272 pattern->OnColorModeChange(1);
3273 g_isConfigChangePerform = false;
3274
3275 auto context = frameNode->GetRenderContext();
3276 ASSERT_NE(context, nullptr);
3277 Dimension defaultDimension(0);
3278 BorderWidthProperty defaultBorderWidth = { defaultDimension, defaultDimension, defaultDimension, defaultDimension };
3279 auto contextBorderWidth = context->GetDashWidthValue(defaultBorderWidth);
3280 EXPECT_EQ(contextBorderWidth.bottomDimen, BOTTOM);
3281 }
3282
3283 /**
3284 * @tc.name: ViewAbstractTest077
3285 * @tc.desc: Test the operation of View_Abstract
3286 * @tc.type: FUNC
3287 */
3288 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest077, TestSize.Level1)
3289 {
3290 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3291 ASSERT_NE(frameNode, nullptr);
3292 auto pattern = frameNode->GetPattern();
3293 ASSERT_NE(pattern, nullptr);
3294 std::string bundleName = "com.example.test";
3295 std::string moduleName = "entry";
3296 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3297 ViewAbstract::SetPosition(ZERO, ZERO, resObj, resObj);
3298 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3299 g_isConfigChangePerform = true;
3300 ViewAbstract::SetPosition(ZERO, ZERO, resObj, resObj);
3301 pattern->OnColorModeChange(1);
3302 g_isConfigChangePerform = false;
3303
3304 auto context = frameNode->GetRenderContext();
3305 ASSERT_NE(context, nullptr);
3306 OffsetT<Dimension> defaultDimension = { WIDTH, HEIGHT };
3307 auto positionValue = context->GetPositionValue(OffsetT<Dimension>(defaultDimension));
3308 EXPECT_EQ(positionValue.GetX(), ZERO);
3309 EXPECT_EQ(positionValue.GetY(), ZERO);
3310 }
3311
3312 /**
3313 * @tc.name: ViewAbstractTest078
3314 * @tc.desc: Test the operation of View_Abstract
3315 * @tc.type: FUNC
3316 */
3317 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest078, TestSize.Level1)
3318 {
3319 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3320 ASSERT_NE(frameNode, nullptr);
3321 auto pattern = frameNode->GetPattern();
3322 ASSERT_NE(pattern, nullptr);
3323 std::string bundleName = "com.example.test";
3324 std::string moduleName = "entry";
3325 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3326 ViewAbstract::SetOffset(ZERO, ZERO, resObj, resObj);
3327 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3328 g_isConfigChangePerform = true;
3329 ViewAbstract::SetOffset(ZERO, ZERO, resObj, resObj);
3330 pattern->OnColorModeChange(1);
3331 g_isConfigChangePerform = false;
3332
3333 auto context = frameNode->GetRenderContext();
3334 ASSERT_NE(context, nullptr);
3335 OffsetT<Dimension> defaultDimension = { WIDTH, HEIGHT };
3336 auto offsetValue = context->GetOffsetValue(OffsetT<Dimension>(defaultDimension));
3337 EXPECT_EQ(offsetValue.GetX(), ZERO);
3338 EXPECT_EQ(offsetValue.GetY(), ZERO);
3339 }
3340
3341 /**
3342 * @tc.name: ViewAbstractTest079
3343 * @tc.desc: Test the operation of View_Abstract
3344 * @tc.type: FUNC
3345 */
3346 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest079, TestSize.Level1)
3347 {
3348 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3349 ASSERT_NE(frameNode, nullptr);
3350 auto pattern = frameNode->GetPattern();
3351 ASSERT_NE(pattern, nullptr);
3352 std::string bundleName = "com.example.test";
3353 std::string moduleName = "entry";
3354 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3355 ViewAbstract::MarkAnchor(ZERO, ZERO, resObj, resObj);
3356 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3357 g_isConfigChangePerform = true;
3358 ViewAbstract::MarkAnchor(ZERO, ZERO, resObj, resObj);
3359 pattern->OnColorModeChange(1);
3360 g_isConfigChangePerform = false;
3361
3362 auto context = frameNode->GetRenderContext();
3363 ASSERT_NE(context, nullptr);
3364 OffsetT<Dimension> defaultDimension = { WIDTH, HEIGHT };
3365 auto anchorValue = context->GetAnchorValue(OffsetT<Dimension>(defaultDimension));
3366 EXPECT_EQ(anchorValue.GetX(), ZERO);
3367 EXPECT_EQ(anchorValue.GetY(), ZERO);
3368 }
3369
3370 /**
3371 * @tc.name: ViewAbstractTest080
3372 * @tc.desc: Test the operation of View_Abstract
3373 * @tc.type: FUNC
3374 */
3375 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest080, TestSize.Level1)
3376 {
3377 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3378 ASSERT_NE(frameNode, nullptr);
3379 auto pattern = frameNode->GetPattern();
3380 ASSERT_NE(pattern, nullptr);
3381 std::string bundleName = "com.example.test";
3382 std::string moduleName = "entry";
3383 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3384 NG::PaddingProperty paddings;
__anon34ec4f1b2502(const RefPtr<ResourceObject>& resObj, NG::PaddingProperty& paddings) 3385 auto updateFunc = [](const RefPtr<ResourceObject>& resObj, NG::PaddingProperty& paddings) {
3386 paddings.bottom = NG::CalcLength(BOTTOM);
3387 };
3388 paddings.AddResource("paddings.bottom", resObj, std::move(updateFunc));
3389 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3390 g_isConfigChangePerform = true;
3391 ViewAbstract::SetSafeAreaPadding(paddings);
3392 pattern->OnColorModeChange(1);
3393 g_isConfigChangePerform = false;
3394 pattern->RemoveResObj("paddings");
3395
3396 auto layoutProperty = frameNode->GetLayoutProperty<LayoutProperty>();
3397 ASSERT_NE(layoutProperty, nullptr);
3398 auto& safeAreaPaddingProperty = layoutProperty->GetSafeAreaPaddingProperty();
3399 ASSERT_NE(safeAreaPaddingProperty, nullptr);
3400 EXPECT_EQ(safeAreaPaddingProperty->bottom, NG::CalcLength(BOTTOM));
3401 }
3402
3403 /**
3404 * @tc.name: ViewAbstractTest081
3405 * @tc.desc: Test the operation of View_Abstract
3406 * @tc.type: FUNC
3407 */
3408 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest081, TestSize.Level1)
3409 {
3410 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3411 ASSERT_NE(frameNode, nullptr);
3412 auto pattern = frameNode->GetPattern();
3413 ASSERT_NE(pattern, nullptr);
3414 std::string bundleName = "com.example.test";
3415 std::string moduleName = "entry";
3416 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3417 EdgesParam edgesParam;
3418 edgesParam.bottom = BOTTOM;
3419
3420 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3421 g_isConfigChangePerform = true;
3422 ViewAbstract::SetPositionEdges(edgesParam);
3423 pattern->OnColorModeChange(1);
3424 g_isConfigChangePerform = false;
3425 pattern->RemoveResObj("edgesParam");
3426
3427 auto context = frameNode->GetRenderContext();
3428 ASSERT_NE(context, nullptr);
3429 Dimension defaultDimension(0);
3430 EdgesParam defaultEdgesParam = { defaultDimension, defaultDimension, defaultDimension, defaultDimension,
3431 std::nullopt, std::nullopt };
3432 auto positionEdges = context->GetPositionEdgesValue(defaultEdgesParam);
3433 EXPECT_EQ(positionEdges.bottom, BOTTOM);
3434 }
3435
3436 /**
3437 * @tc.name: ViewAbstractTest082
3438 * @tc.desc: Test the operation of View_Abstract
3439 * @tc.type: FUNC
3440 */
3441 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest082, TestSize.Level1)
3442 {
3443 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3444 ASSERT_NE(frameNode, nullptr);
3445 auto pattern = frameNode->GetPattern();
3446 ASSERT_NE(pattern, nullptr);
3447 std::string bundleName = "com.example.test";
3448 std::string moduleName = "entry";
3449 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3450 EdgesParam edgesParam;
3451 edgesParam.bottom = BOTTOM;
3452 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3453 g_isConfigChangePerform = true;
3454 ViewAbstract::SetOffsetEdges(edgesParam);
3455 pattern->OnColorModeChange(1);
3456 g_isConfigChangePerform = false;
3457
3458 auto context = frameNode->GetRenderContext();
3459 ASSERT_NE(context, nullptr);
3460 Dimension defaultDimension(0);
3461 EdgesParam defaultEdgesParam = { defaultDimension, defaultDimension, defaultDimension, defaultDimension,
3462 std::nullopt, std::nullopt };
3463 auto positionEdges = context->GetOffsetEdgesValue(defaultEdgesParam);
3464 EXPECT_EQ(positionEdges.bottom, BOTTOM);
3465 }
3466
3467 /**
3468 * @tc.name: RemoveResObj
3469 * @tc.desc: Test RemoveResObj of View_Abstract
3470 * @tc.type: FUNC
3471 */
3472 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0083, TestSize.Level1)
3473 {
3474 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3475 ASSERT_NE(frameNode, nullptr);
3476 auto pattern = frameNode->GetPattern<Pattern>();
3477 ASSERT_NE(pattern, nullptr);
3478 g_isConfigChangePerform = false;
3479 std::string key = "clipShape";
3480 viewAbstractModelNG.RemoveResObj(key);
3481 g_isConfigChangePerform = true;
3482 viewAbstractModelNG.RemoveResObj(key);
3483 g_isConfigChangePerform = false;
3484 std::string maskShape = pattern->GetResCacheMapByKey("clipShape");
3485 EXPECT_EQ(maskShape, "");
3486 }
3487
3488 /**
3489 * @tc.name: ViewAbstractTestNg0084
3490 * @tc.desc: Test the operation of View_Abstract
3491 * @tc.type: FUNC
3492 */
3493 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0084, TestSize.Level1)
3494 {
3495 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3496 ASSERT_NE(frameNode, nullptr);
3497 auto pattern = frameNode->GetPattern();
3498 ASSERT_NE(pattern, nullptr);
3499 std::string bundleName = "com.example.test";
3500 std::string moduleName = "entry";
3501 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3502 OffsetT<Dimension> value = { ZERO, ZERO };
3503 ViewAbstract::SetPosition(frameNode, value, resObj, resObj);
3504 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
3505 g_isConfigChangePerform = true;
3506 ViewAbstract::SetPosition(frameNode, value, resObj, resObj);
3507 pattern->OnColorModeChange(1);
3508 g_isConfigChangePerform = false;
3509
3510 auto context = frameNode->GetRenderContext();
3511 EXPECT_NE(context, nullptr);
3512 OffsetT<Dimension> defaultDimension = { WIDTH, HEIGHT };
3513 auto positionValue = context->GetPositionValue(OffsetT<Dimension>(defaultDimension));
3514 EXPECT_EQ(positionValue.GetX(), ZERO);
3515 EXPECT_EQ(positionValue.GetY(), ZERO);
3516 }
3517
3518 /**
3519 * @tc.name: ViewAbstractSetClickFocusTest001
3520 * @tc.desc: Test that container node becomes focusable when click event is set and no focusable children exist.
3521 * @tc.type: FUNC
3522 */
3523 HWTEST_F(ViewAbstractTestNg, ViewAbstractSetClickFocusTest001, TestSize.Level1)
3524 {
3525 /**
3526 * @tc.steps1: Create a FrameNode and set a native onClick event via SetOnClick.
3527 * @tc.expected: The FrameNode should be focusable after setting onClick.
3528 */
3529 auto frameNode1 = FrameNode::CreateFrameNode(
3530 V2::BUTTON_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ButtonPattern>());
3531 ASSERT_NE(frameNode1, nullptr);
3532
__anon34ec4f1b2602(GestureEvent&) 3533 GestureEventFunc onClick = [](GestureEvent&) {};
3534 ViewAbstract::SetOnClick(AceType::RawPtr(frameNode1), std::move(onClick), 10.0);
3535
3536 auto focusHub1 = frameNode1->GetFocusHub();
3537 ASSERT_NE(focusHub1, nullptr);
3538 EXPECT_TRUE(focusHub1->IsFocusable());
3539
3540 /**
3541 * @tc.steps2: Create another FrameNode and set a JS-based onClick event via SetJSFrameNodeOnClick.
3542 * @tc.expected: The FrameNode should also become focusable after setting JS onClick.
3543 */
3544 auto frameNode2 = FrameNode::CreateFrameNode(
3545 V2::BUTTON_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ButtonPattern>());
3546 ASSERT_NE(frameNode2, nullptr);
3547
__anon34ec4f1b2702(GestureEvent&) 3548 GestureEventFunc jsOnClick = [](GestureEvent&) {};
3549 ViewAbstract::SetJSFrameNodeOnClick(AceType::RawPtr(frameNode2), std::move(jsOnClick));
3550
3551 auto focusHub2 = frameNode2->GetFocusHub();
3552 ASSERT_NE(focusHub2, nullptr);
3553 EXPECT_TRUE(focusHub2->IsFocusable());
3554 }
3555
3556 /**
3557 * @tc.name: ViewAbstractTestNg0097
3558 * @tc.desc: test position attribute, use Edges type.
3559 * @tc.type: FUNC
3560 */
3561 HWTEST_F(ViewAbstractTestNg, ViewAbstractTestNg0097, TestSize.Level1)
3562 {
3563 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3564 ASSERT_NE(frameNode, nullptr);
3565 std::string bundleName = "com.example.test";
3566 std::string moduleName = "entry";
3567 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
__anon34ec4f1b2802(const RefPtr<ResourceObject>& resObj, EdgesParam& edges) 3568 auto&& updateFunc = [](const RefPtr<ResourceObject>& resObj, EdgesParam& edges) {};
3569 EdgesParam edgesParam;
3570 edgesParam.AddResource("edges.top", resObj, std::move(updateFunc));
3571 EXPECT_EQ(edgesParam.resMap_.empty(), false);
3572 ViewAbstract::SetPositionEdges(frameNode, edgesParam);
3573 auto renderContext = frameNode->GetRenderContext();
3574 EXPECT_EQ(renderContext->HasPositionEdges(), true);
3575 }
3576
3577 /**
3578 * @tc.name: SetLinearGradient
3579 * @tc.desc: Test SetLinearGradient of View_Abstract
3580 * @tc.type: FUNC
3581 */
3582 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest001, TestSize.Level1)
3583 {
3584 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3585 ASSERT_NE(frameNode, nullptr);
3586 auto pattern = frameNode->GetPattern<Pattern>();
3587 ASSERT_NE(pattern, nullptr);
3588 g_isConfigChangePerform = true;
3589 NG::Gradient gradient;
3590 gradient.CreateGradientWithType(NG::GradientType::LINEAR);
3591 gradient.GetLinearGradient()->linearX = NG::GradientDirection::LEFT;
3592 ViewAbstract::SetLinearGradient(frameNode, gradient);
3593 auto renderContext = frameNode->GetRenderContext();
3594 ASSERT_NE(renderContext, nullptr);
3595 EXPECT_EQ(renderContext->GetLinearGradient().has_value(), true);
3596 EXPECT_EQ(renderContext->GetLinearGradient()->GetLinearGradient()->linearX, NG::GradientDirection::LEFT);
3597 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3598 g_isConfigChangePerform = false;
3599 }
3600
3601 /**
3602 * @tc.name: SetSweepGradient
3603 * @tc.desc: Test SetSweepGradient of View_Abstract
3604 * @tc.type: FUNC
3605 */
3606 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest002, TestSize.Level1)
3607 {
3608 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3609 ASSERT_NE(frameNode, nullptr);
3610 auto pattern = frameNode->GetPattern<Pattern>();
3611 ASSERT_NE(pattern, nullptr);
3612 g_isConfigChangePerform = true;
3613 NG::Gradient gradient;
3614 gradient.CreateGradientWithType(NG::GradientType::SWEEP);
3615 gradient.GetSweepGradient()->endAngle = CalcDimension(100.0f, DimensionUnit::PX);
3616 ViewAbstract::SetSweepGradient(frameNode, gradient);
3617 auto renderContext = frameNode->GetRenderContext();
3618 ASSERT_NE(renderContext, nullptr);
3619 EXPECT_EQ(renderContext->GetSweepGradient().has_value(), true);
3620 EXPECT_EQ(renderContext->GetSweepGradient()->GetSweepGradient()->endAngle,
3621 CalcDimension(100.0f, DimensionUnit::PX));
3622 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3623 g_isConfigChangePerform = false;
3624 }
3625
3626 /**
3627 * @tc.name: SetRadialGradient
3628 * @tc.desc: Test SetRadialGradient of View_Abstract
3629 * @tc.type: FUNC
3630 */
3631 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest003, TestSize.Level1)
3632 {
3633 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3634 ASSERT_NE(frameNode, nullptr);
3635 auto pattern = frameNode->GetPattern<Pattern>();
3636 ASSERT_NE(pattern, nullptr);
3637 g_isConfigChangePerform = true;
3638 NG::Gradient gradient;
3639 gradient.CreateGradientWithType(NG::GradientType::RADIAL);
3640 gradient.GetRadialGradient()->radialSizeType = std::make_optional(RadialSizeType::CLOSEST_CORNER);
3641 ViewAbstract::SetRadialGradient(frameNode, gradient);
3642 auto renderContext = frameNode->GetRenderContext();
3643 ASSERT_NE(renderContext, nullptr);
3644 EXPECT_EQ(renderContext->GetRadialGradient().has_value(), true);
3645 EXPECT_EQ(renderContext->GetRadialGradient()->GetRadialGradient()->radialSizeType, RadialSizeType::CLOSEST_CORNER);
3646 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3647 g_isConfigChangePerform = false;
3648 }
3649
3650 /**
3651 * @tc.name: SetForegroundColor
3652 * @tc.desc: Test SetForegroundColor of View_Abstract
3653 * @tc.type: FUNC
3654 */
3655 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest004, TestSize.Level1)
3656 {
3657 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3658 ASSERT_NE(frameNode, nullptr);
3659 auto pattern = frameNode->GetPattern<Pattern>();
3660 ASSERT_NE(pattern, nullptr);
3661 std::string foregroundColor = pattern->GetResCacheMapByKey("foregroundColor");
3662 EXPECT_EQ(foregroundColor, "");
3663 g_isConfigChangePerform = true;
3664 std::string bundleName = "com.example.test";
3665 std::string moduleName = "entry";
3666 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3667 Color color;
3668 ViewAbstract::SetForegroundColor(frameNode, color, resObj);
3669 Color result;
3670 ResourceParseUtils::ParseResColor(resObj, result);
3671 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3672 g_isConfigChangePerform = false;
3673 foregroundColor = pattern->GetResCacheMapByKey("foregroundColor");
3674 EXPECT_EQ(foregroundColor, result.ColorToString());
3675 }
3676
3677 /**
3678 * @tc.name: SetOpacity
3679 * @tc.desc: Test SetOpacity of View_Abstract
3680 * @tc.type: FUNC
3681 */
3682 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest005, TestSize.Level1)
3683 {
3684 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3685 ASSERT_NE(frameNode, nullptr);
3686 auto pattern = frameNode->GetPattern<Pattern>();
3687 ASSERT_NE(pattern, nullptr);
3688 std::string opacityStr = pattern->GetResCacheMapByKey("viewAbstract.opacity");
3689 EXPECT_EQ(opacityStr, "");
3690 g_isConfigChangePerform = true;
3691 std::string bundleName = "com.example.test";
3692 std::string moduleName = "entry";
3693 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
3694 double opacity = 0.0;
3695 ViewAbstract::SetOpacity(frameNode, opacity, resObj);
3696 double result;
3697 ResourceParseUtils::ParseResDouble(resObj, result);
3698 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3699 g_isConfigChangePerform = false;
3700 opacityStr = pattern->GetResCacheMapByKey("viewAbstract.opacity");
3701 EXPECT_EQ(opacityStr, std::to_string(result));
3702 }
3703
3704 /**
3705 * @tc.name: SetClipShape
3706 * @tc.desc: Test SetClipShape of View_Abstract
3707 * @tc.type: FUNC
3708 */
3709 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest006, TestSize.Level1)
3710 {
3711 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3712 ASSERT_NE(frameNode, nullptr);
3713 auto pattern = frameNode->GetPattern<Pattern>();
3714 ASSERT_NE(pattern, nullptr);
3715 g_isConfigChangePerform = true;
3716 ViewAbstract::SetClipEdge(frameNode, true);
3717 auto basicShape = AceType::MakeRefPtr<Circle>();
3718 basicShape->SetBasicShapeType(BasicShapeType::CIRCLE);
3719 EXPECT_EQ(basicShape->GetBasicShapeType(), BasicShapeType::CIRCLE);
3720 ViewAbstract::SetClipShape(frameNode, basicShape);
3721 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3722 g_isConfigChangePerform = false;
3723 std::string shapeStr = pattern->GetResCacheMapByKey("clipShape");
3724 EXPECT_EQ(shapeStr, "");
3725 }
3726
3727 /**
3728 * @tc.name: SetBackgroundBlurStyle
3729 * @tc.desc: Test SetBackgroundBlurStyle of View_Abstract
3730 * @tc.type: FUNC
3731 */
3732 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest007, TestSize.Level1)
3733 {
3734 BlurStyleOption blurStyleOption;
3735 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
3736 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
3737 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
3738 blurStyleOption.policy = BlurStyleActivePolicy::ALWAYS_INACTIVE;
3739 g_isConfigChangePerform = true;
3740 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3741 ASSERT_NE(frameNode, nullptr);
3742 auto pattern = frameNode->GetPattern<Pattern>();
3743 ASSERT_NE(pattern, nullptr);
3744 ViewAbstract::SetBackgroundBlurStyle(frameNode, blurStyleOption);
3745 auto renderContext = frameNode->GetRenderContext();
3746 ASSERT_NE(renderContext, nullptr);
3747 EXPECT_EQ(renderContext->GetBackBlurStyle().has_value(), true);
3748 EXPECT_EQ(renderContext->GetBackBlurStyle()->blurStyle, BlurStyle::NO_MATERIAL);
3749 EXPECT_EQ(renderContext->GetBackBlurStyle()->colorMode, ThemeColorMode::SYSTEM);
3750 EXPECT_EQ(renderContext->GetBackBlurStyle()->adaptiveColor, AdaptiveColor::DEFAULT);
3751 EXPECT_EQ(renderContext->GetBackBlurStyle()->policy, BlurStyleActivePolicy::ALWAYS_INACTIVE);
3752 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3753 g_isConfigChangePerform = false;
3754 }
3755
3756 /**
3757 * @tc.name: UpdateBackgroundBlurStyle
3758 * @tc.desc: Test UpdateBackgroundBlurStyle of View_Abstract
3759 * @tc.type: FUNC
3760 */
3761 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest008, TestSize.Level1)
3762 {
3763 BlurStyleOption blurStyleOption;
3764 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
3765 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
3766 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
3767 blurStyleOption.policy = BlurStyleActivePolicy::ALWAYS_INACTIVE;
3768 g_isConfigChangePerform = true;
3769 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3770 ASSERT_NE(frameNode, nullptr);
3771 auto pattern = frameNode->GetPattern<Pattern>();
3772 ASSERT_NE(pattern, nullptr);
3773 auto target = frameNode->GetRenderContext();
3774 ASSERT_NE(target, nullptr);
3775
3776 SysOptions sysOptions;
3777 EffectOption effectOption;
3778 Color effectOptionColor;
3779 effectOption.color = effectOptionColor;
3780 target->UpdateBackgroundEffect(effectOption, sysOptions);
3781 target->UpdateBackBlurRadius(Dimension(0.5f, DimensionUnit::PERCENT));
3782 ViewAbstract::UpdateBackgroundBlurStyle(frameNode, blurStyleOption, sysOptions);
3783 EXPECT_EQ(target->GetBackBlurStyle().has_value(), true);
3784 EXPECT_EQ(target->GetBackBlurStyle()->blurStyle, BlurStyle::NO_MATERIAL);
3785 EXPECT_EQ(target->GetBackBlurStyle()->colorMode, ThemeColorMode::SYSTEM);
3786 EXPECT_EQ(target->GetBackBlurStyle()->adaptiveColor, AdaptiveColor::DEFAULT);
3787 EXPECT_EQ(target->GetBackBlurStyle()->policy, BlurStyleActivePolicy::ALWAYS_INACTIVE);
3788 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3789 g_isConfigChangePerform = false;
3790 }
3791
3792 /**
3793 * @tc.name: SetBackgroundEffect
3794 * @tc.desc: Test SetBackgroundEffect of View_Abstract
3795 * @tc.type: FUNC
3796 */
3797 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest009, TestSize.Level1)
3798 {
3799 EffectOption option;
3800 Color color = Color::TRANSPARENT;
3801 option.color = color;
3802 option.policy = BlurStyleActivePolicy::ALWAYS_INACTIVE;
3803 g_isConfigChangePerform = true;
3804 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3805 ASSERT_NE(frameNode, nullptr);
3806 auto pattern = frameNode->GetPattern<Pattern>();
3807 ASSERT_NE(pattern, nullptr);
3808 ViewAbstract::SetBackgroundEffect(frameNode, option);
3809 auto renderContext = frameNode->GetRenderContext();
3810 ASSERT_NE(renderContext, nullptr);
3811 EXPECT_EQ(renderContext->GetBackgroundEffect().has_value(), true);
3812 EXPECT_EQ(renderContext->GetBackgroundEffect()->color, Color::TRANSPARENT);
3813 EXPECT_EQ(renderContext->GetBackgroundEffect()->policy, BlurStyleActivePolicy::ALWAYS_INACTIVE);
3814 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3815 g_isConfigChangePerform = false;
3816 }
3817
3818 /**
3819 * @tc.name: UpdateBackgroundEffect
3820 * @tc.desc: Test UpdateBackgroundEffect of View_Abstract
3821 * @tc.type: FUNC
3822 */
3823 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest010, TestSize.Level1)
3824 {
3825 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3826 ASSERT_NE(frameNode, nullptr);
3827 auto pattern = frameNode->GetPattern<Pattern>();
3828 ASSERT_NE(pattern, nullptr);
3829 auto target = frameNode->GetRenderContext();
3830 ASSERT_NE(target, nullptr);
3831 g_isConfigChangePerform = true;
3832 SysOptions sysOptions;
3833 EffectOption effectOption;
3834 effectOption.color = Color::TRANSPARENT;
3835 effectOption.policy = BlurStyleActivePolicy::FOLLOWS_WINDOW_ACTIVE_STATE;
3836
3837 BlurStyleOption blurStyleOption;
3838 blurStyleOption.blurStyle = BlurStyle::NO_MATERIAL;
3839 blurStyleOption.colorMode = ThemeColorMode::SYSTEM;
3840 blurStyleOption.adaptiveColor = AdaptiveColor::DEFAULT;
3841 blurStyleOption.policy = BlurStyleActivePolicy::ALWAYS_INACTIVE;
3842 ViewAbstract::UpdateBackgroundBlurStyle(frameNode, blurStyleOption, sysOptions);
3843 target->UpdateBackBlurRadius(Dimension(0.5f, DimensionUnit::PERCENT));
3844 EXPECT_EQ(target->GetBackBlurStyle().has_value(), true);
3845 EXPECT_EQ(target->GetBackBlurStyle()->blurStyle, BlurStyle::NO_MATERIAL);
3846 EXPECT_EQ(target->GetBackBlurStyle()->colorMode, ThemeColorMode::SYSTEM);
3847 EXPECT_EQ(target->GetBackBlurStyle()->adaptiveColor, AdaptiveColor::DEFAULT);
3848 EXPECT_EQ(target->GetBackBlurStyle()->policy, BlurStyleActivePolicy::ALWAYS_INACTIVE);
3849
3850 ViewAbstract::UpdateBackgroundEffect(frameNode, effectOption, sysOptions);
3851 EXPECT_EQ(target->GetBackgroundEffect().has_value(), true);
3852 EXPECT_EQ(target->GetBackgroundEffect()->color, Color::TRANSPARENT);
3853 EXPECT_EQ(target->GetBackgroundEffect()->policy, BlurStyleActivePolicy::FOLLOWS_WINDOW_ACTIVE_STATE);
3854 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3855 g_isConfigChangePerform = false;
3856 }
3857
3858 /**
3859 * @tc.name: SetPixelStretchEffect
3860 * @tc.desc: Test SetPixelStretchEffect of View_Abstract
3861 * @tc.type: FUNC
3862 */
3863 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest011, TestSize.Level1)
3864 {
3865 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3866 ASSERT_NE(frameNode, nullptr);
3867 auto pattern = frameNode->GetPattern<Pattern>();
3868 ASSERT_NE(pattern, nullptr);
3869 g_isConfigChangePerform = true;
3870 PixStretchEffectOption option;
3871 option.ResetValue();
3872 ViewAbstract::SetPixelStretchEffect(frameNode, option);
3873 auto renderContext = frameNode->GetRenderContext();
3874 ASSERT_NE(renderContext, nullptr);
3875 EXPECT_EQ(renderContext->GetPixelStretchEffect().has_value(), true);
3876 EXPECT_EQ(renderContext->GetPixelStretchEffect()->left, Dimension(0.0f));
3877 EXPECT_EQ(renderContext->GetPixelStretchEffect()->top, Dimension(0.0f));
3878 EXPECT_EQ(renderContext->GetPixelStretchEffect()->right, Dimension(0.0f));
3879 EXPECT_EQ(renderContext->GetPixelStretchEffect()->bottom, Dimension(0.0f));
3880 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3881 g_isConfigChangePerform = false;
3882 }
3883
3884 /**
3885 * @tc.name: SetOuterBorderRadius
3886 * @tc.desc: Test SetOuterBorderRadius of View_Abstract
3887 * @tc.type: FUNC
3888 */
3889 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest012, TestSize.Level1)
3890 {
3891 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3892 ASSERT_NE(frameNode, nullptr);
3893 auto pattern = frameNode->GetPattern<Pattern>();
3894 ASSERT_NE(pattern, nullptr);
3895 g_isConfigChangePerform = true;
3896 NG::BorderRadiusProperty borderRadius;
3897 borderRadius.radiusTopLeft = Dimension(1.0f, OHOS::Ace::DimensionUnit::VP);
3898 borderRadius.radiusTopRight = Dimension(2.0f, OHOS::Ace::DimensionUnit::VP);
3899 borderRadius.radiusBottomRight = Dimension(3.0f, OHOS::Ace::DimensionUnit::VP);
3900 borderRadius.radiusBottomLeft = Dimension(4.0f, OHOS::Ace::DimensionUnit::VP);
3901 borderRadius.radiusTopStart = Dimension(5.0f, OHOS::Ace::DimensionUnit::VP);
3902 borderRadius.radiusTopEnd = Dimension(6.0f, OHOS::Ace::DimensionUnit::VP);
3903 borderRadius.radiusBottomEnd = Dimension(7.0f, OHOS::Ace::DimensionUnit::VP);
3904 borderRadius.radiusBottomStart = Dimension(8.0f, OHOS::Ace::DimensionUnit::VP);
3905 borderRadius.multiValued = true;
3906 ViewAbstract::SetOuterBorderRadius(frameNode, borderRadius);
3907 auto renderContext = frameNode->GetRenderContext();
3908 ASSERT_NE(renderContext, nullptr);
3909 EXPECT_EQ(renderContext->GetOuterBorderRadius().has_value(), true);
3910 EXPECT_EQ(renderContext->GetOuterBorderRadius()->multiValued, true);
3911 EXPECT_EQ(renderContext->GetOuterBorderRadius()->radiusTopLeft, Dimension(1.0f, OHOS::Ace::DimensionUnit::VP));
3912 EXPECT_EQ(renderContext->GetOuterBorderRadius()->radiusTopRight, Dimension(2.0f, OHOS::Ace::DimensionUnit::VP));
3913 EXPECT_EQ(renderContext->GetOuterBorderRadius()->radiusBottomRight, Dimension(3.0f, OHOS::Ace::DimensionUnit::VP));
3914 EXPECT_EQ(renderContext->GetOuterBorderRadius()->radiusBottomLeft, Dimension(4.0f, OHOS::Ace::DimensionUnit::VP));
3915 EXPECT_EQ(renderContext->GetOuterBorderRadius()->radiusTopStart, Dimension(5.0f, OHOS::Ace::DimensionUnit::VP));
3916 EXPECT_EQ(renderContext->GetOuterBorderRadius()->radiusTopEnd, Dimension(6.0f, OHOS::Ace::DimensionUnit::VP));
3917 EXPECT_EQ(renderContext->GetOuterBorderRadius()->radiusBottomEnd, Dimension(7.0f, OHOS::Ace::DimensionUnit::VP));
3918 EXPECT_EQ(renderContext->GetOuterBorderRadius()->radiusBottomStart, Dimension(8.0f, OHOS::Ace::DimensionUnit::VP));
3919 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3920 g_isConfigChangePerform = false;
3921 }
3922
3923 /**
3924 * @tc.name: SetOuterBorderColor
3925 * @tc.desc: Test SetOuterBorderColor of View_Abstract
3926 * @tc.type: FUNC
3927 */
3928 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest013, TestSize.Level1)
3929 {
3930 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3931 ASSERT_NE(frameNode, nullptr);
3932 auto pattern = frameNode->GetPattern<Pattern>();
3933 ASSERT_NE(pattern, nullptr);
3934 g_isConfigChangePerform = true;
3935 BorderColorProperty borderColor;
3936 borderColor.leftColor = Color::BLUE;
3937 borderColor.rightColor = Color::BLACK;
3938 borderColor.topColor = Color::WHITE;
3939 borderColor.bottomColor = Color::RED;
3940 borderColor.startColor = Color::GRAY;
3941 borderColor.endColor = Color::GREEN;
3942 borderColor.multiValued = true;
3943 ViewAbstract::SetOuterBorderColor(frameNode, borderColor);
3944 auto renderContext = frameNode->GetRenderContext();
3945 ASSERT_NE(renderContext, nullptr);
3946 EXPECT_EQ(renderContext->GetOuterBorderColor().has_value(), true);
3947 EXPECT_EQ(renderContext->GetOuterBorderColor()->multiValued, true);
3948 EXPECT_EQ(renderContext->GetOuterBorderColor()->leftColor, Color::BLUE);
3949 EXPECT_EQ(renderContext->GetOuterBorderColor()->rightColor, Color::BLACK);
3950 EXPECT_EQ(renderContext->GetOuterBorderColor()->topColor, Color::WHITE);
3951 EXPECT_EQ(renderContext->GetOuterBorderColor()->bottomColor, Color::RED);
3952 EXPECT_EQ(renderContext->GetOuterBorderColor()->startColor, Color::GRAY);
3953 EXPECT_EQ(renderContext->GetOuterBorderColor()->endColor, Color::GREEN);
3954 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3955 g_isConfigChangePerform = false;
3956 }
3957
3958 /**
3959 * @tc.name: SetOuterBorderWidth
3960 * @tc.desc: Test SetOuterBorderWidth of View_Abstract
3961 * @tc.type: FUNC
3962 */
3963 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest014, TestSize.Level1)
3964 {
3965 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
3966 ASSERT_NE(frameNode, nullptr);
3967 auto pattern = frameNode->GetPattern<Pattern>();
3968 ASSERT_NE(pattern, nullptr);
3969 g_isConfigChangePerform = true;
3970 BorderWidthProperty borderWidth;
3971 borderWidth.leftDimen = Dimension(1.0f, OHOS::Ace::DimensionUnit::VP);
3972 borderWidth.topDimen = Dimension(2.0f, OHOS::Ace::DimensionUnit::VP);
3973 borderWidth.rightDimen = Dimension(3.0f, OHOS::Ace::DimensionUnit::VP);
3974 borderWidth.bottomDimen = Dimension(4.0f, OHOS::Ace::DimensionUnit::VP);
3975 borderWidth.startDimen = Dimension(5.0f, OHOS::Ace::DimensionUnit::VP);
3976 borderWidth.endDimen = Dimension(6.0f, OHOS::Ace::DimensionUnit::VP);
3977 borderWidth.multiValued = true;
3978 ViewAbstract::SetOuterBorderWidth(frameNode, borderWidth);
3979 auto renderContext = frameNode->GetRenderContext();
3980 ASSERT_NE(renderContext, nullptr);
3981 EXPECT_EQ(renderContext->GetOuterBorderWidth().has_value(), true);
3982 EXPECT_EQ(renderContext->GetOuterBorderWidth()->multiValued, true);
3983 EXPECT_EQ(renderContext->GetOuterBorderWidth()->leftDimen, Dimension(1.0f, OHOS::Ace::DimensionUnit::VP));
3984 EXPECT_EQ(renderContext->GetOuterBorderWidth()->topDimen, Dimension(2.0f, OHOS::Ace::DimensionUnit::VP));
3985 EXPECT_EQ(renderContext->GetOuterBorderWidth()->rightDimen, Dimension(3.0f, OHOS::Ace::DimensionUnit::VP));
3986 EXPECT_EQ(renderContext->GetOuterBorderWidth()->bottomDimen, Dimension(4.0f, OHOS::Ace::DimensionUnit::VP));
3987 EXPECT_EQ(renderContext->GetOuterBorderWidth()->startDimen, Dimension(5.0f, OHOS::Ace::DimensionUnit::VP));
3988 EXPECT_EQ(renderContext->GetOuterBorderWidth()->endDimen, Dimension(6.0f, OHOS::Ace::DimensionUnit::VP));
3989 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
3990 g_isConfigChangePerform = false;
3991 }
3992
3993 /**
3994 * @tc.name: SetColorBlend
3995 * @tc.desc: Test SetColorBlend of View_Abstract
3996 * @tc.type: FUNC
3997 */
3998 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest015, TestSize.Level1)
3999 {
4000 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
4001 ASSERT_NE(frameNode, nullptr);
4002 auto pattern = frameNode->GetPattern<Pattern>();
4003 ASSERT_NE(pattern, nullptr);
4004 g_isConfigChangePerform = true;
4005 std::string colorStr = pattern->GetResCacheMapByKey("viewAbstract.colorBlend");
4006 EXPECT_EQ(colorStr, "");
4007 std::string bundleName = "com.example.test";
4008 std::string moduleName = "entry";
4009 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
4010 Color colorBlend = Color::BLUE;
4011 ViewAbstract::SetColorBlend(frameNode, colorBlend, resObj);
4012 Color result;
4013 ResourceParseUtils::ParseResColor(resObj, result);
4014 colorStr = pattern->GetResCacheMapByKey("viewAbstract.colorBlend");
4015 EXPECT_EQ(colorStr, result.ToString());
4016 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
4017 g_isConfigChangePerform = false;
4018 }
4019
4020 /**
4021 * @tc.name: SetMask
4022 * @tc.desc: Test SetMask of View_Abstract
4023 * @tc.type: FUNC
4024 */
4025 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest016, TestSize.Level1)
4026 {
4027 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
4028 ASSERT_NE(frameNode, nullptr);
4029 auto pattern = frameNode->GetPattern<Pattern>();
4030 ASSERT_NE(pattern, nullptr);
4031 g_isConfigChangePerform = true;
4032 RefPtr<BasicShape> basicShape = AceType::MakeRefPtr<BasicShape>(BasicShapeType::CIRCLE);
4033 RefPtr<NG::ProgressMaskProperty> progressMaskProperty = AceType::MakeRefPtr<NG::ProgressMaskProperty>();
4034 progressMaskProperty->SetMaxValue(200.0f);
4035 progressMaskProperty->SetColor(Color(0xffff0000));
4036 progressMaskProperty->SetValue(1.0f);
4037 auto target = frameNode->GetRenderContext();
4038 ASSERT_NE(target, nullptr);
4039 target->UpdateClipMask(basicShape);
4040 ViewAbstract::SetProgressMask(frameNode, progressMaskProperty);
4041 auto renderContext = frameNode->GetRenderContext();
4042 ASSERT_NE(renderContext, nullptr);
4043 EXPECT_EQ(renderContext->GetProgressMask().has_value(), true);
4044 g_isConfigChangePerform = true;
4045
4046 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
4047 ViewAbstract::SetMask(frameNode, basicShape);
4048 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
4049 EXPECT_TRUE(result);
4050
4051 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
4052 g_isConfigChangePerform = false;
4053 }
4054
4055 /**
4056 * @tc.name: SetProgressMask
4057 * @tc.desc: Test SetProgressMask of View_Abstract
4058 * @tc.type: FUNC
4059 */
4060 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest017, TestSize.Level1)
4061 {
4062 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
4063 ASSERT_NE(frameNode, nullptr);
4064 auto pattern = frameNode->GetPattern<Pattern>();
4065 ASSERT_NE(pattern, nullptr);
4066 g_isConfigChangePerform = true;
4067 RefPtr<BasicShape> basicShape = AceType::MakeRefPtr<BasicShape>(BasicShapeType::CIRCLE);
4068 RefPtr<NG::ProgressMaskProperty> progressMaskProperty = AceType::MakeRefPtr<NG::ProgressMaskProperty>();
4069 progressMaskProperty->SetMaxValue(200.0f);
4070 progressMaskProperty->SetColor(Color(0xffff0000));
4071 progressMaskProperty->SetValue(1.0f);
4072 auto target = frameNode->GetRenderContext();
4073 ASSERT_NE(target, nullptr);
4074 target->UpdateClipMask(basicShape);
4075 ViewAbstract::SetProgressMask(frameNode, progressMaskProperty);
4076 auto renderContext = frameNode->GetRenderContext();
4077 ASSERT_NE(renderContext, nullptr);
4078 EXPECT_EQ(renderContext->GetProgressMask().has_value(), true);
4079 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
4080 g_isConfigChangePerform = false;
4081 }
4082
4083 /**
4084 * @tc.name: SetLightPosition
4085 * @tc.desc: Test SetLightPosition of View_Abstract
4086 * @tc.type: FUNC
4087 */
4088 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest018, TestSize.Level1)
4089 {
4090 NG::TranslateOptions option;
4091 option.x = Dimension(30.0f, OHOS::Ace::DimensionUnit::VP);
4092 option.y = Dimension(20.0f, OHOS::Ace::DimensionUnit::VP);
4093 option.z = Dimension(10.0f, OHOS::Ace::DimensionUnit::VP);
4094 g_isConfigChangePerform = true;
4095 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
4096 ASSERT_NE(frameNode, nullptr);
4097 auto pattern = frameNode->GetPattern<Pattern>();
4098 ASSERT_NE(pattern, nullptr);
4099 ViewAbstract::SetLightPosition(frameNode, option);
4100 auto renderContext = frameNode->GetRenderContext();
4101 ASSERT_NE(renderContext, nullptr);
4102 EXPECT_EQ(renderContext->GetLightPosition().has_value(), true);
4103 EXPECT_EQ(renderContext->GetLightPosition()->x, Dimension(30.0f, OHOS::Ace::DimensionUnit::VP));
4104 EXPECT_EQ(renderContext->GetLightPosition()->y, Dimension(20.0f, OHOS::Ace::DimensionUnit::VP));
4105 EXPECT_EQ(renderContext->GetLightPosition()->z, Dimension(10.0f, OHOS::Ace::DimensionUnit::VP));
4106 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
4107 g_isConfigChangePerform = false;
4108 }
4109
4110 /**
4111 * @tc.name: SetLightColor
4112 * @tc.desc: Test SetLightColor of View_Abstract
4113 * @tc.type: FUNC
4114 */
4115 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest019, TestSize.Level1)
4116 {
4117 Color color = Color::TRANSPARENT;
4118 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
4119 ASSERT_NE(frameNode, nullptr);
4120 auto pattern = frameNode->GetPattern<Pattern>();
4121 ASSERT_NE(pattern, nullptr);
4122 g_isConfigChangePerform = true;
4123 std::string colorStr = pattern->GetResCacheMapByKey("LightColorRes");
4124 EXPECT_EQ(colorStr, "");
4125 std::string bundleName = "com.example.test";
4126 std::string moduleName = "entry";
4127 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(bundleName, moduleName, 0);
4128 ViewAbstract::SetLightColor(frameNode, color, resObj);
4129 Color lightColor;
4130 ResourceParseUtils::ParseResColor(resObj, lightColor);
4131 colorStr = pattern->GetResCacheMapByKey("LightColorRes");
4132 EXPECT_EQ(colorStr, lightColor.ColorToString());
4133 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
4134 g_isConfigChangePerform = false;
4135 std::string lightSource = pattern->GetResCacheMapByKey("LightColorRes");
4136 EXPECT_EQ(lightSource, lightColor.ColorToString());
4137 }
4138
4139 /**
4140 * @tc.name: SetBackShadow
4141 * @tc.desc: Test SetBackShadow of View_Abstract
4142 * @tc.type: FUNC
4143 */
4144 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest020, TestSize.Level1)
4145 {
4146 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
4147 ASSERT_NE(frameNode, nullptr);
4148 auto pattern = frameNode->GetPattern<Pattern>();
4149 ASSERT_NE(pattern, nullptr);
4150 g_isConfigChangePerform = true;
4151 Shadow shadow;
4152 shadow.SetBlurRadius(10);
4153 shadow.SetOffsetX(10.0);
4154 shadow.SetOffsetY(10.0);
4155 shadow.SetColor(Color(Color::RED));
4156 shadow.SetShadowType(ShadowType::COLOR);
4157 ViewAbstract::SetBackShadow(frameNode, shadow);
4158 auto renderContext = frameNode->GetRenderContext();
4159 ASSERT_NE(renderContext, nullptr);
4160 EXPECT_EQ(renderContext->GetBackShadow().has_value(), true);
4161 EXPECT_EQ(renderContext->GetBackShadow()->GetBlurRadius(), 10);
4162 EXPECT_EQ(renderContext->GetBackShadow()->GetOffset().GetX(), 10);
4163 EXPECT_EQ(renderContext->GetBackShadow()->GetOffset().GetY(), 10);
4164 EXPECT_EQ(renderContext->GetBackShadow()->GetColor(), Color(Color::RED));
4165 EXPECT_EQ(renderContext->GetBackShadow()->GetShadowType(), ShadowType::COLOR);
4166 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
4167 g_isConfigChangePerform = false;
4168 }
4169
4170 /**
4171 * @tc.name: SetForegroundColorStrategy
4172 * @tc.desc: Test SetForegroundColorStrategy of View_Abstract
4173 * @tc.type: FUNC
4174 */
4175 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest021, TestSize.Level1)
4176 {
4177 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
4178 ASSERT_NE(frameNode, nullptr);
4179 auto pattern = frameNode->GetPattern<Pattern>();
4180 ASSERT_NE(pattern, nullptr);
4181 g_isConfigChangePerform = true;
4182 ForegroundColorStrategy strategy = ForegroundColorStrategy::INVERT;
4183 ViewAbstract::SetForegroundColorStrategy(strategy);
4184 auto renderContext = frameNode->GetRenderContext();
4185 ASSERT_NE(renderContext, nullptr);
4186 EXPECT_EQ(renderContext->GetForegroundColorStrategy().has_value(), true);
4187 EXPECT_EQ(renderContext->GetForegroundColorStrategyValue(), strategy);
4188 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
4189 EXPECT_EQ(renderContext->GetForegroundColorStrategy().has_value(), true);
4190 EXPECT_EQ(renderContext->GetForegroundColorStrategyValue(), strategy);
4191 g_isConfigChangePerform = false;
4192 }
4193
4194 /**
4195 * @tc.name: SetForegroundColorStrategy
4196 * @tc.desc: Test SetForegroundColorStrategy of View_Abstract
4197 * @tc.type: FUNC
4198 */
4199 HWTEST_F(ViewAbstractTestNg, ViewAbstractResourceObjectTest022, TestSize.Level1)
4200 {
4201 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
4202 ASSERT_NE(frameNode, nullptr);
4203 auto pattern = frameNode->GetPattern<Pattern>();
4204 ASSERT_NE(pattern, nullptr);
4205 g_isConfigChangePerform = true;
4206 ForegroundColorStrategy strategy = ForegroundColorStrategy::INVERT;
4207 ViewAbstract::SetForegroundColorStrategy(frameNode, strategy);
4208 auto renderContext = frameNode->GetRenderContext();
4209 ASSERT_NE(renderContext, nullptr);
4210 EXPECT_EQ(renderContext->GetForegroundColorStrategy().has_value(), true);
4211 EXPECT_EQ(renderContext->GetForegroundColorStrategyValue(), strategy);
4212 pattern->OnColorModeChange((uint32_t)ColorMode::DARK);
4213 EXPECT_EQ(renderContext->GetForegroundColorStrategy().has_value(), true);
4214 EXPECT_EQ(renderContext->GetForegroundColorStrategyValue(), strategy);
4215 g_isConfigChangePerform = false;
4216 }
4217
4218 /**
4219 * @tc.name: CreateWithColorResourceObj
4220 * @tc.desc: Test CreateWithColorResourceObj of View_Abstract
4221 * @tc.type: FUNC
4222 */
4223 HWTEST_F(ViewAbstractTestNg, CreateWithColorResourceObj, TestSize.Level1)
4224 {
4225 /**
4226 * @tc.steps: step1. Create frame node and initialize components.
4227 * @tc.expected: step1. Frame node and related components are created successfully.
4228 */
4229 const RefPtr<FrameNode> frameNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<BubblePattern>());
4230 ASSERT_NE(frameNode, nullptr);
4231 ViewStackProcessor::GetInstance()->Push(frameNode);
4232
4233 auto pattern = frameNode->GetPattern<BubblePattern>();
4234 ASSERT_NE(pattern, nullptr);
4235
4236 /**
4237 * @tc.steps: step2. Create resource objects and configure popup parameters.
4238 * @tc.expected: step2. Resource objects and popup parameters are initialized correctly.
4239 */
4240 std::vector<ResourceObjectParams> params = { { "", ResourceObjectParamType::NONE } };
4241 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(-1, 10003, params, "", "", 0);
4242 ASSERT_NE(resObj, nullptr);
4243
4244 RefPtr<PopupParam> param = AceType::MakeRefPtr<PopupParam>();
4245 ASSERT_NE(param, nullptr);
4246 param->SetTextColorResourceObject(resObj);
4247 param->SetPopupColorResourceObject(resObj);
4248 param->SetMaskColorResourceObject(resObj);
4249
4250 RefPtr<ResourceObject> boolResObj = AceType::MakeRefPtr<ResourceObject>(-1, 10005, params, "", "", 0);
4251 ASSERT_NE(resObj, nullptr);
4252 param->SetMaskResourceObject(boolResObj);
4253
4254 RefPtr<ResourceObject> defaultResObj = AceType::MakeRefPtr<ResourceObject>("", "", 0);
4255 ASSERT_NE(defaultResObj, nullptr);
4256
4257 /**
4258 * @tc.steps: step3. Test CreateWithResourceObj for text color resource.
4259 * @tc.expected: step3. Text color resource is applied and type string is correct.
4260 */
4261 PopupType type = POPUPTYPE_TEXTCOLOR;
4262 auto textColorResourceObject = param->GetTextColorResourceObject();
4263 ASSERT_NE(textColorResourceObject, nullptr);
4264 viewAbstractModelNG.CreateWithResourceObj(frameNode, textColorResourceObject, type);
4265 pattern->OnColorModeChange(1);
4266 auto textColorStr = viewAbstractModelNG.PopupTypeStr(type);
4267 EXPECT_EQ(textColorStr, "TextColor");
4268
4269 /**
4270 * @tc.steps: step4. Test CreateWithResourceObj for popup color resource.
4271 * @tc.expected: step4. Popup color resource is applied and type string is correct.
4272 */
4273 type = POPUPTYPE_POPUPCOLOR;
4274 auto popupColorResourceObject = param->GetPopupColorResourceObject();
4275 ASSERT_NE(textColorResourceObject, nullptr);
4276 viewAbstractModelNG.CreateWithResourceObj(frameNode, popupColorResourceObject, type);
4277 pattern->OnColorModeChange(1);
4278 auto popupColorStr = viewAbstractModelNG.PopupTypeStr(type);
4279 EXPECT_EQ(popupColorStr, "PopupColor");
4280
4281 /**
4282 * @tc.steps: step5. Test CreateWithResourceObj for mask color resource.
4283 * @tc.expected: step5. Mask color resource is applied and type string is correct.
4284 */
4285 type = POPUPTYPE_MASKCOLOR;
4286 auto maskColorResourceObject = param->GetMaskColorResourceObject();
4287 ASSERT_NE(textColorResourceObject, nullptr);
4288 viewAbstractModelNG.CreateWithResourceObj(frameNode, maskColorResourceObject, type);
4289 pattern->OnColorModeChange(1);
4290 auto maskColorStr = viewAbstractModelNG.PopupTypeStr(type);
4291 EXPECT_EQ(maskColorStr, "MaskColor");
4292
4293 /**
4294 * @tc.steps: step6. Test CreateWithResourceObj for mask resource without type.
4295 * @tc.expected: step6. Mask resource is applied with correct instance ID.
4296 */
4297 auto maskResourceObject = param->GetMaskResourceObject();
4298 ASSERT_NE(textColorResourceObject, nullptr);
4299 viewAbstractModelNG.CreateWithResourceObj(frameNode, maskResourceObject);
4300 pattern->OnColorModeChange(1);
4301 EXPECT_EQ(maskResourceObject->GetInstanceId(), 0);
4302
4303 /**
4304 * @tc.steps: step7. Test CreateWithResourceObj with invalid type.
4305 * @tc.expected: step7. Type string for invalid type is empty.
4306 */
4307 type = static_cast<PopupType>(POPUPTYPE_MASKCOLOR + 1);
4308 viewAbstractModelNG.CreateWithResourceObj(frameNode, defaultResObj, type);
4309 auto defaultStr = viewAbstractModelNG.PopupTypeStr(type);
4310 EXPECT_EQ(defaultStr, "");
4311 }
4312
4313 /**
4314 * @tc.name: CreateWithDimensionResourceObj001
4315 * @tc.desc: Test CreateWithDimensionResourceObj of View_Abstract
4316 * @tc.type: FUNC
4317 */
4318 HWTEST_F(ViewAbstractTestNg, CreateWithDimensionResourceObj001, TestSize.Level1)
4319 {
4320 /**
4321 * @tc.steps: step1. Create frame node and initialize components.
4322 * @tc.expected: step1. Frame node and related components are created successfully.
4323 */
4324 const RefPtr<FrameNode> frameNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<BubblePattern>());
4325 ASSERT_NE(frameNode, nullptr);
4326 ViewStackProcessor::GetInstance()->Push(frameNode);
4327
4328 auto pattern = frameNode->GetPattern<BubblePattern>();
4329 ASSERT_NE(pattern, nullptr);
4330
4331 /**
4332 * @tc.steps: step2. Create dimension resource object and configure popup parameters.
4333 * @tc.expected: step2. Dimension resource object and popup parameters are initialized correctly.
4334 */
4335 std::vector<ResourceObjectParams> params = { { "", ResourceObjectParamType::NONE } };
4336 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(0, 10007, params, "", "", 0);
4337 ASSERT_NE(resObj, nullptr);
4338
4339 RefPtr<PopupParam> param = AceType::MakeRefPtr<PopupParam>();
4340 ASSERT_NE(param, nullptr);
4341
4342 param->SetWidthResourceObject(resObj);
4343 param->SetArrowWidthResourceObject(resObj);
4344 param->SetArrowHeightResourceObject(resObj);
4345
4346 /**
4347 * @tc.steps: step3. Test CreateWithResourceObj for width dimension resource.
4348 * @tc.expected: step3. Width dimension resource is applied and type string is correct.
4349 */
4350 PopupOptionsType type = POPUP_OPTIONTYPE_WIDTH;
4351 auto widthResourceObject = param->GetWidthResourceObject();
4352 ASSERT_NE(widthResourceObject, nullptr);
4353 viewAbstractModelNG.CreateWithResourceObj(frameNode, widthResourceObject, type);
4354 pattern->OnColorModeChange(1);
4355 auto widthStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4356 EXPECT_EQ(widthStr, "width");
4357
4358 /**
4359 * @tc.steps: step4. Test CreateWithResourceObj for arrow width dimension resource.
4360 * @tc.expected: step4. Arrow width dimension resource is applied and type string is correct.
4361 */
4362 type = POPUP_OPTIONTYPE_ARROWWIDTH;
4363 auto arrowWidthResourceObject = param->GetArrowWidthResourceObject();
4364 ASSERT_NE(arrowWidthResourceObject, nullptr);
4365 viewAbstractModelNG.CreateWithResourceObj(frameNode, arrowWidthResourceObject, type);
4366 pattern->OnColorModeChange(1);
4367 auto arrowWidthStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4368 EXPECT_EQ(arrowWidthStr, "arrowWidth");
4369
4370 /**
4371 * @tc.steps: step5. Test CreateWithResourceObj for arrow height dimension resource.
4372 * @tc.expected: step5. Arrow height dimension resource is applied and type string is correct.
4373 */
4374 type = POPUP_OPTIONTYPE_ARROWHEIGHT;
4375 auto arrowHeighResourceObject = param->GetArrowHeightResourceObject();
4376 ASSERT_NE(arrowHeighResourceObject, nullptr);
4377 viewAbstractModelNG.CreateWithResourceObj(frameNode, arrowHeighResourceObject, type);
4378 pattern->OnColorModeChange(1);
4379 auto arrowHeighStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4380 EXPECT_EQ(arrowHeighStr, "arrowHeight");
4381 }
4382
4383 /**
4384 * @tc.name: CreateWithDimensionResourceObj002
4385 * @tc.desc: Test CreateWithDimensionResourceObj of View_Abstract
4386 * @tc.type: FUNC
4387 */
4388 HWTEST_F(ViewAbstractTestNg, CreateWithDimensionResourceObj002, TestSize.Level1)
4389 {
4390 /**
4391 * @tc.steps: step1. Create frame node and initialize components.
4392 * @tc.expected: step1. Frame node and related components are created successfully.
4393 */
4394 const RefPtr<FrameNode> frameNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<BubblePattern>());
4395 ASSERT_NE(frameNode, nullptr);
4396 ViewStackProcessor::GetInstance()->Push(frameNode);
4397
4398 auto pattern = frameNode->GetPattern<BubblePattern>();
4399 ASSERT_NE(pattern, nullptr);
4400
4401 /**
4402 * @tc.steps: step2. Create dimension resource object and configure popup parameters.
4403 * @tc.expected: step2. Dimension resource object and popup parameters are initialized correctly.
4404 */
4405 std::vector<ResourceObjectParams> params = { { "", ResourceObjectParamType::NONE } };
4406 RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>(0, 10007, params, "", "", 0);
4407 ASSERT_NE(resObj, nullptr);
4408
4409 RefPtr<PopupParam> param = AceType::MakeRefPtr<PopupParam>();
4410 ASSERT_NE(param, nullptr);
4411
4412 param->SetRadiusResourceObject(resObj);
4413 param->SetOutlineWidthObject(resObj);
4414 param->SetBorderWidthObject(resObj);
4415
4416 /**
4417 * @tc.steps: step3. Test CreateWithResourceObj for radius dimension resource.
4418 * @tc.expected: step3. Radius dimension resource is applied and type string is correct.
4419 */
4420 PopupOptionsType type = POPUP_OPTIONTYPE_RADIUS;
4421 auto radiusResourceObject = param->GetRadiusResourceObject();
4422 ASSERT_NE(radiusResourceObject, nullptr);
4423 viewAbstractModelNG.CreateWithResourceObj(frameNode, radiusResourceObject, type);
4424 pattern->OnColorModeChange(1);
4425 auto radiusStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4426 EXPECT_EQ(radiusStr, "radius");
4427
4428 /**
4429 * @tc.steps: step4. Test CreateWithResourceObj for outline width dimension resource.
4430 * @tc.expected: step4. Outline width dimension resource is applied and type string is correct.
4431 */
4432 type = POPUP_OPTIONTYPE_OUTLINEWIDTH;
4433 auto outlineWidthResourceObject = param->GetOutlineWidthResourceObject();
4434 ASSERT_NE(outlineWidthResourceObject, nullptr);
4435 viewAbstractModelNG.CreateWithResourceObj(frameNode, outlineWidthResourceObject, type);
4436 pattern->OnColorModeChange(1);
4437 auto outlineWidthStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4438 EXPECT_EQ(outlineWidthStr, "outlineWidth");
4439
4440 /**
4441 * @tc.steps: step5. Test CreateWithResourceObj for border width dimension resource.
4442 * @tc.expected: step5. Border width dimension resource is applied and type string is correct.
4443 */
4444 type = POPUP_OPTIONTYPE_BORDERWIDTH;
4445 auto borderWidthResourceObject = param->GetBorderWidthResourceObject();
4446 ASSERT_NE(borderWidthResourceObject, nullptr);
4447 viewAbstractModelNG.CreateWithResourceObj(frameNode, borderWidthResourceObject, type);
4448 pattern->OnColorModeChange(1);
4449 auto borderWidthStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4450 EXPECT_EQ(borderWidthStr, "borderWidth");
4451 }
4452
4453 /**
4454 * @tc.name: CreateWithDimensionResourceObj003
4455 * @tc.desc: Test CreateWithDimensionResourceObj of View_Abstract
4456 * @tc.type: FUNC
4457 */
4458 HWTEST_F(ViewAbstractTestNg, CreateWithDimensionResourceObj003, TestSize.Level1)
4459 {
4460 /**
4461 * @tc.steps: step1. Create frame node and initialize components.
4462 * @tc.expected: step1. Frame node and related components are created successfully.
4463 */
4464 const RefPtr<FrameNode> frameNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<BubblePattern>());
4465 ASSERT_NE(frameNode, nullptr);
4466 ViewStackProcessor::GetInstance()->Push(frameNode);
4467
4468 auto pattern = frameNode->GetPattern<BubblePattern>();
4469 ASSERT_NE(pattern, nullptr);
4470
4471 /**
4472 * @tc.steps: step2. Create default resource object and configure popup parameters.
4473 * @tc.expected: step2. Default resource object and popup parameters are initialized correctly.
4474 */
4475 RefPtr<ResourceObject> defaultResObj = AceType::MakeRefPtr<ResourceObject>("", "", 0);
4476 ASSERT_NE(defaultResObj, nullptr);
4477
4478 RefPtr<PopupParam> param = AceType::MakeRefPtr<PopupParam>();
4479 ASSERT_NE(param, nullptr);
4480
4481 param->SetWidthResourceObject(defaultResObj);
4482 param->SetArrowWidthResourceObject(defaultResObj);
4483 param->SetArrowHeightResourceObject(defaultResObj);
4484
4485 /**
4486 * @tc.steps: step3. Test CreateWithResourceObj for width dimension with default resource.
4487 * @tc.expected: step3. Width dimension resource is applied and type string is correct.
4488 */
4489 PopupOptionsType type = POPUP_OPTIONTYPE_WIDTH;
4490 auto defaultWidthResourceObject = param->GetWidthResourceObject();
4491 ASSERT_NE(defaultWidthResourceObject, nullptr);
4492 viewAbstractModelNG.CreateWithResourceObj(frameNode, defaultWidthResourceObject, type);
4493 pattern->OnColorModeChange(1);
4494 auto widthStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4495 EXPECT_EQ(widthStr, "width");
4496
4497 /**
4498 * @tc.steps: step4. Test CreateWithResourceObj for arrow width dimension with default resource.
4499 * @tc.expected: step4. Arrow width dimension resource is applied and type string is correct.
4500 */
4501 type = POPUP_OPTIONTYPE_ARROWWIDTH;
4502 auto defaultArrowWidthResourceObject = param->GetArrowWidthResourceObject();
4503 ASSERT_NE(defaultArrowWidthResourceObject, nullptr);
4504 viewAbstractModelNG.CreateWithResourceObj(frameNode, defaultArrowWidthResourceObject, type);
4505 pattern->OnColorModeChange(1);
4506 auto arrowWidthStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4507 EXPECT_EQ(arrowWidthStr, "arrowWidth");
4508
4509 /**
4510 * @tc.steps: step5. Test CreateWithResourceObj for arrow height dimension with default resource.
4511 * @tc.expected: step5. Arrow height dimension resource is applied and type string is correct.
4512 */
4513 type = POPUP_OPTIONTYPE_ARROWHEIGHT;
4514 auto defaultArrowHeightResourceObject = param->GetArrowHeightResourceObject();
4515 ASSERT_NE(defaultArrowHeightResourceObject, nullptr);
4516 viewAbstractModelNG.CreateWithResourceObj(frameNode, defaultArrowHeightResourceObject, type);
4517 pattern->OnColorModeChange(1);
4518 auto arrowHeighStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4519 EXPECT_EQ(arrowHeighStr, "arrowHeight");
4520 }
4521
4522 /**
4523 * @tc.name: CreateWithDimensionResourceObj004
4524 * @tc.desc: Test CreateWithDimensionResourceObj of View_Abstract
4525 * @tc.type: FUNC
4526 */
4527 HWTEST_F(ViewAbstractTestNg, CreateWithDimensionResourceObj004, TestSize.Level1)
4528 {
4529 /**
4530 * @tc.steps: step1. Create frame node and initialize components.
4531 * @tc.expected: step1. Frame node and related components are created successfully.
4532 */
4533 const RefPtr<FrameNode> frameNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<BubblePattern>());
4534 ASSERT_NE(frameNode, nullptr);
4535 ViewStackProcessor::GetInstance()->Push(frameNode);
4536
4537 auto pattern = frameNode->GetPattern<BubblePattern>();
4538 ASSERT_NE(pattern, nullptr);
4539
4540 /**
4541 * @tc.steps: step2. Create default resource object and configure popup parameters.
4542 * @tc.expected: step2. Default resource object and popup parameters are initialized correctly.
4543 */
4544 RefPtr<ResourceObject> defaultResObj = AceType::MakeRefPtr<ResourceObject>("", "", 0);
4545 ASSERT_NE(defaultResObj, nullptr);
4546
4547 RefPtr<PopupParam> param = AceType::MakeRefPtr<PopupParam>();
4548 ASSERT_NE(param, nullptr);
4549
4550 param->SetRadiusResourceObject(defaultResObj);
4551 param->SetOutlineWidthObject(defaultResObj);
4552 param->SetBorderWidthObject(defaultResObj);
4553
4554 /**
4555 * @tc.steps: step3. Test CreateWithResourceObj for radius dimension with default resource.
4556 * @tc.expected: step3. Radius dimension resource is applied and type string is correct.
4557 */
4558 PopupOptionsType type = POPUP_OPTIONTYPE_RADIUS;
4559 auto defaultRadiusResourceObject = param->GetRadiusResourceObject();
4560 ASSERT_NE(defaultRadiusResourceObject, nullptr);
4561 viewAbstractModelNG.CreateWithResourceObj(frameNode, defaultRadiusResourceObject, type);
4562 pattern->OnColorModeChange(1);
4563 auto radiusStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4564 EXPECT_EQ(radiusStr, "radius");
4565
4566 /**
4567 * @tc.steps: step4. Test CreateWithResourceObj for outline width dimension with default resource.
4568 * @tc.expected: step4. Outline width dimension resource is applied and type string is correct.
4569 */
4570 type = POPUP_OPTIONTYPE_OUTLINEWIDTH;
4571 auto defaultOutlineWidthObject = param->GetOutlineWidthResourceObject();
4572 ASSERT_NE(defaultOutlineWidthObject, nullptr);
4573 viewAbstractModelNG.CreateWithResourceObj(frameNode, defaultOutlineWidthObject, type);
4574 pattern->OnColorModeChange(1);
4575 auto outlineWidthStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4576 EXPECT_EQ(outlineWidthStr, "outlineWidth");
4577
4578 /**
4579 * @tc.steps: step5. Test CreateWithResourceObj for border width dimension with default resource.
4580 * @tc.expected: step5. Border width dimension resource is applied and type string is correct.
4581 */
4582 type = POPUP_OPTIONTYPE_BORDERWIDTH;
4583 auto defaultBorderWidthObject = param->GetBorderWidthResourceObject();
4584 ASSERT_NE(defaultBorderWidthObject, nullptr);
4585 viewAbstractModelNG.CreateWithResourceObj(frameNode, defaultBorderWidthObject, type);
4586 pattern->OnColorModeChange(1);
4587 auto borderWidthStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4588 EXPECT_EQ(borderWidthStr, "borderWidth");
4589
4590 /**
4591 * @tc.steps: step6. Test CreateWithResourceObj with invalid type using default resource.
4592 * @tc.expected: step6. Type string for invalid type is empty.
4593 */
4594 type = POPUP_OPTIONTYPE_OFFSETDX;
4595 viewAbstractModelNG.CreateWithResourceObj(frameNode, defaultResObj, type);
4596 pattern->OnColorModeChange(1);
4597 auto defaultStr = viewAbstractModelNG.PopupOptionTypeStr(type);
4598 EXPECT_EQ(defaultStr, "");
4599 }
4600 } // namespace OHOS::Ace::NG